diff --git a/.config/lychee.toml b/.config/lychee.toml index 733b77ec0cff9e616ecc0f851d9a3ed5e8574636..b7bb6f0ce4953bcdba91685d8161d9046765cdcb 100644 --- a/.config/lychee.toml +++ b/.config/lychee.toml @@ -33,16 +33,14 @@ exclude = [ "https://github.com/paritytech/substrate/frame/fast-unstake", "https://github.com/zkcrypto/bls12_381/blob/e224ad4ea1babfc582ccd751c2bf128611d10936/src/test-data/mod.rs", "https://polkadot.network/the-path-of-a-parachain-block/", - "https://research.web3.foundation/en/latest/polkadot/BABE/Babe/#6-practical-results", "https://research.web3.foundation/en/latest/polkadot/NPoS/3.%20Balancing.html", "https://research.web3.foundation/en/latest/polkadot/Token%20Economics.html#inflation-model", - "https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html", - "https://research.web3.foundation/en/latest/polkadot/block-production/Babe.html#-6.-practical-results", "https://research.web3.foundation/en/latest/polkadot/networking/3-avail-valid.html#topology", "https://research.web3.foundation/en/latest/polkadot/overview/2-token-economics.html", "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", @@ -53,5 +51,6 @@ exclude = [ "https://www.reddit.com/r/rust/comments/3spfh1/does_collect_allocate_more_than_once_while/", # 403 rate limited: "https://etherscan.io/block/11090290", + "https://subscan.io/", "https://substrate.stackexchange.com/.*", ] 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 f701392d16b15aab8351b730efa13f3abffe2406..7a67ba2695cf697c886b31520431ea0ee33e14c9 100644 --- a/.config/zepter.yaml +++ b/.config/zepter.yaml @@ -25,9 +25,13 @@ workflows: '--show-path', '--quiet', ] - # Same as `check`, but with the `--fix` flag. + # The umbrella crate uses more features, so we to check those too: + check_umbrella: + - [ $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' ] + - [ $check_umbrella.0, '--fix' ] # Will be displayed when any workflow fails: help: 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 new file mode 100644 index 0000000000000000000000000000000000000000..6f8eed8882ea36f39d1f0a519180f92eb905f7be --- /dev/null +++ b/.forklift/config.toml @@ -0,0 +1,29 @@ +[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 = "gcs" + +[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 new file mode 100644 index 0000000000000000000000000000000000000000..622fc64c488123a153b438af8516f3fa65133776 --- /dev/null +++ b/.github/scripts/deny-git-deps.py @@ -0,0 +1,50 @@ +""" +Script to deny Git dependencies in the Cargo workspace. Can be passed one optional argument for the +root folder. If not provided, it will use the cwd. + +## Usage + python3 .github/scripts/deny-git-deps.py polkadot-sdk +""" + +import os +import sys + +from cargo_workspace import Workspace, DependencyLocation + +KNOWN_BAD_GIT_DEPS = { + 'simple-mermaid': ['xcm-docs'], + # Fix in + 'bandersnatch_vrfs': ['sp-core'], +} + +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: + return + + if used_by in KNOWN_BAD_GIT_DEPS.get(dep.name, []): + print(f'🤨 Ignoring git dependency {dep.name} in {used_by}') + else: + 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 = """
+ +Polkadot logo + +# {name} + +This crate is part of the [Polkadot SDK](https://github.com/paritytech/polkadot-sdk/). + +
+ +## Description + +{description} + +## Additional Resources + +In order to learn about Polkadot SDK, head over to the [Polkadot SDK Developer Documentation](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/index.html). + +To learn about Polkadot, visit [polkadot.com](https://polkadot.com/). + +## License + +This crate is licensed with {license}. +""" + +VERSION_TEMPLATE = """ +## Version + +This version of `{name}` is associated with Polkadot {sdk_version} release. +""" + + +def generate_readme(member, *, workspace_dir, workspace_license, sdk_version): + print(f"Loading manifest for: {member}") + manifest = toml.load(os.path.join(workspace_dir, member, "Cargo.toml")) + if manifest["package"].get("publish", True) == False: + print(f"⏩ Skipping un-published crate: {member}") + return + if os.path.exists(os.path.join(workspace_dir, member, "README.md")): + print(f"⏩ Skipping crate with an existing readme: {member}") + return + print(f"📝 Generating README for: {member}") + + license = manifest["package"]["license"] + if isinstance(license, dict): + if not license.get("workspace", False): + print( + f"❌ License for {member} is unexpectedly declared as workspace=false." + ) + # Skipping this crate as it is not clear what license it should use. + return + license = workspace_license + + name = manifest["package"]["name"] + description = manifest["package"]["description"] + description = description + "." if not description.endswith(".") else description + + filled_readme = README_TEMPLATE.format( + name=name, description=description, license=license + ) + + if sdk_version: + filled_readme += VERSION_TEMPLATE.format(name=name, sdk_version=sdk_version) + + with open(os.path.join(workspace_dir, member, "README.md"), "w") as new_readme: + new_readme.write(filled_readme) + + +def parse_args(): + parser = argparse.ArgumentParser( + description="Generate readmes for published crates." + ) + + parser.add_argument( + "workspace_dir", + help="The directory to check", + metavar="workspace_dir", + type=str, + nargs=1, + ) + parser.add_argument( + "--sdk-version", + help="Optional SDK release version", + metavar="sdk_version", + type=str, + nargs=1, + required=False, + ) + + args = parser.parse_args() + return (args.workspace_dir[0], args.sdk_version[0] if args.sdk_version else None) + + +def main(): + (workspace_dir, sdk_version) = parse_args() + root_manifest = toml.load(os.path.join(workspace_dir, "Cargo.toml")) + workspace_license = root_manifest["workspace"]["package"]["license"] + members = check_workspace.get_members(workspace_dir, []) + for member in members: + generate_readme( + member, + workspace_dir=workspace_dir, + workspace_license=workspace_license, + sdk_version=sdk_version, + ) + + +if __name__ == "__main__": + main() diff --git a/.github/scripts/update-wishlist-leaderboard.py b/.github/scripts/update-wishlist-leaderboard.py new file mode 100644 index 0000000000000000000000000000000000000000..82d1085144844f0fc9b46d94f668ba9a153400a3 --- /dev/null +++ b/.github/scripts/update-wishlist-leaderboard.py @@ -0,0 +1,79 @@ +from github import Github +import re +import os +from datetime import date + +g = Github(os.getenv("GH_TOKEN")) + +# Regex pattern to match wish format: +wish_pattern = re.compile( + r"I wish for:? (https://github\.com/([a-zA-Z0-9_.-]+)/([a-zA-Z0-9_.-]+)/(issues|pull)/(\d+))" +) + +wishlist_issue = g.get_repo(os.getenv("WISHLIST_REPOSITORY")).get_issue( + int(os.getenv("WISHLIST_ISSUE_NUMBER")) +) +new_leaderboard = ( + "| Feature Request | Summary | Votes | Status |\n| --- | --- | --- | --- |\n" +) +wishes = {} +issue_details = {} + +for comment in wishlist_issue.get_comments(): + # in the comment body, if there is a string `#(\d)`, replace it with + # https://github.com/paritytech/polkadot-sdk/issues/(number) + updated_body = re.sub( + r"#(\d+)", r"https://github.com/paritytech/polkadot-sdk/issues/\1", comment.body + ) + + matches = wish_pattern.findall(updated_body) + for match in matches: + url, org, repo_name, _, issue_id = match + issue_key = (url, org, repo_name, issue_id) + if issue_key not in wishes: + wishes[issue_key] = [] + + # Get the author and upvoters of the wish comment. + wishes[issue_key].append(comment.user.id) + wishes[issue_key].extend( + [ + reaction.user.id + for reaction in comment.get_reactions() + if reaction.content in ["+1", "heart", "rocket"] + ] + ) + + # Get upvoters of the desired issue. + desired_issue = g.get_repo(f"{org}/{repo_name}").get_issue(int(issue_id)) + wishes[issue_key].extend( + [ + reaction.user.id + for reaction in desired_issue.get_reactions() + if reaction.content in ["+1", "heart", "rocket"] + ] + ) + issue_details[url] = [ + desired_issue.title, + "👾 Open" if desired_issue.state == "open" else "✅Closed", + ] + +# Count unique wishes - the author of the wish, upvoters of the wish, and upvoters of the desired issue. +for key in wishes: + wishes[key] = len(list(set(wishes[key]))) + +# Sort wishes by count and add to the markdown table +sorted_wishes = sorted(wishes.items(), key=lambda x: x[1], reverse=True) +for (url, _, _, _), count in sorted_wishes: + [summary, status] = issue_details.get(url, "No summary available") + new_leaderboard += f"| {url} | {summary} | {count} | {status} |\n" +new_leaderboard += f"\n> Last updated: {date.today().strftime('%Y-%m-%d')}\n" +print(new_leaderboard) + +new_content = re.sub( + r"(\| Feature Request \|)(.*?)(> Last updated:)(.*?\n)", + new_leaderboard, + wishlist_issue.body, + flags=re.DOTALL, +) + +wishlist_issue.edit(body=new_content) diff --git a/.github/workflows/build-and-attach-release-runtimes.yml b/.github/workflows/build-and-attach-release-runtimes.yml deleted file mode 100644 index 680a9ecffd312dba61c2eaee3a3e2e6a9d5b136c..0000000000000000000000000000000000000000 --- a/.github/workflows/build-and-attach-release-runtimes.yml +++ /dev/null @@ -1,65 +0,0 @@ -name: Build and Attach Runtimes to Releases/RC - -on: - release: - types: - - published - -env: - PROFILE: production - -jobs: - build_and_upload: - strategy: - matrix: - runtime: - - { name: westend, package: westend-runtime, path: polkadot/runtime/westend } - - { name: rococo, package: rococo-runtime, path: polkadot/runtime/rococo } - - { name: asset-hub-rococo, package: asset-hub-rococo-runtime, path: cumulus/parachains/runtimes/assets/asset-hub-rococo } - - { name: asset-hub-westend, package: asset-hub-westend-runtime, path: cumulus/parachains/runtimes/assets/asset-hub-westend } - - { name: bridge-hub-rococo, package: bridge-hub-rococo-runtime, path: cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo } - - { name: contracts-rococo, package: contracts-rococo-runtime, path: cumulus/parachains/runtimes/contracts/contracts-rococo } - - { name: collectives-westend, package: collectives-westend-runtime, path: cumulus/parachains/runtimes/collectives/collectives-westend } - - { name: glutton-westend, package: glutton-westend-runtime, path: cumulus/parachains/runtimes/glutton/glutton-westend } - build_config: - # Release build has logging disabled and no dev features - - { type: on-chain-release, opts: --features on-chain-release-build } - # Debug build has logging enabled and developer features - - { type: dev-debug-build, opts: --features try-runtime } - - runs-on: ubuntu-22.04 - - steps: - - name: Checkout code - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - - name: Build ${{ matrix.runtime.name }} ${{ matrix.build_config.type }} - id: srtool_build - uses: chevdor/srtool-actions@v0.9.2 - env: - BUILD_OPTS: ${{ matrix.build_config.opts }} - with: - chain: ${{ matrix.runtime.name }} - package: ${{ matrix.runtime.package }} - runtime_dir: ${{ matrix.runtime.path }} - profile: ${{ env.PROFILE }} - - - name: Set up paths and runtime names - id: setup - run: | - RUNTIME_BLOB_NAME=$(echo ${{ matrix.runtime.package }} | sed 's/-/_/g').compact.compressed.wasm - PREFIX=${{ matrix.build_config.type == 'dev-debug-build' && 'DEV_DEBUG_BUILD__' || '' }} - - echo "RUNTIME_BLOB_NAME=$RUNTIME_BLOB_NAME" >> $GITHUB_ENV - echo "ASSET_PATH=./${{ matrix.runtime.path }}/target/srtool/${{ env.PROFILE }}/wbuild/${{ matrix.runtime.package }}/$RUNTIME_BLOB_NAME" >> $GITHUB_ENV - echo "ASSET_NAME=$PREFIX$RUNTIME_BLOB_NAME" >> $GITHUB_ENV - - - name: Upload Runtime to Release - uses: actions/upload-release-asset@v1 - with: - upload_url: ${{ github.event.release.upload_url }} - asset_path: ${{ env.ASSET_PATH }} - asset_name: ${{ env.ASSET_NAME }} - asset_content_type: application/octet-stream - env: - GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.github/workflows/check-cargo-check-runtimes.yml b/.github/workflows/check-cargo-check-runtimes.yml new file mode 100644 index 0000000000000000000000000000000000000000..ebcf6c5fc9bd30b16d4cdfaa3d2fd8f35b9eb3e1 --- /dev/null +++ b/.github/workflows/check-cargo-check-runtimes.yml @@ -0,0 +1,136 @@ +name: Check Cargo Check Runtimes + +on: + pull_request: + types: [ opened, synchronize, reopened, ready_for_review, labeled ] + + +# Jobs in this workflow depend on each other, only for limiting peak amount of spawned workers + +jobs: + # 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. + set-image: + if: contains(github.event.label.name, 'GHA-migration') || contains(github.event.pull_request.labels.*.name, 'GHA-migration') + runs-on: ubuntu-latest + timeout-minutes: 20 + outputs: + IMAGE: ${{ steps.set_image.outputs.IMAGE }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - id: set_image + run: cat .github/env >> $GITHUB_OUTPUT + check-runtime-assets: + runs-on: arc-runners-polkadot-sdk-beefy + needs: [set-image] + timeout-minutes: 20 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/assets + + check-runtime-collectives: + runs-on: arc-runners-polkadot-sdk-beefy + needs: [check-runtime-assets, set-image] + timeout-minutes: 20 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/collectives + + check-runtime-coretime: + runs-on: arc-runners-polkadot-sdk-beefy + container: + image: ${{ needs.set-image.outputs.IMAGE }} + needs: [check-runtime-assets, set-image] + timeout-minutes: 20 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/coretime + + check-runtime-bridge-hubs: + runs-on: arc-runners-polkadot-sdk-beefy + container: + image: ${{ needs.set-image.outputs.IMAGE }} + needs: [set-image] + timeout-minutes: 20 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/bridge-hubs + + check-runtime-contracts: + runs-on: arc-runners-polkadot-sdk-beefy + container: + image: ${{ needs.set-image.outputs.IMAGE }} + needs: [check-runtime-collectives, set-image] + timeout-minutes: 20 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/contracts + + check-runtime-starters: + runs-on: arc-runners-polkadot-sdk-beefy + container: + image: ${{ needs.set-image.outputs.IMAGE }} + needs: [check-runtime-assets, set-image] + timeout-minutes: 20 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/starters + + check-runtime-testing: + runs-on: arc-runners-polkadot-sdk-beefy + container: + image: ${{ needs.set-image.outputs.IMAGE }} + needs: [check-runtime-starters, set-image] + timeout-minutes: 20 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Run cargo check + uses: ./.github/actions/cargo-check-runtimes + with: + root: cumulus/parachains/runtimes/testing + + confirm-required-jobs-passed: + runs-on: ubuntu-latest + name: All check-runtime-* tests passed + # If any new job gets added, be sure to add it to this array + needs: + - check-runtime-assets + - check-runtime-collectives + - check-runtime-coretime + - check-runtime-bridge-hubs + - check-runtime-contracts + - check-runtime-starters + - check-runtime-testing + steps: + - run: echo '### Good job! All the tests passed 🚀' >> $GITHUB_STEP_SUMMARY diff --git a/.github/workflows/check-features.yml b/.github/workflows/check-features.yml index 53d6ac6b4dbfd7e3ccf1ca09ad9e1e70a49a9ff9..d34b3d52c5332b61d9a90dc03de938f154de5c7e 100644 --- a/.github/workflows/check-features.yml +++ b/.github/workflows/check-features.yml @@ -13,7 +13,7 @@ jobs: - name: Check uses: hack-ink/cargo-featalign-action@bea88a864d6ca7d0c53c26f1391ce1d431dc7f34 # v0.1.1 with: - crate: substrate/bin/node/runtime + crate: templates/parachain/runtime/ features: std,runtime-benchmarks,try-runtime ignore: sc-executor default-std: true diff --git a/.github/workflows/check-frame-omni-bencher.yml b/.github/workflows/check-frame-omni-bencher.yml new file mode 100644 index 0000000000000000000000000000000000000000..e9db2d9129797b1707a273122c5edf19542f9381 --- /dev/null +++ b/.github/workflows/check-frame-omni-bencher.yml @@ -0,0 +1,85 @@ +name: Short benchmarks (frame-omni-bencher) + +on: + push: + branches: + - master + pull_request: + types: [ opened, synchronize, reopened, ready_for_review, labeled ] + merge_group: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +env: + ARTIFACTS_NAME: frame-omni-bencher-artifacts + +jobs: + changes: + # TODO: remove once migration is complete or this workflow is fully stable + if: contains(github.event.label.name, 'GHA-migration') + 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 + needs: changes + if: ${{ needs.changes.outputs.rust }} + outputs: + IMAGE: ${{ steps.set_image.outputs.IMAGE }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - id: set_image + run: cat .github/env >> $GITHUB_OUTPUT + + run-frame-omni-bencher: + runs-on: arc-runners-polkadot-sdk-beefy + needs: [ set-image, changes ] # , build-frame-omni-bencher ] + if: ${{ needs.changes.outputs.rust }} + timeout-minutes: 30 + strategy: + fail-fast: false # keep running other workflows even if one fails, to see the logs of all possible failures + matrix: + runtime: + [ + westend-runtime, + rococo-runtime, + asset-hub-rococo-runtime, + asset-hub-westend-runtime, + bridge-hub-rococo-runtime, + bridge-hub-westend-runtime, + collectives-westend-runtime, + coretime-rococo-runtime, + coretime-westend-runtime, + people-rococo-runtime, + people-westend-runtime, + glutton-westend-runtime, + ] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + PACKAGE_NAME: ${{ matrix.runtime }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: script + run: | + RUNTIME_BLOB_NAME=$(echo $PACKAGE_NAME | sed 's/-/_/g').compact.compressed.wasm + RUNTIME_BLOB_PATH=./target/release/wbuild/$PACKAGE_NAME/$RUNTIME_BLOB_NAME + forklift cargo build --release --locked -p $PACKAGE_NAME -p frame-omni-bencher --features runtime-benchmarks + echo "Running short benchmarking for PACKAGE_NAME=$PACKAGE_NAME and RUNTIME_BLOB_PATH=$RUNTIME_BLOB_PATH" + ls -lrt $RUNTIME_BLOB_PATH + ./target/release/frame-omni-bencher v1 benchmark pallet --runtime $RUNTIME_BLOB_PATH --all --steps 2 --repeat 1 + confirm-frame-omni-benchers-passed: + runs-on: ubuntu-latest + name: All benchmarks passed + needs: run-frame-omni-bencher + steps: + - run: echo '### Good job! All the benchmarks passed 🚀' >> $GITHUB_STEP_SUMMARY diff --git a/.github/workflows/check-licenses.yml b/.github/workflows/check-licenses.yml index c32b6fcf89e06bb56cefc0517e1dcab1d1ef0f37..a74986048976ecc0974285da3f14a9f8ee2b683d 100644 --- a/.github/workflows/check-licenses.yml +++ b/.github/workflows/check-licenses.yml @@ -10,13 +10,14 @@ permissions: jobs: check-licenses: runs-on: ubuntu-latest + timeout-minutes: 10 env: LICENSES: "'Apache-2.0' 'GPL-3.0-only' 'GPL-3.0-or-later WITH Classpath-exception-2.0'" NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }} steps: - name: Checkout sources - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - uses: actions/setup-node@v4.0.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + - uses: actions/setup-node@v4.0.3 with: node-version: "18.x" registry-url: "https://npm.pkg.github.com" diff --git a/.github/workflows/check-links.yml b/.github/workflows/check-links.yml index 58065f369c9cf160b0b94c233df9df1016426d07..d10f34e6faef4012b6348b20400f5c304f317df4 100644 --- a/.github/workflows/check-links.yml +++ b/.github/workflows/check-links.yml @@ -18,17 +18,17 @@ jobs: runs-on: ubuntu-latest steps: - name: Restore lychee cache - uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.2 (7. Sep 2023) + uses: actions/cache@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v3.3.2 (7. Sep 2023) with: path: .lycheecache key: cache-lychee-${{ github.sha }} # This should restore from the most recent one: restore-keys: cache-lychee- - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.0 (22. Sep 2023) + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.0 (22. Sep 2023) - name: Lychee link checker - uses: lycheeverse/lychee-action@c3089c702fbb949e3f7a8122be0c33c017904f9b # for v1.9.1 (10. Jan 2024) + uses: lycheeverse/lychee-action@2b973e86fc7b1f6b36a93795fe2c9c6ae1118621 # for v1.9.1 (10. Jan 2024) with: args: >- --config .config/lychee.toml diff --git a/.github/workflows/check-markdown.yml b/.github/workflows/check-markdown.yml deleted file mode 100644 index 2b8a66db35b3adacea4f131a881103d48e3704ae..0000000000000000000000000000000000000000 --- a/.github/workflows/check-markdown.yml +++ /dev/null @@ -1,35 +0,0 @@ -name: Check Markdown - -on: - pull_request: - types: [opened, synchronize, reopened, ready_for_review] - merge_group: - -permissions: - packages: read - -jobs: - lint-markdown: - runs-on: ubuntu-latest - - steps: - - name: Checkout sources - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - - uses: actions/setup-node@v4.0.1 - with: - node-version: "18.x" - registry-url: "https://npm.pkg.github.com" - scope: "@paritytech" - - - name: Install tooling - run: | - npm install -g markdownlint-cli - markdownlint --version - - - name: Check Markdown - env: - CONFIG: .github/.markdownlint.yaml - run: | - echo "Checking markdown formatting. More info: docs/contributor/markdown_linting.md" - markdownlint --config "$CONFIG" --ignore target . diff --git a/.github/workflows/check-prdoc.yml b/.github/workflows/check-prdoc.yml index c31dee06ec54a0154efc3ad46ff24c79de4d0d7b..69311c41dd6f11800b7a0c23e9f7ab8416e80178 100644 --- a/.github/workflows/check-prdoc.yml +++ b/.github/workflows/check-prdoc.yml @@ -6,7 +6,7 @@ on: merge_group: env: - IMAGE: docker.io/paritytech/prdoc:v0.0.7 + IMAGE: docker.io/paritytech/prdoc:v0.0.8 API_BASE: https://api.github.com/repos REPO: ${{ github.repository }} GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} @@ -20,7 +20,7 @@ jobs: if: github.event.pull_request.number != '' steps: - name: Checkout repo - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 #v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 #v4.1.7 # we cannot show the version in this step (ie before checking out the repo) # due to https://github.com/paritytech/prdoc/issues/15 - name: Check if PRdoc is required diff --git a/.github/workflows/check-runtime-migration.yml b/.github/workflows/check-runtime-migration.yml new file mode 100644 index 0000000000000000000000000000000000000000..b93a07bf61f1152e05df493fa9dc6d8b3f675a68 --- /dev/null +++ b/.github/workflows/check-runtime-migration.yml @@ -0,0 +1,166 @@ +name: check-runtime-migration + +on: + push: + branches: + - master + pull_request: + types: [opened, synchronize, reopened, ready_for_review] + # Take a snapshot at 5am when most SDK devs are not working. + schedule: + - cron: "0 5 * * *" + merge_group: + workflow_dispatch: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +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. + 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 + # More info can be found here: https://github.com/paritytech/polkadot/pull/5865 + check-runtime-migration: + runs-on: ${{ needs.set-image.outputs.RUNNER }} + # We need to set this to rather long to allow the snapshot to be created, but the average time + # should be much lower. + timeout-minutes: 60 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + strategy: + fail-fast: false + matrix: + network: + [ + westend, + rococo, + asset-hub-westend, + asset-hub-rococo, + bridge-hub-westend, + bridge-hub-rococo, + contracts-rococo, + collectives-westend, + coretime-rococo, + ] + include: + - network: westend + package: westend-runtime + wasm: westend_runtime.compact.compressed.wasm + uri: "wss://try-runtime-westend.polkadot.io:443" + subcommand_extra_args: "--no-weight-warnings" + command_extra_args: "" + - network: rococo + package: rococo-runtime + wasm: rococo_runtime.compact.compressed.wasm + uri: "wss://try-runtime-rococo.polkadot.io:443" + subcommand_extra_args: "--no-weight-warnings" + command_extra_args: "" + - network: asset-hub-westend + package: asset-hub-westend-runtime + wasm: asset_hub_westend_runtime.compact.compressed.wasm + uri: "wss://westend-asset-hub-rpc.polkadot.io:443" + subcommand_extra_args: "" + command_extra_args: "" + - network: "asset-hub-rococo" + package: "asset-hub-rococo-runtime" + wasm: "asset_hub_rococo_runtime.compact.compressed.wasm" + uri: "wss://rococo-asset-hub-rpc.polkadot.io:443" + subcommand_extra_args: "" + command_extra_args: "" + - network: "bridge-hub-westend" + package: "bridge-hub-westend-runtime" + wasm: "bridge_hub_westend_runtime.compact.compressed.wasm" + uri: "wss://westend-bridge-hub-rpc.polkadot.io:443" + - network: "bridge-hub-rococo" + package: "bridge-hub-rococo-runtime" + wasm: "bridge_hub_rococo_runtime.compact.compressed.wasm" + uri: "wss://rococo-bridge-hub-rpc.polkadot.io:443" + - network: "contracts-rococo" + package: "contracts-rococo-runtime" + wasm: "contracts_rococo_runtime.compact.compressed.wasm" + uri: "wss://rococo-contracts-rpc.polkadot.io:443" + - network: "collectives-westend" + package: "collectives-westend-runtime" + wasm: "collectives_westend_runtime.compact.compressed.wasm" + uri: "wss://westend-collectives-rpc.polkadot.io:443" + command_extra_args: "--disable-spec-name-check" + - network: "coretime-rococo" + package: "coretime-rococo-runtime" + wasm: "coretime_rococo_runtime.compact.compressed.wasm" + uri: "wss://rococo-coretime-rpc.polkadot.io:443" + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Download CLI + run: | + curl -sL https://github.com/paritytech/try-runtime-cli/releases/download/v0.7.0/try-runtime-x86_64-unknown-linux-musl -o try-runtime + chmod +x ./try-runtime + echo "Using try-runtime-cli version:" + ./try-runtime --version + + - name: Get Date + id: get-date + run: | + echo "today=$(/bin/date -u "+%Y%m%d")" >> $GITHUB_OUTPUT + shell: bash + + - name: Download Snapshot + uses: actions/cache@v4 + with: + path: snapshot.raw + key: try-runtime-snapshot-${{ matrix.network }}-${{ steps.get-date.outputs.today }} + save-always: true + + - name: Create Snapshot If Stale + if: ${{ hashFiles('snapshot.raw') == '' }} + run: | + echo "Creating new snapshot for today (${{ steps.get-date.outputs.today }})" + ./try-runtime create-snapshot --uri ${{ matrix.uri }} snapshot.raw + + - name: Build Runtime + run: | + echo "---------- Building ${{ matrix.package }} runtime ----------" + time forklift cargo build --release --locked -p ${{ matrix.package }} --features try-runtime -q + + - name: Run Check + run: | + echo "Running ${{ matrix.network }} runtime migration check" + export RUST_LOG=remote-ext=debug,runtime=debug + + echo "---------- Executing on-runtime-upgrade for ${{ matrix.network }} ----------" + time ./try-runtime ${{ matrix.command_extra_args }} \ + --runtime ./target/release/wbuild/${{ matrix.package }}/${{ matrix.wasm }} \ + on-runtime-upgrade --disable-spec-version-check --checks=all ${{ matrix.subcommand_extra_args }} snap -p snapshot.raw + sleep 5 + # 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 runtime migrations passed + # If any new job gets added, be sure to add it to this array + needs: [check-runtime-migration] + steps: + - run: echo '### Good job! All the checks passed 🚀' >> $GITHUB_STEP_SUMMARY diff --git a/.github/workflows/check-semver.yml b/.github/workflows/check-semver.yml index f0e076e8a1683a0cb5a46aa9010ec9bd3d1bc898..15eb32f4062cfaa0a18125117c8015f0e57f05bb 100644 --- a/.github/workflows/check-semver.yml +++ b/.github/workflows/check-semver.yml @@ -3,8 +3,14 @@ name: Check semver on: pull_request: types: [opened, synchronize, reopened, ready_for_review] - paths: - - prdoc/*.prdoc + workflow_dispatch: + +concurrency: + group: check-semver-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +env: + TOOLCHAIN: nightly-2024-06-01 jobs: check-semver: @@ -12,7 +18,48 @@ jobs: container: image: docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v20240408 steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + with: + fetch-depth: 2 + + - name: extra git setup + run: | + git config --global --add safe.directory '*' + + git branch old HEAD^1 + + - name: Comment If Backport + if: ${{ startsWith(github.event.pull_request.base.ref, 'stable') }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + PR: ${{ github.event.pull_request.number }} + run: | + echo "This is a backport into stable." + + wget -q https://github.com/cli/cli/releases/download/v2.51.0/gh_2.51.0_linux_amd64.tar.gz -O gh.tar.gz && \ + tar -xzf gh.tar.gz && mv gh_2.51.0_linux_amd64/bin/gh /usr/local/bin/gh && rm gh.tar.gz + chmod +x /usr/local/bin/gh + + cat > msg.txt <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,24 +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' - if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc --toolchain nightly-2024-03-01 -v; then + export SKIP_WASM_BUILD=1 + + if ! parity-publish --color always prdoc --since old --validate prdoc/pr_$PR.prdoc $PRDOC_EXTRA_ARGS -v --toolchain $TOOLCHAIN; then + cat < - python3 .github/scripts/check-workspace.py . - --exclude - "substrate/frame/contracts/fixtures/build" - "substrate/frame/contracts/fixtures/contracts/common" diff --git a/.github/workflows/checks-quick.yml b/.github/workflows/checks-quick.yml new file mode 100644 index 0000000000000000000000000000000000000000..ee5ac31e9caad1a4b0917b47bc929c40d3d87dfb --- /dev/null +++ b/.github/workflows/checks-quick.yml @@ -0,0 +1,183 @@ +# Checks that doesn't require heavy lifting, like formatting, linting, etc. +name: quick-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: + 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 + timeout-minutes: 20 + outputs: + IMAGE: ${{ steps.set_image.outputs.IMAGE }} + steps: + - name: Checkout + uses: actions/checkout@v4 + - id: set_image + run: cat .github/env >> $GITHUB_OUTPUT + fmt: + runs-on: ubuntu-latest + timeout-minutes: 20 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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: 20 + steps: + - 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: 20 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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 --version + time zepter run check + test-rust-features: + runs-on: ubuntu-latest + timeout-minutes: 20 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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: 20 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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: 20 + steps: + - 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 + pip3 install toml "cargo-workspace>=1.2.6" + - name: check integrity + run: > + python3 .github/scripts/check-workspace.py . + --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: 20 + steps: + - name: Checkout sources + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + - name: Setup Node.js + uses: actions/setup-node@v4.0.3 + with: + node-version: "18.x" + registry-url: "https://npm.pkg.github.com" + scope: "@paritytech" + - name: Install tooling + run: | + npm install -g markdownlint-cli + markdownlint --version + - name: Check Markdown + env: + CONFIG: .github/.markdownlint.yaml + run: | + echo "Checking markdown formatting. More info: docs/contributor/markdown_linting.md" + echo "To fix potential erros, you can run 'markdownlint --config .github/.markdownlint.yaml -f --ignore target .' locally." + markdownlint --config "$CONFIG" --ignore target . + check-umbrella: + runs-on: ubuntu-latest + timeout-minutes: 20 + needs: [set-image] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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 + run: | + # Fixes "detected dubious ownership" error in the ci + git config --global --add safe.directory '*' + python3 scripts/generate-umbrella.py --sdk . --version 0.1.0 + cargo +nightly fmt --all + + if [ -n "$(git status --porcelain)" ]; then + cat <> $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..dac46cf435a670942e7d54eff0cb6e8b1170e8a8 --- /dev/null +++ b/.github/workflows/cmd.yml @@ -0,0 +1,411 @@ +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 }} + \`\`\` + +
` + }) + + - name: Add confused 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' + }) + + set-image: + 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 + outputs: + IMAGE: ${{ steps.set-image.outputs.IMAGE }} + RUNNER: ${{ steps.set-image.outputs.RUNNER }} + steps: + - name: Checkout + uses: actions/checkout@v4 + + - id: set-image + run: | + BODY=$(echo "${{ github.event.comment.body }}" | xargs) + IMAGE_OVERRIDE=$(echo $BODY | grep -oe 'docker.io/paritytech/ci-unified:.*\s' | xargs) + + cat .github/env >> $GITHUB_OUTPUT + + if [ -n "$IMAGE_OVERRIDE" ]; then + echo "IMAGE=$IMAGE_OVERRIDE" >> $GITHUB_OUTPUT + fi + + if [[ $BODY == "/cmd bench"* ]]; then + echo "RUNNER=arc-runners-polkadot-sdk-benchmark" >> $GITHUB_OUTPUT + elif [[ $BODY == "/cmd update-ui"* ]]; then + echo "RUNNER=arc-runners-polkadot-sdk-beefy" >> $GITHUB_OUTPUT + else + echo "RUNNER=ubuntu-latest" >> $GITHUB_OUTPUT + fi + + cmd: + needs: [ set-image ] + env: + JOB_NAME: 'cmd' + runs-on: ${{ needs.set-image.outputs.RUNNER }} + container: + image: ${{ needs.set-image.outputs.IMAGE }} + steps: + - 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: Build workflow link + if: ${{ !contains(github.event.comment.body, '--quiet') }} + id: build-link + run: | + # Get exactly the CMD job link, filtering out the other jobs + jobLink=$(curl -s \ + -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \ + -H "Accept: application/vnd.github.v3+json" \ + https://api.github.com/repos/${{ github.repository }}/actions/runs/${{ github.run_id }}/jobs | jq '.jobs[] | select(.name | contains("${{ env.JOB_NAME }}")) | .html_url') + + runLink=$(curl -s \ + -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \ + -H "Accept: application/vnd.github.v3+json" \ + https://api.github.com/repos/${{ github.repository }}/actions/runs/${{ github.run_id }} | jq '.html_url') + + echo "job_url=${jobLink}" + echo "run_url=${runLink}" + echo "job_url=$jobLink" >> $GITHUB_OUTPUT + echo "run_url=$runLink" >> $GITHUB_OUTPUT + + + - name: Comment PR (Start) + if: ${{ !contains(github.event.comment.body, '--quiet') }} + uses: actions/github-script@v7 + with: + github-token: ${{ secrets.GITHUB_TOKEN }} + script: | + let job_url = ${{ 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 started 🚀 [See logs here](${job_url})` + }) + + - name: Checkout + uses: actions/checkout@v4 + with: + ref: ${{ github.head_ref }} + + - name: Install dependencies for bench + if: startsWith(steps.get-pr-comment.outputs.group2, 'bench') + run: cargo install subweight frame-omni-bencher --locked + + - name: Run cmd + id: cmd + env: + CMD: ${{ steps.get-pr-comment.outputs.group2 }} # to avoid "" around the command + run: | + echo "Running command: '$CMD' on '${{ needs.set-image.outputs.RUNNER }}' runner, container: '${{ needs.set-image.outputs.IMAGE }}'" + echo "RUST_NIGHTLY_VERSION: $RUST_NIGHTLY_VERSION" + # Fixes "detected dubious ownership" error in the ci + git config --global --add safe.directory '*' + git remote -v + python3 .github/scripts/cmd/cmd.py $CMD + git status + git diff + + - name: Commit changes + run: | + if [ -n "$(git status --porcelain)" ]; then + git config --local user.email "action@github.com" + git config --local user.name "GitHub Action" + + git pull origin ${{ github.head_ref }} + git add . + git restore --staged Cargo.lock # ignore changes in Cargo.lock + git commit -m "Update from ${{ github.actor }} running command '${{ steps.get-pr-comment.outputs.group2 }}'" || true + git push origin ${{ github.head_ref }} + else + echo "Nothing to commit"; + fi + + - name: Run Subweight + id: subweight + if: startsWith(steps.get-pr-comment.outputs.group2, 'bench') + shell: bash + run: | + git fetch + result=$(subweight compare commits \ + --path-pattern "./**/weights/**/*.rs,./**/weights.rs" \ + --method asymptotic \ + --format markdown \ + --no-color \ + --change added changed \ + --ignore-errors \ + refs/remotes/origin/master ${{ github.ref }}) + + # Save the multiline result to the output + { + echo "result<> $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/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="" + docs_dir="./crate-docs" + + inject_simple_analytics() { + find "$1" -name '*.html' | xargs -I {} -P "$(nproc)" bash -c 'file="{}"; echo "Adding Simple Analytics script to $file"; sed -i "s||'"$2"'|" "$file";' + } + + inject_simple_analytics "$docs_dir" "$script_content" + - run: echo "" > ./crate-docs/index.html + - uses: actions/upload-artifact@v4 + with: + name: ${{ github.sha }}-doc + path: ./crate-docs/ + retention-days: 1 + if-no-files-found: error + + build-implementers-guide: + runs-on: ubuntu-latest + container: + image: paritytech/mdbook-utils:e14aae4a-20221123 + options: --user root + steps: + - uses: actions/checkout@v4 + - run: mdbook build ./polkadot/roadmap/implementers-guide + - run: mkdir -p artifacts + - run: mv polkadot/roadmap/implementers-guide/book artifacts/ + - uses: actions/upload-artifact@v4 + with: + name: ${{ github.sha }}-guide + path: ./artifacts/ + retention-days: 1 + if-no-files-found: error + + publish-rustdoc: + if: github.ref == 'refs/heads/master' + runs-on: ubuntu-latest + environment: subsystem-benchmarks + needs: [build-rustdoc, build-implementers-guide] + steps: + - uses: actions/checkout@v4 + with: + ref: gh-pages + - uses: actions/create-github-app-token@v1 + id: app-token + with: + app-id: ${{ secrets.POLKADOTSDK_GHPAGES_APP_ID }} + private-key: ${{ secrets.POLKADOTSDK_GHPAGES_APP_KEY }} + - name: Ensure destination dir does not exist + run: | + rm -rf book/ + rm -rf ${REF_NAME} + env: + REF_NAME: ${{ github.head_ref || github.ref_name }} + - name: Download rustdocs + uses: actions/download-artifact@v4 + with: + name: ${{ github.sha }}-doc + path: ${{ github.head_ref || github.ref_name }} + - name: Download guide + uses: actions/download-artifact@v4 + with: + name: ${{ github.sha }}-guide + path: /tmp + - run: mkdir -p book + - name: Move book files + run: mv /tmp/book/html/* book/ + - name: Push to GH-Pages branch + uses: github-actions-x/commit@v2.9 + with: + github-token: ${{ steps.app-token.outputs.token }} + push-branch: "gh-pages" + commit-message: "___Updated docs for ${{ github.head_ref || github.ref_name }}___" + force-add: "true" + files: ${{ github.head_ref || github.ref_name }}/ book/ + name: devops-parity + email: devops-team@parity.io diff --git a/.github/workflows/fmt-check.yml b/.github/workflows/fmt-check.yml deleted file mode 100644 index 324c9bfff7a54cf594726328097f88bb23c9d951..0000000000000000000000000000000000000000 --- a/.github/workflows/fmt-check.yml +++ /dev/null @@ -1,23 +0,0 @@ -name: Rustfmt check - -on: - push: - branches: - - master - pull_request: - types: [opened, synchronize, reopened, ready_for_review] - merge_group: - -jobs: - quick_check: - strategy: - matrix: - os: ["ubuntu-latest"] - runs-on: ${{ matrix.os }} - container: - image: docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v20240408 - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - - name: Cargo fmt - run: cargo +nightly fmt --all -- --check diff --git a/.github/workflows/fork-sync-action.yml b/.github/workflows/fork-sync-action.yml new file mode 100644 index 0000000000000000000000000000000000000000..69e9e93bf54b023330232c0fe5df0430832a6e2b --- /dev/null +++ b/.github/workflows/fork-sync-action.yml @@ -0,0 +1,20 @@ +# This Workflow is not supposed to run in the paritytech/polkadot-sdk repo. +# This Workflow is supposed to run only in the forks of the repo, +# paritytech-release/polkadot-sdk specifically, +# to automatically maintain the critical fork synced with the upstream. +# This Workflow should be always disabled in the paritytech/polkadot-sdk repo. + +name: Sync the forked repo with the upstream +on: + schedule: + - cron: "0 0/4 * * *" + workflow_dispatch: + +jobs: + job_sync_branches: + uses: paritytech-release/sync-workflows/.github/workflows/sync-with-upstream.yml@latest + with: + fork_writer_app_id: ${{ vars.UPSTREAM_CONTENT_SYNC_APP_ID}} + fork_owner: ${{ vars.RELEASE_ORG}} + secrets: + fork_writer_app_key: ${{ secrets.UPSTREAM_CONTENT_SYNC_APP_KEY }} diff --git a/.github/workflows/auto-add-parachain-issues.yml b/.github/workflows/issues-auto-add-parachain.yml similarity index 100% rename from .github/workflows/auto-add-parachain-issues.yml rename to .github/workflows/issues-auto-add-parachain.yml diff --git a/.github/workflows/auto-label-issues.yml b/.github/workflows/issues-auto-label.yml similarity index 100% rename from .github/workflows/auto-label-issues.yml rename to .github/workflows/issues-auto-label.yml diff --git a/.github/workflows/notif-burnin-label.yml b/.github/workflows/misc-notify-burnin-label.yml similarity index 100% rename from .github/workflows/notif-burnin-label.yml rename to .github/workflows/misc-notify-burnin-label.yml diff --git a/.github/workflows/merge-queue.yml b/.github/workflows/misc-review-bot-merge-queue.yml similarity index 79% rename from .github/workflows/merge-queue.yml rename to .github/workflows/misc-review-bot-merge-queue.yml index cce326f44931bed8357fb661c8b053f60205f119..28b3bc7533c054d645c3b922e5a6e7e2f298b0be 100644 --- a/.github/workflows/merge-queue.yml +++ b/.github/workflows/misc-review-bot-merge-queue.yml @@ -1,3 +1,4 @@ +# Actions that makes review-bot green in the merge queue name: Merge-Queue on: @@ -18,7 +19,7 @@ jobs: uses: billyjbryant/create-status-check@3e6fa0ac599d10d9588cf9516ca4330ef669b858 # v2 with: authToken: ${{ steps.app_token.outputs.token }} - context: 'review-bot' - description: 'PRs for merge queue gets approved' - state: 'success' + context: "review-bot" + description: "PRs for merge queue gets approved" + state: "success" sha: ${{ github.event.merge_group.head_commit.id }} diff --git a/.github/workflows/sync-templates.yml b/.github/workflows/misc-sync-templates.yml similarity index 69% rename from .github/workflows/sync-templates.yml rename to .github/workflows/misc-sync-templates.yml index 3617d6c34a3e342e1abd52acaffbf3a8c61ec43b..c06beb5e98eb7772f8f364c3a8a4121d40b7e522 100644 --- a/.github/workflows/sync-templates.yml +++ b/.github/workflows/misc-sync-templates.yml @@ -18,11 +18,10 @@ on: # A manual dispatch for now - automatic on releases later. workflow_dispatch: inputs: - crate_release_version: - description: 'A release version to use, e.g. 1.9.0' + stable_release_branch: + description: 'Stable release branch, e.g. stable2407' required: true - jobs: sync-templates: runs-on: ubuntu-latest @@ -41,10 +40,10 @@ jobs: run: | git config --global user.name "Template Bot" git config --global user.email "163342540+paritytech-polkadotsdk-templatebot[bot]@users.noreply.github.com" - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: path: polkadot-sdk - ref: "release-crates-io-v${{ github.event.inputs.crate_release_version }}" + ref: "${{ github.event.inputs.stable_release_branch }}" - name: Generate a token for the template repository id: app_token uses: actions/create-github-app-token@v1.9.3 @@ -53,7 +52,7 @@ jobs: repositories: "polkadot-sdk-${{ matrix.template }}-template" app-id: ${{ secrets.TEMPLATE_APP_ID }} private-key: ${{ secrets.TEMPLATE_APP_KEY }} - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 with: repository: "paritytech/polkadot-sdk-${{ matrix.template }}-template" path: "${{ env.template-path }}" @@ -69,11 +68,11 @@ jobs: protobuf-compiler rustup target add wasm32-unknown-unknown rustup component add rustfmt clippy rust-src - + # 2. Yanking the template out of the monorepo workspace. - - name: Use psvm to replace git references with released creates. - run: find . -type f -name 'Cargo.toml' -exec psvm -o -v ${{ github.event.inputs.crate_release_version }} -p {} \; + - name: Replace dev-dependencies path references with workspace references + run: find . -type f -name 'Cargo.toml' -exec sed -i'' -E "s/path = \"\.\.\/.*\"/workspace = true/g" {} \; working-directory: polkadot-sdk/templates/${{ matrix.template }}/ - name: Create a new workspace Cargo.toml run: | @@ -81,7 +80,7 @@ jobs: [workspace.package] license = "MIT-0" authors = ["Parity Technologies "] - 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 @@ -104,10 +108,6 @@ jobs: toml set templates/${{ matrix.template }}/Cargo.toml 'workspace.package.edition' "$(toml get --raw Cargo.toml 'workspace.package.edition')" > Cargo.temp mv Cargo.temp ./templates/${{ matrix.template }}/Cargo.toml - - toml get Cargo.toml 'workspace.lints' --output-toml >> ./templates/${{ matrix.template }}/Cargo.toml - - toml get Cargo.toml 'workspace.dependencies' --output-toml >> ./templates/${{ matrix.template }}/Cargo.toml working-directory: polkadot-sdk - name: Print the result Cargo.tomls for debugging if: runner.debug == '1' @@ -121,6 +121,21 @@ jobs: 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: | + 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 + # Get its name.. + missing_dep=$(cargo tree --depth 1 --prefix none --no-dedupe 2>&1 | grep 'was not found in `workspace.dependencies`' | sed -E 's/(.*)`dependency.(.*)` was not found in `workspace.dependencies`/\2/') + # And copy the dependency from the monorepo. + toml get ../polkadot-sdk/Cargo.toml 'workspace.dependencies' --output-toml | grep "^${missing_dep} = " >> Cargo.toml + done; + working-directory: "${{ env.template-path }}" + # 3. Verify the build. Push the changes or create a PR. # We've run into out-of-disk error when compiling in the next step, so we free up some space this way. @@ -142,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" + 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_name }}" - - name: Push changes - run: | - git add -A . - git commit --allow-empty -m "Update template 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/check-publish.yml b/.github/workflows/publish-check-crates.yml similarity index 80% rename from .github/workflows/check-publish.yml rename to .github/workflows/publish-check-crates.yml index 9b5b89e34475699ccbcaeca34cd290882ee45a9a..9f96b92e0ce73eb1874ff7e11c9e43d820eaa649 100644 --- a/.github/workflows/check-publish.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/claim-crates.yml b/.github/workflows/publish-claim-crates.yml similarity index 80% rename from .github/workflows/claim-crates.yml rename to .github/workflows/publish-claim-crates.yml index 9643361d9d318f84d64a212358a825a8e0b5aa20..bee709a12076ed4a5ff212796f7691650f32ad7f 100644 --- a/.github/workflows/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 new file mode 100644 index 0000000000000000000000000000000000000000..e5b9db0836f3f6a944778a30df49ea7f98b3af34 --- /dev/null +++ b/.github/workflows/publish-subsystem-benchmarks.yml @@ -0,0 +1,55 @@ +# The actions takes json file as input and runs github-action-benchmark for it. + +on: + workflow_dispatch: + inputs: + benchmark-data-dir-path: + description: "Path to the benchmark data directory" + required: true + type: string + output-file-path: + description: "Path to the benchmark data file" + required: true + type: string + +jobs: + subsystem-benchmarks: + runs-on: ubuntu-latest + environment: subsystem-benchmarks + steps: + - name: Validate inputs + run: | + echo "${{ github.event.inputs.benchmark-data-dir-path }}" | grep -P '^[a-z\-]' + echo "${{ github.event.inputs.output-file-path }}" | grep -P '^[a-z\-]+\.json' + + - name: Checkout Sources + uses: actions/checkout@v4 + with: + fetch-depth: 0 + ref: "gh-pages" + + - name: Copy bench results + id: step_one + run: | + cp bench/gitlab/${{ github.event.inputs.output-file-path }} ${{ github.event.inputs.output-file-path }} + + - name: Switch branch + id: step_two + run: | + git checkout master -- + + - uses: actions/create-github-app-token@v1 + id: app-token + with: + app-id: ${{ secrets.POLKADOTSDK_GHPAGES_APP_ID }} + private-key: ${{ secrets.POLKADOTSDK_GHPAGES_APP_KEY }} + + - name: Store benchmark result + uses: benchmark-action/github-action-benchmark@v1 + with: + tool: "customSmallerIsBetter" + name: ${{ github.event.inputs.benchmark-data-dir-path }} + output-file-path: ${{ github.event.inputs.output-file-path }} + benchmark-data-dir-path: "bench/${{ github.event.inputs.benchmark-data-dir-path }}" + github-token: ${{ steps.app-token.outputs.token }} + auto-push: true diff --git a/.github/workflows/quick-checks.yml b/.github/workflows/quick-checks.yml deleted file mode 100644 index 7bf1983a1f69c4de2d6611f0023216eaf2f55466..0000000000000000000000000000000000000000 --- a/.github/workflows/quick-checks.yml +++ /dev/null @@ -1,81 +0,0 @@ -# Checks that doesn't require heavy lifting, like formatting, linting, etc. -name: quick-checks - -on: - 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 - -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. - runs-on: arc-runners-polkadot-sdk-default - timeout-minutes: 10 - outputs: - IMAGE: ${{ steps.set_image.outputs.IMAGE }} - steps: - - name: Checkout - uses: actions/checkout@v4 - - id: set_image - run: cat .github/env >> $GITHUB_OUTPUT - fmt: - runs-on: arc-runners-polkadot-sdk-default - timeout-minutes: 10 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - name: Cargo fmt - run: cargo +nightly fmt --all -- --check - check-dependency-rules: - runs-on: arc-runners-polkadot-sdk-default - timeout-minutes: 10 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - name: check dependency rules - run: | - cd substrate/ - ../.gitlab/ensure-deps.sh - check-rust-feature-propagation: - runs-on: arc-runners-polkadot-sdk-default - # runs-on: ubuntu-latest - timeout-minutes: 10 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - name: run zepter - run: zepter run check - test-rust-features: - runs-on: arc-runners-polkadot-sdk-default - # runs-on: ubuntu-latest - timeout-minutes: 10 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - name: run rust features - run: bash .gitlab/rust-features.sh . - check-toml-format: - runs-on: arc-runners-polkadot-sdk-default - timeout-minutes: 10 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - steps: - - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - - 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" 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.
+ Release process for polkadot ${{ steps.compute_tag.outputs.new_tag }} has been started.
diff --git a/.github/workflows/release-30_publish_release_draft.yml b/.github/workflows/release-30_publish_release_draft.yml index a9e521051d04079a49af76c78681af8ae52ae5da..4343dbf915a9809996274dec48c27b40140170b2 100644 --- a/.github/workflows/release-30_publish_release_draft.yml +++ b/.github/workflows/release-30_publish_release_draft.yml @@ -23,19 +23,50 @@ jobs: echo "stable=$RUST_STABLE_VERSION" >> $GITHUB_OUTPUT build-runtimes: - uses: "./.github/workflows/srtool.yml" + uses: "./.github/workflows/release-srtool.yml" with: excluded_runtimes: "substrate-test bp cumulus-test kitchensink minimal-template parachain-template penpal polkadot-test seedling shell frame-try sp solochain-template" + build_opts: "--features on-chain-release-build" + + build-binaries: + runs-on: ubuntu-latest + strategy: + matrix: + # Tuples of [package, binary-name] + binary: [ [frame-omni-bencher, frame-omni-bencher], [staging-chain-spec-builder, chain-spec-builder] ] + steps: + - name: Checkout sources + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.0.0 + + - name: Install protobuf-compiler + run: | + sudo apt update + sudo apt install -y protobuf-compiler + + - name: Build ${{ matrix.binary[1] }} binary + run: | + cargo build --locked --profile=production -p ${{ matrix.binary[0] }} --bin ${{ matrix.binary[1] }} + target/production/${{ matrix.binary[1] }} --version + + - name: Upload ${{ matrix.binary[1] }} binary + uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1 + with: + name: ${{ matrix.binary[1] }} + path: target/production/${{ matrix.binary[1] }} + publish-release-draft: runs-on: ubuntu-latest - needs: [get-rust-versions, build-runtimes] + needs: [ get-rust-versions, build-runtimes ] outputs: release_url: ${{ steps.create-release.outputs.html_url }} asset_upload_url: ${{ steps.create-release.outputs.upload_url }} steps: - name: Checkout - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.0.0 + + - name: Download artifacts + uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8 - name: Prepare tooling run: | @@ -43,9 +74,6 @@ jobs: wget $URL -O tera.deb sudo dpkg -i tera.deb - - name: Download artifacts - uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4 - - name: Prepare draft id: draft env: @@ -106,10 +134,10 @@ jobs: steps: - name: Checkout sources - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.0.0 - name: Download artifacts - uses: actions/download-artifact@c850b930e6ba138125429b7e5c93fc707a7f8427 # v4.1.4 + uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8 - name: Get runtime info env: @@ -129,6 +157,30 @@ jobs: asset_name: ${{ matrix.chain }}_runtime-v${{ env.SPEC }}.compact.compressed.wasm asset_content_type: application/wasm + publish-binaries: + needs: [ publish-release-draft, build-binaries ] + continue-on-error: true + runs-on: ubuntu-latest + strategy: + matrix: + binary: [frame-omni-bencher, chain-spec-builder] + + steps: + - name: Download artifacts + uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8 + with: + name: ${{ matrix.binary }} + + - name: Upload ${{ matrix.binary }} binary + uses: actions/upload-release-asset@e8f9f06c4b078e705bd2ea027f0926603fc9b4d5 #v1.0.2 + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + with: + upload_url: ${{ needs.publish-release-draft.outputs.asset_upload_url }} + asset_path: ${{ github.workspace}}/${{ matrix.binary }} + asset_name: ${{ matrix.binary }} + asset_content_type: application/octet-stream + post_to_matrix: runs-on: ubuntu-latest needs: publish-release-draft diff --git a/.github/workflows/release-50_publish-docker.yml b/.github/workflows/release-50_publish-docker.yml index 67e93ee96574de1f1e3e29f1bf6d90085865100d..c5d214ec68abac781b9b350897ae8267d1740e04 100644 --- a/.github/workflows/release-50_publish-docker.yml +++ b/.github/workflows/release-50_publish-docker.yml @@ -27,6 +27,7 @@ on: options: - polkadot - polkadot-parachain + - chain-spec-builder release_id: description: | @@ -44,7 +45,7 @@ on: type: string default: docker.io - # The owner is often the same than the Docker Hub username but does ont have to be. + # The owner is often the same as the Docker Hub username but does ont have to be. # In our case, it is not. owner: description: Owner of the container image repo @@ -57,6 +58,10 @@ on: default: v0.9.18 required: true + stable_tag: + description: Tag matching the actual stable release version in the format stableYYMM or stableYYMM-X for patch releases + required: true + permissions: contents: write @@ -70,16 +75,43 @@ env: # EVENT_ACTION: ${{ github.event.action }} EVENT_NAME: ${{ github.event_name }} IMAGE_TYPE: ${{ inputs.image_type }} - VERSION: ${{ inputs.version }} jobs: + validate-inputs: + runs-on: ubuntu-latest + outputs: + version: ${{ steps.validate_inputs.outputs.VERSION }} + release_id: ${{ steps.validate_inputs.outputs.RELEASE_ID }} + stable_tag: ${{ steps.validate_inputs.outputs.stable_tag }} + + steps: + - name: Checkout sources + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + + - name: Validate inputs + id: validate_inputs + run: | + . ./.github/scripts/common/lib.sh + + VERSION=$(filter_version_from_input "${{ inputs.version }}") + echo "VERSION=${VERSION}" >> $GITHUB_OUTPUT + + RELEASE_ID=$(check_release_id "${{ inputs.release_id }}") + echo "RELEASE_ID=${RELEASE_ID}" >> $GITHUB_OUTPUT + + echo "Release ID: $RELEASE_ID" + + STABLE_TAG=$(validate_stable_tag ${{ inputs.stable_tag }}) + echo "stable_tag=${STABLE_TAG}" >> $GITHUB_OUTPUT + fetch-artifacts: # this job will be triggered for the polkadot-parachain rc and release or polkadot rc image build - if: ${{ inputs.binary == 'polkadot-parachain' || inputs.image_type == 'rc' }} + if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'chain-spec-builder' || inputs.image_type == 'rc' }} runs-on: ubuntu-latest + needs: [validate-inputs] steps: - name: Checkout sources - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 #TODO: this step will be needed when automated triggering will work #this step runs only if the workflow is triggered automatically when new release is published @@ -97,52 +129,55 @@ jobs: - name: Fetch rc artifacts or release artifacts from s3 based on version #this step runs only if the workflow is triggered manually - if: ${{ env.EVENT_NAME == 'workflow_dispatch' }} + if: ${{ env.EVENT_NAME == 'workflow_dispatch' && inputs.binary != 'chain-spec-builder'}} run: | . ./.github/scripts/common/lib.sh - VERSION=$(filter_version_from_input "${{ inputs.version }}") - echo "VERSION=${VERSION}" >> $GITHUB_ENV - + VERSION="${{ needs.validate-inputs.outputs.VERSION }}" fetch_release_artifacts_from_s3 - - name: Cache the artifacts - uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.3 + - name: Fetch chain-spec-builder rc artifacts or release artifacts based on release id + #this step runs only if the workflow is triggered manually and only for chain-spec-builder + if: ${{ env.EVENT_NAME == 'workflow_dispatch' && inputs.binary == 'chain-spec-builder' }} + run: | + . ./.github/scripts/common/lib.sh + + RELEASE_ID="${{ needs.validate-inputs.outputs.RELEASE_ID }}" + fetch_release_artifacts + + - name: Upload artifacts + uses: actions/upload-artifact@5d5d22a31266ced268874388b861e4b58bb5c2f3 # v4.3.1 with: - key: artifacts-${{ env.BINARY }}-${{ github.sha }} - path: | - ./release-artifacts/${{ env.BINARY }}/**/* + name: release-artifacts + path: release-artifacts/${{ env.BINARY }}/**/* build-container: # this job will be triggered for the polkadot-parachain rc and release or polkadot rc image build - if: ${{ inputs.binary == 'polkadot-parachain' || inputs.image_type == 'rc' }} + if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'chain-spec-builder' || inputs.image_type == 'rc' }} runs-on: ubuntu-latest - needs: fetch-artifacts + needs: [fetch-artifacts, validate-inputs] environment: release steps: - name: Checkout sources - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 - - name: Get artifacts from cache - uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.3 - with: - key: artifacts-${{ env.BINARY }}-${{ github.sha }} - fail-on-cache-miss: true - path: | - ./release-artifacts/${{ env.BINARY }}/**/* + - name: Download artifacts + uses: actions/download-artifact@fa0a91b85d4f404e444e00e005971372dc801d16 # v4.1.8 - name: Check sha256 ${{ env.BINARY }} - working-directory: ./release-artifacts/${{ env.BINARY }} + if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'polkadot' }} + working-directory: release-artifacts run: | - . ../../.github/scripts/common/lib.sh + . ../.github/scripts/common/lib.sh echo "Checking binary $BINARY" check_sha256 $BINARY && echo "OK" || echo "ERR" - name: Check GPG ${{ env.BINARY }} - working-directory: ./release-artifacts/${{ env.BINARY }} + if: ${{ inputs.binary == 'polkadot-parachain' || inputs.binary == 'polkadot' }} + working-directory: release-artifacts run: | - . ../../.github/scripts/common/lib.sh + . ../.github/scripts/common/lib.sh import_gpg_keys check_gpg $BINARY @@ -152,8 +187,7 @@ jobs: run: | . ./.github/scripts/common/lib.sh - RELEASE_ID=$(check_release_id "${{ inputs.release_id }}") - release=release-$RELEASE_ID && \ + release="release-${{ needs.validate-inputs.outputs.RELEASE_ID }}" && \ echo "release=${release}" >> $GITHUB_OUTPUT commit=$(git rev-parse --short HEAD) && \ @@ -164,20 +198,27 @@ jobs: echo "No tag, doing without" - name: Fetch release tags - working-directory: ./release-artifacts/${{ env.BINARY }} + working-directory: release-artifacts if: ${{ env.IMAGE_TYPE == 'release'}} id: fetch_release_refs run: | chmod a+rx $BINARY - VERSION=$(./$BINARY --version | awk '{ print $2 }' ) - release=$( echo $VERSION | cut -f1 -d- ) + + if [[ $BINARY != 'chain-spec-builder' ]]; then + VERSION=$(./$BINARY --version | awk '{ print $2 }' ) + release=$( echo $VERSION | cut -f1 -d- ) + else + release=$(echo ${{ needs.validate-inputs.outputs.VERSION }} | sed 's/^v//') + fi + echo "tag=latest" >> $GITHUB_OUTPUT echo "release=${release}" >> $GITHUB_OUTPUT + echo "stable=${{ needs.validate-inputs.outputs.stable_tag }}" >> $GITHUB_OUTPUT - - name: Build Injected Container image for polkadot rc - if: ${{ env.BINARY == 'polkadot' }} + - name: Build Injected Container image for polkadot rc or chain-spec-builder + if: ${{ env.BINARY == 'polkadot' || env.BINARY == 'chain-spec-builder' }} env: - ARTIFACTS_FOLDER: ./release-artifacts + ARTIFACTS_FOLDER: release-artifacts IMAGE_NAME: ${{ env.BINARY }} OWNER: ${{ env.DOCKER_OWNER }} TAGS: ${{ join(steps.fetch_rc_refs.outputs.*, ',') || join(steps.fetch_release_refs.outputs.*, ',') }} @@ -189,7 +230,7 @@ jobs: - name: Build Injected Container image for polkadot-parachain if: ${{ env.BINARY == 'polkadot-parachain' }} env: - ARTIFACTS_FOLDER: ./release-artifacts + ARTIFACTS_FOLDER: release-artifacts IMAGE_NAME: ${{ env.BINARY }} OWNER: ${{ env.DOCKER_OWNER }} DOCKERFILE: docker/dockerfiles/polkadot-parachain/polkadot-parachain_injected.Dockerfile @@ -203,7 +244,7 @@ jobs: ./docker/scripts/build-injected.sh - name: Login to Dockerhub - uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0 + uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0 with: username: ${{ secrets.CUMULUS_DOCKERHUB_USERNAME }} password: ${{ secrets.CUMULUS_DOCKERHUB_TOKEN }} @@ -219,7 +260,11 @@ jobs: RELEASE_TAG: ${{ steps.fetch_rc_refs.outputs.release || steps.fetch_release_refs.outputs.release }} run: | echo "Checking tag ${RELEASE_TAG} for image ${REGISTRY}/${DOCKER_OWNER}/${BINARY}" - $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG} --version + if [[ ${BINARY} == 'chain-spec-builder' ]]; then + $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG} + else + $ENGINE run -i ${REGISTRY}/${DOCKER_OWNER}/${BINARY}:${RELEASE_TAG} --version + fi fetch-latest-debian-package-version: # this job will be triggered for polkadot release build if: ${{ inputs.binary == 'polkadot' && inputs.image_type == 'release' }} @@ -246,17 +291,17 @@ jobs: build-polkadot-release-container: # this job will be triggered for polkadot release build if: ${{ inputs.binary == 'polkadot' && inputs.image_type == 'release' }} runs-on: ubuntu-latest - needs: fetch-latest-debian-package-version + needs: [fetch-latest-debian-package-version, validate-inputs] environment: release steps: - name: Checkout sources - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 - name: Set up Docker Buildx - uses: docker/setup-buildx-action@f95db51fddba0c2d1ec667646a06c2ce06100226 # v3.0.0 + uses: docker/setup-buildx-action@988b5a0280414f521da01fcc63a27aeeb4b104db # v3.6.1 - name: Cache Docker layers - uses: actions/cache@e12d46a63a90f2fae62d114769bbf2a179198b5c # v3.3.3 + uses: actions/cache@0c45773b623bea8c8e75f6c82b208c3cf94ea4f9 # v4.0.2 with: path: /tmp/.buildx-cache key: ${{ runner.os }}-buildx-${{ github.sha }} @@ -264,7 +309,7 @@ jobs: ${{ runner.os }}-buildx- - name: Login to Docker Hub - uses: docker/login-action@343f7c4344506bcbf9b4de18042ae17996df046d # v3.0.0 + uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3.3.0 with: username: ${{ secrets.POLKADOT_DOCKERHUB_USERNAME }} password: ${{ secrets.POLKADOT_DOCKERHUB_TOKEN }} @@ -277,13 +322,14 @@ jobs: - name: Build and push id: docker_build - uses: docker/build-push-action@4a13e500e55cf31b7a5d59a38ab2040ab0f42f56 # v5.1.0 + uses: docker/build-push-action@5cd11c3a4ced054e52742c5fd54dca954e0edd85 # v6.7.0 with: push: true file: docker/dockerfiles/polkadot/polkadot_injected_debian.Dockerfile # TODO: The owner should be used below but buildx does not resolve the VARs # TODO: It would be good to get rid of this GHA that we don't really need. tags: | + parity/polkadot:${{ needs.validate-inputs.outputs.stable_tag }} parity/polkadot:latest parity/polkadot:${{ needs.fetch-latest-debian-package-version.outputs.polkadot_container_tag }} build-args: | diff --git a/.github/workflows/check-runtimes.yml b/.github/workflows/release-check-runtimes.yml similarity index 94% rename from .github/workflows/check-runtimes.yml rename to .github/workflows/release-check-runtimes.yml index 0e5ad104766a89aaa678cc5436475d95e3ab76fd..930b8da772d0b6d19c0a723f9de09ff8fa5cd0b2 100644 --- a/.github/workflows/check-runtimes.yml +++ b/.github/workflows/release-check-runtimes.yml @@ -35,7 +35,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout the repo - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 - name: Get list id: get-list @@ -56,7 +56,7 @@ jobs: steps: - name: Checkout the repo - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 - name: Fetch release artifacts based on release id env: diff --git a/.github/workflows/release-clobber-stable.yml b/.github/workflows/release-clobber-stable.yml new file mode 100644 index 0000000000000000000000000000000000000000..50c20563b4347334aa591f0f4f2e544f17f12afe --- /dev/null +++ b/.github/workflows/release-clobber-stable.yml @@ -0,0 +1,70 @@ +name: Clobber Stable + +# This action implements the +# [Clobbering](https://github.com/paritytech/polkadot-sdk/blob/master/docs/RELEASE.md#clobbering) +# process from the release process. It pushes a new commit to the `stable` branch with all the +# current content of the `audited` tag. It does not use a merge commit, but rather 'clobbers' the +# branch with a single commit that contains all the changes. It has a naming scheme of `Clobber with +# audited ($COMMIT)`. +# Currently, the script is only triggered manually, but can be easily changed to a schedule. + +on: + workflow_dispatch: + +permissions: + contents: write + +jobs: + clobber-stable: + runs-on: ubuntu-latest + timeout-minutes: 5 + env: + STABLE: stable + UNSTABLE: master + AUDITED: audited + steps: + - name: Checkout + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.1.7 + + - name: Prechecks + run: | + # Properly fetch + git fetch --prune --unshallow origin tag $AUDITED + git fetch origin $STABLE + + # Sanity checks + git checkout -q tags/$AUDITED || (echo "Could not find the '$AUDITED' tag." && exit 1) + COMMIT=$(git rev-parse tags/$AUDITED) + #$(git branch --contains $COMMIT | grep -q $UNSTABLE) || (echo "The '$AUDITED' tag is not on the '$UNSTABLE' branch." && exit 1) + + git config --global user.email "admin@parity.io" + git config --global user.name "Parity Release Team" + + - name: Prepare commit + run: | + git checkout --quiet origin/$STABLE + + # Delete all tracked files in the working directory + git ls-files -z | xargs -0 rm -f + + # Find and delete any empty directories + find . -type d -empty -delete + + git add . 1>/dev/null 2>/dev/null + git commit -qm "Delete all files" + + # Grab the files from the commit + git checkout --quiet tags/$AUDITED -- . + + # Stage, commit, and push the working directory which now matches 'audited' 1:1 + git status + COMMIT=$(git rev-parse --short=10 tags/$AUDITED) + git add . 1>/dev/null 2>/dev/null + git commit --allow-empty --amend -qm "Clobber with $AUDITED ($COMMIT)" + + - name: Push stable branch + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + git log -3 + git push --verbose origin HEAD:$STABLE diff --git a/.github/workflows/srtool.yml b/.github/workflows/release-srtool.yml similarity index 93% rename from .github/workflows/srtool.yml rename to .github/workflows/release-srtool.yml index 95b1846b98e0c47cc6de2c92cadc16adc0cab487..262203f0500523652a9a9e38eab1a1c00bc83a4c 100644 --- a/.github/workflows/srtool.yml +++ b/.github/workflows/release-srtool.yml @@ -5,17 +5,12 @@ env: TOML_CLI_VERSION: 0.2.4 on: - push: - tags: - - "*" - branches: - - release-v[0-9]+.[0-9]+.[0-9]+* - - release-cumulus-v[0-9]+* - - release-polkadot-v[0-9]+* workflow_call: inputs: excluded_runtimes: type: string + build_opts: + type: string outputs: published_runtimes: value: ${{ jobs.find-runtimes.outputs.runtime }} @@ -33,7 +28,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0 + uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.0.0 with: fetch-depth: 0 @@ -74,13 +69,15 @@ jobs: matrix: ${{ fromJSON(needs.find-runtimes.outputs.runtime) }} steps: - - uses: actions/checkout@3df4ab11eba7bda6032a0b82a6bb43b11571feac # v4.0.0 + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 # v4.0.0 with: fetch-depth: 0 - name: Srtool build id: srtool_build uses: chevdor/srtool-actions@v0.9.2 + env: + BUILD_OPTS: ${{ inputs.build_opts }} with: chain: ${{ matrix.chain }} runtime_dir: ${{ matrix.runtime_dir }} diff --git a/.github/workflows/reusable-check-changed-files.yml b/.github/workflows/reusable-check-changed-files.yml new file mode 100644 index 0000000000000000000000000000000000000000..47f0620439c77f262c4fda1b68f0e250f2ec8ac6 --- /dev/null +++ b/.github/workflows/reusable-check-changed-files.yml @@ -0,0 +1,59 @@ +# Reusable workflow to perform checks and generate conditions for other workflows. +# Currently it checks if any Rust (build-related) file is changed +# and if the current (caller) workflow file is changed. +# Example: +# +# jobs: +# changes: +# permissions: +# pull-requests: read +# uses: ./.github/workflows/reusable-check-changed-files.yml +# some-job: +# needs: changes +# if: ${{ needs.changes.outputs.rust }} +# ....... + +name: Check changes files + +on: + workflow_call: + # Map the workflow outputs to job outputs + outputs: + rust: + value: ${{ jobs.changes.outputs.rust }} + description: "true if any of the build-related OR current (caller) workflow files have changed" + current-workflow: + value: ${{ jobs.changes.outputs.current-workflow }} + description: "true if current (caller) workflow file has changed" + +jobs: + changes: + runs-on: ubuntu-latest + permissions: + pull-requests: read + outputs: + # true if current workflow (caller) file is changed + rust: ${{ steps.filter.outputs.rust == 'true' || steps.filter.outputs.current-workflow == 'true' }} + current-workflow: ${{ steps.filter.outputs.current-workflow }} + steps: + - id: current-file + run: echo "current-workflow-file=$(echo ${{ github.workflow_ref }} | sed -nE "s/.*(\.github\/workflows\/[a-zA-Z0-9_-]*\.y[a]?ml)@refs.*/\1/p")" >> $GITHUB_OUTPUT + - run: echo "${{ steps.current-file.outputs.current-workflow-file }}" + # For pull requests it's not necessary to checkout the code + - name: Checkout + if: github.event_name != 'pull_request' + uses: actions/checkout@v4 + - id: filter + uses: dorny/paths-filter@v3 + with: + predicate-quantifier: "every" + # current-workflow - check if the current (caller) workflow file is changed + # rust - check if any Rust (build-related) file is changed + filters: | + current-workflow: + - '${{ steps.current-file.outputs.current-workflow-file }}' + rust: + - '**/*' + - '!.github/**/*' + - '!prdoc/**/*' + - '!docs/**/*' diff --git a/.github/workflows/review-bot.yml b/.github/workflows/review-bot.yml index f1401406ae47afd3230cc163f35df0e3bcbac7b7..3dd5b1114813dbb2e151319293ade7ce44f4aae9 100644 --- a/.github/workflows/review-bot.yml +++ b/.github/workflows/review-bot.yml @@ -15,7 +15,6 @@ on: jobs: review-approvals: runs-on: ubuntu-latest - environment: master steps: - name: Generate token id: app_token @@ -30,7 +29,7 @@ jobs: with: artifact-name: pr_number - name: "Evaluates PR reviews and assigns reviewers" - uses: paritytech/review-bot@v2.4.0 + uses: paritytech/review-bot@v2.6.0 with: repo-token: ${{ steps.app_token.outputs.token }} team-token: ${{ steps.app_token.outputs.token }} diff --git a/.github/workflows/runtimes-matrix.json b/.github/workflows/runtimes-matrix.json new file mode 100644 index 0000000000000000000000000000000000000000..45a3acd3f166d9f2fad3187e2f3f3ac9f0245bfb --- /dev/null +++ b/.github/workflows/runtimes-matrix.json @@ -0,0 +1,98 @@ +[ + { + "name": "dev", + "package": "kitchensink-runtime", + "path": "substrate/frame", + "uri": null, + "is_relay": false + }, + { + "name": "westend", + "package": "westend-runtime", + "path": "polkadot/runtime/westend", + "uri": "wss://try-runtime-westend.polkadot.io:443", + "is_relay": true + }, + { + "name": "rococo", + "package": "rococo-runtime", + "path": "polkadot/runtime/rococo", + "uri": "wss://try-runtime-rococo.polkadot.io:443", + "is_relay": true + }, + { + "name": "asset-hub-westend", + "package": "asset-hub-westend-runtime", + "path": "cumulus/parachains/runtimes/assets/asset-hub-westend", + "uri": "wss://westend-asset-hub-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "asset-hub-rococo", + "package": "asset-hub-rococo-runtime", + "path": "cumulus/parachains/runtimes/assets/asset-hub-rococo", + "uri": "wss://rococo-asset-hub-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "bridge-hub-rococo", + "package": "bridge-hub-rococo-runtime", + "path": "cumulus/parachains/runtimes/bridges/bridge-hub-rococo", + "uri": "wss://rococo-bridge-hub-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "bridge-hub-westend", + "package": "bridge-hub-rococo-runtime", + "path": "cumulus/parachains/runtimes/bridges/bridge-hub-westend", + "uri": "wss://westend-bridge-hub-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "collectives-westend", + "package": "collectives-westend-runtime", + "path": "cumulus/parachains/runtimes/collectives/collectives-westend", + "uri": "wss://westend-collectives-rpc.polkadot.io:443" + }, + { + "name": "contracts-rococo", + "package": "contracts-rococo-runtime", + "path": "cumulus/parachains/runtimes/contracts/contracts-rococo", + "uri": "wss://rococo-contracts-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "coretime-rococo", + "package": "coretime-rococo-runtime", + "path": "cumulus/parachains/runtimes/coretime/coretime-rococo", + "uri": "wss://rococo-coretime-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "coretime-westend", + "package": "coretime-westend-runtime", + "path": "cumulus/parachains/runtimes/coretime/coretime-westend", + "uri": "wss://westend-coretime-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "glutton-westend", + "package": "glutton-westend-runtime", + "path": "cumulus/parachains/runtimes/gluttons/glutton-westend", + "is_relay": false + }, + { + "name": "people-rococo", + "package": "people-rococo-runtime", + "path": "cumulus/parachains/runtimes/people/people-rococo", + "uri": "wss://rococo-people-rpc.polkadot.io:443", + "is_relay": false + }, + { + "name": "people-westend", + "package": "people-westend-runtime", + "path": "cumulus/parachains/runtimes/people/people-westend", + "uri": "wss://westend-people-rpc.polkadot.io:443", + "is_relay": false + } +] diff --git a/.github/workflows/subsystem-benchmarks.yml b/.github/workflows/subsystem-benchmarks.yml index 1a726b669e9094e8be53ef5a1ddb1b3198210d33..7c19b420a6acb42ed473bb2c4bd54c07cefdd0e4 100644 --- a/.github/workflows/subsystem-benchmarks.yml +++ b/.github/workflows/subsystem-benchmarks.yml @@ -1,55 +1,82 @@ -# The actions takes json file as input and runs github-action-benchmark for it. - on: - workflow_dispatch: - inputs: - benchmark-data-dir-path: - description: "Path to the benchmark data directory" - required: true - type: string - output-file-path: - description: "Path to the benchmark data file" - required: true - type: string + push: + branches: + - master + pull_request: + types: [ opened, synchronize, reopened, closed, labeled ] + merge_group: + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +permissions: + contents: read + pull-requests: write jobs: - subsystem-benchmarks: + set-image: + # TODO: remove once migration is complete or this workflow is fully stable + if: contains(github.event.label.name, 'GHA-migration') + # 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 - environment: subsystem-benchmarks + outputs: + IMAGE: ${{ steps.set_image.outputs.IMAGE }} steps: - - name: Validate inputs - run: | - echo "${{ github.event.inputs.benchmark-data-dir-path }}" | grep -P '^[a-z\-]' - echo "${{ github.event.inputs.output-file-path }}" | grep -P '^[a-z\-]+\.json' + - name: Checkout + uses: actions/checkout@v4 + - id: set_image + run: cat .github/env >> $GITHUB_OUTPUT - - name: Checkout Sources - uses: actions/checkout@v4.1.2 - with: - fetch-depth: 0 - ref: "gh-pages" + build: + needs: [ set-image ] + runs-on: arc-runners-polkadot-sdk-benchmark + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + BENCH_DIR: ./charts/bench/${{ matrix.features.bench }} + BENCH_FILE_NAME: ${{ matrix.features.bench }} + strategy: + fail-fast: false + matrix: + features: [ + { name: "polkadot-availability-recovery", bench: "availability-recovery-regression-bench" }, + { name: "polkadot-availability-distribution", bench: "availability-distribution-regression-bench" }, + { name: "polkadot-node-core-approval-voting", bench: "approval-voting-regression-bench" }, + { name: "polkadot-statement-distribution", bench: "statement-distribution-regression-bench" } + ] + steps: + - name: Checkout + uses: actions/checkout@v4 - - name: Copy bench results - id: step_one + - name: Check Rust run: | - cp bench/gitlab/${{ github.event.inputs.output-file-path }} ${{ github.event.inputs.output-file-path }} + rustup show + rustup +nightly show - - name: Switch branch - id: step_two + - name: Run Benchmarks + continue-on-error: true + id: run-benchmarks run: | - git checkout master -- - - - uses: actions/create-github-app-token@v1 - id: app-token - with: - app-id: ${{ secrets.POLKADOTSDK_GHPAGES_APP_ID }} - private-key: ${{ secrets.POLKADOTSDK_GHPAGES_APP_KEY }} + cargo bench -p ${{ matrix.features.name }} --bench ${{ matrix.features.bench }} --features subsystem-benchmarks || echo "Benchmarks failed" + ls -lsa ./charts + mkdir -p $BENCH_DIR || echo "Directory exists" + cp charts/${BENCH_FILE_NAME}.json $BENCH_DIR + ls -lsa $BENCH_DIR + # Fixes "detected dubious ownership" error in the ci + git config --global --add safe.directory '*' - - name: Store benchmark result + - name: Publish result to GH Pages + if: ${{ steps.run-benchmarks.outcome == 'success' }} uses: benchmark-action/github-action-benchmark@v1 with: tool: "customSmallerIsBetter" - name: ${{ github.event.inputs.benchmark-data-dir-path }} - output-file-path: ${{ github.event.inputs.output-file-path }} - benchmark-data-dir-path: "bench/${{ github.event.inputs.benchmark-data-dir-path }}" - github-token: ${{ steps.app-token.outputs.token }} - auto-push: true + name: ${{ env.BENCH_FILE_NAME }} + output-file-path: ${{ env.BENCH_DIR }}/${{ env.BENCH_FILE_NAME }}.json + benchmark-data-dir-path: ${{ env.BENCH_DIR }} + github-token: ${{ secrets.GITHUB_TOKEN }} + comment-on-alert: ${{ github.event_name == 'pull_request' }} # will comment on PRs if regression is detected + auto-push: false # TODO: enable when gitlab part is removed ${{ github.ref == 'refs/heads/master' }} + diff --git a/.github/workflows/test-github-actions.yml b/.github/workflows/test-github-actions.yml deleted file mode 100644 index e35ee09948634e37d4d601bea262140c87ff6c98..0000000000000000000000000000000000000000 --- a/.github/workflows/test-github-actions.yml +++ /dev/null @@ -1,57 +0,0 @@ -name: test-github-actions - -on: - 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 - -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. - 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-linux-stable-int: - runs-on: arc-runners-polkadot-sdk-beefy - timeout-minutes: 30 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - env: - RUSTFLAGS: "-C debug-assertions -D warnings" - RUST_BACKTRACE: 1 - WASM_BUILD_NO_COLOR: 1 - WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings" - # Ensure we run the UI tests. - RUN_UI_TESTS: 1 - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: script - run: WASM_BUILD_NO_COLOR=1 time cargo test -p staging-node-cli --release --locked -- --ignored - quick-benchmarks: - runs-on: arc-runners-polkadot-sdk-beefy - timeout-minutes: 30 - needs: [set-image] - container: - image: ${{ needs.set-image.outputs.IMAGE }} - env: - RUSTFLAGS: "-C debug-assertions -D warnings" - RUST_BACKTRACE: "full" - WASM_BUILD_NO_COLOR: 1 - WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings" - steps: - - name: Checkout - uses: actions/checkout@v4 - - name: script - run: time cargo run --locked --release -p staging-node-cli --bin substrate-node --features runtime-benchmarks -- benchmark pallet --chain dev --pallet "*" --extrinsic "*" --steps 2 --repeat 1 --quiet diff --git a/.github/workflows/tests-linux-stable.yml b/.github/workflows/tests-linux-stable.yml new file mode 100644 index 0000000000000000000000000000000000000000..4a13f5318f7deb34a4727a3dc88967df12a67ed7 --- /dev/null +++ b/.github/workflows/tests-linux-stable.yml @@ -0,0 +1,126 @@ +# GHA for test-linux-stable-int, test-linux-stable, test-linux-stable-oldkernel +name: tests linux stable + +on: + push: + branches: + - master + pull_request: + types: [opened, synchronize, reopened, ready_for_review, labeled] + merge_group: +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + changes: + # TODO: remove once migration is complete or this workflow is fully stable + if: contains(github.event.label.name, 'GHA-migration') + 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. + needs: changes + if: ${{ needs.changes.outputs.rust }} + 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-linux-stable-int: + needs: [set-image, changes] + if: ${{ needs.changes.outputs.rust }} + runs-on: arc-runners-polkadot-sdk-beefy + timeout-minutes: 60 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + RUSTFLAGS: "-C debug-assertions -D warnings" + RUST_BACKTRACE: 1 + WASM_BUILD_NO_COLOR: 1 + WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings" + # Ensure we run the UI tests. + RUN_UI_TESTS: 1 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + run: WASM_BUILD_NO_COLOR=1 forklift cargo test -p staging-node-cli --release --locked -- --ignored + + # https://github.com/paritytech/ci_cd/issues/864 + test-linux-stable-runtime-benchmarks: + needs: [set-image, changes] + if: ${{ needs.changes.outputs.rust }} + runs-on: arc-runners-polkadot-sdk-beefy + timeout-minutes: 60 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + RUST_TOOLCHAIN: stable + # Enable debug assertions since we are running optimized builds for testing + # but still want to have debug assertions. + RUSTFLAGS: "-Cdebug-assertions=y -Dwarnings" + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + run: forklift cargo nextest run --workspace --features runtime-benchmarks benchmark --locked --cargo-profile testnet + + test-linux-stable: + needs: [set-image, changes] + if: ${{ needs.changes.outputs.rust }} + runs-on: ${{ matrix.runners }} + timeout-minutes: 60 + strategy: + fail-fast: false + matrix: + partition: [1/3, 2/3, 3/3] + runners: [arc-runners-polkadot-sdk-beefy, oldlinux] + container: + image: ${{ needs.set-image.outputs.IMAGE }} + # needed for tests that use unshare syscall + options: --security-opt seccomp=unconfined + env: + RUST_TOOLCHAIN: stable + # Enable debug assertions since we are running optimized builds for testing + # but still want to have debug assertions. + RUSTFLAGS: "-Cdebug-assertions=y -Dwarnings" + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + run: | + # Fixes "detected dubious ownership" error in the ci + git config --global --add safe.directory '*' + forklift cargo nextest run \ + --workspace \ + --locked \ + --release \ + --no-fail-fast \ + --features try-runtime,experimental,riscv,ci-only-tests \ + --partition count:${{ matrix.partition }} + # run runtime-api tests with `enable-staging-api` feature on the 1st node + - name: runtime-api tests + if: ${{ matrix.partition == '1/3' }} + run: forklift cargo nextest run -p sp-api-test --features enable-staging-api + + confirm-required-jobs-passed: + runs-on: ubuntu-latest + name: All tests passed + # If any new job gets added, be sure to add it to this array + needs: + [ + test-linux-stable-int, + test-linux-stable-runtime-benchmarks, + test-linux-stable, + ] + steps: + - run: echo '### Good job! All the tests passed 🚀' >> $GITHUB_STEP_SUMMARY diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000000000000000000000000000000000000..25761fb94fd33b5002b7939f972dc372243ea3de --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,103 @@ +name: tests + +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 + +jobs: + # 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 + + # This job runs all benchmarks defined in the `/bin/node/runtime` once to check that there are no errors. + quick-benchmarks: + needs: [set-image] + # if: ${{ needs.changes.outputs.rust }} + runs-on: ${{ needs.set-image.outputs.RUNNER }} + timeout-minutes: 60 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + RUSTFLAGS: "-C debug-assertions -D warnings" + RUST_BACKTRACE: "full" + WASM_BUILD_NO_COLOR: 1 + WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings" + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + run: forklift cargo run --locked --release -p staging-node-cli --bin substrate-node --features runtime-benchmarks -- benchmark pallet --chain dev --pallet "*" --extrinsic "*" --steps 2 --repeat 1 --quiet + + # cf https://github.com/paritytech/polkadot-sdk/issues/1652 + test-syscalls: + needs: [set-image] + # if: ${{ needs.changes.outputs.rust }} + runs-on: ${{ needs.set-image.outputs.RUNNER }} + timeout-minutes: 60 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + continue-on-error: true # this rarely triggers in practice + env: + SKIP_WASM_BUILD: 1 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + id: test + run: | + forklift cargo build --locked --profile production --target x86_64-unknown-linux-musl --bin polkadot-execute-worker --bin polkadot-prepare-worker + cd polkadot/scripts/list-syscalls + ./list-syscalls.rb ../../../target/x86_64-unknown-linux-musl/production/polkadot-execute-worker --only-used-syscalls | diff -u execute-worker-syscalls - + ./list-syscalls.rb ../../../target/x86_64-unknown-linux-musl/production/polkadot-prepare-worker --only-used-syscalls | diff -u prepare-worker-syscalls - + - name: on_failure + if: failure() && steps.test.outcome == 'failure' + run: | + echo "The x86_64 syscalls used by the worker binaries have changed. Please review if this is expected and update polkadot/scripts/list-syscalls/*-worker-syscalls as needed." >> $GITHUB_STEP_SUMMARY + + cargo-check-all-benches: + needs: [set-image] + # if: ${{ needs.changes.outputs.rust }} + runs-on: ${{ needs.set-image.outputs.RUNNER }} + timeout-minutes: 60 + container: + image: ${{ needs.set-image.outputs.IMAGE }} + env: + SKIP_WASM_BUILD: 1 + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: script + run: forklift cargo check --all --benches diff --git a/.gitignore b/.gitignore index 2f1631fb4b9d14496021907cca96b4cdf4902eb8..0263626d832df2633a3c5fc9db18268c2cc9953b 100644 --- a/.gitignore +++ b/.gitignore @@ -14,6 +14,7 @@ *.orig *.rej *.swp +*.wasm **/._* **/.criterion/ **/*.rs.bk @@ -22,6 +23,7 @@ **/node_modules **/target/ **/wip/*.stderr +**/__pycache__/ /.cargo/config /.envrc artifacts diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 5e57dd86f14166e695f1c64b6b5aee56529a4781..56d426218c80e3c8f9bf0248b7bbe4d9f03aa52a 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -120,7 +120,8 @@ default: .forklift-cache: before_script: - mkdir ~/.forklift - - cp $FL_FORKLIFT_CONFIG ~/.forklift/config.toml + - cp .forklift/config-gitlab.toml ~/.forklift/config.toml + - cat .forklift/config-gitlab.toml > .forklift/config.toml - > if [ "$FORKLIFT_BYPASS" != "true" ]; then echo "FORKLIFT_BYPASS not set"; @@ -339,11 +340,6 @@ cancel-pipeline-check-tracing: needs: - job: check-tracing -cancel-pipeline-cargo-clippy: - extends: .cancel-pipeline-template - needs: - - job: cargo-clippy - cancel-pipeline-build-linux-stable: extends: .cancel-pipeline-template needs: @@ -369,16 +365,6 @@ cancel-pipeline-test-frame-ui: needs: - job: test-frame-ui -cancel-pipeline-quick-benchmarks: - extends: .cancel-pipeline-template - needs: - - job: quick-benchmarks - -cancel-pipeline-check-try-runtime: - extends: .cancel-pipeline-template - needs: - - job: check-try-runtime - cancel-pipeline-test-frame-examples-compile-to-wasm: extends: .cancel-pipeline-template needs: @@ -388,13 +374,3 @@ cancel-pipeline-build-short-benchmark: extends: .cancel-pipeline-template needs: - job: build-short-benchmark - -cancel-pipeline-check-runtime-migration-rococo: - extends: .cancel-pipeline-template - needs: - - job: check-runtime-migration-rococo - -cancel-pipeline-check-runtime-migration-westend: - extends: .cancel-pipeline-template - needs: - - job: check-runtime-migration-westend diff --git a/.gitlab/pipeline/check.yml b/.gitlab/pipeline/check.yml index 6fb8a97fe95821886c416d97224fb21fd0f2897b..2212c1aeb0a81156a60cbca041c978993ddd40b8 100644 --- a/.gitlab/pipeline/check.yml +++ b/.gitlab/pipeline/check.yml @@ -1,53 +1,3 @@ -cargo-clippy: - stage: check - extends: - - .docker-env - - .common-refs - - .pipeline-stopper-artifacts - variables: - RUSTFLAGS: "-D warnings" - script: - - SKIP_WASM_BUILD=1 cargo clippy --all-targets --locked --workspace --quiet - - SKIP_WASM_BUILD=1 cargo clippy --all-targets --all-features --locked --workspace --quiet - -check-try-runtime: - stage: check - extends: - - .docker-env - - .common-refs - script: - - time cargo check --locked --all --features try-runtime - # this is taken from cumulus - # Check that parachain-template will compile with `try-runtime` feature flag. - - time 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 - - time cargo check --locked --all --features try-runtime,experimental - -# FIXME -.cargo-deny-licenses: - stage: check - extends: - - .docker-env - - .test-pr-refs - variables: - CARGO_DENY_CMD: "cargo deny --all-features check licenses -c ./substrate/scripts/ci/deny.toml" - script: - - $CARGO_DENY_CMD --hide-inclusion-graph - after_script: - - echo "___The complete log is in the artifacts___" - - $CARGO_DENY_CMD 2> deny.log - - if [ $CI_JOB_STATUS != 'success' ]; then - echo 'Please check license of your crate or add an exception to scripts/ci/deny.toml'; - fi - allow_failure: true - artifacts: - name: $CI_COMMIT_SHORT_SHA - expire_in: 3 days - when: always - paths: - - deny.log - # from substrate # not sure if it's needed in monorepo check-dependency-rules: @@ -96,178 +46,3 @@ check-toml-format: script: - taplo format --check --config .config/taplo.toml - echo "Please run `taplo format --config .config/taplo.toml` to fix any toml formatting issues" - -# More info can be found here: https://github.com/paritytech/polkadot/pull/5865 -.check-runtime-migration: - stage: check - extends: - - .docker-env - - .test-pr-refs - script: - - export RUST_LOG=remote-ext=debug,runtime=debug - - echo "---------- Downloading try-runtime CLI ----------" - - curl -sL https://github.com/paritytech/try-runtime-cli/releases/download/v0.5.4/try-runtime-x86_64-unknown-linux-musl -o try-runtime - - chmod +x ./try-runtime - - echo "Using try-runtime-cli version:" - - ./try-runtime --version - - echo "---------- Building ${PACKAGE} runtime ----------" - - time cargo build --release --locked -p "$PACKAGE" --features try-runtime - - echo "---------- Executing on-runtime-upgrade for ${NETWORK} ----------" - - > - time ./try-runtime ${COMMAND_EXTRA_ARGS} \ - --runtime ./target/release/wbuild/"$PACKAGE"/"$WASM" \ - on-runtime-upgrade --disable-spec-version-check --checks=all ${SUBCOMMAND_EXTRA_ARGS} live --uri ${URI} - - sleep 5 - -# Check runtime migrations for Parity managed relay chains -check-runtime-migration-westend: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "westend" - PACKAGE: "westend-runtime" - WASM: "westend_runtime.compact.compressed.wasm" - URI: "wss://westend-try-runtime-node.parity-chains.parity.io:443" - SUBCOMMAND_EXTRA_ARGS: "--no-weight-warnings" - -check-runtime-migration-rococo: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "rococo" - PACKAGE: "rococo-runtime" - WASM: "rococo_runtime.compact.compressed.wasm" - URI: "wss://rococo-try-runtime-node.parity-chains.parity.io:443" - SUBCOMMAND_EXTRA_ARGS: "--no-weight-warnings" - -# Check runtime migrations for Parity managed asset hub chains -check-runtime-migration-asset-hub-westend: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "asset-hub-westend" - PACKAGE: "asset-hub-westend-runtime" - WASM: "asset_hub_westend_runtime.compact.compressed.wasm" - URI: "wss://westend-asset-hub-rpc.polkadot.io:443" - -check-runtime-migration-asset-hub-rococo: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "asset-hub-rococo" - PACKAGE: "asset-hub-rococo-runtime" - WASM: "asset_hub_rococo_runtime.compact.compressed.wasm" - URI: "wss://rococo-asset-hub-rpc.polkadot.io:443" - -# Check runtime migrations for Parity managed bridge hub chains -check-runtime-migration-bridge-hub-westend: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "bridge-hub-westend" - PACKAGE: "bridge-hub-westend-runtime" - WASM: "bridge_hub_westend_runtime.compact.compressed.wasm" - URI: "wss://westend-bridge-hub-rpc.polkadot.io:443" - -check-runtime-migration-bridge-hub-rococo: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "bridge-hub-rococo" - PACKAGE: "bridge-hub-rococo-runtime" - WASM: "bridge_hub_rococo_runtime.compact.compressed.wasm" - URI: "wss://rococo-bridge-hub-rpc.polkadot.io:443" - -# Check runtime migrations for Parity managed contract chains -check-runtime-migration-contracts-rococo: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "contracts-rococo" - PACKAGE: "contracts-rococo-runtime" - WASM: "contracts_rococo_runtime.compact.compressed.wasm" - URI: "wss://rococo-contracts-rpc.polkadot.io:443" - -# Check runtime migrations for Parity managed collectives chains -check-runtime-migration-collectives-westend: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "collectives-westend" - PACKAGE: "collectives-westend-runtime" - WASM: "collectives_westend_runtime.compact.compressed.wasm" - URI: "wss://westend-collectives-rpc.polkadot.io:443" - COMMAND_EXTRA_ARGS: "--disable-spec-name-check" - -# Check runtime migrations for Parity managed coretime chain -check-runtime-migration-coretime-rococo: - stage: check - extends: - - .docker-env - - .test-pr-refs - - .check-runtime-migration - variables: - NETWORK: "coretime-rococo" - PACKAGE: "coretime-rococo-runtime" - WASM: "coretime_rococo_runtime.compact.compressed.wasm" - URI: "wss://rococo-coretime-rpc.polkadot.io:443" - -find-fail-ci-phrase: - stage: check - variables: - CI_IMAGE: "paritytech/tools:latest" - ASSERT_REGEX: "FAIL-CI" - GIT_DEPTH: 1 - extends: - - .kubernetes-env - - .test-pr-refs - script: - - 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 - -check-core-crypto-features: - stage: check - extends: - - .docker-env - - .common-refs - script: - - pushd substrate/primitives/core - - ./check-features-variants.sh - - popd - - pushd substrate/primitives/application-crypto - - ./check-features-variants.sh - - popd - - pushd substrate/primitives/keyring - - ./check-features-variants.sh - - popd diff --git a/.gitlab/pipeline/publish.yml b/.gitlab/pipeline/publish.yml index 68712610ad2361601af3763485d1ab3e6c158682..44cd1933a9cfa0b3cbff384ff4184a36bf864021 100644 --- a/.gitlab/pipeline/publish.yml +++ b/.gitlab/pipeline/publish.yml @@ -76,6 +76,8 @@ publish-subsystem-benchmarks: artifacts: true - job: subsystem-benchmark-approval-voting artifacts: true + - job: subsystem-benchmark-statement-distribution + artifacts: true - job: publish-rustdoc artifacts: false script: @@ -119,6 +121,8 @@ trigger_workflow: artifacts: true - job: subsystem-benchmark-approval-voting artifacts: true + - job: subsystem-benchmark-statement-distribution + artifacts: true script: - echo "Triggering workflow" - > @@ -129,7 +133,7 @@ trigger_workflow: curl -q -X POST \ -H "Accept: application/vnd.github.v3+json" \ -H "Authorization: token $GITHUB_TOKEN" \ - https://api.github.com/repos/paritytech/${CI_PROJECT_NAME}/actions/workflows/subsystem-benchmarks.yml/dispatches \ + https://api.github.com/repos/paritytech/${CI_PROJECT_NAME}/actions/workflows/publish-subsystem-benchmarks.yml/dispatches \ -d "{\"ref\":\"refs/heads/master\",\"inputs\":{\"benchmark-data-dir-path\":\"$benchmark_dir\",\"output-file-path\":\"$benchmark_name\"}}"; sleep 300; done diff --git a/.gitlab/pipeline/test.yml b/.gitlab/pipeline/test.yml index 796e4d65310481fef4e831a42497044a9ccaae5a..85f6e8dc780bd27631df0dc67ff5807f401a4631 100644 --- a/.gitlab/pipeline/test.yml +++ b/.gitlab/pipeline/test.yml @@ -24,7 +24,7 @@ # # -# +# codecov-start: stage: test when: manual @@ -53,11 +53,11 @@ codecov-finish: extends: - .kubernetes-env - .common-refs - - .pipeline-stopper-artifacts + - .pipeline-stopper-artifacts needs: - test-linux-stable-codecov script: - - !reference [.codecov-check, script] + - !reference [.codecov-check, script] - codecovcli -v create-report-results -t ${CODECOV_TOKEN} -r paritytech/polkadot-sdk --commit-sha ${CI_COMMIT_SHA} --git-service github - codecovcli -v get-report-results -t ${CODECOV_TOKEN} -r paritytech/polkadot-sdk --commit-sha ${CI_COMMIT_SHA} --git-service github - codecovcli -v send-notifications -t ${CODECOV_TOKEN} -r paritytech/polkadot-sdk --commit-sha ${CI_COMMIT_SHA} --git-service github @@ -78,14 +78,14 @@ test-linux-stable-codecov: RUST_TOOLCHAIN: stable RUSTFLAGS: "-Cdebug-assertions=y -Cinstrument-coverage" LLVM_PROFILE_FILE: "target/coverage/cargo-test-${CI_NODE_INDEX}-%p-%m.profraw" - CARGO_INCREMENTAL: 0 - FORKLIFT_BYPASS: "true" + CARGO_INCREMENTAL: 0 + FORKLIFT_BYPASS: "true" parallel: 2 script: # tools - - !reference [.codecov-check, script] + - !reference [.codecov-check, script] - rustup component add llvm-tools-preview - - mkdir -p target/coverage/result/ + - mkdir -p target/coverage/result/ # Place real test call here - > time cargo nextest run -p polkadot \ @@ -102,15 +102,13 @@ test-linux-stable-codecov: -t lcov \ --branch \ -o target/coverage/result/report-${CI_NODE_INDEX}.lcov - - ls -l target/coverage/result/ + - ls -l target/coverage/result/ - > if [ "$CI_COMMIT_REF_NAME" != "master" ]; then codecovcli -v do-upload -f target/coverage/result/report-${CI_NODE_INDEX}.lcov --disable-search -t ${CODECOV_TOKEN} -r paritytech/polkadot-sdk --commit-sha ${CI_COMMIT_SHA} --fail-on-error --pr ${CI_COMMIT_REF_NAME} --git-service github; else codecovcli -v do-upload -f target/coverage/result/report-${CI_NODE_INDEX}.lcov --disable-search -t ${CODECOV_TOKEN} -r paritytech/polkadot-sdk --commit-sha ${CI_COMMIT_SHA} --fail-on-error --git-service github; fi - - # test-linux-stable: stage: test @@ -128,8 +126,6 @@ test-linux-stable: script: # Build all but only execute 'runtime' tests. - echo "Node index - ${CI_NODE_INDEX}. Total amount - ${CI_NODE_TOTAL}" - # add experimental to features after https://github.com/paritytech/substrate/pull/14502 is merged - # "upgrade_version_checks_should_work" is currently failing - > time cargo nextest run \ --workspace \ @@ -254,18 +250,6 @@ test-rustdoc: script: - time cargo doc --workspace --all-features --no-deps -cargo-check-all-benches: - stage: test - extends: - - .docker-env - - .common-refs - # DAG - needs: - - job: cargo-hfuzz - artifacts: false - script: - - time cargo check --all --benches - test-node-metrics: stage: test extends: @@ -412,25 +396,13 @@ test-frame-ui: script: - time cargo test --locked -q --profile testnet -p frame-support-test --features=frame-feature-testing,no-metadata-docs,try-runtime,experimental - time cargo test --locked -q --profile testnet -p frame-support-test --features=frame-feature-testing,frame-feature-testing-2,no-metadata-docs,try-runtime,experimental + - time cargo test --locked -q --profile testnet -p xcm-procedural + - time cargo test --locked -q --profile testnet -p frame-election-provider-solution-type + - time cargo test --locked -q --profile testnet -p sp-api-test + # There is multiple version of sp-runtime-interface in the repo. So we point to the manifest. + - time cargo test --locked -q --profile testnet --manifest-path substrate/primitives/runtime-interface/Cargo.toml - cat /cargo_target_dir/debug/.fingerprint/memory_units-759eddf317490d2b/lib-memory_units.json || true -# This job runs all benchmarks defined in the `/bin/node/runtime` once to check that there are no errors. -quick-benchmarks: - stage: test - extends: - - .docker-env - - .common-refs - - .run-immediately - variables: - # Enable debug assertions since we are running optimized builds for testing - # but still want to have debug assertions. - RUSTFLAGS: "-C debug-assertions -D warnings" - RUST_BACKTRACE: "full" - WASM_BUILD_NO_COLOR: 1 - WASM_BUILD_RUSTFLAGS: "-C debug-assertions -D warnings" - script: - - time cargo run --locked --release -p staging-node-cli --bin substrate-node --features runtime-benchmarks --quiet -- benchmark pallet --chain dev --pallet "*" --extrinsic "*" --steps 2 --repeat 1 --quiet - quick-benchmarks-omni: stage: test extends: @@ -505,6 +477,17 @@ check-tracing: - time cargo test --locked --manifest-path ./substrate/primitives/tracing/Cargo.toml --no-default-features - time cargo test --locked --manifest-path ./substrate/primitives/tracing/Cargo.toml --no-default-features --features=with-tracing +# Check that `westend-runtime` compiles with the `metadata-hash` feature enabled. +check-metadata-hash: + stage: test + extends: + - .docker-env + - .common-refs + - .run-immediately + - .pipeline-stopper-artifacts + script: + - time cargo build --locked -p westend-runtime --features metadata-hash + # more information about this job can be found here: # https://github.com/paritytech/substrate/pull/3778 test-full-crypto-feature: @@ -598,26 +581,6 @@ cargo-hfuzz: - for target in $(cargo read-manifest | jq -r '.targets | .[] | .name'); do cargo hfuzz run "$target" || { printf "fuzzing failure for %s\n" "$target"; exit 1; }; done -# cf https://github.com/paritytech/polkadot-sdk/issues/1652 -test-syscalls: - stage: test - extends: - - .docker-env - - .common-refs - - .run-immediately - variables: - SKIP_WASM_BUILD: 1 - script: - - cargo build --locked --profile production --target x86_64-unknown-linux-musl --bin polkadot-execute-worker --bin polkadot-prepare-worker - - cd polkadot/scripts/list-syscalls - - ./list-syscalls.rb ../../../target/x86_64-unknown-linux-musl/production/polkadot-execute-worker --only-used-syscalls | diff -u execute-worker-syscalls - - - ./list-syscalls.rb ../../../target/x86_64-unknown-linux-musl/production/polkadot-prepare-worker --only-used-syscalls | diff -u prepare-worker-syscalls - - after_script: - - if [[ "$CI_JOB_STATUS" == "failed" ]]; then - printf "The x86_64 syscalls used by the worker binaries have changed. Please review if this is expected and update polkadot/scripts/list-syscalls/*-worker-syscalls as needed.\n"; - fi - allow_failure: false # this rarely triggers in practice - .subsystem-benchmark-template: stage: test artifacts: @@ -653,3 +616,10 @@ subsystem-benchmark-approval-voting: script: - cargo bench -p polkadot-node-core-approval-voting --bench approval-voting-regression-bench --features subsystem-benchmarks allow_failure: true + +subsystem-benchmark-statement-distribution: + extends: + - .subsystem-benchmark-template + script: + - cargo bench -p polkadot-statement-distribution --bench statement-distribution-regression-bench --features subsystem-benchmarks + allow_failure: true diff --git a/.gitlab/pipeline/zombienet.yml b/.gitlab/pipeline/zombienet.yml index 52948e1eb719d9f8669523d9762f5662fd1b6e96..7897e55e291bd3cae1f3df42d1fcf5c811ff52f2 100644 --- a/.gitlab/pipeline/zombienet.yml +++ b/.gitlab/pipeline/zombienet.yml @@ -1,8 +1,9 @@ .zombienet-refs: extends: .build-refs variables: - ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.99" + ZOMBIENET_IMAGE: "docker.io/paritytech/zombienet:v1.3.105" PUSHGATEWAY_URL: "http://zombienet-prometheus-pushgateway.managed-monitoring:9091/metrics/job/zombie-metrics" + DEBUG: "zombie,zombie::network-node,zombie::kube::client::logs" include: # substrate tests diff --git a/.gitlab/pipeline/zombienet/bridges.yml b/.gitlab/pipeline/zombienet/bridges.yml index 9d7a8b9311934a148e855caf7c4315d8a281aed1..070bfc8472d5ab797141862bd0d0066d420bc922 100644 --- a/.gitlab/pipeline/zombienet/bridges.yml +++ b/.gitlab/pipeline/zombienet/bridges.yml @@ -52,12 +52,12 @@ zombienet-bridges-0001-asset-transfer-works: extends: - .zombienet-bridges-common script: - - /home/nonroot/bridges-polkadot-sdk/bridges/testing/run-new-test.sh 0001-asset-transfer --docker + - /home/nonroot/bridges-polkadot-sdk/bridges/testing/run-test.sh 0001-asset-transfer --docker - echo "Done" zombienet-bridges-0002-free-headers-synced-while-idle: extends: - .zombienet-bridges-common script: - - /home/nonroot/bridges-polkadot-sdk/bridges/testing/run-new-test.sh 0002-free-headers-synced-while-idle --docker + - /home/nonroot/bridges-polkadot-sdk/bridges/testing/run-test.sh 0002-free-headers-synced-while-idle --docker - echo "Done" diff --git a/.gitlab/pipeline/zombienet/cumulus.yml b/.gitlab/pipeline/zombienet/cumulus.yml index c473f5c5fed755bfcceeeceea30a93c1d0c3403d..6e2b53fae6198501297960de84ecdb1606d3e128 100644 --- a/.gitlab/pipeline/zombienet/cumulus.yml +++ b/.gitlab/pipeline/zombienet/cumulus.yml @@ -15,7 +15,6 @@ - echo "${COL_IMAGE}" - echo "${GH_DIR}" - echo "${LOCAL_DIR}" - - export DEBUG=zombie - export RELAY_IMAGE=${POLKADOT_IMAGE} - export COL_IMAGE=${COL_IMAGE} @@ -150,3 +149,27 @@ zombienet-cumulus-0007-full_node_warp_sync: --local-dir="${LOCAL_DIR}" --concurrency=1 --test="0007-full_node_warp_sync.zndsl" + +zombienet-cumulus-0008-elastic_authoring: + extends: + - .zombienet-cumulus-common + - .zombienet-refs + - .zombienet-before-script + - .zombienet-after-script + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}" + --concurrency=1 + --test="0008-elastic_authoring.zndsl" + +zombienet-cumulus-0009-elastic_pov_recovery: + extends: + - .zombienet-cumulus-common + - .zombienet-refs + - .zombienet-before-script + - .zombienet-after-script + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}" + --concurrency=1 + --test="0009-elastic_pov_recovery.zndsl" diff --git a/.gitlab/pipeline/zombienet/polkadot.yml b/.gitlab/pipeline/zombienet/polkadot.yml index 38c5332f309703dab881d1df88709fc4fe95e49c..b4ef4bb7446c8a9bfe602322cd8ac07a30f14b40 100644 --- a/.gitlab/pipeline/zombienet/polkadot.yml +++ b/.gitlab/pipeline/zombienet/polkadot.yml @@ -10,7 +10,6 @@ - if [[ $CI_COMMIT_REF_NAME == *"gh-readonly-queue"* ]]; then export DOCKER_IMAGES_VERSION="${CI_COMMIT_SHORT_SHA}"; fi - export PIPELINE_IMAGE_TAG=${DOCKER_IMAGES_VERSION} - export BUILD_RELEASE_VERSION="$(cat ./artifacts/BUILD_RELEASE_VERSION)" # from build-linux-stable job - - export DEBUG=zombie,zombie::network-node - export ZOMBIENET_INTEGRATION_TEST_IMAGE="${POLKADOT_IMAGE}":${PIPELINE_IMAGE_TAG} - export COL_IMAGE="${COLANDER_IMAGE}":${PIPELINE_IMAGE_TAG} - export CUMULUS_IMAGE="docker.io/paritypr/polkadot-parachain-debug:${DOCKER_IMAGES_VERSION}" @@ -163,6 +162,9 @@ zombienet-polkadot-elastic-scaling-0001-basic-3cores-6s-blocks: - .zombienet-polkadot-common variables: FORCED_INFRA_INSTANCE: "spot-iops" + before_script: + - !reference [.zombienet-polkadot-common, before_script] + - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/elastic_scaling script: - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh --local-dir="${LOCAL_DIR}/elastic_scaling" @@ -171,6 +173,9 @@ zombienet-polkadot-elastic-scaling-0001-basic-3cores-6s-blocks: zombienet-polkadot-elastic-scaling-0002-elastic-scaling-doesnt-break-parachains: extends: - .zombienet-polkadot-common + before_script: + - !reference [.zombienet-polkadot-common, before_script] + - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/elastic_scaling script: - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh --local-dir="${LOCAL_DIR}/elastic_scaling" @@ -184,6 +189,33 @@ zombienet-polkadot-functional-0012-spam-statement-distribution-requests: --local-dir="${LOCAL_DIR}/functional" --test="0012-spam-statement-distribution-requests.zndsl" +zombienet-polkadot-functional-0013-systematic-chunk-recovery: + extends: + - .zombienet-polkadot-common + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}/functional" + --test="0013-systematic-chunk-recovery.zndsl" + +zombienet-polkadot-functional-0014-chunk-fetching-network-compatibility: + extends: + - .zombienet-polkadot-common + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}/functional" + --test="0014-chunk-fetching-network-compatibility.zndsl" + +zombienet-polkadot-functional-0015-coretime-shared-core: + extends: + - .zombienet-polkadot-common + before_script: + - !reference [.zombienet-polkadot-common, before_script] + - cp --remove-destination ${LOCAL_DIR}/assign-core.js ${LOCAL_DIR}/functional + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}/functional" + --test="0015-coretime-shared-core.zndsl" + zombienet-polkadot-smoke-0001-parachains-smoke-test: extends: - .zombienet-polkadot-common @@ -244,6 +276,14 @@ zombienet-polkadot-smoke-0004-coretime-smoke-test: --local-dir="${LOCAL_DIR}/smoke" --test="0004-coretime-smoke-test.zndsl" +zombienet-polkadot-smoke-0005-precompile-pvf-smoke: + extends: + - .zombienet-polkadot-common + script: + - /home/nonroot/zombie-net/scripts/ci/run-test-local-env-manager.sh + --local-dir="${LOCAL_DIR}/smoke" + --test="0005-precompile-pvf-smoke.zndsl" + zombienet-polkadot-misc-0001-parachains-paritydb: extends: - .zombienet-polkadot-common diff --git a/.gitlab/pipeline/zombienet/substrate.yml b/.gitlab/pipeline/zombienet/substrate.yml index 8a627c454f9f3853f04694827e1484571f5444a9..2013ffd571cf388ba154f3965c166765f40baaf6 100644 --- a/.gitlab/pipeline/zombienet/substrate.yml +++ b/.gitlab/pipeline/zombienet/substrate.yml @@ -13,7 +13,6 @@ - echo "${ZOMBIENET_IMAGE}" - echo "${GH_DIR}" - echo "${LOCAL_DIR}" - - export DEBUG=zombie,zombie::network-node - export ZOMBIENET_INTEGRATION_TEST_IMAGE="${SUBSTRATE_IMAGE}":${SUBSTRATE_IMAGE_TAG} - echo "${ZOMBIENET_INTEGRATION_TEST_IMAGE}" stage: zombienet diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 120000 index 0000000000000000000000000000000000000000..63b2a0dc1abc8daf348a8112688d254407837dd9 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1 @@ +docs/contributor/CODE_OF_CONDUCT.md \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 120000 index 0000000000000000000000000000000000000000..0f645512e8e47f744720a79767f0f78f919ea914 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1 @@ +docs/contributor/CONTRIBUTING.md \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index d43088704b5dd9f238af11c61942f98fce98a0ac..8eb4fa5b4e8330eaf7c667861c644f6cf9bcaac4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -83,19 +83,19 @@ version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9" dependencies = [ - "getrandom 0.2.10", + "getrandom", "once_cell", "version_check", ] [[package]] name = "ahash" -version = "0.8.8" +version = "0.8.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff" +checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011" dependencies = [ "cfg-if", - "getrandom 0.2.10", + "getrandom", "once_cell", "version_check", "zerocopy", @@ -130,7 +130,7 @@ dependencies = [ "hex-literal", "itoa", "proptest", - "rand 0.8.5", + "rand", "ruint", "serde", "tiny-keccak", @@ -157,9 +157,9 @@ dependencies = [ "dunce", "heck 0.4.1", "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", "syn-solidity", "tiny-keccak", ] @@ -262,9 +262,9 @@ dependencies = [ [[package]] name = "anyhow" -version = "1.0.81" +version = "1.0.86" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0952808a6c2afd1aa8947271f3a60f1a6763c7b912d210184c5149b5cf147247" +checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da" [[package]] name = "approx" @@ -284,9 +284,9 @@ dependencies = [ "include_dir", "itertools 0.10.5", "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -294,6 +294,9 @@ name = "arbitrary" version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110" +dependencies = [ + "derive_arbitrary", +] [[package]] name = "ark-bls12-377" @@ -481,7 +484,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44" dependencies = [ - "quote 1.0.35", + "quote 1.0.36", "syn 1.0.109", ] @@ -491,7 +494,7 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" dependencies = [ - "quote 1.0.35", + "quote 1.0.36", "syn 1.0.109", ] @@ -503,7 +506,7 @@ checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20" dependencies = [ "num-bigint", "num-traits", - "quote 1.0.35", + "quote 1.0.36", "syn 1.0.109", ] @@ -515,8 +518,8 @@ checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" dependencies = [ "num-bigint", "num-traits", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -577,7 +580,7 @@ dependencies = [ [[package]] name = "ark-secret-scalar" version = "0.0.2" -source = "git+https://github.com/w3f/ring-vrf?rev=e9782f9#e9782f938629c90f3adb3fff2358bc8d1386af3e" +source = "git+https://github.com/w3f/ring-vrf?rev=0fef826#0fef8266d851932ad25d6b41bc4b34d834d1e11d" dependencies = [ "ark-ec", "ark-ff 0.4.2", @@ -617,8 +620,8 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -629,7 +632,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c" dependencies = [ "num-traits", - "rand 0.8.5", + "rand", ] [[package]] @@ -639,20 +642,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" dependencies = [ "num-traits", - "rand 0.8.5", + "rand", "rayon", ] [[package]] name = "ark-transcript" version = "0.0.2" -source = "git+https://github.com/w3f/ring-vrf?rev=e9782f9#e9782f938629c90f3adb3fff2358bc8d1386af3e" +source = "git+https://github.com/w3f/ring-vrf?rev=0fef826#0fef8266d851932ad25d6b41bc4b34d834d1e11d" dependencies = [ "ark-ff 0.4.2", "ark-serialize 0.4.2", "ark-std 0.4.0", "digest 0.10.7", - "rand_core 0.6.4", + "rand_core", "sha3", ] @@ -689,8 +692,24 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f6fd5ddaf0351dff5b8da21b2fb4ff8e08ddd02857f0bf69c47639106c0fff0" dependencies = [ - "asn1-rs-derive", - "asn1-rs-impl", + "asn1-rs-derive 0.4.0", + "asn1-rs-impl 0.1.0", + "displaydoc", + "nom", + "num-traits", + "rusticata-macros", + "thiserror", + "time", +] + +[[package]] +name = "asn1-rs" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "22ad1373757efa0f70ec53939aabc7152e1591cb485208052993070ac8d2429d" +dependencies = [ + "asn1-rs-derive 0.5.0", + "asn1-rs-impl 0.2.0", "displaydoc", "nom", "num-traits", @@ -705,10 +724,22 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "726535892e8eae7e70657b4c8ea93d26b8553afb1ce617caee529ef96d7dee6c" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", - "synstructure", + "synstructure 0.12.6", +] + +[[package]] +name = "asn1-rs-derive" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7378575ff571966e99a744addeff0bff98b8ada0dedf1956d59e634db95eaac1" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", + "synstructure 0.13.1", ] [[package]] @@ -717,16 +748,27 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2777730b2039ac0f95f093556e61b6d26cebed5393ca6f152717777cec3a42ed" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] +[[package]] +name = "asn1-rs-impl" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + [[package]] name = "assert_cmd" -version = "2.0.12" +version = "2.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "88903cb14723e4d4003335bb7f8a14f27691649105346a0f0957466c096adfe6" +checksum = "ed72493ac66d5804837f480ab3766c72bdfab91a65e565fc54fa9e42db0073a8" dependencies = [ "anstyle", "bstr", @@ -763,7 +805,6 @@ name = "asset-hub-rococo-integration-tests" version = "1.0.0" dependencies = [ "assert_matches", - "asset-hub-rococo-runtime", "asset-test-utils", "cumulus-pallet-parachain-system", "emulated-integration-tests-common", @@ -777,14 +818,13 @@ dependencies = [ "pallet-xcm", "parachains-common", "parity-scale-codec", - "penpal-runtime", "polkadot-runtime-common", - "rococo-runtime", "rococo-runtime-constants", "rococo-system-emulated-network", "sp-runtime", "staging-xcm", "staging-xcm-executor", + "xcm-runtime-apis", ] [[package]] @@ -808,6 +848,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -819,6 +860,7 @@ dependencies = [ "pallet-asset-conversion-ops", "pallet-asset-conversion-tx-payment", "pallet-assets", + "pallet-assets-freezer", "pallet-aura", "pallet-authorship", "pallet-balances", @@ -830,7 +872,6 @@ dependencies = [ "pallet-nfts-runtime-api", "pallet-proxy", "pallet-session", - "pallet-state-trie-migration", "pallet-timestamp", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", @@ -856,7 +897,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -867,7 +907,7 @@ dependencies = [ "staging-xcm-executor", "substrate-wasm-builder", "testnet-parachains-constants", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -890,11 +930,11 @@ name = "asset-hub-westend-integration-tests" version = "1.0.0" dependencies = [ "assert_matches", - "asset-hub-westend-runtime", "asset-test-utils", "cumulus-pallet-parachain-system", "cumulus-pallet-xcmp-queue", "emulated-integration-tests-common", + "frame-metadata-hash-extension", "frame-support", "frame-system", "pallet-asset-conversion", @@ -907,16 +947,14 @@ dependencies = [ "pallet-xcm", "parachains-common", "parity-scale-codec", - "penpal-runtime", "polkadot-runtime-common", "sp-core", "sp-keyring", "sp-runtime", "staging-xcm", "staging-xcm-executor", - "westend-runtime", "westend-system-emulated-network", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -940,6 +978,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -951,6 +990,7 @@ dependencies = [ "pallet-asset-conversion-ops", "pallet-asset-conversion-tx-payment", "pallet-assets", + "pallet-assets-freezer", "pallet-aura", "pallet-authorship", "pallet-balances", @@ -977,6 +1017,7 @@ dependencies = [ "polkadot-runtime-common", "primitive-types", "scale-info", + "snowbridge-router-primitives", "sp-api", "sp-block-builder", "sp-consensus-aura", @@ -997,7 +1038,7 @@ dependencies = [ "substrate-wasm-builder", "testnet-parachains-constants", "westend-runtime-constants", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -1022,7 +1063,6 @@ dependencies = [ "parity-scale-codec", "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-parachain-info", "staging-xcm", "staging-xcm-builder", @@ -1045,7 +1085,6 @@ dependencies = [ "scale-info", "sp-api", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", @@ -1058,7 +1097,7 @@ version = "1.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3203e79f4dd9bdda415ed03cf14dae5a2bf775c683a00f94e9cd1faf0f596e5" dependencies = [ - "quote 1.0.35", + "quote 1.0.36", "syn 1.0.109", ] @@ -1069,7 +1108,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35" dependencies = [ "concurrent-queue", - "event-listener", + "event-listener 2.5.3", "futures-core", ] @@ -1079,11 +1118,11 @@ version = "1.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6fa3dc5f2a8564f07759c008b9109dc0d39de92a88d5588b8a5036d286383afb" dependencies = [ - "async-lock", + "async-lock 2.8.0", "async-task", "concurrent-queue", "fastrand 1.9.0", - "futures-lite", + "futures-lite 1.13.0", "slab", ] @@ -1093,10 +1132,10 @@ version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "279cf904654eeebfa37ac9bb1598880884924aab82e290aa65c9e77a0e142e06" dependencies = [ - "async-lock", + "async-lock 2.8.0", "autocfg", "blocking", - "futures-lite", + "futures-lite 1.13.0", ] [[package]] @@ -1107,10 +1146,10 @@ checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776" dependencies = [ "async-channel", "async-executor", - "async-io", - "async-lock", + "async-io 1.13.0", + "async-lock 2.8.0", "blocking", - "futures-lite", + "futures-lite 1.13.0", "once_cell", ] @@ -1120,27 +1159,57 @@ version = "1.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af" dependencies = [ - "async-lock", + "async-lock 2.8.0", "autocfg", "cfg-if", "concurrent-queue", - "futures-lite", + "futures-lite 1.13.0", "log", "parking", - "polling", + "polling 2.8.0", "rustix 0.37.23", "slab", "socket2 0.4.9", "waker-fn", ] +[[package]] +name = "async-io" +version = "2.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d6baa8f0178795da0e71bc42c9e5d13261aac7ee549853162e66a241ba17964" +dependencies = [ + "async-lock 3.4.0", + "cfg-if", + "concurrent-queue", + "futures-io", + "futures-lite 2.3.0", + "parking", + "polling 3.4.0", + "rustix 0.38.21", + "slab", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "async-lock" version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b" dependencies = [ - "event-listener", + "event-listener 2.5.3", +] + +[[package]] +name = "async-lock" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18" +dependencies = [ + "event-listener 5.2.0", + "event-listener-strategy", + "pin-project-lite", ] [[package]] @@ -1149,10 +1218,10 @@ version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4051e67316bc7eff608fe723df5d32ed639946adcd69e07df41fd42a7b411f1f" dependencies = [ - "async-io", + "async-io 1.13.0", "autocfg", "blocking", - "futures-lite", + "futures-lite 1.13.0", ] [[package]] @@ -1161,13 +1230,13 @@ version = "1.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a9d28b1d97e08915212e2e45310d47854eafa69600756fc735fb788f75199c9" dependencies = [ - "async-io", - "async-lock", + "async-io 1.13.0", + "async-lock 2.8.0", "autocfg", "blocking", "cfg-if", - "event-listener", - "futures-lite", + "event-listener 2.5.3", + "futures-lite 1.13.0", "rustix 0.37.23", "signal-hook", "windows-sys 0.48.0", @@ -1182,19 +1251,19 @@ dependencies = [ "async-attributes", "async-channel", "async-global-executor", - "async-io", - "async-lock", + "async-io 1.13.0", + "async-lock 2.8.0", "crossbeam-utils", "futures-channel", "futures-core", "futures-io", - "futures-lite", + "futures-lite 1.13.0", "gloo-timers", "kv-log-macro", "log", "memchr", "once_cell", - "pin-project-lite 0.2.12", + "pin-project-lite", "pin-utils", "slab", "wasm-bindgen-futures", @@ -1208,7 +1277,7 @@ checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51" dependencies = [ "async-stream-impl", "futures-core", - "pin-project-lite 0.2.12", + "pin-project-lite", ] [[package]] @@ -1217,9 +1286,9 @@ version = "0.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -1230,13 +1299,13 @@ checksum = "ecc7ab41815b3c653ccd2978ec3255c81349336702dfdf62ee6f7069b12a3aae" [[package]] name = "async-trait" -version = "0.1.79" +version = "0.1.80" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a507401cad91ec6a857ed5513a2073c82a9b9048762b885bb98655b306964681" +checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -1249,7 +1318,7 @@ dependencies = [ "futures-sink", "futures-util", "memchr", - "pin-project-lite 0.2.12", + "pin-project-lite", ] [[package]] @@ -1264,6 +1333,17 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1181e1e0d1fce796a03db1ae795d67167da795f9cf4a39c37589e85ef57f26d3" +[[package]] +name = "attohttpc" +version = "0.24.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8d9a9bf8b79a749ee0b911b91b671cc2b6c670bdbc7e3dfd537576ddc94bb2a2" +dependencies = [ + "http 0.2.9", + "log", + "url", +] + [[package]] name = "atty" version = "0.2.14" @@ -1282,8 +1362,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fee3da8ef1276b0bee5dd1c7258010d8fffd31801447323115a25560e1327b89" dependencies = [ "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -1299,16 +1379,16 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b62ddb9cb1ec0a098ad4bbf9344d0713fa193ae1a80af55febcff2627b6a00c1" dependencies = [ - "getrandom 0.2.10", + "getrandom", "instant", - "rand 0.8.5", + "rand", ] [[package]] name = "backtrace" -version = "0.3.69" +version = "0.3.71" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" +checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d" dependencies = [ "addr2line 0.21.0", "cc", @@ -1322,7 +1402,7 @@ dependencies = [ [[package]] name = "bandersnatch_vrfs" version = "0.0.4" -source = "git+https://github.com/w3f/ring-vrf?rev=e9782f9#e9782f938629c90f3adb3fff2358bc8d1386af3e" +source = "git+https://github.com/w3f/ring-vrf?rev=0fef826#0fef8266d851932ad25d6b41bc4b34d834d1e11d" dependencies = [ "ark-bls12-381", "ark-ec", @@ -1331,10 +1411,8 @@ dependencies = [ "ark-serialize 0.4.2", "ark-std 0.4.0", "dleq_vrf", - "fflonk", - "merlin", - "rand_chacha 0.3.1", - "rand_core 0.6.4", + "rand_chacha", + "rand_core", "ring 0.1.0", "sha2 0.10.8", "sp-ark-bls12-381", @@ -1366,6 +1444,12 @@ version = "0.21.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d" +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + [[package]] name = "base64ct" version = "1.6.0" @@ -1381,25 +1465,16 @@ dependencies = [ "serde", ] -[[package]] -name = "beef" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1" -dependencies = [ - "serde", -] - [[package]] name = "binary-merkle-tree" version = "13.0.0" dependencies = [ "array-bytes", - "env_logger 0.11.3", "hash-db", "log", "sp-core", "sp-runtime", + "sp-tracing 16.0.0", ] [[package]] @@ -1424,12 +1499,12 @@ dependencies = [ "lazycell", "peeking_take_while", "prettyplease 0.2.12", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "regex", - "rustc-hash", + "rustc-hash 1.1.0", "shlex", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -1488,9 +1563,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.4.0" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635" +checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de" [[package]] name = "bitvec" @@ -1538,13 +1613,13 @@ dependencies = [ [[package]] name = "blake2b_simd" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c2f0dc9a68c6317d884f97cc36cf5a3d20ba14ce404227df55e1af708ab04bc" +checksum = "23285ad32269793932e830392f2fe2f83e26488fd3ec778883a93c8323735780" dependencies = [ "arrayref", "arrayvec 0.7.4", - "constant_time_eq 0.2.6", + "constant_time_eq 0.3.0", ] [[package]] @@ -1596,11 +1671,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "77231a1c8f801696fc0123ec6150ce92cffb8e164a02afb9c8ddee0e9b65ad65" dependencies = [ "async-channel", - "async-lock", + "async-lock 2.8.0", "async-task", "atomic-waker", "fastrand 1.9.0", - "futures-lite", + "futures-lite 1.13.0", "log", ] @@ -1897,7 +1972,7 @@ dependencies = [ "bp-parachains", "bp-polkadot-core", "bp-runtime", - "ed25519-dalek 2.1.0", + "ed25519-dalek", "finality-grandpa", "parity-scale-codec", "sp-application-crypto", @@ -1949,7 +2024,6 @@ dependencies = [ "snowbridge-core", "sp-core", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", ] @@ -1970,8 +2044,6 @@ dependencies = [ name = "bridge-hub-rococo-integration-tests" version = "1.0.0" dependencies = [ - "asset-hub-rococo-runtime", - "bridge-hub-rococo-runtime", "cumulus-pallet-xcmp-queue", "emulated-integration-tests-common", "frame-support", @@ -2031,6 +2103,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -2093,10 +2166,9 @@ dependencies = [ "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", - "static_assertions", "substrate-wasm-builder", "testnet-parachains-constants", - "tuplex", + "xcm-runtime-apis", ] [[package]] @@ -2131,7 +2203,6 @@ dependencies = [ "sp-io", "sp-keyring", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "staging-xcm", "staging-xcm-builder", @@ -2155,10 +2226,13 @@ dependencies = [ name = "bridge-hub-westend-integration-tests" version = "1.0.0" dependencies = [ + "asset-hub-westend-runtime", "bridge-hub-westend-runtime", "cumulus-pallet-xcmp-queue", "emulated-integration-tests-common", "frame-support", + "hex-literal", + "log", "pallet-asset-conversion", "pallet-assets", "pallet-balances", @@ -2166,10 +2240,20 @@ dependencies = [ "pallet-message-queue", "pallet-xcm", "parachains-common", + "parity-scale-codec", "rococo-westend-system-emulated-network", + "scale-info", + "snowbridge-core", + "snowbridge-pallet-inbound-queue", + "snowbridge-pallet-inbound-queue-fixtures", + "snowbridge-pallet-outbound-queue", + "snowbridge-pallet-system", + "snowbridge-router-primitives", + "sp-core", "sp-runtime", "staging-xcm", "staging-xcm-executor", + "testnet-parachains-constants", ] [[package]] @@ -2202,6 +2286,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -2233,6 +2318,17 @@ dependencies = [ "polkadot-runtime-common", "scale-info", "serde", + "snowbridge-beacon-primitives", + "snowbridge-core", + "snowbridge-outbound-queue-runtime-api", + "snowbridge-pallet-ethereum-client", + "snowbridge-pallet-inbound-queue", + "snowbridge-pallet-outbound-queue", + "snowbridge-pallet-system", + "snowbridge-router-primitives", + "snowbridge-runtime-common", + "snowbridge-runtime-test-common", + "snowbridge-system-runtime-api", "sp-api", "sp-block-builder", "sp-consensus-aura", @@ -2252,11 +2348,10 @@ dependencies = [ "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", - "static_assertions", "substrate-wasm-builder", "testnet-parachains-constants", - "tuplex", "westend-runtime-constants", + "xcm-runtime-apis", ] [[package]] @@ -2274,7 +2369,6 @@ dependencies = [ "bp-xcm-bridge-hub-router", "frame-support", "frame-system", - "hash-db", "log", "pallet-balances", "pallet-bridge-grandpa", @@ -2285,8 +2379,6 @@ dependencies = [ "pallet-utility", "parity-scale-codec", "scale-info", - "sp-api", - "sp-core", "sp-io", "sp-runtime", "sp-std 14.0.0", @@ -2305,9 +2397,9 @@ checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3" [[package]] name = "bs58" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" +checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4" dependencies = [ "tinyvec", ] @@ -2364,9 +2456,9 @@ checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "bytes" -version = "1.4.0" +version = "1.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be" +checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9" [[package]] name = "bzip2-sys" @@ -2435,14 +2527,20 @@ checksum = "a2698f953def977c68f935bb0dfa959375ad4638570e969e2f1e9f433cbf1af6" [[package]] name = "cc" -version = "1.0.83" +version = "1.0.94" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" +checksum = "17f6e324229dc011159fcc089755d1e2e216a90d43a7dea6853ca740b84f35e7" dependencies = [ "jobserver", "libc", ] +[[package]] +name = "cesu8" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" + [[package]] name = "cexpr" version = "0.6.0" @@ -2507,6 +2605,31 @@ dependencies = [ "zeroize", ] +[[package]] +name = "chain-spec-guide-runtime" +version = "0.0.0" +dependencies = [ + "docify", + "pallet-balances", + "pallet-sudo", + "pallet-timestamp", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc-runtime-api", + "parity-scale-codec", + "polkadot-sdk-frame", + "sc-chain-spec", + "scale-info", + "serde", + "serde_json", + "sp-application-crypto", + "sp-core", + "sp-genesis-builder", + "sp-keyring", + "sp-runtime", + "staging-chain-spec-builder", + "substrate-wasm-builder", +] + [[package]] name = "chrono" version = "0.4.31" @@ -2558,7 +2681,7 @@ dependencies = [ "multibase", "multihash 0.17.0", "serde", - "unsigned-varint", + "unsigned-varint 0.7.2", ] [[package]] @@ -2571,7 +2694,7 @@ dependencies = [ "multibase", "multihash 0.18.1", "serde", - "unsigned-varint", + "unsigned-varint 0.7.2", ] [[package]] @@ -2648,12 +2771,12 @@ dependencies = [ [[package]] name = "clap" -version = "4.5.3" +version = "4.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "949626d00e063efc93b6dca932419ceb5432f99769911c0b995f7e884c778813" +checksum = "35723e6a11662c2afb578bcf0b88bf6ea8e21282a953428f240574fcc3a2b5b3" dependencies = [ "clap_builder", - "clap_derive 4.5.3", + "clap_derive 4.5.11", ] [[package]] @@ -2667,9 +2790,9 @@ dependencies = [ [[package]] name = "clap_builder" -version = "4.5.2" +version = "4.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae129e2e766ae0ec03484e609954119f123cc1fe650337e155d03b022f24f7b4" +checksum = "49eb96cbfa7cfa35017b7cd548c75b14c3118c98b423041d70562665e07fb0fa" dependencies = [ "anstream", "anstyle", @@ -2684,7 +2807,7 @@ version = "4.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "586a385f7ef2f8b4d86bddaa0c094794e7ccbfe5ffef1f434fe928143fc783a5" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", ] [[package]] @@ -2695,21 +2818,21 @@ checksum = "ae6371b8bdc8b7d3959e9cf7b22d4435ef3e79e138688421ec654acf8c81b008" dependencies = [ "heck 0.4.1", "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] [[package]] name = "clap_derive" -version = "4.5.3" +version = "4.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90239a040c80f5e14809ca132ddc4176ab33d5e17e49691793296e3fcb34d72f" +checksum = "5d029b67f89d30bbb547c89fd5161293c0aec155fc691d7924b64550662db93e" dependencies = [ "heck 0.5.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -2735,7 +2858,7 @@ checksum = "a90d114103adbc625300f346d4d09dfb4ab1c4a8df6868435dd903392ecf4354" dependencies = [ "libc", "once_cell", - "wasi 0.11.0+wasi-snapshot-preview1", + "wasi", "wasm-bindgen", ] @@ -2767,8 +2890,6 @@ name = "collectives-westend-integration-tests" version = "1.0.0" dependencies = [ "assert_matches", - "asset-hub-westend-runtime", - "collectives-westend-runtime", "cumulus-pallet-parachain-system", "cumulus-pallet-xcmp-queue", "emulated-integration-tests-common", @@ -2779,6 +2900,7 @@ dependencies = [ "pallet-message-queue", "pallet-treasury", "pallet-utility", + "pallet-whitelist", "pallet-xcm", "parachains-common", "parity-scale-codec", @@ -2787,7 +2909,6 @@ dependencies = [ "staging-xcm", "staging-xcm-executor", "testnet-parachains-constants", - "westend-runtime", "westend-runtime-constants", "westend-system-emulated-network", ] @@ -2855,7 +2976,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -2866,6 +2986,7 @@ dependencies = [ "substrate-wasm-builder", "testnet-parachains-constants", "westend-runtime-constants", + "xcm-runtime-apis", ] [[package]] @@ -2897,8 +3018,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d51beaa537d73d2d1ff34ee70bc095f170420ab2ec5d687ecd3ec2b0d092514b" dependencies = [ "nom", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -2943,7 +3064,7 @@ dependencies = [ [[package]] name = "common" version = "0.1.0" -source = "git+https://github.com/w3f/ring-proof#b273d33f9981e2bb3375ab45faeb537f7ee35224" +source = "git+https://github.com/w3f/ring-proof?rev=665f5f5#665f5f51af5734c7b6d90b985dd6861d4c5b4752" dependencies = [ "ark-ec", "ark-ff 0.4.2", @@ -2953,7 +3074,7 @@ dependencies = [ "fflonk", "getrandom_or_panic", "merlin", - "rand_chacha 0.3.1", + "rand_chacha", ] [[package]] @@ -3029,7 +3150,7 @@ version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9d7d6ab3c3a2282db210df5f02c4dab6e0a7057af0fb7ebd4070f30fe05c0ddb" dependencies = [ - "getrandom 0.2.10", + "getrandom", "once_cell", "proc-macro-hack", "tiny-keccak", @@ -3111,7 +3232,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -3121,6 +3241,7 @@ dependencies = [ "staging-xcm-executor", "substrate-wasm-builder", "testnet-parachains-constants", + "xcm-runtime-apis", ] [[package]] @@ -3131,9 +3252,9 @@ checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" [[package]] name = "core-foundation" -version = "0.9.3" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146" +checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" dependencies = [ "core-foundation-sys", "libc", @@ -3141,9 +3262,9 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.8.4" +version = "0.8.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa" +checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" [[package]] name = "core2" @@ -3154,6 +3275,36 @@ dependencies = [ "memchr", ] +[[package]] +name = "coretime-rococo-emulated-chain" +version = "0.0.0" +dependencies = [ + "coretime-rococo-runtime", + "cumulus-primitives-core", + "emulated-integration-tests-common", + "frame-support", + "parachains-common", + "sp-core", + "testnet-parachains-constants", +] + +[[package]] +name = "coretime-rococo-integration-tests" +version = "0.1.0" +dependencies = [ + "emulated-integration-tests-common", + "frame-support", + "pallet-balances", + "pallet-identity", + "pallet-message-queue", + "polkadot-runtime-common", + "rococo-runtime-constants", + "rococo-system-emulated-network", + "sp-runtime", + "staging-xcm", + "staging-xcm-executor", +] + [[package]] name = "coretime-rococo-runtime" version = "0.1.0" @@ -3169,6 +3320,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -3207,7 +3359,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -3217,6 +3368,37 @@ dependencies = [ "staging-xcm-executor", "substrate-wasm-builder", "testnet-parachains-constants", + "xcm-runtime-apis", +] + +[[package]] +name = "coretime-westend-emulated-chain" +version = "0.0.0" +dependencies = [ + "coretime-westend-runtime", + "cumulus-primitives-core", + "emulated-integration-tests-common", + "frame-support", + "parachains-common", + "sp-core", + "testnet-parachains-constants", +] + +[[package]] +name = "coretime-westend-integration-tests" +version = "0.1.0" +dependencies = [ + "emulated-integration-tests-common", + "frame-support", + "pallet-balances", + "pallet-identity", + "pallet-message-queue", + "polkadot-runtime-common", + "sp-runtime", + "staging-xcm", + "staging-xcm-executor", + "westend-runtime-constants", + "westend-system-emulated-network", ] [[package]] @@ -3234,6 +3416,7 @@ dependencies = [ "cumulus-primitives-utility", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -3270,7 +3453,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -3281,6 +3463,7 @@ dependencies = [ "substrate-wasm-builder", "testnet-parachains-constants", "westend-runtime-constants", + "xcm-runtime-apis", ] [[package]] @@ -3451,7 +3634,7 @@ dependencies = [ "anes", "cast", "ciborium", - "clap 4.5.3", + "clap 4.5.11", "criterion-plot", "futures", "is-terminal", @@ -3536,7 +3719,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf4c2f4e1afd912bc40bfd6fed5d9dc1f288e0ba01bfcc835cc5bc3eb13efe15" dependencies = [ "generic-array 0.14.7", - "rand_core 0.6.4", + "rand_core", "subtle 2.5.0", "zeroize", ] @@ -3548,7 +3731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" dependencies = [ "generic-array 0.14.7", - "rand_core 0.6.4", + "rand_core", "typenum", ] @@ -3585,7 +3768,7 @@ dependencies = [ name = "cumulus-client-cli" version = "0.7.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "parity-scale-codec", "sc-chain-spec", "sc-cli", @@ -3610,7 +3793,7 @@ dependencies = [ "cumulus-test-runtime", "futures", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-node-subsystem-test-helpers", @@ -3641,6 +3824,7 @@ dependencies = [ "cumulus-relay-chain-interface", "futures", "parity-scale-codec", + "parking_lot 0.12.3", "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-overseer", @@ -3651,6 +3835,7 @@ dependencies = [ "sc-consensus-babe", "sc-consensus-slots", "sc-telemetry", + "sc-utils", "schnellru", "sp-api", "sp-application-crypto", @@ -3665,6 +3850,7 @@ dependencies = [ "sp-state-machine", "sp-timestamp", "substrate-prometheus-endpoint", + "tokio", "tracing", ] @@ -3696,6 +3882,7 @@ dependencies = [ "sp-timestamp", "sp-tracing 16.0.0", "sp-trie", + "sp-version", "substrate-prometheus-endpoint", "tracing", ] @@ -3723,7 +3910,7 @@ dependencies = [ "cumulus-primitives-core", "cumulus-relay-chain-interface", "futures", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-consensus", "sp-api", "sp-block-builder", @@ -3748,14 +3935,17 @@ dependencies = [ "futures", "futures-timer", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-primitives", + "polkadot-node-subsystem", "polkadot-parachain-primitives", "polkadot-primitives", "polkadot-test-client", "portpicker", + "rstest", "sc-cli", "sc-client-api", + "sp-api", "sp-blockchain", "sp-consensus", "sp-core", @@ -3763,6 +3953,7 @@ dependencies = [ "sp-keystore", "sp-runtime", "sp-state-machine", + "sp-version", "substrate-test-utils", "tokio", "tracing", @@ -3780,13 +3971,11 @@ dependencies = [ "cumulus-test-relay-sproof-builder", "parity-scale-codec", "sc-client-api", - "scale-info", "sp-api", "sp-crypto-hashing", "sp-inherents", "sp-runtime", "sp-state-machine", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-trie", "tracing", @@ -3796,9 +3985,11 @@ dependencies = [ name = "cumulus-client-pov-recovery" version = "0.7.0" dependencies = [ + "assert_matches", "async-trait", "cumulus-primitives-core", "cumulus-relay-chain-interface", + "cumulus-test-client", "cumulus-test-service", "futures", "futures-timer", @@ -3808,13 +3999,19 @@ dependencies = [ "polkadot-overseer", "polkadot-primitives", "portpicker", - "rand 0.8.5", + "rand", + "rstest", "sc-cli", "sc-client-api", "sc-consensus", + "sc-utils", + "sp-api", + "sp-blockchain", "sp-consensus", "sp-maybe-compressed-blob", "sp-runtime", + "sp-tracing 16.0.0", + "sp-version", "substrate-test-utils", "tokio", "tracing", @@ -3870,7 +4067,6 @@ dependencies = [ "sp-application-crypto", "sp-consensus-aura", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -3887,7 +4083,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "staging-xcm", ] @@ -3919,7 +4114,7 @@ dependencies = [ "polkadot-parachain-primitives", "polkadot-runtime-common", "polkadot-runtime-parachains", - "rand 0.8.5", + "rand", "sc-client-api", "scale-info", "sp-consensus-slots", @@ -3945,10 +4140,10 @@ dependencies = [ name = "cumulus-pallet-parachain-system-proc-macro" version = "0.6.0" dependencies = [ - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -3961,7 +4156,6 @@ dependencies = [ "pallet-session", "parity-scale-codec", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -3976,7 +4170,6 @@ dependencies = [ "polkadot-primitives", "scale-info", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -3990,7 +4183,6 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", ] @@ -4015,7 +4207,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", @@ -4032,21 +4223,33 @@ dependencies = [ "parity-scale-codec", "scale-info", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", ] [[package]] -name = "cumulus-primitives-aura" -version = "0.7.0" +name = "cumulus-pov-validator" +version = "0.1.0" dependencies = [ + "anyhow", + "clap 4.5.11", "parity-scale-codec", - "polkadot-core-primitives", + "polkadot-node-primitives", + "polkadot-parachain-primitives", "polkadot-primitives", + "sc-executor", + "sp-core", + "sp-io", + "sp-maybe-compressed-blob", + "tracing", + "tracing-subscriber 0.3.18", +] + +[[package]] +name = "cumulus-primitives-aura" +version = "0.7.0" +dependencies = [ "sp-api", "sp-consensus-aura", - "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -4060,7 +4263,6 @@ dependencies = [ "scale-info", "sp-api", "sp-runtime", - "sp-std 14.0.0", "sp-trie", "staging-xcm", ] @@ -4075,9 +4277,6 @@ dependencies = [ "scale-info", "sp-core", "sp-inherents", - "sp-runtime", - "sp-state-machine", - "sp-std 14.0.0", "sp-trie", ] @@ -4108,7 +4307,6 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-trie", ] @@ -4117,10 +4315,7 @@ name = "cumulus-primitives-timestamp" version = "0.7.0" dependencies = [ "cumulus-primitives-core", - "futures", - "parity-scale-codec", "sp-inherents", - "sp-std 14.0.0", "sp-timestamp", ] @@ -4134,10 +4329,7 @@ dependencies = [ "pallet-asset-conversion", "parity-scale-codec", "polkadot-runtime-common", - "polkadot-runtime-parachains", - "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", @@ -4185,6 +4377,7 @@ dependencies = [ "sp-api", "sp-blockchain", "sp-state-machine", + "sp-version", "thiserror", ] @@ -4198,15 +4391,8 @@ dependencies = [ "cumulus-relay-chain-interface", "cumulus-relay-chain-rpc-interface", "futures", - "parking_lot 0.12.1", - "polkadot-availability-recovery", - "polkadot-collator-protocol", "polkadot-core-primitives", "polkadot-network-bridge", - "polkadot-node-collation-generation", - "polkadot-node-core-chain-api", - "polkadot-node-core-prospective-parachains", - "polkadot-node-core-runtime-api", "polkadot-node-network-protocol", "polkadot-node-subsystem-util", "polkadot-overseer", @@ -4243,7 +4429,7 @@ dependencies = [ "parity-scale-codec", "pin-project", "polkadot-overseer", - "rand 0.8.5", + "rand", "sc-client-api", "sc-rpc-api", "sc-service", @@ -4313,7 +4499,6 @@ dependencies = [ "polkadot-primitives", "sp-runtime", "sp-state-machine", - "sp-std 14.0.0", "sp-trie", ] @@ -4352,9 +4537,9 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-transaction-pool", "sp-version", + "staging-parachain-info", "substrate-wasm-builder", ] @@ -4363,7 +4548,7 @@ name = "cumulus-test-service" version = "0.1.0" dependencies = [ "async-trait", - "clap 4.5.3", + "clap 4.5.11", "criterion", "cumulus-client-cli", "cumulus-client-collator", @@ -4398,8 +4583,7 @@ dependencies = [ "polkadot-service", "polkadot-test-service", "portpicker", - "rand 0.8.5", - "rococo-parachain-runtime", + "rand", "sc-basic-authorship", "sc-block-builder", "sc-chain-spec", @@ -4424,7 +4608,6 @@ dependencies = [ "sp-blockchain", "sp-consensus", "sp-consensus-aura", - "sp-consensus-grandpa", "sp-core", "sp-io", "sp-keyring", @@ -4451,7 +4634,7 @@ dependencies = [ "openssl-probe", "openssl-sys", "schannel", - "socket2 0.5.6", + "socket2 0.5.7", "windows-sys 0.52.0", ] @@ -4473,29 +4656,15 @@ dependencies = [ [[package]] name = "curve25519-dalek" -version = "3.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61" -dependencies = [ - "byteorder", - "digest 0.9.0", - "rand_core 0.5.1", - "subtle 2.5.0", - "zeroize", -] - -[[package]] -name = "curve25519-dalek" -version = "4.1.2" +version = "4.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348" +checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be" dependencies = [ "cfg-if", "cpufeatures", "curve25519-dalek-derive", "digest 0.10.7", "fiat-crypto", - "platforms", "rustc_version 0.4.0", "subtle 2.5.0", "zeroize", @@ -4507,9 +4676,9 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "83fdaf97f4804dcebfa5862639bc9ce4121e82140bec2a987ac5140294865b5b" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -4520,7 +4689,7 @@ checksum = "1c359b7249347e46fb28804470d071c921156ad62b3eef5d34e2ba867533dec8" dependencies = [ "byteorder", "digest 0.9.0", - "rand_core 0.6.4", + "rand_core", "subtle-ng", "zeroize", ] @@ -4546,10 +4715,10 @@ dependencies = [ "cc", "codespan-reporting", "once_cell", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "scratch", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -4564,9 +4733,9 @@ version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50c49547d73ba8dcfd4ad7325d64c6d5391ff4224d498fc39a6f3f49825a530d" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -4633,7 +4802,21 @@ version = "8.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dbd676fbbab537128ef0278adb5576cf363cff6aa22a7b24effe97347cfab61e" dependencies = [ - "asn1-rs", + "asn1-rs 0.5.2", + "displaydoc", + "nom", + "num-bigint", + "num-traits", + "rusticata-macros", +] + +[[package]] +name = "der-parser" +version = "9.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5cd0a5c643689626bec213c4d8bd4d96acc8ffdb4ad4bb6bc16abf27d5f4b553" +dependencies = [ + "asn1-rs 0.6.1", "displaydoc", "nom", "num-bigint", @@ -4643,9 +4826,12 @@ dependencies = [ [[package]] name = "deranged" -version = "0.3.8" +version = "0.3.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946" +checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" +dependencies = [ + "powerfmt", +] [[package]] name = "derivative" @@ -4653,31 +4839,31 @@ version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] [[package]] name = "derive-syn-parse" -version = "0.1.5" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e79116f119dd1dba1abf1f3405f03b9b0e79a27a3883864bfebded8a3dc768cd" +checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 1.0.109", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] -name = "derive-syn-parse" -version = "0.2.0" +name = "derive_arbitrary" +version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762" +checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -4687,8 +4873,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" dependencies = [ "convert_case", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "rustc_version 0.4.0", "syn 1.0.109", ] @@ -4783,9 +4969,9 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "487585f4d0c6655fe74905e2504d8ad6908e4db67f744eb140876906c2f3175d" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -4797,7 +4983,7 @@ checksum = "86e3bdc80eee6e16b2b6b0f87fbc98c04bee3455e35174c0de1a125d0688c632" [[package]] name = "dleq_vrf" version = "0.0.2" -source = "git+https://github.com/w3f/ring-vrf?rev=e9782f9#e9782f938629c90f3adb3fff2358bc8d1386af3e" +source = "git+https://github.com/w3f/ring-vrf?rev=0fef826#0fef8266d851932ad25d6b41bc4b34d834d1e11d" dependencies = [ "ark-ec", "ark-ff 0.4.2", @@ -4841,12 +5027,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1a081e51fb188742f5a7a1164ad752121abcb22874b21e2c3b0dd040c515fdad" dependencies = [ "common-path", - "derive-syn-parse 0.2.0", + "derive-syn-parse", "once_cell", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "regex", - "syn 2.0.53", + "syn 2.0.61", "termcolor", "toml 0.8.8", "walkdir", @@ -4892,8 +5078,8 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -4914,19 +5100,10 @@ dependencies = [ "elliptic-curve", "rfc6979", "serdect", - "signature 2.1.0", + "signature", "spki", ] -[[package]] -name = "ed25519" -version = "1.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91cff35c70bba8a626e3185d8cd48cc11b5437e1a5bcd15b9b5fa3c64b6dfee7" -dependencies = [ - "signature 1.6.4", -] - [[package]] name = "ed25519" version = "2.2.2" @@ -4934,32 +5111,18 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "60f6d271ca33075c88028be6f04d502853d63a5ece419d269c15315d4fc1cf1d" dependencies = [ "pkcs8", - "signature 2.1.0", -] - -[[package]] -name = "ed25519-dalek" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c762bae6dcaf24c4c84667b8579785430908723d5c889f469d76a41d59cc7a9d" -dependencies = [ - "curve25519-dalek 3.2.0", - "ed25519 1.5.3", - "rand 0.7.3", - "serde", - "sha2 0.9.9", - "zeroize", + "signature", ] [[package]] name = "ed25519-dalek" -version = "2.1.0" +version = "2.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f628eaec48bfd21b865dc2950cfa014450c01d2fa2b69a86c2fd5844ec523c0" +checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871" dependencies = [ - "curve25519-dalek 4.1.2", - "ed25519 2.2.2", - "rand_core 0.6.4", + "curve25519-dalek", + "ed25519", + "rand_core", "serde", "sha2 0.10.8", "subtle 2.5.0", @@ -4972,11 +5135,11 @@ version = "4.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d9ce6874da5d4415896cd45ffbc4d1cfc0c4f9c079427bd870742c30f2f65a9" dependencies = [ - "curve25519-dalek 4.1.2", - "ed25519 2.2.2", + "curve25519-dalek", + "ed25519", "hashbrown 0.14.3", "hex", - "rand_core 0.6.4", + "rand_core", "sha2 0.10.8", "zeroize", ] @@ -5000,7 +5163,7 @@ dependencies = [ "generic-array 0.14.7", "group", "pkcs8", - "rand_core 0.6.4", + "rand_core", "sec1", "serdect", "subtle 2.5.0", @@ -5061,8 +5224,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116" dependencies = [ "heck 0.4.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -5073,9 +5236,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5ffccbb6966c05b32ef8fbac435df276c4ae4d3dc55a8cd0eb9745e6c12f546a" dependencies = [ "heck 0.4.1", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -5093,20 +5256,20 @@ version = "0.7.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e9a1f9f7d83e59740248a6e14ecf93929ade55027844dfcea78beafccc15745" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "enumn" -version = "0.1.12" +version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2ad8cef1d801a4686bfd8919f0b30eac4c8e48968c437a6405ded4fb5272d2b" +checksum = "6fd000fd6988e73bbe993ea3db9b1aa64906ab88766d654973924340c8cddb42" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -5116,7 +5279,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a009aa4810eb158359dda09d0c87378e4bbb89b5a801f016885a4707ba24f7ea" dependencies = [ "log", - "regex", ] [[package]] @@ -5129,19 +5291,6 @@ dependencies = [ "regex", ] -[[package]] -name = "env_logger" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7" -dependencies = [ - "atty", - "humantime", - "log", - "regex", - "termcolor", -] - [[package]] name = "env_logger" version = "0.10.1" @@ -5164,7 +5313,6 @@ dependencies = [ "anstream", "anstyle", "env_filter", - "humantime", "log", ] @@ -5283,37 +5431,48 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0" [[package]] -name = "exit-future" -version = "0.2.0" +name = "event-listener" +version = "5.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e43f2f1833d64e33f15592464d6fdd70f349dda7b1a53088eb83cd94014008c5" +checksum = "2b5fb89194fa3cad959b833185b3063ba881dbfc7030680b314250779fb4cc91" dependencies = [ - "futures", + "concurrent-queue", + "parking", + "pin-project-lite", ] [[package]] -name = "expander" -version = "0.0.4" +name = "event-listener-strategy" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a718c0675c555c5f976fff4ea9e2c150fa06cefa201cadef87cfbf9324075881" +checksum = "0f214dc438f977e6d4e3500aaa277f5ad94ca83fbbd9b1a15713ce2344ccc5a1" dependencies = [ - "blake3", - "fs-err", - "proc-macro2 1.0.75", - "quote 1.0.35", + "event-listener 5.2.0", + "pin-project-lite", +] + +[[package]] +name = "exit-future" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e43f2f1833d64e33f15592464d6fdd70f349dda7b1a53088eb83cd94014008c5" +dependencies = [ + "futures", ] [[package]] name = "expander" -version = "2.0.0" +version = "2.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f86a749cf851891866c10515ef6c299b5c69661465e9c3bbe7e07a2b77fb0f7" +checksum = "e2c470c71d91ecbd179935b24170459e926382eaaa86b590b78814e180d8a8e2" dependencies = [ "blake2 0.10.6", + "file-guard", "fs-err", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "prettyplease 0.2.12", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -5349,9 +5508,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.0.0" +version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764" +checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a" [[package]] name = "fastrlp" @@ -5366,9 +5525,9 @@ dependencies = [ [[package]] name = "fatality" -version = "0.0.6" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ad875162843b0d046276327afe0136e9ed3a23d5a754210fb6f1f33610d39ab" +checksum = "ec6f82451ff7f0568c6181287189126d492b5654e30a788add08027b6363d019" dependencies = [ "fatality-proc-macro", "thiserror", @@ -5376,17 +5535,16 @@ dependencies = [ [[package]] name = "fatality-proc-macro" -version = "0.0.6" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5aa1e3ae159e592ad222dc90c5acbad632b527779ba88486abe92782ab268bd" +checksum = "eb42427514b063d97ce21d5199f36c0c307d981434a6be32582bc79fe5bd2303" dependencies = [ - "expander 0.0.4", - "indexmap 1.9.3", - "proc-macro-crate 1.3.1", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 1.0.109", - "thiserror", + "expander", + "indexmap 2.2.3", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -5421,7 +5579,7 @@ version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" dependencies = [ - "rand_core 0.6.4", + "rand_core", "subtle 2.5.0", ] @@ -5444,6 +5602,16 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "27573eac26f4dd11e2b1916c3fe1baa56407c83c71a773a8ba17ec0bca03b6b7" +[[package]] +name = "file-guard" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21ef72acf95ec3d7dbf61275be556299490a245f017cf084bd23b4f68cf9407c" +dependencies = [ + "libc", + "winapi", +] + [[package]] name = "file-per-thread-logger" version = "0.1.6" @@ -5478,8 +5646,8 @@ dependencies = [ "log", "num-traits", "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "scale-info", ] @@ -5494,7 +5662,7 @@ dependencies = [ "futures", "log", "num-traits", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "relay-utils", ] @@ -5517,7 +5685,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" dependencies = [ "byteorder", - "rand 0.8.5", + "rand", "rustc-hex", "static_assertions", ] @@ -5535,7 +5703,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c6c98ee8095e9d1dcbf2fcc6d95acccb90d1c81db1e44725c6a984b1dbdfb010" dependencies = [ "crc32fast", - "libz-sys", "miniz_oxide", ] @@ -5578,9 +5745,9 @@ dependencies = [ [[package]] name = "form_urlencoded" -version = "1.2.0" +version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652" +checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" dependencies = [ "percent-encoding", ] @@ -5633,7 +5800,6 @@ dependencies = [ "sp-keystore", "sp-runtime", "sp-runtime-interface 24.0.0", - "sp-std 14.0.0", "sp-storage 19.0.0", "static_assertions", ] @@ -5645,7 +5811,7 @@ dependencies = [ "Inflector", "array-bytes", "chrono", - "clap 4.5.3", + "clap 4.5.11", "comfy-table", "frame-benchmarking", "frame-support", @@ -5657,7 +5823,7 @@ dependencies = [ "linked-hash-map", "log", "parity-scale-codec", - "rand 0.8.5", + "rand", "rand_pcg", "sc-block-builder", "sc-chain-spec", @@ -5698,7 +5864,6 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -5708,12 +5873,12 @@ dependencies = [ "frame-election-provider-support", "frame-support", "parity-scale-codec", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "scale-info", "sp-arithmetic", - "syn 2.0.53", + "syn 2.0.61", "trybuild", ] @@ -5725,27 +5890,26 @@ dependencies = [ "frame-support", "frame-system", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "sp-arithmetic", "sp-core", "sp-io", "sp-npos-elections", "sp-runtime", - "sp-std 14.0.0", ] [[package]] name = "frame-election-solution-type-fuzzer" version = "2.0.0-alpha.5" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "frame-election-provider-solution-type", "frame-election-provider-support", "frame-support", "honggfuzz", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "sp-arithmetic", "sp-npos-elections", @@ -5770,7 +5934,6 @@ dependencies = [ "sp-inherents", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "sp-version", ] @@ -5787,18 +5950,39 @@ dependencies = [ "serde", ] +[[package]] +name = "frame-metadata-hash-extension" +version = "0.1.0" +dependencies = [ + "array-bytes", + "docify", + "frame-metadata", + "frame-support", + "frame-system", + "log", + "merkleized-metadata", + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-runtime", + "sp-tracing 16.0.0", + "sp-transaction-pool", + "substrate-test-runtime-client", + "substrate-wasm-builder", +] + [[package]] name = "frame-omni-bencher" version = "0.1.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "cumulus-primitives-proof-size-hostfunction", - "env_logger 0.11.3", "frame-benchmarking-cli", "log", "sc-cli", "sp-runtime", "sp-statement-store", + "tracing-subscriber 0.3.18", ] [[package]] @@ -5874,17 +6058,28 @@ version = "23.0.0" dependencies = [ "Inflector", "cfg-expr", - "derive-syn-parse 0.2.0", - "expander 2.0.0", + "derive-syn-parse", + "docify", + "expander", + "frame-support", "frame-support-procedural-tools", + "frame-system", "itertools 0.11.0", "macro_magic", - "proc-macro-warning", - "proc-macro2 1.0.75", - "quote 1.0.35", + "parity-scale-codec", + "pretty_assertions", + "proc-macro-warning 1.0.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "regex", + "scale-info", + "sp-core", "sp-crypto-hashing", - "syn 2.0.53", + "sp-io", + "sp-metadata-ir", + "sp-runtime", + "static_assertions", + "syn 2.0.61", ] [[package]] @@ -5892,19 +6087,19 @@ name = "frame-support-procedural-tools" version = "10.0.0" dependencies = [ "frame-support-procedural-tools-derive", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "frame-support-procedural-tools-derive" version = "11.0.0" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -5929,7 +6124,6 @@ dependencies = [ "sp-metadata-ir", "sp-runtime", "sp-state-machine", - "sp-std 14.0.0", "sp-version", "static_assertions", "trybuild", @@ -6004,7 +6198,6 @@ dependencies = [ "sp-externalities 0.25.0", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-version", ] @@ -6012,6 +6205,7 @@ dependencies = [ name = "frame-system-rpc-runtime-api" version = "26.0.0" dependencies = [ + "docify", "parity-scale-codec", "sp-api", ] @@ -6024,7 +6218,6 @@ dependencies = [ "parity-scale-codec", "sp-api", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -6080,6 +6273,16 @@ dependencies = [ "futures-util", ] +[[package]] +name = "futures-bounded" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b07bbbe7d7e78809544c6f718d875627addc73a7c3582447abc052cd3dc67e0" +dependencies = [ + "futures-timer", + "futures-util", +] + [[package]] name = "futures-channel" version = "0.3.30" @@ -6125,30 +6328,39 @@ dependencies = [ "futures-io", "memchr", "parking", - "pin-project-lite 0.2.12", + "pin-project-lite", "waker-fn", ] +[[package]] +name = "futures-lite" +version = "2.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52527eb5074e35e9339c6b4e8d12600c7128b68fb25dcb9fa9dec18f7c25f3a5" +dependencies = [ + "futures-core", + "pin-project-lite", +] + [[package]] name = "futures-macro" version = "0.3.30" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "futures-rustls" -version = "0.22.2" +version = "0.24.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2411eed028cdf8c8034eaf21f9915f956b6c3abec4d4c7949ee67f0721127bd" +checksum = "35bd3cf68c183738046838e300353e4716c674dc5e56890de4826801a6622a28" dependencies = [ "futures-io", - "rustls 0.20.8", - "webpki", + "rustls 0.21.7", ] [[package]] @@ -6165,9 +6377,9 @@ checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" [[package]] name = "futures-timer" -version = "3.0.2" +version = "3.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c" +checksum = "f288b0a4f20f9a56b5d1da57e2227c661b7b16168e2f72365f57b63326e29b24" [[package]] name = "futures-util" @@ -6182,7 +6394,7 @@ dependencies = [ "futures-sink", "futures-task", "memchr", - "pin-project-lite 0.2.12", + "pin-project-lite", "pin-utils", "slab", ] @@ -6239,17 +6451,6 @@ dependencies = [ "winapi", ] -[[package]] -name = "getrandom" -version = "0.1.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" -dependencies = [ - "cfg-if", - "libc", - "wasi 0.9.0+wasi-snapshot-preview1", -] - [[package]] name = "getrandom" version = "0.2.10" @@ -6258,7 +6459,7 @@ checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427" dependencies = [ "cfg-if", "libc", - "wasi 0.11.0+wasi-snapshot-preview1", + "wasi", ] [[package]] @@ -6267,8 +6468,8 @@ version = "0.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ea1015b5a70616b688dc230cfe50c8af89d972cb132d5a622814d29773b10b9" dependencies = [ - "rand 0.8.5", - "rand_core 0.6.4", + "rand", + "rand_core", ] [[package]] @@ -6354,7 +6555,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -6378,9 +6578,9 @@ dependencies = [ "futures-timer", "no-std-compat", "nonzero_ext", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "quanta", - "rand 0.8.5", + "rand", "smallvec", ] @@ -6391,7 +6591,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" dependencies = [ "ff", - "rand_core 0.6.4", + "rand_core", "subtle 2.5.0", ] @@ -6406,7 +6606,26 @@ dependencies = [ "futures-core", "futures-sink", "futures-util", - "http", + "http 0.2.9", + "indexmap 2.2.3", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "h2" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa82e28a107a8cc405f0839610bdc9b15f1e25ec7d696aa5cf173edbcb1486ab" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http 1.1.0", "indexmap 2.2.3", "slab", "tokio", @@ -6464,7 +6683,7 @@ version = "0.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", ] [[package]] @@ -6473,7 +6692,7 @@ version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", "allocator-api2", "serde", ] @@ -6543,9 +6762,9 @@ checksum = "6fe2267d4ed49bc07b63801559be28c718ea06c4738b7a03c94df7386d2cde46" [[package]] name = "hkdf" -version = "0.12.3" +version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437" +checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7" dependencies = [ "hmac 0.12.1", ] @@ -6614,6 +6833,17 @@ dependencies = [ "itoa", ] +[[package]] +name = "http" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258" +dependencies = [ + "bytes", + "fnv", + "itoa", +] + [[package]] name = "http-body" version = "0.4.5" @@ -6621,19 +6851,36 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1" dependencies = [ "bytes", - "http", - "pin-project-lite 0.2.12", + "http 0.2.9", + "pin-project-lite", ] [[package]] -name = "http-range-header" -version = "0.3.1" +name = "http-body" +version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "add0ab9360ddbd88cfeb3bd9574a1d85cfdfa14db10b3e21d3700dbc4328758f" +checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643" +dependencies = [ + "bytes", + "http 1.1.0", +] [[package]] -name = "httparse" -version = "1.8.0" +name = "http-body-util" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "793429d76616a256bcb62c2a2ec2bed781c8307e797e2598c50010f2bee2544f" +dependencies = [ + "bytes", + "futures-util", + "http 1.1.0", + "http-body 1.0.0", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" @@ -6651,44 +6898,103 @@ checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" [[package]] name = "hyper" -version = "0.14.27" +version = "0.14.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468" +checksum = "f361cde2f109281a220d4307746cdfd5ee3f410da58a70377762396775634b33" dependencies = [ "bytes", "futures-channel", "futures-core", "futures-util", - "h2", - "http", - "http-body", + "h2 0.3.26", + "http 0.2.9", + "http-body 0.4.5", "httparse", "httpdate", "itoa", - "pin-project-lite 0.2.12", - "socket2 0.4.9", + "pin-project-lite", + "socket2 0.5.7", "tokio", "tower-service", "tracing", "want", ] +[[package]] +name = "hyper" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d" +dependencies = [ + "bytes", + "futures-channel", + "futures-util", + "h2 0.4.5", + "http 1.1.0", + "http-body 1.0.0", + "httparse", + "httpdate", + "itoa", + "pin-project-lite", + "smallvec", + "tokio", + "want", +] + [[package]] name = "hyper-rustls" -version = "0.24.1" +version = "0.24.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97" +checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" dependencies = [ "futures-util", - "http", - "hyper", + "http 0.2.9", + "hyper 0.14.29", "log", - "rustls 0.21.6", + "rustls 0.21.7", "rustls-native-certs 0.6.3", "tokio", "tokio-rustls 0.24.1", ] +[[package]] +name = "hyper-rustls" +version = "0.27.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ee4be2c948921a1a5320b629c4193916ed787a7f7f293fd3f7f5a6c9de74155" +dependencies = [ + "futures-util", + "http 1.1.0", + "hyper 1.3.1", + "hyper-util", + "log", + "rustls 0.23.10", + "rustls-pki-types", + "tokio", + "tokio-rustls 0.26.0", + "tower-service", +] + +[[package]] +name = "hyper-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b875924a60b96e5d7b9ae7b066540b1dd1cbd90d1828f54c92e02a283351c56" +dependencies = [ + "bytes", + "futures-channel", + "futures-util", + "http 1.1.0", + "http-body 1.0.0", + "hyper 1.3.1", + "pin-project-lite", + "socket2 0.5.7", + "tokio", + "tower", + "tower-service", + "tracing", +] + [[package]] name = "iana-time-zone" version = "0.1.57" @@ -6733,23 +7039,33 @@ dependencies = [ "unicode-normalization", ] +[[package]] +name = "idna" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" +dependencies = [ + "unicode-bidi", + "unicode-normalization", +] + [[package]] name = "if-addrs" -version = "0.7.0" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cbc0fa01ffc752e9dbc72818cdb072cd028b86be5e09dd04c5a643704fe101a9" +checksum = "cabb0019d51a643781ff15c9c8a3e5dedc365c47211270f4e8f82812fedd8f0a" dependencies = [ "libc", - "winapi", + "windows-sys 0.48.0", ] [[package]] name = "if-watch" -version = "3.0.1" +version = "3.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9465340214b296cd17a0009acdb890d6160010b8adf8f78a00d0d7ab270f79f" +checksum = "d6b0422c86d7ce0e97169cc42e04ae643caf278874a7a3c87b8150a220dc7e1e" dependencies = [ - "async-io", + "async-io 2.3.3", "core-foundation", "fnv", "futures", @@ -6759,7 +7075,26 @@ dependencies = [ "rtnetlink", "system-configuration", "tokio", - "windows 0.34.0", + "windows 0.51.1", +] + +[[package]] +name = "igd-next" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "064d90fec10d541084e7b39ead8875a5a80d9114a2b18791565253bae25f49e4" +dependencies = [ + "async-trait", + "attohttpc", + "bytes", + "futures", + "http 0.2.9", + "hyper 0.14.29", + "log", + "rand", + "tokio", + "url", + "xmltree", ] [[package]] @@ -6806,8 +7141,8 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -6826,8 +7161,8 @@ version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b139284b5cf57ecfa712bcc66950bb635b31aff41c188e8a4cfc758eca374a3f" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", ] [[package]] @@ -6932,7 +7267,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f" dependencies = [ - "socket2 0.5.6", + "socket2 0.5.7", "widestring", "windows-sys 0.48.0", "winreg", @@ -6976,13 +7311,13 @@ dependencies = [ "curl", "curl-sys", "encoding_rs", - "event-listener", - "futures-lite", - "http", + "event-listener 2.5.3", + "futures-lite 1.13.0", + "http 0.2.9", "log", "mime", "once_cell", - "polling", + "polling 2.8.0", "slab", "sluice", "tracing", @@ -7015,6 +7350,43 @@ version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38" +[[package]] +name = "jemalloc_pprof" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96368c0fc161a0a1a20b3952b6fd31ee342fffc87ed9e48ac1ed49fb25686655" +dependencies = [ + "anyhow", + "libc", + "mappings", + "once_cell", + "pprof_util", + "tempfile", + "tikv-jemalloc-ctl", + "tokio", + "tracing", +] + +[[package]] +name = "jni" +version = "0.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec" +dependencies = [ + "cesu8", + "combine", + "jni-sys", + "log", + "thiserror", + "walkdir", +] + +[[package]] +name = "jni-sys" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" + [[package]] name = "jobserver" version = "0.1.26" @@ -7052,9 +7424,9 @@ dependencies = [ [[package]] name = "jsonrpsee" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfdb12a2381ea5b2e68c3469ec604a007b367778cdb14d09612c8069ebd616ad" +checksum = "5ec465b607a36dc5dd45d48b7689bc83f679f66a3ac6b6b21cc787a11e0f8685" dependencies = [ "jsonrpsee-core", "jsonrpsee-http-client", @@ -7068,20 +7440,22 @@ dependencies = [ [[package]] name = "jsonrpsee-client-transport" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4978087a58c3ab02efc5b07c5e5e2803024536106fd5506f558db172c889b3aa" +checksum = "90f0977f9c15694371b8024c35ab58ca043dbbf4b51ccb03db8858a021241df1" dependencies = [ + "base64 0.22.1", "futures-util", - "http", + "http 1.1.0", "jsonrpsee-core", "pin-project", - "rustls-native-certs 0.7.0", + "rustls 0.23.10", "rustls-pki-types", - "soketto", + "rustls-platform-verifier", + "soketto 0.8.0", "thiserror", "tokio", - "tokio-rustls 0.25.0", + "tokio-rustls 0.26.0", "tokio-util", "tracing", "url", @@ -7089,21 +7463,22 @@ dependencies = [ [[package]] name = "jsonrpsee-core" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4b257e1ec385e07b0255dde0b933f948b5c8b8c28d42afda9587c3a967b896d" +checksum = "e942c55635fbf5dc421938b8558a8141c7e773720640f4f1dbe1f4164ca4e221" dependencies = [ - "anyhow", "async-trait", - "beef", + "bytes", "futures-timer", "futures-util", - "hyper", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", "jsonrpsee-types", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", - "rand 0.8.5", - "rustc-hash", + "rand", + "rustc-hash 2.0.0", "serde", "serde_json", "thiserror", @@ -7114,15 +7489,20 @@ dependencies = [ [[package]] name = "jsonrpsee-http-client" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ccf93fc4a0bfe05d851d37d7c32b7f370fe94336b52a2f0efc5f1981895c2e5" +checksum = "e33774602df12b68a2310b38a535733c477ca4a498751739f89fe8dbbb62ec4c" dependencies = [ "async-trait", - "hyper", - "hyper-rustls", + "base64 0.22.1", + "http-body 1.0.0", + "hyper 1.3.1", + "hyper-rustls 0.27.2", + "hyper-util", "jsonrpsee-core", "jsonrpsee-types", + "rustls 0.23.10", + "rustls-platform-verifier", "serde", "serde_json", "thiserror", @@ -7134,33 +7514,36 @@ dependencies = [ [[package]] name = "jsonrpsee-proc-macros" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d0bb047e79a143b32ea03974a6bf59b62c2a4c5f5d42a381c907a8bbb3f75c0" +checksum = "6b07a2daf52077ab1b197aea69a5c990c060143835bf04c77070e98903791715" dependencies = [ - "heck 0.4.1", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "heck 0.5.0", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "jsonrpsee-server" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12d8b6a9674422a8572e0b0abb12feeb3f2aeda86528c80d0350c2bd0923ab41" +checksum = "038fb697a709bec7134e9ccbdbecfea0e2d15183f7140254afef7c5610a3f488" dependencies = [ "futures-util", - "http", - "hyper", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", + "hyper 1.3.1", + "hyper-util", "jsonrpsee-core", "jsonrpsee-types", "pin-project", "route-recognizer", "serde", "serde_json", - "soketto", + "soketto 0.8.0", "thiserror", "tokio", "tokio-stream", @@ -7171,12 +7554,11 @@ dependencies = [ [[package]] name = "jsonrpsee-types" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "150d6168405890a7a3231a3c74843f58b8959471f6df76078db2619ddee1d07d" +checksum = "23b67d6e008164f027afbc2e7bb79662650158d26df200040282d2aa1cbb093b" dependencies = [ - "anyhow", - "beef", + "http 1.1.0", "serde", "serde_json", "thiserror", @@ -7184,11 +7566,11 @@ dependencies = [ [[package]] name = "jsonrpsee-ws-client" -version = "0.22.5" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "58b9db2dfd5bb1194b0ce921504df9ceae210a345bc2f6c5a61432089bbab070" +checksum = "992bf67d1132f88edf4a4f8cff474cf01abb2be203004a2b8e11c2b20795b99e" dependencies = [ - "http", + "http 1.1.0", "jsonrpsee-client-transport", "jsonrpsee-core", "jsonrpsee-types", @@ -7239,123 +7621,15 @@ checksum = "c33070833c9ee02266356de0c43f723152bd38bd96ddf52c82b3af10c9138b28" name = "kitchensink-runtime" version = "3.0.0-dev" dependencies = [ - "frame-benchmarking", - "frame-benchmarking-pallet-pov", - "frame-election-provider-support", - "frame-executive", - "frame-support", - "frame-system", - "frame-system-benchmarking", - "frame-system-rpc-runtime-api", - "frame-try-runtime", "log", "node-primitives", - "pallet-alliance", - "pallet-asset-conversion", - "pallet-asset-conversion-ops", - "pallet-asset-conversion-tx-payment", - "pallet-asset-rate", - "pallet-asset-tx-payment", - "pallet-assets", - "pallet-authority-discovery", - "pallet-authorship", - "pallet-babe", - "pallet-bags-list", - "pallet-balances", - "pallet-beefy", - "pallet-beefy-mmr", - "pallet-bounties", - "pallet-broker", - "pallet-child-bounties", - "pallet-collective", - "pallet-contracts", - "pallet-conviction-voting", - "pallet-core-fellowship", - "pallet-democracy", - "pallet-election-provider-multi-phase", - "pallet-election-provider-support-benchmarking", - "pallet-elections-phragmen", "pallet-example-mbm", "pallet-example-tasks", - "pallet-fast-unstake", - "pallet-glutton", - "pallet-grandpa", - "pallet-identity", - "pallet-im-online", - "pallet-indices", - "pallet-insecure-randomness-collective-flip", - "pallet-lottery", - "pallet-membership", - "pallet-message-queue", - "pallet-migrations", - "pallet-mixnet", - "pallet-mmr", - "pallet-multisig", - "pallet-nft-fractionalization", - "pallet-nfts", - "pallet-nfts-runtime-api", - "pallet-nis", - "pallet-nomination-pools", - "pallet-nomination-pools-benchmarking", - "pallet-nomination-pools-runtime-api", - "pallet-offences", - "pallet-offences-benchmarking", - "pallet-parameters", - "pallet-preimage", - "pallet-proxy", - "pallet-ranked-collective", - "pallet-recovery", - "pallet-referenda", - "pallet-remark", - "pallet-root-testing", - "pallet-safe-mode", - "pallet-salary", - "pallet-scheduler", - "pallet-session", - "pallet-session-benchmarking", - "pallet-skip-feeless-payment", - "pallet-society", - "pallet-staking", - "pallet-staking-reward-curve", - "pallet-staking-runtime-api", - "pallet-state-trie-migration", - "pallet-statement", - "pallet-sudo", - "pallet-timestamp", - "pallet-tips", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc-runtime-api", - "pallet-transaction-storage", - "pallet-treasury", - "pallet-tx-pause", - "pallet-uniques", - "pallet-utility", - "pallet-vesting", - "pallet-whitelist", "parity-scale-codec", + "polkadot-sdk", "primitive-types", "scale-info", "serde_json", - "sp-api", - "sp-authority-discovery", - "sp-block-builder", - "sp-consensus-babe", - "sp-consensus-beefy", - "sp-consensus-grandpa", - "sp-core", - "sp-genesis-builder", - "sp-inherents", - "sp-io", - "sp-mixnet", - "sp-offchain", - "sp-runtime", - "sp-session", - "sp-staking", - "sp-statement-store", - "sp-std 14.0.0", - "sp-storage 19.0.0", - "sp-transaction-pool", - "sp-version", "static_assertions", "substrate-wasm-builder", ] @@ -7385,7 +7659,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bf7a85fe66f9ff9cd74e169fdd2c94c6e1e74c412c99a73b4df3200b5d3760b2" dependencies = [ "kvdb", - "parking_lot 0.12.1", + "parking_lot 0.12.3", ] [[package]] @@ -7396,7 +7670,7 @@ checksum = "b644c70b92285f66bfc2032922a79000ea30af7bc2ab31902992a5dcb9b434f6" dependencies = [ "kvdb", "num_cpus", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "regex", "rocksdb", "smallvec", @@ -7442,9 +7716,9 @@ checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" [[package]] name = "libc" -version = "0.2.153" +version = "0.2.155" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd" +checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c" [[package]] name = "libflate" @@ -7489,9 +7763,9 @@ dependencies = [ [[package]] name = "libm" -version = "0.2.7" +version = "0.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4" +checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058" [[package]] name = "libnghttp2-sys" @@ -7505,14 +7779,15 @@ dependencies = [ [[package]] name = "libp2p" -version = "0.51.4" +version = "0.52.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f35eae38201a993ece6bdc823292d6abd1bffed1c4d0f4a3517d2bd8e1d917fe" +checksum = "e94495eb319a85b70a68b85e2389a95bb3555c71c49025b78c691a854a7e6464" dependencies = [ "bytes", + "either", "futures", "futures-timer", - "getrandom 0.2.10", + "getrandom", "instant", "libp2p-allow-block-list", "libp2p-connection-limits", @@ -7529,18 +7804,21 @@ dependencies = [ "libp2p-request-response", "libp2p-swarm", "libp2p-tcp", + "libp2p-upnp", "libp2p-wasm-ext", "libp2p-websocket", "libp2p-yamux", - "multiaddr", + "multiaddr 0.18.1", "pin-project", + "rw-stream-sink", + "thiserror", ] [[package]] name = "libp2p-allow-block-list" -version = "0.1.1" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "510daa05efbc25184458db837f6f9a5143888f1caa742426d92e1833ddd38a50" +checksum = "55b46558c5c0bf99d3e2a1a38fd54ff5476ca66dd1737b12466a1824dd219311" dependencies = [ "libp2p-core", "libp2p-identity", @@ -7550,9 +7828,9 @@ dependencies = [ [[package]] name = "libp2p-connection-limits" -version = "0.1.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4caa33f1d26ed664c4fe2cca81a08c8e07d4c1c04f2f4ac7655c2dd85467fda0" +checksum = "2f5107ad45cb20b2f6c3628c7b6014b996fcb13a88053f4569c872c6e30abf58" dependencies = [ "libp2p-core", "libp2p-identity", @@ -7562,9 +7840,9 @@ dependencies = [ [[package]] name = "libp2p-core" -version = "0.39.2" +version = "0.40.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c1df63c0b582aa434fb09b2d86897fa2b419ffeccf934b36f87fcedc8e835c2" +checksum = "dd44289ab25e4c9230d9246c475a22241e301b23e8f4061d3bdef304a1a99713" dependencies = [ "either", "fnv", @@ -7573,50 +7851,53 @@ dependencies = [ "instant", "libp2p-identity", "log", - "multiaddr", - "multihash 0.17.0", + "multiaddr 0.18.1", + "multihash 0.19.1", "multistream-select", "once_cell", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", "quick-protobuf", - "rand 0.8.5", + "rand", "rw-stream-sink", "smallvec", "thiserror", - "unsigned-varint", + "unsigned-varint 0.7.2", "void", ] [[package]] name = "libp2p-dns" -version = "0.39.0" +version = "0.40.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "146ff7034daae62077c415c2376b8057368042df6ab95f5432ad5e88568b1554" +checksum = "e6a18db73084b4da2871438f6239fef35190b05023de7656e877c18a00541a3b" dependencies = [ + "async-trait", "futures", "libp2p-core", + "libp2p-identity", "log", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "smallvec", - "trust-dns-resolver 0.22.0", + "trust-dns-resolver", ] [[package]] name = "libp2p-identify" -version = "0.42.2" +version = "0.43.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5455f472243e63b9c497ff320ded0314254a9eb751799a39c283c6f20b793f3c" +checksum = "45a96638a0a176bec0a4bcaebc1afa8cf909b114477209d7456ade52c61cd9cd" dependencies = [ "asynchronous-codec", "either", "futures", + "futures-bounded", "futures-timer", "libp2p-core", "libp2p-identity", "libp2p-swarm", "log", - "lru 0.10.1", + "lru 0.12.3", "quick-protobuf", "quick-protobuf-codec", "smallvec", @@ -7626,27 +7907,27 @@ dependencies = [ [[package]] name = "libp2p-identity" -version = "0.1.3" +version = "0.2.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "276bb57e7af15d8f100d3c11cbdd32c6752b7eef4ba7a18ecf464972c07abcce" +checksum = "55cca1eb2bc1fd29f099f3daaab7effd01e1a54b7c577d0ed082521034d912e8" dependencies = [ - "bs58 0.4.0", - "ed25519-dalek 2.1.0", - "log", - "multiaddr", - "multihash 0.17.0", + "bs58 0.5.1", + "ed25519-dalek", + "hkdf", + "multihash 0.19.1", "quick-protobuf", - "rand 0.8.5", + "rand", "sha2 0.10.8", "thiserror", + "tracing", "zeroize", ] [[package]] name = "libp2p-kad" -version = "0.43.3" +version = "0.44.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39d5ef876a2b2323d63c258e63c2f8e36f205fe5a11f0b3095d59635650790ff" +checksum = "16ea178dabba6dde6ffc260a8e0452ccdc8f79becf544946692fff9d412fc29d" dependencies = [ "arrayvec 0.7.4", "asynchronous-codec", @@ -7661,20 +7942,21 @@ dependencies = [ "libp2p-swarm", "log", "quick-protobuf", - "rand 0.8.5", + "quick-protobuf-codec", + "rand", "sha2 0.10.8", "smallvec", "thiserror", "uint", - "unsigned-varint", + "unsigned-varint 0.7.2", "void", ] [[package]] name = "libp2p-mdns" -version = "0.43.1" +version = "0.44.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19983e1f949f979a928f2c603de1cf180cc0dc23e4ac93a62651ccb18341460b" +checksum = "42a2567c305232f5ef54185e9604579a894fd0674819402bb0ac0246da82f52a" dependencies = [ "data-encoding", "futures", @@ -7683,9 +7965,9 @@ dependencies = [ "libp2p-identity", "libp2p-swarm", "log", - "rand 0.8.5", + "rand", "smallvec", - "socket2 0.4.9", + "socket2 0.5.7", "tokio", "trust-dns-proto 0.22.0", "void", @@ -7693,63 +7975,69 @@ dependencies = [ [[package]] name = "libp2p-metrics" -version = "0.12.0" +version = "0.13.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a42ec91e227d7d0dafa4ce88b333cdf5f277253873ab087555c92798db2ddd46" +checksum = "239ba7d28f8d0b5d77760dc6619c05c7e88e74ec8fbbe97f856f20a56745e620" dependencies = [ + "instant", "libp2p-core", "libp2p-identify", + "libp2p-identity", "libp2p-kad", "libp2p-ping", "libp2p-swarm", + "once_cell", "prometheus-client", ] [[package]] name = "libp2p-noise" -version = "0.42.2" +version = "0.43.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c3673da89d29936bc6435bafc638e2f184180d554ce844db65915113f86ec5e" +checksum = "d2eeec39ad3ad0677551907dd304b2f13f17208ccebe333bef194076cd2e8921" dependencies = [ "bytes", - "curve25519-dalek 3.2.0", + "curve25519-dalek", "futures", "libp2p-core", "libp2p-identity", "log", + "multiaddr 0.18.1", + "multihash 0.19.1", "once_cell", "quick-protobuf", - "rand 0.8.5", + "rand", "sha2 0.10.8", "snow", "static_assertions", "thiserror", - "x25519-dalek 1.1.1", + "x25519-dalek", "zeroize", ] [[package]] name = "libp2p-ping" -version = "0.42.0" +version = "0.43.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e57759c19c28a73ef1eb3585ca410cefb72c1a709fcf6de1612a378e4219202" +checksum = "e702d75cd0827dfa15f8fd92d15b9932abe38d10d21f47c50438c71dd1b5dae3" dependencies = [ "either", "futures", "futures-timer", "instant", "libp2p-core", + "libp2p-identity", "libp2p-swarm", "log", - "rand 0.8.5", + "rand", "void", ] [[package]] name = "libp2p-quic" -version = "0.7.0-alpha.3" +version = "0.9.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c6b26abd81cd2398382a1edfe739b539775be8a90fa6914f39b2ab49571ec735" +checksum = "130d451d83f21b81eb7b35b360bc7972aeafb15177784adc56528db082e6b927" dependencies = [ "bytes", "futures", @@ -7759,19 +8047,21 @@ dependencies = [ "libp2p-identity", "libp2p-tls", "log", - "parking_lot 0.12.1", - "quinn-proto", - "rand 0.8.5", - "rustls 0.20.8", + "parking_lot 0.12.3", + "quinn 0.10.2", + "rand", + "ring 0.16.20", + "rustls 0.21.7", + "socket2 0.5.7", "thiserror", "tokio", ] [[package]] name = "libp2p-request-response" -version = "0.24.1" +version = "0.25.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ffdb374267d42dc5ed5bc53f6e601d4a64ac5964779c6e40bb9e4f14c1e30d5" +checksum = "d8e3b4d67870478db72bac87bfc260ee6641d0734e0e3e275798f089c3fecfd4" dependencies = [ "async-trait", "futures", @@ -7779,15 +8069,17 @@ dependencies = [ "libp2p-core", "libp2p-identity", "libp2p-swarm", - "rand 0.8.5", + "log", + "rand", "smallvec", + "void", ] [[package]] name = "libp2p-swarm" -version = "0.42.2" +version = "0.43.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "903b3d592d7694e56204d211f29d31bc004be99386644ba8731fc3e3ef27b296" +checksum = "580189e0074af847df90e75ef54f3f30059aedda37ea5a1659e8b9fca05c0141" dependencies = [ "either", "fnv", @@ -7798,7 +8090,9 @@ dependencies = [ "libp2p-identity", "libp2p-swarm-derive", "log", - "rand 0.8.5", + "multistream-select", + "once_cell", + "rand", "smallvec", "tokio", "void", @@ -7806,36 +8100,39 @@ dependencies = [ [[package]] name = "libp2p-swarm-derive" -version = "0.32.0" +version = "0.33.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0fba456131824ab6acd4c7bf61e9c0f0a3014b5fc9868ccb8e10d344594cdc4f" +checksum = "c4d5ec2a3df00c7836d7696c136274c9c59705bac69133253696a6c932cd1d74" dependencies = [ "heck 0.4.1", - "quote 1.0.35", - "syn 1.0.109", + "proc-macro-warning 0.4.2", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "libp2p-tcp" -version = "0.39.0" +version = "0.40.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "33d33698596d7722d85d3ab0c86c2c322254fce1241e91208e3679b4eb3026cf" +checksum = "b558dd40d1bcd1aaaed9de898e9ec6a436019ecc2420dd0016e712fbb61c5508" dependencies = [ "futures", "futures-timer", "if-watch", "libc", "libp2p-core", + "libp2p-identity", "log", - "socket2 0.4.9", + "socket2 0.5.7", "tokio", ] [[package]] name = "libp2p-tls" -version = "0.1.0" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff08d13d0dc66e5e9ba6279c1de417b84fa0d0adc3b03e5732928c180ec02781" +checksum = "8218d1d5482b122ccae396bbf38abdcb283ecc96fa54760e1dfd251f0546ac61" dependencies = [ "futures", "futures-rustls", @@ -7843,51 +8140,69 @@ dependencies = [ "libp2p-identity", "rcgen", "ring 0.16.20", - "rustls 0.20.8", + "rustls 0.21.7", + "rustls-webpki 0.101.4", "thiserror", - "webpki", - "x509-parser 0.14.0", + "x509-parser 0.15.1", "yasna", ] +[[package]] +name = "libp2p-upnp" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82775a47b34f10f787ad3e2a22e2c1541e6ebef4fe9f28f3ac553921554c94c1" +dependencies = [ + "futures", + "futures-timer", + "igd-next", + "libp2p-core", + "libp2p-swarm", + "log", + "tokio", + "void", +] + [[package]] name = "libp2p-wasm-ext" -version = "0.39.0" +version = "0.40.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77dff9d32353a5887adb86c8afc1de1a94d9e8c3bc6df8b2201d7cdf5c848f43" +checksum = "1e5d8e3a9e07da0ef5b55a9f26c009c8fb3c725d492d8bb4b431715786eea79c" dependencies = [ "futures", "js-sys", "libp2p-core", - "parity-send-wrapper", + "send_wrapper", "wasm-bindgen", "wasm-bindgen-futures", ] [[package]] name = "libp2p-websocket" -version = "0.41.0" +version = "0.42.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "111273f7b3d3510524c752e8b7a5314b7f7a1fee7e68161c01a7d72cbb06db9f" +checksum = "004ee9c4a4631435169aee6aad2f62e3984dc031c43b6d29731e8e82a016c538" dependencies = [ "either", "futures", "futures-rustls", "libp2p-core", + "libp2p-identity", "log", - "parking_lot 0.12.1", - "quicksink", + "parking_lot 0.12.3", + "pin-project-lite", "rw-stream-sink", - "soketto", + "soketto 0.8.0", + "thiserror", "url", - "webpki-roots 0.22.6", + "webpki-roots 0.25.2", ] [[package]] name = "libp2p-yamux" -version = "0.43.1" +version = "0.44.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dcd21d950662700a385d4c6d68e2f5f54d778e97068cdd718522222ef513bda" +checksum = "8eedcb62824c4300efb9cfd4e2a6edaf3ca097b9e68b36dabe45a44469fd6a85" dependencies = [ "futures", "libp2p-core", @@ -7924,7 +8239,7 @@ dependencies = [ "libsecp256k1-core", "libsecp256k1-gen-ecmult", "libsecp256k1-gen-genmult", - "rand 0.8.5", + "rand", "serde", "sha2 0.9.9", "typenum", @@ -8054,39 +8369,40 @@ dependencies = [ [[package]] name = "litep2p" -version = "0.3.0" -source = "git+https://github.com/paritytech/litep2p?rev=e03a6023882db111beeb24d8c0ceaac0721d3f0f#e03a6023882db111beeb24d8c0ceaac0721d3f0f" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f46c51c205264b834ceed95c8b195026e700494bc3991aaba3b4ea9e20626d9" dependencies = [ "async-trait", "bs58 0.4.0", "bytes", "cid 0.10.1", - "ed25519-dalek 1.0.1", + "ed25519-dalek", "futures", "futures-timer", "hex-literal", "indexmap 2.2.3", "libc", - "mockall", - "multiaddr", + "mockall 0.12.1", + "multiaddr 0.17.1", "multihash 0.17.0", "network-interface", "nohash-hasher", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", - "prost 0.11.9", + "prost 0.12.6", "prost-build 0.11.9", - "quinn", - "rand 0.8.5", + "quinn 0.9.4", + "rand", "rcgen", "ring 0.16.20", - "rustls 0.20.8", + "rustls 0.20.9", "serde", "sha2 0.10.8", "simple-dns", "smallvec", "snow", - "socket2 0.5.6", + "socket2 0.5.7", "static_assertions", "str0m", "thiserror", @@ -8095,13 +8411,13 @@ dependencies = [ "tokio-tungstenite", "tokio-util", "tracing", - "trust-dns-resolver 0.23.2", + "trust-dns-resolver", "uint", - "unsigned-varint", + "unsigned-varint 0.8.0", "url", "webpki", - "x25519-dalek 2.0.0", - "x509-parser 0.15.1", + "x25519-dalek", + "x509-parser 0.16.0", "yasna", "zeroize", ] @@ -8118,9 +8434,9 @@ dependencies = [ [[package]] name = "log" -version = "0.4.21" +version = "0.4.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" dependencies = [ "serde", "value-bag", @@ -8137,18 +8453,18 @@ dependencies = [ [[package]] name = "lru" -version = "0.10.1" +version = "0.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "718e8fae447df0c7e1ba7f5189829e63fd536945c8988d61444c19039f16b670" -dependencies = [ - "hashbrown 0.13.2", -] +checksum = "eedb2bdbad7e0634f83989bf596f497b070130daaa398ab22d84c39e266deec5" [[package]] name = "lru" -version = "0.11.0" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eedb2bdbad7e0634f83989bf596f497b070130daaa398ab22d84c39e266deec5" +checksum = "d3262e75e648fce39813cb56ac41f3c3e3f65217ebf3844d818d1f9398cfb0dc" +dependencies = [ + "hashbrown 0.14.3", +] [[package]] name = "lru-cache" @@ -8199,50 +8515,50 @@ dependencies = [ [[package]] name = "macro_magic" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e03844fc635e92f3a0067e25fa4bf3e3dbf3f2927bf3aa01bb7bc8f1c428949d" +checksum = "cc33f9f0351468d26fbc53d9ce00a096c8522ecb42f19b50f34f2c422f76d21d" dependencies = [ "macro_magic_core", "macro_magic_macros", - "quote 1.0.35", - "syn 2.0.53", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "macro_magic_core" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "468155613a44cfd825f1fb0ffa532b018253920d404e6fca1e8d43155198a46d" +checksum = "1687dc887e42f352865a393acae7cf79d98fab6351cde1f58e9e057da89bf150" dependencies = [ "const-random", - "derive-syn-parse 0.1.5", + "derive-syn-parse", "macro_magic_core_macros", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "macro_magic_core_macros" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ea73aa640dc01d62a590d48c0c3521ed739d53b27f919b25c3551e233481654" +checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "macro_magic_macros" -version = "0.5.0" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef9d79ae96aaba821963320eb2b6e34d17df1e5a83d8a1985c29cc5be59577b3" +checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869" dependencies = [ "macro_magic_core", - "quote 1.0.35", - "syn 2.0.53", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -8251,6 +8567,19 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d" +[[package]] +name = "mappings" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8fa2605f461115ef6336342b12f0d8cabdfd7b258fed86f5f98c725535843601" +dependencies = [ + "anyhow", + "libc", + "once_cell", + "pprof_util", + "tracing", +] + [[package]] name = "match_cfg" version = "0.1.0" @@ -8293,9 +8622,9 @@ dependencies = [ [[package]] name = "memchr" -version = "2.6.4" +version = "2.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" [[package]] name = "memfd" @@ -8351,6 +8680,20 @@ dependencies = [ "hash-db", ] +[[package]] +name = "merkleized-metadata" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f313fcff1d2a4bcaa2deeaa00bf7530d77d5f7bd0467a117dde2e29a75a7a17a" +dependencies = [ + "array-bytes", + "blake3", + "frame-metadata", + "parity-scale-codec", + "scale-decode", + "scale-info", +] + [[package]] name = "merlin" version = "3.0.0" @@ -8359,7 +8702,7 @@ checksum = "58c38e2799fc0978b65dfff8023ec7843e2330bb462f19198840b34b6582397d" dependencies = [ "byteorder", "keccak", - "rand_core 0.6.4", + "rand_core", "zeroize", ] @@ -8370,13 +8713,12 @@ dependencies = [ "async-std", "async-trait", "bp-messages", - "env_logger 0.11.3", "finality-relay", "futures", "hex", "log", "num-traits", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "relay-utils", "sp-arithmetic", ] @@ -8388,7 +8730,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "69672161530e8aeca1d1400fbf3f1a1747ff60ea604265a4e906c2442df20532" dependencies = [ "futures", - "rand 0.8.5", + "rand", "thrift", ] @@ -8404,70 +8746,28 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" -[[package]] -name = "minimal-template" -version = "0.0.0" -dependencies = [ - "docify", - "minimal-template-node", - "minimal-template-runtime", - "pallet-minimal-template", - "polkadot-sdk-docs", - "polkadot-sdk-frame", - "simple-mermaid", -] - [[package]] name = "minimal-template-node" version = "0.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", + "docify", "futures", "futures-timer", "jsonrpsee", "minimal-template-runtime", - "polkadot-sdk-frame", - "sc-basic-authorship", - "sc-cli", - "sc-client-api", - "sc-consensus", - "sc-consensus-manual-seal", - "sc-executor", - "sc-network", - "sc-offchain", - "sc-rpc-api", - "sc-service", - "sc-telemetry", - "sc-transaction-pool", - "sc-transaction-pool-api", + "polkadot-sdk", "serde_json", - "sp-api", - "sp-block-builder", - "sp-blockchain", - "sp-io", - "sp-keyring", - "sp-runtime", - "sp-timestamp", - "substrate-build-script-utils", - "substrate-frame-rpc-system", ] [[package]] name = "minimal-template-runtime" version = "0.0.0" dependencies = [ - "pallet-balances", "pallet-minimal-template", - "pallet-sudo", - "pallet-timestamp", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc-runtime-api", "parity-scale-codec", - "polkadot-sdk-frame", + "polkadot-sdk", "scale-info", - "sp-genesis-builder", - "sp-runtime", - "substrate-wasm-builder", ] [[package]] @@ -8486,7 +8786,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c" dependencies = [ "libc", - "wasi 0.11.0+wasi-snapshot-preview1", + "wasi", "windows-sys 0.48.0", ] @@ -8501,14 +8801,14 @@ dependencies = [ "bitflags 1.3.2", "blake2 0.10.6", "c2-chacha", - "curve25519-dalek 4.1.2", + "curve25519-dalek", "either", "hashlink", "lioness", "log", - "parking_lot 0.12.1", - "rand 0.8.5", - "rand_chacha 0.3.1", + "parking_lot 0.12.3", + "rand", + "rand_chacha", "rand_distr", "subtle 2.5.0", "thiserror", @@ -8522,7 +8822,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-offchain", @@ -8563,11 +8863,26 @@ dependencies = [ "downcast", "fragile", "lazy_static", - "mockall_derive", + "mockall_derive 0.11.4", "predicates 2.1.5", "predicates-tree", ] +[[package]] +name = "mockall" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43766c2b5203b10de348ffe19f7e54564b64f3d6018ff7648d1e2d6d3a0f0a48" +dependencies = [ + "cfg-if", + "downcast", + "fragile", + "lazy_static", + "mockall_derive 0.12.1", + "predicates 3.0.3", + "predicates-tree", +] + [[package]] name = "mockall_derive" version = "0.11.4" @@ -8575,11 +8890,29 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "22ce75669015c4f47b289fd4d4f56e894e4c96003ffdf3ac51313126f94c6cbb" dependencies = [ "cfg-if", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] +[[package]] +name = "mockall_derive" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af7cbce79ec385a1d4f54baa90a76401eb15d9cab93685f62e7e9f942aa00ae2" +dependencies = [ + "cfg-if", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + +[[package]] +name = "multi-stash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "685a9ac4b61f4e728e1d2c6a7844609c16527aeb5e6c865915c08e619c16410f" + [[package]] name = "multiaddr" version = "0.17.1" @@ -8595,7 +8928,26 @@ dependencies = [ "percent-encoding", "serde", "static_assertions", - "unsigned-varint", + "unsigned-varint 0.7.2", + "url", +] + +[[package]] +name = "multiaddr" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8b852bc02a2da5feed68cd14fa50d0774b92790a5bdbfa932a813926c8472070" +dependencies = [ + "arrayref", + "byteorder", + "data-encoding", + "libp2p-identity", + "multibase", + "multihash 0.19.1", + "percent-encoding", + "serde", + "static_assertions", + "unsigned-varint 0.7.2", "url", ] @@ -8621,10 +8973,10 @@ dependencies = [ "blake3", "core2", "digest 0.10.7", - "multihash-derive 0.8.0", + "multihash-derive", "sha2 0.10.8", "sha3", - "unsigned-varint", + "unsigned-varint 0.7.2", ] [[package]] @@ -8638,10 +8990,10 @@ dependencies = [ "blake3", "core2", "digest 0.10.7", - "multihash-derive 0.8.0", + "multihash-derive", "sha2 0.10.8", "sha3", - "unsigned-varint", + "unsigned-varint 0.7.2", ] [[package]] @@ -8651,27 +9003,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "076d548d76a0e2a0d4ab471d0b1c36c577786dfc4471242035d97a12a735c492" dependencies = [ "core2", - "unsigned-varint", -] - -[[package]] -name = "multihash-codetable" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f6d815ecb3c8238d00647f8630ede7060a642c9f704761cd6082cb4028af6935" -dependencies = [ - "blake2b_simd", - "blake2s_simd", - "blake3", - "core2", - "digest 0.10.7", - "multihash-derive 0.9.0", - "ripemd", - "serde", - "sha1", - "sha2 0.10.8", - "sha3", - "strobe-rs", + "unsigned-varint 0.7.2", ] [[package]] @@ -8682,35 +9014,10 @@ checksum = "fc076939022111618a5026d3be019fd8b366e76314538ff9a1b59ffbcbf98bcd" dependencies = [ "proc-macro-crate 1.3.1", "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 1.0.109", - "synstructure", -] - -[[package]] -name = "multihash-derive" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "890e72cb7396cb99ed98c1246a97b243cc16394470d94e0bc8b0c2c11d84290e" -dependencies = [ - "core2", - "multihash 0.19.1", - "multihash-derive-impl", -] - -[[package]] -name = "multihash-derive-impl" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d38685e08adb338659871ecfc6ee47ba9b22dcc8abcf6975d379cc49145c3040" -dependencies = [ - "proc-macro-crate 1.3.1", - "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", - "synstructure", + "synstructure 0.12.6", ] [[package]] @@ -8721,16 +9028,16 @@ checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a" [[package]] name = "multistream-select" -version = "0.12.1" +version = "0.13.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c8552ab875c1313b97b8d20cb857b9fd63e2d1d6a0a1b53ce9821e575405f27a" +checksum = "ea0df8e5eec2298a62b326ee4f0d7fe1a6b90a09dfcf9df37b38f947a8c42f19" dependencies = [ "bytes", "futures", "log", "pin-project", "smallvec", - "unsigned-varint", + "unsigned-varint 0.7.2", ] [[package]] @@ -8755,8 +9062,8 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "91761aed67d03ad966ef783ae962ef9bbaca728d2dd7ceb7939ec110fffad998" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -8767,7 +9074,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7bddcd3bf5144b6392de80e04c347cd7fab2508f6df16a85fc496ecd5cec39bc" dependencies = [ "clap 3.2.25", - "rand 0.8.5", + "rand", ] [[package]] @@ -8879,12 +9186,13 @@ dependencies = [ [[package]] name = "nix" -version = "0.27.1" +version = "0.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2eb04e9c688eff1c89d72b407f168cf79bb9e867a9d3323ed6c01519eb9cc053" +checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "cfg-if", + "cfg_aliases", "libc", ] @@ -8905,7 +9213,7 @@ name = "node-bench" version = "0.9.0-dev" dependencies = [ "array-bytes", - "clap 4.5.3", + "clap 4.5.11", "derive_more", "fs_extra", "futures", @@ -8918,7 +9226,7 @@ dependencies = [ "node-primitives", "node-testing", "parity-db", - "rand 0.8.5", + "rand", "sc-basic-authorship", "sc-client-api", "sc-transaction-pool", @@ -8962,15 +9270,15 @@ dependencies = [ "sc-consensus-grandpa-rpc", "sc-mixnet", "sc-rpc", - "sc-rpc-api", - "sc-rpc-spec-v2", "sc-sync-state-rpc", "sc-transaction-pool-api", "sp-api", + "sp-application-crypto", "sp-block-builder", "sp-blockchain", "sp-consensus", "sp-consensus-babe", + "sp-consensus-beefy", "sp-keystore", "sp-runtime", "sp-statement-store", @@ -8982,7 +9290,7 @@ dependencies = [ name = "node-runtime-generate-bags" version = "3.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "generate-bags", "kitchensink-runtime", ] @@ -8991,7 +9299,7 @@ dependencies = [ name = "node-template-release" version = "3.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "flate2", "fs_extra", "glob", @@ -9005,6 +9313,7 @@ dependencies = [ name = "node-testing" version = "3.0.0-dev" dependencies = [ + "frame-metadata-hash-extension", "frame-system", "fs_extra", "futures", @@ -9132,6 +9441,23 @@ dependencies = [ "num-traits", ] +[[package]] +name = "num-conv" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" + +[[package]] +name = "num-derive" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + [[package]] name = "num-format" version = "0.4.4" @@ -9231,13 +9557,31 @@ dependencies = [ "memchr", ] +[[package]] +name = "object" +version = "0.36.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "081b846d1d56ddfc18fdf1a922e4f6e07a11768ea1b92dec44e42b72712ccfce" +dependencies = [ + "memchr", +] + [[package]] name = "oid-registry" version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9bedf36ffb6ba96c2eb7144ef6270557b52e54b20c0a8e1eb2ff99a6c6959bff" dependencies = [ - "asn1-rs", + "asn1-rs 0.5.2", +] + +[[package]] +name = "oid-registry" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c958dd45046245b9c3c2547369bb634eb461670b2e7e0de552905801a648d1d" +dependencies = [ + "asn1-rs 0.6.1", ] [[package]] @@ -9270,7 +9614,7 @@ version = "0.10.64" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "cfg-if", "foreign-types", "libc", @@ -9285,9 +9629,9 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -9326,9 +9670,9 @@ checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" [[package]] name = "orchestra" -version = "0.3.5" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2356622ffdfe72362a45a1e5e87bb113b8327e596e39b91f11f0ef4395c8da79" +checksum = "41f6bbacc8c189a3f2e45e0fd0436e5d97f194db888e721bdbc3973e7dbed4c2" dependencies = [ "async-trait", "dyn-clonable", @@ -9343,17 +9687,17 @@ dependencies = [ [[package]] name = "orchestra-proc-macro" -version = "0.3.5" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eedb646674596266dc9bb2b5c7eea7c36b32ecc7777eba0d510196972d72c4fd" +checksum = "f7b1d40dd8f367db3c65bec8d3dd47d4a604ee8874480738f93191bddab4e0e0" dependencies = [ - "expander 2.0.0", + "expander", "indexmap 2.2.3", "itertools 0.11.0", "petgraph", - "proc-macro-crate 1.3.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -9402,7 +9746,6 @@ dependencies = [ "sp-crypto-hashing", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9423,7 +9766,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9444,7 +9786,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9462,7 +9803,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-storage 19.0.0", ] @@ -9479,7 +9819,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9500,7 +9839,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-storage 19.0.0", ] @@ -9511,6 +9849,7 @@ dependencies = [ "frame-benchmarking", "frame-support", "frame-system", + "impl-trait-for-tuples", "log", "pallet-balances", "parity-scale-codec", @@ -9518,7 +9857,23 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", +] + +[[package]] +name = "pallet-assets-freezer" +version = "0.1.0" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-assets", + "pallet-balances", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", ] [[package]] @@ -9533,7 +9888,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9551,7 +9905,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9568,7 +9921,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9583,7 +9935,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9611,7 +9962,6 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -9631,7 +9981,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", ] @@ -9642,7 +9991,7 @@ dependencies = [ "frame-election-provider-support", "honggfuzz", "pallet-bags-list", - "rand 0.8.5", + "rand", ] [[package]] @@ -9679,7 +10028,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9707,7 +10055,6 @@ dependencies = [ "sp-session", "sp-staking", "sp-state-machine", - "sp-std 14.0.0", ] [[package]] @@ -9716,6 +10063,7 @@ version = "28.0.0" dependencies = [ "array-bytes", "binary-merkle-tree", + "frame-benchmarking", "frame-support", "frame-system", "log", @@ -9732,7 +10080,6 @@ dependencies = [ "sp-runtime", "sp-staking", "sp-state-machine", - "sp-std 14.0.0", ] [[package]] @@ -9750,7 +10097,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9767,7 +10113,7 @@ dependencies = [ "pallet-beefy-mmr", "pallet-mmr", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "serde", "sp-consensus-beefy", @@ -9784,7 +10130,6 @@ dependencies = [ "bp-header-chain", "bp-runtime", "bp-test-utils", - "finality-grandpa", "frame-benchmarking", "frame-support", "frame-system", @@ -9796,13 +10141,13 @@ dependencies = [ "sp-io", "sp-runtime", "sp-std 14.0.0", - "sp-trie", ] [[package]] name = "pallet-bridge-messages" version = "0.7.0" dependencies = [ + "bp-header-chain", "bp-messages", "bp-runtime", "bp-test-utils", @@ -9810,13 +10155,15 @@ dependencies = [ "frame-support", "frame-system", "log", - "num-traits", "pallet-balances", + "pallet-bridge-grandpa", "parity-scale-codec", "scale-info", + "sp-core", "sp-io", "sp-runtime", "sp-std 14.0.0", + "sp-trie", ] [[package]] @@ -9839,7 +10186,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-std 14.0.0", - "sp-trie", ] [[package]] @@ -9880,7 +10226,7 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", + "sp-tracing 16.0.0", ] [[package]] @@ -9899,7 +10245,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9916,14 +10261,13 @@ dependencies = [ "pallet-session", "pallet-timestamp", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "sp-consensus-aura", "sp-core", "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", "sp-tracing 16.0.0", ] @@ -9940,7 +10284,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9955,7 +10298,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -9965,7 +10307,6 @@ dependencies = [ "array-bytes", "assert_matches", "bitflags 1.3.2", - "env_logger 0.11.3", "environmental", "frame-benchmarking", "frame-support", @@ -9985,7 +10326,7 @@ dependencies = [ "parity-scale-codec", "paste", "pretty_assertions", - "rand 0.8.5", + "rand", "rand_pcg", "scale-info", "serde", @@ -10000,7 +10341,7 @@ dependencies = [ "staging-xcm", "staging-xcm-builder", "wasm-instrument", - "wasmi", + "wasmi 0.32.3", "wat", ] @@ -10011,7 +10352,7 @@ dependencies = [ "anyhow", "frame-system", "parity-wasm", - "polkavm-linker", + "polkavm-linker 0.9.2", "sp-runtime", "tempfile", "toml 0.8.8", @@ -10048,7 +10389,6 @@ dependencies = [ "sp-io", "sp-keystore", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "staging-xcm", "staging-xcm-builder", @@ -10060,9 +10400,9 @@ dependencies = [ name = "pallet-contracts-proc-macro" version = "18.0.0" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -10072,7 +10412,7 @@ dependencies = [ "bitflags 1.3.2", "parity-scale-codec", "paste", - "polkavm-derive", + "polkavm-derive 0.9.1", "scale-info", ] @@ -10092,7 +10432,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10110,7 +10449,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10124,7 +10462,29 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", +] + +[[package]] +name = "pallet-delegated-staking" +version = "1.0.0" +dependencies = [ + "frame-election-provider-support", + "frame-support", + "frame-system", + "log", + "pallet-balances", + "pallet-nomination-pools", + "pallet-staking", + "pallet-staking-reward-curve", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-tracing 16.0.0", + "substrate-test-utils", ] [[package]] @@ -10144,7 +10504,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10160,7 +10519,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10179,7 +10537,7 @@ dependencies = [ "pallet-staking", "pallet-timestamp", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "scale-info", "sp-core", "sp-io", @@ -10202,15 +10560,14 @@ dependencies = [ "pallet-balances", "pallet-election-provider-support-benchmarking", "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "scale-info", "sp-arithmetic", "sp-core", "sp-io", "sp-npos-elections", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "strum 0.26.2", ] @@ -10225,7 +10582,6 @@ dependencies = [ "parity-scale-codec", "sp-npos-elections", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10244,7 +10600,6 @@ dependencies = [ "sp-npos-elections", "sp-runtime", "sp-staking", - "sp-std 14.0.0", "sp-tracing 16.0.0", "substrate-test-utils", ] @@ -10263,7 +10618,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10289,7 +10643,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10320,7 +10673,6 @@ dependencies = [ "sp-io", "sp-keystore", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10339,7 +10691,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-version", ] @@ -10355,7 +10706,6 @@ dependencies = [ "scale-info", "sp-core", "sp-io", - "sp-std 14.0.0", ] [[package]] @@ -10371,7 +10721,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10409,7 +10758,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", "sp-tracing 16.0.0", "substrate-test-utils", ] @@ -10427,9 +10775,9 @@ dependencies = [ "parity-scale-codec", "scale-info", "sp-core", + "sp-inherents", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10459,12 +10807,11 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", ] [[package]] name = "pallet-identity" -version = "28.0.0" +version = "29.0.0" dependencies = [ "enumflags2", "frame-benchmarking", @@ -10478,7 +10825,6 @@ dependencies = [ "sp-io", "sp-keystore", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10498,7 +10844,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -10515,7 +10860,6 @@ dependencies = [ "sp-io", "sp-keyring", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10530,7 +10874,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10547,7 +10890,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10563,7 +10905,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10576,7 +10917,7 @@ dependencies = [ "frame-system", "log", "parity-scale-codec", - "rand 0.8.5", + "rand", "rand_distr", "scale-info", "serde", @@ -10585,7 +10926,6 @@ dependencies = [ "sp-crypto-hashing", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "sp-weights", ] @@ -10609,7 +10949,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "sp-version", ] @@ -10619,7 +10958,7 @@ name = "pallet-minimal-template" version = "0.0.0" dependencies = [ "parity-scale-codec", - "polkadot-sdk-frame", + "polkadot-sdk", "scale-info", ] @@ -10639,7 +10978,6 @@ dependencies = [ "sp-io", "sp-mixnet", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10647,7 +10985,6 @@ name = "pallet-mmr" version = "27.0.0" dependencies = [ "array-bytes", - "env_logger 0.11.3", "frame-benchmarking", "frame-support", "frame-system", @@ -10659,7 +10996,7 @@ dependencies = [ "sp-io", "sp-mmr-primitives", "sp-runtime", - "sp-std 14.0.0", + "sp-tracing 16.0.0", ] [[package]] @@ -10675,7 +11012,6 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10713,7 +11049,6 @@ dependencies = [ "sp-io", "sp-keystore", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10723,7 +11058,6 @@ dependencies = [ "pallet-nfts", "parity-scale-codec", "sp-api", - "sp-std 14.0.0", ] [[package]] @@ -10740,7 +11074,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10755,7 +11088,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10772,7 +11104,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", "sp-tracing 16.0.0", ] @@ -10786,6 +11117,7 @@ dependencies = [ "frame-system", "pallet-bags-list", "pallet-balances", + "pallet-delegated-staking", "pallet-nomination-pools", "pallet-staking", "pallet-staking-reward-curve", @@ -10797,7 +11129,6 @@ dependencies = [ "sp-runtime", "sp-runtime-interface 24.0.0", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -10809,7 +11140,7 @@ dependencies = [ "honggfuzz", "log", "pallet-nomination-pools", - "rand 0.8.5", + "rand", "sp-io", "sp-runtime", "sp-tracing 16.0.0", @@ -10822,11 +11153,35 @@ dependencies = [ "pallet-nomination-pools", "parity-scale-codec", "sp-api", +] + +[[package]] +name = "pallet-nomination-pools-test-delegate-stake" +version = "1.0.0" +dependencies = [ + "frame-election-provider-support", + "frame-support", + "frame-system", + "log", + "pallet-bags-list", + "pallet-balances", + "pallet-delegated-staking", + "pallet-nomination-pools", + "pallet-staking", + "pallet-staking-reward-curve", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-staking", "sp-std 14.0.0", + "sp-tracing 16.0.0", ] [[package]] -name = "pallet-nomination-pools-test-staking" +name = "pallet-nomination-pools-test-transfer-stake" version = "1.0.0" dependencies = [ "frame-election-provider-support", @@ -10864,7 +11219,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -10891,7 +11245,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -10908,7 +11261,6 @@ dependencies = [ "sp-io", "sp-metadata-ir", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10953,7 +11305,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10970,7 +11321,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -10987,7 +11337,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11005,7 +11354,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11021,7 +11369,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11043,7 +11390,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11059,7 +11405,115 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", +] + +[[package]] +name = "pallet-revive" +version = "0.1.0" +dependencies = [ + "array-bytes", + "assert_matches", + "bitflags 1.3.2", + "environmental", + "frame-benchmarking", + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "log", + "pallet-assets", + "pallet-balances", + "pallet-message-queue", + "pallet-proxy", + "pallet-revive-fixtures", + "pallet-revive-proc-macro", + "pallet-revive-uapi", + "pallet-timestamp", + "pallet-utility", + "parity-scale-codec", + "paste", + "polkavm 0.10.0", + "pretty_assertions", + "scale-info", + "serde", + "sp-api", + "sp-core", + "sp-io", + "sp-keystore", + "sp-runtime", "sp-std 14.0.0", + "sp-tracing 16.0.0", + "staging-xcm", + "staging-xcm-builder", + "wat", +] + +[[package]] +name = "pallet-revive-fixtures" +version = "0.1.0" +dependencies = [ + "anyhow", + "frame-system", + "parity-wasm", + "polkavm-linker 0.10.0", + "sp-runtime", + "tempfile", + "toml 0.8.8", +] + +[[package]] +name = "pallet-revive-mock-network" +version = "0.1.0" +dependencies = [ + "assert_matches", + "frame-support", + "frame-system", + "pallet-assets", + "pallet-balances", + "pallet-message-queue", + "pallet-proxy", + "pallet-revive", + "pallet-revive-fixtures", + "pallet-revive-proc-macro", + "pallet-revive-uapi", + "pallet-timestamp", + "pallet-utility", + "pallet-xcm", + "parity-scale-codec", + "polkadot-parachain-primitives", + "polkadot-primitives", + "polkadot-runtime-parachains", + "pretty_assertions", + "scale-info", + "sp-api", + "sp-core", + "sp-io", + "sp-keystore", + "sp-runtime", + "sp-tracing 16.0.0", + "staging-xcm", + "staging-xcm-builder", + "staging-xcm-executor", + "xcm-simulator", +] + +[[package]] +name = "pallet-revive-proc-macro" +version = "0.1.0" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + +[[package]] +name = "pallet-revive-uapi" +version = "0.1.0" +dependencies = [ + "bitflags 1.3.2", + "parity-scale-codec", + "paste", + "polkavm-derive 0.10.0", + "scale-info", ] [[package]] @@ -11094,7 +11548,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11114,7 +11567,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11132,7 +11584,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11151,7 +11602,6 @@ dependencies = [ "sp-crypto-hashing", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11169,7 +11619,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-weights", "substrate-test-utils", ] @@ -11186,7 +11635,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11206,7 +11654,6 @@ dependencies = [ "sp-session", "sp-staking", "sp-state-machine", - "sp-std 14.0.0", "sp-trie", ] @@ -11224,13 +11671,12 @@ dependencies = [ "pallet-staking-reward-curve", "pallet-timestamp", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "sp-core", "sp-io", "sp-runtime", "sp-session", - "sp-std 14.0.0", ] [[package]] @@ -11242,7 +11688,6 @@ dependencies = [ "parity-scale-codec", "scale-info", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11256,14 +11701,13 @@ dependencies = [ "log", "pallet-balances", "parity-scale-codec", - "rand_chacha 0.3.1", + "rand_chacha", "scale-info", "sp-arithmetic", "sp-core", "sp-crypto-hashing", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11282,7 +11726,7 @@ dependencies = [ "pallet-staking-reward-curve", "pallet-timestamp", "parity-scale-codec", - "rand_chacha 0.3.1", + "rand_chacha", "scale-info", "serde", "sp-application-crypto", @@ -11291,7 +11735,6 @@ dependencies = [ "sp-npos-elections", "sp-runtime", "sp-staking", - "sp-std 14.0.0", "sp-tracing 16.0.0", "substrate-test-utils", ] @@ -11300,11 +11743,11 @@ dependencies = [ name = "pallet-staking-reward-curve" version = "11.0.0" dependencies = [ - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "sp-runtime", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -11335,13 +11778,12 @@ dependencies = [ "log", "pallet-balances", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "scale-info", "serde", "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "substrate-state-trie-migration-rpc", "thousands", @@ -11364,7 +11806,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-statement-store", - "sp-std 14.0.0", ] [[package]] @@ -11380,7 +11821,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11412,7 +11852,6 @@ dependencies = [ "sp-inherents", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-timestamp", ] @@ -11433,7 +11872,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-storage 19.0.0", ] @@ -11451,7 +11889,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11497,7 +11934,6 @@ dependencies = [ "sp-inherents", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-transaction-storage-proof", ] @@ -11518,7 +11954,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11537,7 +11972,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11573,7 +12007,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11590,7 +12023,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11608,7 +12040,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -11630,11 +12061,10 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -11654,7 +12084,6 @@ dependencies = [ "scale-info", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "staging-xcm", "staging-xcm-builder", @@ -11675,6 +12104,7 @@ dependencies = [ "log", "pallet-balances", "pallet-bridge-messages", + "pallet-xcm-bridge-hub-router", "parity-scale-codec", "scale-info", "sp-core", @@ -11709,7 +12139,7 @@ dependencies = [ name = "parachain-template-node" version = "0.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "color-print", "cumulus-client-cli", "cumulus-client-collator", @@ -11780,6 +12210,7 @@ dependencies = [ "docify", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -11814,7 +12245,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-transaction-pool", "sp-version", "staging-parachain-info", @@ -11847,7 +12277,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "staging-parachain-info", "staging-xcm", "staging-xcm-executor", @@ -11892,7 +12321,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-tracing 16.0.0", "staging-parachain-info", "staging-xcm", @@ -11907,8 +12335,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4e69bf016dc406eff7d53a7d3f7cf1c2e72c82b9088aac1118591e36dd2cd3e9" dependencies = [ "bitcoin_hashes 0.13.0", - "rand 0.7.3", - "rand_core 0.5.1", + "rand", + "rand_core", "serde", "unicode-normalization", ] @@ -11933,17 +12361,17 @@ dependencies = [ "log", "lz4", "memmap2 0.5.10", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "siphasher", "snap", ] [[package]] name = "parity-scale-codec" -version = "3.6.5" +version = "3.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dec8a8073036902368c2cdc0387e85ff9a37054d7e7c98e592145e0c92cd4fb" +checksum = "306800abfa29c7f16596b5970a588435e3d5b3149683d00c12b699cc19f895ee" dependencies = [ "arrayvec 0.7.4", "bitvec", @@ -11956,22 +12384,16 @@ dependencies = [ [[package]] name = "parity-scale-codec-derive" -version = "3.6.5" +version = "3.6.12" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "312270ee71e1cd70289dacf597cab7b207aa107d2f28191c2ae45b2ece18a260" +checksum = "d830939c76d294956402033aee57a6da7b438f2294eb94864c37b0569053a42c" dependencies = [ - "proc-macro-crate 1.3.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] -[[package]] -name = "parity-send-wrapper" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aa9777aa91b8ad9dd5aaa04a9b6bcb02c7f1deb952fca5a66034d5e63afc5c6f" - [[package]] name = "parity-util-mem" version = "0.12.0" @@ -11984,7 +12406,7 @@ dependencies = [ "impl-trait-for-tuples", "lru 0.8.1", "parity-util-mem-derive", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "primitive-types", "smallvec", "winapi", @@ -11996,9 +12418,9 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f557c32c6d268a07c921471619c0295f5efad3a0e76d4f97a05c091a51d110b2" dependencies = [ - "proc-macro2 1.0.75", + "proc-macro2 1.0.82", "syn 1.0.109", - "synstructure", + "synstructure 0.12.6", ] [[package]] @@ -12026,9 +12448,9 @@ dependencies = [ [[package]] name = "parking_lot" -version = "0.12.1" +version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" +checksum = "f1bf18183cf54e8d6059647fc3063646a1801cf30896933ec2311622cc4b9a27" dependencies = [ "lock_api", "parking_lot_core 0.9.8", @@ -12074,15 +12496,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166" dependencies = [ "base64ct", - "rand_core 0.6.4", + "rand_core", "subtle 2.5.0", ] [[package]] name = "paste" -version = "1.0.14" +version = "1.0.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" [[package]] name = "pbkdf2" @@ -12172,7 +12594,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -12181,7 +12602,7 @@ dependencies = [ "staging-xcm-builder", "staging-xcm-executor", "substrate-wasm-builder", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -12209,9 +12630,7 @@ dependencies = [ "pallet-message-queue", "parachains-common", "parity-scale-codec", - "people-rococo-runtime", "polkadot-runtime-common", - "rococo-runtime", "rococo-runtime-constants", "rococo-system-emulated-network", "sp-runtime", @@ -12272,7 +12691,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -12282,6 +12700,7 @@ dependencies = [ "staging-xcm-executor", "substrate-wasm-builder", "testnet-parachains-constants", + "xcm-runtime-apis", ] [[package]] @@ -12307,14 +12726,13 @@ dependencies = [ "pallet-balances", "pallet-identity", "pallet-message-queue", + "pallet-xcm", "parachains-common", "parity-scale-codec", - "people-westend-runtime", "polkadot-runtime-common", "sp-runtime", "staging-xcm", "staging-xcm-executor", - "westend-runtime", "westend-runtime-constants", "westend-system-emulated-network", ] @@ -12371,7 +12789,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -12382,13 +12799,14 @@ dependencies = [ "substrate-wasm-builder", "testnet-parachains-constants", "westend-runtime-constants", + "xcm-runtime-apis", ] [[package]] name = "percent-encoding" -version = "2.3.0" +version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94" +checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" [[package]] name = "pest" @@ -12418,9 +12836,9 @@ checksum = "68ca01446f50dbda87c1786af8770d535423fa8a53aec03b8f4e3d7eb10e0929" dependencies = [ "pest", "pest_meta", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -12459,22 +12877,16 @@ version = "1.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "pin-project-lite" -version = "0.1.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "257b64915a082f7811703966789728173279bdebb956b143dbcd23f6f970a777" - -[[package]] -name = "pin-project-lite" -version = "0.2.12" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "12cc1b0bf1727a77a54b6654e7b5f1af8604923edc8b81885f8ec92f9e3f0a05" +checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02" [[package]] name = "pin-utils" @@ -12538,7 +12950,7 @@ version = "6.0.0" dependencies = [ "assert_cmd", "color-eyre", - "nix 0.27.1", + "nix 0.28.0", "polkadot-cli", "polkadot-core-primitives", "polkadot-node-core-pvf", @@ -12559,7 +12971,6 @@ version = "7.0.0" dependencies = [ "assert_matches", "bitvec", - "env_logger 0.11.3", "futures", "futures-timer", "itertools 0.11.0", @@ -12573,12 +12984,13 @@ dependencies = [ "polkadot-node-subsystem-util", "polkadot-primitives", "polkadot-primitives-test-helpers", - "rand 0.8.5", - "rand_chacha 0.3.1", - "rand_core 0.6.4", + "rand", + "rand_chacha", + "rand_core", "schnorrkel 0.11.4", "sp-authority-discovery", "sp-core", + "sp-tracing 16.0.0", "tracing-gum", ] @@ -12589,23 +13001,22 @@ dependencies = [ "always-assert", "assert_matches", "bitvec", - "env_logger 0.11.3", "futures", "futures-timer", - "log", "maplit", "polkadot-node-network-protocol", "polkadot-node-subsystem", "polkadot-node-subsystem-test-helpers", "polkadot-node-subsystem-util", "polkadot-primitives", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "sp-application-crypto", "sp-authority-discovery", "sp-core", "sp-keyring", "sp-keystore", + "sp-tracing 16.0.0", "tracing-gum", ] @@ -12628,7 +13039,8 @@ dependencies = [ "polkadot-primitives", "polkadot-primitives-test-helpers", "polkadot-subsystem-bench", - "rand 0.8.5", + "rand", + "rstest", "sc-network", "schnellru", "sp-core", @@ -12645,7 +13057,6 @@ version = "7.0.0" dependencies = [ "assert_matches", "async-trait", - "env_logger 0.11.3", "fatality", "futures", "futures-timer", @@ -12660,23 +13071,35 @@ dependencies = [ "polkadot-primitives", "polkadot-primitives-test-helpers", "polkadot-subsystem-bench", - "rand 0.8.5", + "rand", + "rstest", "sc-network", "schnellru", "sp-application-crypto", "sp-core", "sp-keyring", + "sp-tracing 16.0.0", "thiserror", "tokio", "tracing-gum", ] +[[package]] +name = "polkadot-ckb-merkle-mountain-range" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4b44320e5f7ce2c18227537a3032ae5b2c476a7e8eddba45333e1011fc31b92" +dependencies = [ + "cfg-if", + "itertools 0.10.5", +] + [[package]] name = "polkadot-cli" version = "7.0.0" dependencies = [ "cfg-if", - "clap 4.5.3", + "clap 4.5.11", "frame-benchmarking-cli", "futures", "log", @@ -12706,11 +13129,9 @@ version = "7.0.0" dependencies = [ "assert_matches", "bitvec", - "env_logger 0.11.3", "fatality", "futures", "futures-timer", - "log", "parity-scale-codec", "polkadot-node-network-protocol", "polkadot-node-primitives", @@ -12719,12 +13140,14 @@ dependencies = [ "polkadot-node-subsystem-util", "polkadot-primitives", "polkadot-primitives-test-helpers", + "rstest", "sc-keystore", "sc-network", "sp-core", "sp-keyring", "sp-keystore", "sp-runtime", + "sp-tracing 16.0.0", "thiserror", "tokio-util", "tracing-gum", @@ -12738,7 +13161,6 @@ dependencies = [ "scale-info", "sp-core", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -12782,6 +13204,7 @@ dependencies = [ "parity-scale-codec", "polkadot-node-primitives", "polkadot-primitives", + "quickcheck", "reed-solomon-novelpoly", "sp-core", "sp-trie", @@ -12797,15 +13220,15 @@ dependencies = [ "futures", "futures-timer", "lazy_static", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-network-protocol", "polkadot-node-subsystem", "polkadot-node-subsystem-test-helpers", "polkadot-node-subsystem-util", "polkadot-primitives", "quickcheck", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "sc-network", "sc-network-common", "sp-application-crypto", @@ -12831,7 +13254,7 @@ dependencies = [ "futures", "futures-timer", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-metrics", "polkadot-node-network-protocol", "polkadot-node-subsystem", @@ -12878,7 +13301,6 @@ dependencies = [ "async-trait", "bitvec", "derive_more", - "env_logger 0.11.3", "futures", "futures-timer", "itertools 0.11.0", @@ -12887,7 +13309,7 @@ dependencies = [ "log", "merlin", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-jaeger", "polkadot-node-primitives", "polkadot-node-subsystem", @@ -12897,9 +13319,9 @@ dependencies = [ "polkadot-primitives", "polkadot-primitives-test-helpers", "polkadot-subsystem-bench", - "rand 0.8.5", - "rand_chacha 0.3.1", - "rand_core 0.6.4", + "rand", + "rand_chacha", + "rand_core", "sc-keystore", "schnellru", "schnorrkel 0.11.4", @@ -12911,6 +13333,7 @@ dependencies = [ "sp-keyring", "sp-keystore", "sp-runtime", + "sp-tracing 16.0.0", "thiserror", "tracing-gum", ] @@ -12921,14 +13344,13 @@ version = "7.0.0" dependencies = [ "assert_matches", "bitvec", - "env_logger 0.11.3", "futures", "futures-timer", "kvdb", "kvdb-memorydb", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-erasure-coding", "polkadot-node-jaeger", "polkadot-node-primitives", @@ -12941,6 +13363,7 @@ dependencies = [ "sp-consensus", "sp-core", "sp-keyring", + "sp-tracing 16.0.0", "thiserror", "tracing-gum", ] @@ -13008,8 +13431,10 @@ dependencies = [ "polkadot-parachain-primitives", "polkadot-primitives", "polkadot-primitives-test-helpers", + "sp-application-crypto", "sp-core", "sp-keyring", + "sp-keystore", "sp-maybe-compressed-blob", "tracing-gum", ] @@ -13044,7 +13469,7 @@ dependencies = [ "kvdb", "kvdb-memorydb", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-node-subsystem-test-helpers", @@ -13104,23 +13529,17 @@ name = "polkadot-node-core-prospective-parachains" version = "6.0.0" dependencies = [ "assert_matches", - "bitvec", "fatality", "futures", - "parity-scale-codec", - "polkadot-node-primitives", "polkadot-node-subsystem", "polkadot-node-subsystem-test-helpers", - "polkadot-node-subsystem-types", "polkadot-node-subsystem-util", "polkadot-primitives", "polkadot-primitives-test-helpers", + "rand", "rstest", - "sc-keystore", - "sp-application-crypto", "sp-core", - "sp-keyring", - "sp-keystore", + "sp-tracing 16.0.0", "thiserror", "tracing-gum", ] @@ -13175,7 +13594,7 @@ dependencies = [ "polkadot-parachain-primitives", "polkadot-primitives", "procfs", - "rand 0.8.5", + "rand", "rococo-runtime", "rusty-fork", "sc-sysinfo", @@ -13222,7 +13641,7 @@ dependencies = [ "futures", "landlock", "libc", - "nix 0.27.1", + "nix 0.28.0", "parity-scale-codec", "polkadot-parachain-primitives", "polkadot-primitives", @@ -13247,11 +13666,13 @@ dependencies = [ "cfg-if", "cpu-time", "libc", - "nix 0.27.1", + "nix 0.28.0", "parity-scale-codec", "polkadot-node-core-pvf-common", + "polkadot-node-primitives", "polkadot-parachain-primitives", "polkadot-primitives", + "sp-maybe-compressed-blob", "tracing-gum", ] @@ -13263,9 +13684,10 @@ dependencies = [ "cfg-if", "criterion", "libc", - "nix 0.27.1", + "nix 0.28.0", "parity-scale-codec", "polkadot-node-core-pvf-common", + "polkadot-node-primitives", "polkadot-primitives", "rayon", "rococo-runtime", @@ -13307,7 +13729,7 @@ dependencies = [ "log", "mick-jaeger", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-primitives", "polkadot-primitives", "sc-network", @@ -13322,10 +13744,12 @@ name = "polkadot-node-metrics" version = "7.0.0" dependencies = [ "assert_cmd", - "bs58 0.5.0", + "bs58 0.5.1", "futures", "futures-timer", - "hyper", + "http-body-util", + "hyper 1.3.1", + "hyper-util", "log", "parity-scale-codec", "polkadot-primitives", @@ -13358,8 +13782,8 @@ dependencies = [ "polkadot-node-jaeger", "polkadot-node-primitives", "polkadot-primitives", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "sc-authority-discovery", "sc-network", "sc-network-types", @@ -13407,7 +13831,7 @@ version = "1.0.0" dependencies = [ "async-trait", "futures", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-erasure-coding", "polkadot-node-primitives", "polkadot-node-subsystem", @@ -13429,6 +13853,7 @@ dependencies = [ "async-trait", "bitvec", "derive_more", + "fatality", "futures", "orchestra", "polkadot-node-jaeger", @@ -13457,7 +13882,6 @@ dependencies = [ "assert_matches", "async-trait", "derive_more", - "env_logger 0.11.3", "fatality", "futures", "futures-channel", @@ -13469,8 +13893,9 @@ dependencies = [ "log", "parity-db", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", + "polkadot-erasure-coding", "polkadot-node-jaeger", "polkadot-node-metrics", "polkadot-node-network-protocol", @@ -13482,7 +13907,7 @@ dependencies = [ "polkadot-primitives", "polkadot-primitives-test-helpers", "prioritized-metered-channel", - "rand 0.8.5", + "rand", "sc-client-api", "schnellru", "sp-application-crypto", @@ -13503,7 +13928,7 @@ dependencies = [ "futures", "futures-timer", "orchestra", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-node-metrics", "polkadot-node-network-protocol", "polkadot-node-primitives", @@ -13523,18 +13948,48 @@ dependencies = [ name = "polkadot-parachain-bin" version = "4.0.0" dependencies = [ - "assert_cmd", "asset-hub-rococo-runtime", "asset-hub-westend-runtime", - "async-trait", "bridge-hub-rococo-runtime", "bridge-hub-westend-runtime", - "clap 4.5.3", "collectives-westend-runtime", - "color-print", + "color-eyre", "contracts-rococo-runtime", "coretime-rococo-runtime", "coretime-westend-runtime", + "cumulus-primitives-core", + "glutton-westend-runtime", + "hex-literal", + "log", + "parachains-common", + "penpal-runtime", + "people-rococo-runtime", + "people-westend-runtime", + "polkadot-parachain-lib", + "polkadot-service", + "rococo-parachain-runtime", + "sc-chain-spec", + "sc-cli", + "sc-service", + "seedling-runtime", + "serde", + "serde_json", + "shell-runtime", + "sp-core", + "sp-runtime", + "staging-xcm", + "substrate-build-script-utils", + "testnet-parachains-constants", +] + +[[package]] +name = "polkadot-parachain-lib" +version = "0.1.0" +dependencies = [ + "assert_cmd", + "async-trait", + "clap 4.5.11", + "color-print", "cumulus-client-cli", "cumulus-client-collator", "cumulus-client-consensus-aura", @@ -13546,72 +14001,55 @@ dependencies = [ "cumulus-primitives-aura", "cumulus-primitives-core", "cumulus-relay-chain-interface", + "docify", "frame-benchmarking", "frame-benchmarking-cli", "frame-support", "frame-system-rpc-runtime-api", "frame-try-runtime", "futures", - "glutton-westend-runtime", - "hex-literal", "jsonrpsee", "log", - "nix 0.27.1", + "nix 0.28.0", "pallet-transaction-payment", "pallet-transaction-payment-rpc", "pallet-transaction-payment-rpc-runtime-api", "parachains-common", "parity-scale-codec", - "penpal-runtime", - "people-rococo-runtime", - "people-westend-runtime", "polkadot-cli", "polkadot-primitives", - "polkadot-service", - "rococo-parachain-runtime", "sc-basic-authorship", "sc-chain-spec", "sc-cli", "sc-client-api", + "sc-client-db", "sc-consensus", "sc-executor", "sc-network", - "sc-network-sync", "sc-rpc", "sc-service", "sc-sysinfo", "sc-telemetry", "sc-tracing", "sc-transaction-pool", - "sc-transaction-pool-api", - "seedling-runtime", "serde", "serde_json", - "shell-runtime", "sp-api", "sp-block-builder", - "sp-blockchain", "sp-consensus-aura", "sp-core", "sp-genesis-builder", "sp-inherents", - "sp-io", "sp-keystore", - "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-timestamp", - "sp-tracing 16.0.0", "sp-transaction-pool", "sp-version", - "staging-xcm", - "substrate-build-script-utils", + "sp-weights", "substrate-frame-rpc-system", "substrate-prometheus-endpoint", "substrate-state-trie-migration-rpc", - "tempfile", - "testnet-parachains-constants", "tokio", "wait-timeout", ] @@ -13628,7 +14066,6 @@ dependencies = [ "serde", "sp-core", "sp-runtime", - "sp-std 14.0.0", "sp-weights", ] @@ -13655,7 +14092,6 @@ dependencies = [ "sp-keystore", "sp-runtime", "sp-staking", - "sp-std 14.0.0", ] [[package]] @@ -13663,7 +14099,7 @@ name = "polkadot-primitives-test-helpers" version = "1.0.0" dependencies = [ "polkadot-primitives", - "rand 0.8.5", + "rand", "sp-application-crypto", "sp-core", "sp-keyring", @@ -13692,10 +14128,12 @@ dependencies = [ "sc-sync-state-rpc", "sc-transaction-pool-api", "sp-api", + "sp-application-crypto", "sp-block-builder", "sp-blockchain", "sp-consensus", "sp-consensus-babe", + "sp-consensus-beefy", "sp-keystore", "sp-runtime", "substrate-frame-rpc-system", @@ -13751,7 +14189,6 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", @@ -13762,11 +14199,10 @@ dependencies = [ name = "polkadot-runtime-metrics" version = "7.0.0" dependencies = [ - "bs58 0.5.0", + "bs58 0.5.1", "frame-benchmarking", "parity-scale-codec", "polkadot-primitives", - "sp-std 14.0.0", "sp-tracing 16.0.0", ] @@ -13792,6 +14228,7 @@ dependencies = [ "pallet-balances", "pallet-broker", "pallet-message-queue", + "pallet-mmr", "pallet-session", "pallet-staking", "pallet-timestamp", @@ -13802,10 +14239,9 @@ dependencies = [ "polkadot-primitives", "polkadot-primitives-test-helpers", "polkadot-runtime-metrics", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "rstest", - "rustc-hex", "sc-keystore", "scale-info", "serde", @@ -13826,14 +14262,395 @@ dependencies = [ "sp-tracing 16.0.0", "staging-xcm", "staging-xcm-executor", - "static_assertions", - "thousands", + "static_assertions", + "thousands", +] + +[[package]] +name = "polkadot-sdk" +version = "0.1.0" +dependencies = [ + "asset-test-utils", + "assets-common", + "binary-merkle-tree", + "bp-header-chain", + "bp-messages", + "bp-parachains", + "bp-polkadot", + "bp-polkadot-core", + "bp-relayers", + "bp-runtime", + "bp-test-utils", + "bp-xcm-bridge-hub", + "bp-xcm-bridge-hub-router", + "bridge-hub-common", + "bridge-hub-test-utils", + "bridge-runtime-common", + "cumulus-client-cli", + "cumulus-client-collator", + "cumulus-client-consensus-aura", + "cumulus-client-consensus-common", + "cumulus-client-consensus-proposer", + "cumulus-client-consensus-relay-chain", + "cumulus-client-network", + "cumulus-client-parachain-inherent", + "cumulus-client-pov-recovery", + "cumulus-client-service", + "cumulus-pallet-aura-ext", + "cumulus-pallet-dmp-queue", + "cumulus-pallet-parachain-system", + "cumulus-pallet-parachain-system-proc-macro", + "cumulus-pallet-session-benchmarking", + "cumulus-pallet-solo-to-para", + "cumulus-pallet-xcm", + "cumulus-pallet-xcmp-queue", + "cumulus-ping", + "cumulus-primitives-aura", + "cumulus-primitives-core", + "cumulus-primitives-parachain-inherent", + "cumulus-primitives-proof-size-hostfunction", + "cumulus-primitives-storage-weight-reclaim", + "cumulus-primitives-timestamp", + "cumulus-primitives-utility", + "cumulus-relay-chain-inprocess-interface", + "cumulus-relay-chain-interface", + "cumulus-relay-chain-minimal-node", + "cumulus-relay-chain-rpc-interface", + "cumulus-test-relay-sproof-builder", + "emulated-integration-tests-common", + "fork-tree", + "frame-benchmarking", + "frame-benchmarking-cli", + "frame-benchmarking-pallet-pov", + "frame-election-provider-solution-type", + "frame-election-provider-support", + "frame-executive", + "frame-metadata-hash-extension", + "frame-remote-externalities", + "frame-support", + "frame-support-procedural", + "frame-support-procedural-tools", + "frame-support-procedural-tools-derive", + "frame-system", + "frame-system-benchmarking", + "frame-system-rpc-runtime-api", + "frame-try-runtime", + "generate-bags", + "mmr-gadget", + "mmr-rpc", + "pallet-alliance", + "pallet-asset-conversion", + "pallet-asset-conversion-ops", + "pallet-asset-conversion-tx-payment", + "pallet-asset-rate", + "pallet-asset-tx-payment", + "pallet-assets", + "pallet-assets-freezer", + "pallet-atomic-swap", + "pallet-aura", + "pallet-authority-discovery", + "pallet-authorship", + "pallet-babe", + "pallet-bags-list", + "pallet-balances", + "pallet-beefy", + "pallet-beefy-mmr", + "pallet-bounties", + "pallet-bridge-grandpa", + "pallet-bridge-messages", + "pallet-bridge-parachains", + "pallet-bridge-relayers", + "pallet-broker", + "pallet-child-bounties", + "pallet-collator-selection", + "pallet-collective", + "pallet-collective-content", + "pallet-contracts", + "pallet-contracts-mock-network", + "pallet-contracts-proc-macro", + "pallet-contracts-uapi", + "pallet-conviction-voting", + "pallet-core-fellowship", + "pallet-delegated-staking", + "pallet-democracy", + "pallet-dev-mode", + "pallet-election-provider-multi-phase", + "pallet-election-provider-support-benchmarking", + "pallet-elections-phragmen", + "pallet-fast-unstake", + "pallet-glutton", + "pallet-grandpa", + "pallet-identity", + "pallet-im-online", + "pallet-indices", + "pallet-insecure-randomness-collective-flip", + "pallet-lottery", + "pallet-membership", + "pallet-message-queue", + "pallet-migrations", + "pallet-mixnet", + "pallet-mmr", + "pallet-multisig", + "pallet-nft-fractionalization", + "pallet-nfts", + "pallet-nfts-runtime-api", + "pallet-nis", + "pallet-node-authorization", + "pallet-nomination-pools", + "pallet-nomination-pools-benchmarking", + "pallet-nomination-pools-runtime-api", + "pallet-offences", + "pallet-offences-benchmarking", + "pallet-paged-list", + "pallet-parameters", + "pallet-preimage", + "pallet-proxy", + "pallet-ranked-collective", + "pallet-recovery", + "pallet-referenda", + "pallet-remark", + "pallet-revive", + "pallet-revive-fixtures", + "pallet-revive-mock-network", + "pallet-revive-proc-macro", + "pallet-revive-uapi", + "pallet-root-offences", + "pallet-root-testing", + "pallet-safe-mode", + "pallet-salary", + "pallet-scheduler", + "pallet-scored-pool", + "pallet-session", + "pallet-session-benchmarking", + "pallet-skip-feeless-payment", + "pallet-society", + "pallet-staking", + "pallet-staking-reward-curve", + "pallet-staking-reward-fn", + "pallet-staking-runtime-api", + "pallet-state-trie-migration", + "pallet-statement", + "pallet-sudo", + "pallet-timestamp", + "pallet-tips", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc", + "pallet-transaction-payment-rpc-runtime-api", + "pallet-transaction-storage", + "pallet-treasury", + "pallet-tx-pause", + "pallet-uniques", + "pallet-utility", + "pallet-vesting", + "pallet-whitelist", + "pallet-xcm", + "pallet-xcm-benchmarks", + "pallet-xcm-bridge-hub", + "pallet-xcm-bridge-hub-router", + "parachains-common", + "parachains-runtimes-test-utils", + "polkadot-approval-distribution", + "polkadot-availability-bitfield-distribution", + "polkadot-availability-distribution", + "polkadot-availability-recovery", + "polkadot-cli", + "polkadot-collator-protocol", + "polkadot-core-primitives", + "polkadot-dispute-distribution", + "polkadot-erasure-coding", + "polkadot-gossip-support", + "polkadot-network-bridge", + "polkadot-node-collation-generation", + "polkadot-node-core-approval-voting", + "polkadot-node-core-av-store", + "polkadot-node-core-backing", + "polkadot-node-core-bitfield-signing", + "polkadot-node-core-candidate-validation", + "polkadot-node-core-chain-api", + "polkadot-node-core-chain-selection", + "polkadot-node-core-dispute-coordinator", + "polkadot-node-core-parachains-inherent", + "polkadot-node-core-prospective-parachains", + "polkadot-node-core-provisioner", + "polkadot-node-core-pvf", + "polkadot-node-core-pvf-checker", + "polkadot-node-core-pvf-common", + "polkadot-node-core-pvf-execute-worker", + "polkadot-node-core-pvf-prepare-worker", + "polkadot-node-core-runtime-api", + "polkadot-node-jaeger", + "polkadot-node-metrics", + "polkadot-node-network-protocol", + "polkadot-node-primitives", + "polkadot-node-subsystem", + "polkadot-node-subsystem-types", + "polkadot-node-subsystem-util", + "polkadot-overseer", + "polkadot-parachain-lib", + "polkadot-parachain-primitives", + "polkadot-primitives", + "polkadot-rpc", + "polkadot-runtime-common", + "polkadot-runtime-metrics", + "polkadot-runtime-parachains", + "polkadot-sdk-frame", + "polkadot-service", + "polkadot-statement-distribution", + "polkadot-statement-table", + "sc-allocator", + "sc-authority-discovery", + "sc-basic-authorship", + "sc-block-builder", + "sc-chain-spec", + "sc-chain-spec-derive", + "sc-cli", + "sc-client-api", + "sc-client-db", + "sc-consensus", + "sc-consensus-aura", + "sc-consensus-babe", + "sc-consensus-babe-rpc", + "sc-consensus-beefy", + "sc-consensus-beefy-rpc", + "sc-consensus-epochs", + "sc-consensus-grandpa", + "sc-consensus-grandpa-rpc", + "sc-consensus-manual-seal", + "sc-consensus-pow", + "sc-consensus-slots", + "sc-executor", + "sc-executor-common", + "sc-executor-polkavm", + "sc-executor-wasmtime", + "sc-informant", + "sc-keystore", + "sc-mixnet", + "sc-network", + "sc-network-common", + "sc-network-gossip", + "sc-network-light", + "sc-network-statement", + "sc-network-sync", + "sc-network-transactions", + "sc-network-types", + "sc-offchain", + "sc-proposer-metrics", + "sc-rpc", + "sc-rpc-api", + "sc-rpc-server", + "sc-rpc-spec-v2", + "sc-service", + "sc-state-db", + "sc-statement-store", + "sc-storage-monitor", + "sc-sync-state-rpc", + "sc-sysinfo", + "sc-telemetry", + "sc-tracing", + "sc-tracing-proc-macro", + "sc-transaction-pool", + "sc-transaction-pool-api", + "sc-utils", + "slot-range-helper", + "snowbridge-beacon-primitives", + "snowbridge-core", + "snowbridge-ethereum", + "snowbridge-outbound-queue-merkle-tree", + "snowbridge-outbound-queue-runtime-api", + "snowbridge-pallet-ethereum-client", + "snowbridge-pallet-ethereum-client-fixtures", + "snowbridge-pallet-inbound-queue", + "snowbridge-pallet-inbound-queue-fixtures", + "snowbridge-pallet-outbound-queue", + "snowbridge-pallet-system", + "snowbridge-router-primitives", + "snowbridge-runtime-common", + "snowbridge-runtime-test-common", + "snowbridge-system-runtime-api", + "sp-api", + "sp-api-proc-macro", + "sp-application-crypto", + "sp-arithmetic", + "sp-authority-discovery", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-consensus-aura", + "sp-consensus-babe", + "sp-consensus-beefy", + "sp-consensus-grandpa", + "sp-consensus-pow", + "sp-consensus-slots", + "sp-core", + "sp-core-hashing", + "sp-core-hashing-proc-macro", + "sp-crypto-ec-utils 0.10.0", + "sp-crypto-hashing", + "sp-crypto-hashing-proc-macro", + "sp-database", + "sp-debug-derive 14.0.0", + "sp-externalities 0.25.0", + "sp-genesis-builder", + "sp-inherents", + "sp-io", + "sp-keyring", + "sp-keystore", + "sp-maybe-compressed-blob", + "sp-metadata-ir", + "sp-mixnet", + "sp-mmr-primitives", + "sp-npos-elections", + "sp-offchain", + "sp-panic-handler", + "sp-rpc", + "sp-runtime", + "sp-runtime-interface 24.0.0", + "sp-runtime-interface-proc-macro 17.0.0", + "sp-session", + "sp-staking", + "sp-state-machine", + "sp-statement-store", + "sp-std 14.0.0", + "sp-storage 19.0.0", + "sp-timestamp", + "sp-tracing 16.0.0", + "sp-transaction-pool", + "sp-transaction-storage-proof", + "sp-trie", + "sp-version", + "sp-version-proc-macro", + "sp-wasm-interface 20.0.0", + "sp-weights", + "staging-chain-spec-builder", + "staging-node-inspect", + "staging-parachain-info", + "staging-tracking-allocator", + "staging-xcm", + "staging-xcm-builder", + "staging-xcm-executor", + "subkey", + "substrate-bip39", + "substrate-build-script-utils", + "substrate-frame-rpc-support", + "substrate-frame-rpc-system", + "substrate-prometheus-endpoint", + "substrate-rpc-client", + "substrate-state-trie-migration-rpc", + "substrate-wasm-builder", + "testnet-parachains-constants", + "tracing-gum", + "tracing-gum-proc-macro", + "xcm-emulator", + "xcm-procedural", + "xcm-runtime-apis", + "xcm-simulator", ] [[package]] name = "polkadot-sdk-docs" version = "0.0.1" dependencies = [ + "chain-spec-guide-runtime", "cumulus-client-service", "cumulus-pallet-aura-ext", "cumulus-pallet-parachain-system", @@ -13841,9 +14658,14 @@ dependencies = [ "cumulus-primitives-storage-weight-reclaim", "docify", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "kitchensink-runtime", + "log", + "minimal-template-runtime", + "pallet-asset-conversion-tx-payment", + "pallet-asset-tx-payment", "pallet-assets", "pallet-aura", "pallet-authorship", @@ -13851,6 +14673,7 @@ dependencies = [ "pallet-balances", "pallet-broker", "pallet-collective", + "pallet-contracts", "pallet-default-config-example", "pallet-democracy", "pallet-example-offchain-worker", @@ -13862,12 +14685,17 @@ dependencies = [ "pallet-proxy", "pallet-referenda", "pallet-scheduler", + "pallet-skip-feeless-payment", "pallet-timestamp", "pallet-transaction-payment", "pallet-uniques", "pallet-utility", + "pallet-xcm", + "parachain-template-runtime", "parity-scale-codec", + "polkadot-sdk", "polkadot-sdk-frame", + "sc-chain-spec", "sc-cli", "sc-client-db", "sc-consensus-aura", @@ -13882,21 +14710,30 @@ dependencies = [ "sc-rpc-api", "sc-service", "scale-info", - "simple-mermaid", + "simple-mermaid 0.1.1", + "solochain-template-runtime", "sp-api", "sp-arithmetic", "sp-core", + "sp-genesis-builder", "sp-io", "sp-keyring", "sp-offchain", "sp-runtime", + "sp-runtime-interface 24.0.0", + "sp-std 14.0.0", + "sp-tracing 16.0.0", "sp-version", "staging-chain-spec-builder", "staging-node-cli", "staging-parachain-info", "staging-xcm", + "staging-xcm-builder", + "staging-xcm-executor", "subkey", "substrate-wasm-builder", + "xcm-docs", + "xcm-simulator", ] [[package]] @@ -13926,7 +14763,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -13939,9 +14775,9 @@ dependencies = [ "assert_matches", "async-trait", "bitvec", - "env_logger 0.11.3", "frame-benchmarking", "frame-benchmarking-cli", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-rpc-runtime-api", @@ -13958,7 +14794,7 @@ dependencies = [ "pallet-transaction-payment-rpc-runtime-api", "parity-db", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "polkadot-approval-distribution", "polkadot-availability-bitfield-distribution", "polkadot-availability-distribution", @@ -14046,6 +14882,7 @@ dependencies = [ "sp-state-machine", "sp-storage 19.0.0", "sp-timestamp", + "sp-tracing 16.0.0", "sp-transaction-pool", "sp-version", "sp-weights", @@ -14056,7 +14893,7 @@ dependencies = [ "tracing-gum", "westend-runtime", "westend-runtime-constants", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -14079,7 +14916,8 @@ dependencies = [ "polkadot-node-subsystem-util", "polkadot-primitives", "polkadot-primitives-test-helpers", - "rand_chacha 0.3.1", + "polkadot-subsystem-bench", + "rand_chacha", "sc-keystore", "sc-network", "sp-application-crypto", @@ -14111,15 +14949,15 @@ dependencies = [ "async-trait", "bincode", "bitvec", - "clap 4.5.3", + "clap 4.5.11", "clap-num", "color-eyre", "colored", - "env_logger 0.11.3", "futures", "futures-timer", "hex", "itertools 0.11.0", + "jemalloc_pprof", "kvdb-memorydb", "log", "orchestra", @@ -14143,12 +14981,14 @@ dependencies = [ "polkadot-overseer", "polkadot-primitives", "polkadot-primitives-test-helpers", + "polkadot-service", + "polkadot-statement-distribution", "prometheus", "pyroscope", "pyroscope_pprofrs", - "rand 0.8.5", - "rand_chacha 0.3.1", - "rand_core 0.6.4", + "rand", + "rand_chacha", + "rand_core", "rand_distr", "sc-keystore", "sc-network", @@ -14167,7 +15007,10 @@ dependencies = [ "sp-keystore", "sp-runtime", "sp-timestamp", + "sp-tracing 16.0.0", + "strum 0.26.2", "substrate-prometheus-endpoint", + "tikv-jemallocator", "tokio", "tracing-gum", ] @@ -14207,7 +15050,7 @@ version = "1.0.0" dependencies = [ "assert_matches", "async-trait", - "clap 4.5.3", + "clap 4.5.11", "color-eyre", "futures", "futures-timer", @@ -14226,7 +15069,7 @@ dependencies = [ "polkadot-node-subsystem-types", "polkadot-node-subsystem-util", "polkadot-primitives", - "rand 0.8.5", + "rand", "sp-core", "sp-keystore", "substrate-build-script-utils", @@ -14282,7 +15125,6 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", "sp-transaction-pool", "sp-trie", "sp-version", @@ -14314,7 +15156,7 @@ dependencies = [ "polkadot-runtime-parachains", "polkadot-service", "polkadot-test-runtime", - "rand 0.8.5", + "rand", "sc-authority-discovery", "sc-chain-spec", "sc-cli", @@ -14350,7 +15192,7 @@ dependencies = [ name = "polkadot-voter-bags" version = "7.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "generate-bags", "sp-io", "westend-runtime", @@ -14364,9 +15206,22 @@ checksum = "8a3693e5efdb2bf74e449cd25fd777a28bd7ed87e41f5d5da75eb31b4de48b94" dependencies = [ "libc", "log", - "polkavm-assembler", - "polkavm-common", - "polkavm-linux-raw", + "polkavm-assembler 0.9.0", + "polkavm-common 0.9.0", + "polkavm-linux-raw 0.9.0", +] + +[[package]] +name = "polkavm" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7ec0c5935f2eff23cfc4653002f4f8d12b37f87a720e0631282d188c32089d6" +dependencies = [ + "libc", + "log", + "polkavm-assembler 0.10.0", + "polkavm-common 0.10.0", + "polkavm-linux-raw 0.10.0", ] [[package]] @@ -14378,6 +15233,15 @@ dependencies = [ "log", ] +[[package]] +name = "polkavm-assembler" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8e4fd5a43100bf1afe9727b8130d01f966f5cfc9144d5604b21e795c2bcd80e" +dependencies = [ + "log", +] + [[package]] name = "polkavm-common" version = "0.9.0" @@ -14387,13 +15251,32 @@ dependencies = [ "log", ] +[[package]] +name = "polkavm-common" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0097b48bc0bedf9f3f537ce8f37e8f1202d8d83f9b621bdb21ff2c59b9097c50" +dependencies = [ + "log", + "polkavm-assembler 0.10.0", +] + [[package]] name = "polkavm-derive" version = "0.9.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ae8c4bea6f3e11cd89bb18bcdddac10bd9a24015399bd1c485ad68a985a19606" dependencies = [ - "polkavm-derive-impl-macro", + "polkavm-derive-impl-macro 0.9.0", +] + +[[package]] +name = "polkavm-derive" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dcc701385c08c31bdb0569f0c51a290c580d892fa77f1dd88a7352a62679ecf" +dependencies = [ + "polkavm-derive-impl-macro 0.10.0", ] [[package]] @@ -14402,10 +15285,22 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c4fdfc49717fb9a196e74a5d28e0bc764eb394a2c803eb11133a31ac996c60c" dependencies = [ - "polkavm-common", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "polkavm-common 0.9.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + +[[package]] +name = "polkavm-derive-impl" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7855353a5a783dd5d09e3b915474bddf66575f5a3cf45dec8d1c5e051ba320dc" +dependencies = [ + "polkavm-common 0.10.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -14414,8 +15309,18 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ba81f7b5faac81e528eb6158a6f3c9e0bb1008e0ffa19653bc8dea925ecb429" dependencies = [ - "polkavm-derive-impl", - "syn 2.0.53", + "polkavm-derive-impl 0.9.0", + "syn 2.0.61", +] + +[[package]] +name = "polkavm-derive-impl-macro" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9324fe036de37c17829af233b46ef6b5562d4a0c09bb7fdb9f8378856dee30cf" +dependencies = [ + "polkavm-derive-impl 0.10.0", + "syn 2.0.61", ] [[package]] @@ -14428,7 +15333,22 @@ dependencies = [ "hashbrown 0.14.3", "log", "object 0.32.2", - "polkavm-common", + "polkavm-common 0.9.0", + "regalloc2 0.9.3", + "rustc-demangle", +] + +[[package]] +name = "polkavm-linker" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d704edfe7bdcc876784f19436d53d515b65eb07bc9a0fae77085d552c2dbbb5" +dependencies = [ + "gimli 0.28.0", + "hashbrown 0.14.3", + "log", + "object 0.36.1", + "polkavm-common 0.10.0", "regalloc2 0.9.3", "rustc-demangle", ] @@ -14439,6 +15359,12 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "26e85d3456948e650dff0cfc85603915847faf893ed1e66b020bb82ef4557120" +[[package]] +name = "polkavm-linux-raw" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26e45fa59c7e1bb12ef5289080601e9ec9b31435f6e32800a5c90c132453d126" + [[package]] name = "polling" version = "2.8.0" @@ -14451,10 +15377,24 @@ dependencies = [ "concurrent-queue", "libc", "log", - "pin-project-lite 0.2.12", + "pin-project-lite", "windows-sys 0.48.0", ] +[[package]] +name = "polling" +version = "3.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "30054e72317ab98eddd8561db0f6524df3367636884b7b21b703e4b280a84a14" +dependencies = [ + "cfg-if", + "concurrent-queue", + "pin-project-lite", + "rustix 0.38.21", + "tracing", + "windows-sys 0.52.0", +] + [[package]] name = "poly1305" version = "0.8.0" @@ -14490,9 +15430,15 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "be97d76faf1bfab666e1375477b23fde79eccf0276e9b63b92a39d676a889ba9" dependencies = [ - "rand 0.8.5", + "rand", ] +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + [[package]] name = "pprof" version = "0.12.1" @@ -14506,13 +15452,26 @@ dependencies = [ "log", "nix 0.26.2", "once_cell", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "smallvec", "symbolic-demangle", "tempfile", "thiserror", ] +[[package]] +name = "pprof_util" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c620a1858d6ebf10d7c60256629078b2d106968d0e6ff63b850d9ecd84008fbe" +dependencies = [ + "anyhow", + "flate2", + "num", + "paste", + "prost 0.11.9", +] + [[package]] name = "ppv-lite86" version = "0.2.17" @@ -14577,7 +15536,7 @@ version = "0.1.25" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86" dependencies = [ - "proc-macro2 1.0.75", + "proc-macro2 1.0.82", "syn 1.0.109", ] @@ -14587,8 +15546,8 @@ version = "0.2.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6c64d9ba0963cdcea2e1b2230fbae2bab30eb25a174be395c41e764bfb65dd62" dependencies = [ - "proc-macro2 1.0.75", - "syn 2.0.53", + "proc-macro2 1.0.82", + "syn 2.0.61", ] [[package]] @@ -14634,9 +15593,9 @@ dependencies = [ [[package]] name = "proc-macro-crate" -version = "3.0.0" +version = "3.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6b2685dd208a3771337d8d386a89840f0f43cd68be8dae90a5f8c2384effc9cd" +checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284" dependencies = [ "toml_edit 0.21.0", ] @@ -14648,8 +15607,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" dependencies = [ "proc-macro-error-attr", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", "version_check", ] @@ -14660,8 +15619,8 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "version_check", ] @@ -14671,15 +15630,26 @@ version = "0.5.20+deprecated" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068" +[[package]] +name = "proc-macro-warning" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d1eaa7fa0aa1929ffdf7eeb6eac234dde6268914a14ad44d23521ab6a9b258e" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + [[package]] name = "proc-macro-warning" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b698b0b09d40e9b7c1a47b132d66a8b54bcd20583d9b6d06e4535e383b4405c" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -14693,9 +15663,9 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.75" +version = "1.0.82" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "907a61bd0f64c2f29cd1cf1dc34d05176426a3f504a78010f08416ddb7b13708" +checksum = "8ad3d49ab951a01fbaafe34f2ec74122942fe18a3f9814c3268f1bb72042131b" dependencies = [ "unicode-ident", ] @@ -14706,7 +15676,7 @@ version = "0.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "731e0d9356b0c25f16f33b5be79b1c57b562f141ebfcdb0ad8ac2c13a24293b4" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "chrono", "flate2", "hex", @@ -14721,7 +15691,7 @@ version = "0.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2d3554923a69f4ce04c4a754260c338f505ce22642d3830e049a399fc2059a29" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "chrono", "hex", ] @@ -14736,19 +15706,19 @@ dependencies = [ "fnv", "lazy_static", "memchr", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "thiserror", ] [[package]] name = "prometheus-client" -version = "0.19.0" +version = "0.21.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d6fa99d535dd930d1249e6c79cb3c2915f9172a540fe2b02a4c8f9ca954721e" +checksum = "3c99afa9a01501019ac3a14d71d9f94050346f55ca471ce90c799a15c58f61e2" dependencies = [ "dtoa", "itoa", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "prometheus-client-derive-encode", ] @@ -14758,9 +15728,9 @@ version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "440f724eba9f6996b75d63681b0a92b06947f1457076d503a4d2e2c8f56442b8" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -14783,11 +15753,11 @@ checksum = "31b476131c3c86cb68032fdc5cb6d5a1045e3e42d96b69fa599fd77701e1f5bf" dependencies = [ "bit-set", "bit-vec", - "bitflags 2.4.0", + "bitflags 2.6.0", "lazy_static", "num-traits", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "rand_xorshift", "regex-syntax 0.8.2", "rusty-fork", @@ -14807,12 +15777,12 @@ dependencies = [ [[package]] name = "prost" -version = "0.12.4" +version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0f5d036824e4761737860779c906171497f6d55681139d8312388f8fe398922" +checksum = "deb1435c188b76130da55f17a466d252ff7b1418b2ad3e037d127b94e3411f29" dependencies = [ "bytes", - "prost-derive 0.12.4", + "prost-derive 0.12.6", ] [[package]] @@ -14851,10 +15821,10 @@ dependencies = [ "once_cell", "petgraph", "prettyplease 0.2.12", - "prost 0.12.4", + "prost 0.12.6", "prost-types 0.12.4", "regex", - "syn 2.0.53", + "syn 2.0.61", "tempfile", ] @@ -14866,22 +15836,22 @@ checksum = "e5d2d8d10f3c6ded6da8b05b5fb3b8a5082514344d56c9f871412d29b4e075b4" dependencies = [ "anyhow", "itertools 0.10.5", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] [[package]] name = "prost-derive" -version = "0.12.4" +version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19de2de2a00075bf566bee3bd4db014b11587e84184d3f7a791bc17f1a8e9e48" +checksum = "81bddcdb20abf9501610992b6759a4c888aef7d1a7247ef75e2404275ac24af1" dependencies = [ "anyhow", "itertools 0.11.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -14899,7 +15869,7 @@ version = "0.12.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3235c33eb02c1f1e212abdbe34c78b264b038fb58ca612664343271e36e55ffe" dependencies = [ - "prost 0.12.4", + "prost 0.12.6", ] [[package]] @@ -14952,7 +15922,7 @@ dependencies = [ "mach2", "once_cell", "raw-cpuid", - "wasi 0.11.0+wasi-snapshot-preview1", + "wasi", "web-sys", "winapi", ] @@ -14974,15 +15944,26 @@ dependencies = [ [[package]] name = "quick-protobuf-codec" -version = "0.1.0" +version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1693116345026436eb2f10b677806169c1a1260c1c60eaaffe3fb5a29ae23d8b" +checksum = "f8ededb1cd78531627244d51dd0c7139fbe736c7d57af0092a76f0ffb2f56e98" dependencies = [ "asynchronous-codec", "bytes", "quick-protobuf", "thiserror", - "unsigned-varint", + "unsigned-varint 0.7.2", +] + +[[package]] +name = "quick_cache" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5253a3a0d56548d5b0be25414171dc780cc6870727746d05bd2bde352eee96c5" +dependencies = [ + "ahash 0.8.11", + "hashbrown 0.13.2", + "parking_lot 0.12.3", ] [[package]] @@ -14993,49 +15974,56 @@ checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6" dependencies = [ "env_logger 0.8.4", "log", - "rand 0.8.5", + "rand", ] [[package]] -name = "quicksink" -version = "0.1.2" +name = "quinn" +version = "0.9.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77de3c815e5a160b1539c6592796801df2043ae35e123b46d73380cfa57af858" +checksum = "2e8b432585672228923edbbf64b8b12c14e1112f62e88737655b4a083dbcd78e" dependencies = [ - "futures-core", - "futures-sink", - "pin-project-lite 0.1.12", + "bytes", + "pin-project-lite", + "quinn-proto 0.9.6", + "quinn-udp 0.3.2", + "rustc-hash 1.1.0", + "rustls 0.20.9", + "thiserror", + "tokio", + "tracing", + "webpki", ] [[package]] name = "quinn" -version = "0.9.4" +version = "0.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e8b432585672228923edbbf64b8b12c14e1112f62e88737655b4a083dbcd78e" +checksum = "8cc2c5017e4b43d5995dcea317bc46c1e09404c0a9664d2908f7f02dfe943d75" dependencies = [ "bytes", - "pin-project-lite 0.2.12", - "quinn-proto", - "quinn-udp", - "rustc-hash", - "rustls 0.20.8", + "futures-io", + "pin-project-lite", + "quinn-proto 0.10.6", + "quinn-udp 0.4.1", + "rustc-hash 1.1.0", + "rustls 0.21.7", "thiserror", "tokio", "tracing", - "webpki", ] [[package]] name = "quinn-proto" -version = "0.9.5" +version = "0.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c956be1b23f4261676aed05a0046e204e8a6836e50203902683a718af0797989" +checksum = "94b0b33c13a79f669c85defaf4c275dc86a0c0372807d0ca3d78e0bb87274863" dependencies = [ "bytes", - "rand 0.8.5", + "rand", "ring 0.16.20", - "rustc-hash", - "rustls 0.20.8", + "rustc-hash 1.1.0", + "rustls 0.20.9", "slab", "thiserror", "tinyvec", @@ -15043,6 +16031,23 @@ dependencies = [ "webpki", ] +[[package]] +name = "quinn-proto" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "141bf7dfde2fbc246bfd3fe12f2455aa24b0fbd9af535d8c86c7bd1381ff2b1a" +dependencies = [ + "bytes", + "rand", + "ring 0.16.20", + "rustc-hash 1.1.0", + "rustls 0.21.7", + "slab", + "thiserror", + "tinyvec", + "tracing", +] + [[package]] name = "quinn-udp" version = "0.3.2" @@ -15050,12 +16055,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "641538578b21f5e5c8ea733b736895576d0fe329bb883b937db6f4d163dbaaf4" dependencies = [ "libc", - "quinn-proto", + "quinn-proto 0.9.6", "socket2 0.4.9", "tracing", "windows-sys 0.42.0", ] +[[package]] +name = "quinn-udp" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "055b4e778e8feb9f93c4e439f71dc2156ef13360b432b799e179a8c4cdf0b1d7" +dependencies = [ + "bytes", + "libc", + "socket2 0.5.7", + "tracing", + "windows-sys 0.48.0", +] + [[package]] name = "quote" version = "0.6.13" @@ -15067,11 +16085,11 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.35" +version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7" dependencies = [ - "proc-macro2 1.0.75", + "proc-macro2 1.0.82", ] [[package]] @@ -15080,19 +16098,6 @@ version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" -[[package]] -name = "rand" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" -dependencies = [ - "getrandom 0.1.16", - "libc", - "rand_chacha 0.2.2", - "rand_core 0.5.1", - "rand_hc", -] - [[package]] name = "rand" version = "0.8.5" @@ -15100,18 +16105,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" dependencies = [ "libc", - "rand_chacha 0.3.1", - "rand_core 0.6.4", -] - -[[package]] -name = "rand_chacha" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" -dependencies = [ - "ppv-lite86", - "rand_core 0.5.1", + "rand_chacha", + "rand_core", ] [[package]] @@ -15121,16 +16116,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" dependencies = [ "ppv-lite86", - "rand_core 0.6.4", -] - -[[package]] -name = "rand_core" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" -dependencies = [ - "getrandom 0.1.16", + "rand_core", ] [[package]] @@ -15139,7 +16125,7 @@ version = "0.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" dependencies = [ - "getrandom 0.2.10", + "getrandom", ] [[package]] @@ -15149,16 +16135,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32cb0b9bc82b0a0876c2dd994a7e7a2683d3e7390ca40e6886785ef0c7e3ee31" dependencies = [ "num-traits", - "rand 0.8.5", -] - -[[package]] -name = "rand_hc" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" -dependencies = [ - "rand_core 0.5.1", + "rand", ] [[package]] @@ -15167,7 +16144,7 @@ version = "0.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "59cad018caf63deb318e5a4586d99a24424a364f40f1e5778c29aca23f4fc73e" dependencies = [ - "rand_core 0.6.4", + "rand_core", ] [[package]] @@ -15176,7 +16153,7 @@ version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f" dependencies = [ - "rand_core 0.6.4", + "rand_core", ] [[package]] @@ -15279,7 +16256,7 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b" dependencies = [ - "getrandom 0.2.10", + "getrandom", "redox_syscall 0.2.16", "thiserror", ] @@ -15298,22 +16275,22 @@ dependencies = [ [[package]] name = "ref-cast" -version = "1.0.20" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acde58d073e9c79da00f2b5b84eed919c8326832648a5b109b3fce1bb1175280" +checksum = "ccf0a6f84d5f1d581da8b41b47ec8600871962f2a528115b542b362d4b744931" dependencies = [ "ref-cast-impl", ] [[package]] name = "ref-cast-impl" -version = "1.0.20" +version = "1.0.23" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7473c2cfcf90008193dd0e3e16599455cb601a9fce322b5bb55de799664925" +checksum = "bcc303e793d3734489387d205e9b186fac9c6cfacedd98cbb2e8a5943595f3e6" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -15336,7 +16313,7 @@ checksum = "ad156d539c879b7a24a363a2016d77961786e71f48f2e2fc8302a92abd2429a6" dependencies = [ "hashbrown 0.13.2", "log", - "rustc-hash", + "rustc-hash 1.1.0", "slice-group-by", "smallvec", ] @@ -15409,23 +16386,22 @@ dependencies = [ "bp-runtime", "finality-relay", "frame-support", - "frame-system", "futures", "jsonrpsee", "log", "num-traits", - "pallet-balances", - "pallet-bridge-messages", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", "pallet-utility", "parity-scale-codec", - "rand 0.8.5", + "quick_cache", + "rand", "relay-utils", "sc-chain-spec", "sc-rpc-api", "sc-transaction-pool-api", "scale-info", + "serde_json", "sp-consensus-grandpa", "sp-core", "sp-rpc", @@ -15442,20 +16418,21 @@ dependencies = [ name = "relay-utils" version = "0.1.0" dependencies = [ - "ansi_term", "anyhow", "async-std", "async-trait", "backoff", "bp-runtime", - "env_logger 0.11.3", + "console", "futures", "isahc", "jsonpath_lib", "log", "num-traits", + "parking_lot 0.12.3", "serde_json", "sp-runtime", + "sp-tracing 16.0.0", "substrate-prometheus-endpoint", "sysinfo", "thiserror", @@ -15467,7 +16444,7 @@ dependencies = [ name = "remote-ext-tests-bags-list" version = "1.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "frame-system", "log", "pallet-bags-list-remote-tests", @@ -15489,19 +16466,19 @@ dependencies = [ "encoding_rs", "futures-core", "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-rustls", + "h2 0.3.26", + "http 0.2.9", + "http-body 0.4.5", + "hyper 0.14.29", + "hyper-rustls 0.24.2", "ipnet", "js-sys", "log", "mime", "once_cell", "percent-encoding", - "pin-project-lite 0.2.12", - "rustls 0.21.6", + "pin-project-lite", + "rustls 0.21.7", "rustls-pemfile 1.0.3", "serde", "serde_json", @@ -15540,13 +16517,14 @@ dependencies = [ [[package]] name = "ring" version = "0.1.0" -source = "git+https://github.com/w3f/ring-proof#b273d33f9981e2bb3375ab45faeb537f7ee35224" +source = "git+https://github.com/w3f/ring-proof?rev=665f5f5#665f5f51af5734c7b6d90b985dd6861d4c5b4752" dependencies = [ "ark-ec", "ark-ff 0.4.2", "ark-poly", "ark-serialize 0.4.2", "ark-std 0.4.0", + "arrayvec 0.7.4", "blake2 0.10.6", "common", "fflonk", @@ -15574,21 +16552,12 @@ version = "0.17.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "688c63d65483050968b2a8937f7995f443e27041a0f7700aa59b0822aedebb74" dependencies = [ - "cc", - "getrandom 0.2.10", - "libc", - "spin 0.9.8", - "untrusted 0.9.0", - "windows-sys 0.48.0", -] - -[[package]] -name = "ripemd" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f" -dependencies = [ - "digest 0.10.7", + "cc", + "getrandom", + "libc", + "spin 0.9.8", + "untrusted 0.9.0", + "windows-sys 0.48.0", ] [[package]] @@ -15674,7 +16643,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-transaction-pool", "sp-version", "staging-parachain-info", @@ -15693,6 +16661,7 @@ dependencies = [ "bitvec", "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-remote-externalities", "frame-support", "frame-system", @@ -15775,7 +16744,6 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-tracing 16.0.0", "sp-transaction-pool", @@ -15788,7 +16756,7 @@ dependencies = [ "substrate-wasm-builder", "tiny-keccak", "tokio", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -15812,6 +16780,7 @@ version = "0.0.0" dependencies = [ "asset-hub-rococo-emulated-chain", "bridge-hub-rococo-emulated-chain", + "coretime-rococo-emulated-chain", "emulated-integration-tests-common", "penpal-emulated-chain", "people-rococo-emulated-chain", @@ -15869,12 +16838,12 @@ checksum = "d428f8247852f894ee1be110b375111b586d4fa431f6c46e64ba5a0dcccbe605" dependencies = [ "cfg-if", "glob", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "regex", "relative-path", "rustc_version 0.4.0", - "syn 2.0.53", + "syn 2.0.61", "unicode-ident", ] @@ -15919,7 +16888,7 @@ dependencies = [ "parity-scale-codec", "primitive-types", "proptest", - "rand 0.8.5", + "rand", "rlp", "ruint-macro", "serde", @@ -15945,6 +16914,12 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" +[[package]] +name = "rustc-hash" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152" + [[package]] name = "rustc-hex" version = "2.1.0" @@ -16021,7 +16996,7 @@ version = "0.38.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "errno", "libc", "linux-raw-sys 0.4.10", @@ -16030,11 +17005,10 @@ dependencies = [ [[package]] name = "rustls" -version = "0.20.8" +version = "0.20.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f" +checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99" dependencies = [ - "log", "ring 0.16.20", "sct", "webpki", @@ -16042,9 +17016,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.21.6" +version = "0.21.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d1feddffcfcc0b33f5c6ce9a29e341e4cd59c3f78e7ee45f4a40c038b1d6cbb" +checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8" dependencies = [ "log", "ring 0.16.20", @@ -16054,14 +17028,15 @@ dependencies = [ [[package]] name = "rustls" -version = "0.22.2" +version = "0.23.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e87c9956bd9807afa1f77e0f7594af32566e830e088a5576d27c5b6f30f49d41" +checksum = "05cff451f60db80f490f3c182b77c35260baace73209e9cdbbe526bfe3a4d402" dependencies = [ "log", + "once_cell", "ring 0.17.7", "rustls-pki-types", - "rustls-webpki 0.102.2", + "rustls-webpki 0.102.4", "subtle 2.5.0", "zeroize", ] @@ -16112,9 +17087,36 @@ dependencies = [ [[package]] name = "rustls-pki-types" -version = "1.2.0" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d" + +[[package]] +name = "rustls-platform-verifier" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5f0d26fa1ce3c790f9590868f0109289a044acb954525f933e2aa3b871c157d" +dependencies = [ + "core-foundation", + "core-foundation-sys", + "jni", + "log", + "once_cell", + "rustls 0.23.10", + "rustls-native-certs 0.7.0", + "rustls-platform-verifier-android", + "rustls-webpki 0.102.4", + "security-framework", + "security-framework-sys", + "webpki-roots 0.26.3", + "winapi", +] + +[[package]] +name = "rustls-platform-verifier-android" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a716eb65e3158e90e17cd93d855216e27bde02745ab842f2cab4a39dba1bacf" +checksum = "84e217e7fdc8466b5b35d30f8c0a30febd29173df4a3a0c2115d306b9c4117ad" [[package]] name = "rustls-webpki" @@ -16128,9 +17130,9 @@ dependencies = [ [[package]] name = "rustls-webpki" -version = "0.102.2" +version = "0.102.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "faaa0a62740bedb9b2ef5afa303da42764c012f743917351dc9a237ea1663610" +checksum = "ff448f7e92e913c4b7d4c6d8e4540a1724b319b4152b8aef6d4cf8339712b33e" dependencies = [ "ring 0.17.7", "rustls-pki-types", @@ -16139,9 +17141,9 @@ dependencies = [ [[package]] name = "rustversion" -version = "1.0.14" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" +checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6" [[package]] name = "rusty-fork" @@ -16168,9 +17170,9 @@ dependencies = [ [[package]] name = "rw-stream-sink" -version = "0.3.0" +version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26338f5e09bb721b85b135ea05af7767c90b52f6de4f087d4f4a3a9d64e7dc04" +checksum = "d8c9026ff5d2f23da5e45bbc283f156383001bfb09c4e44256d02c1a685fe9a1" dependencies = [ "futures", "pin-project", @@ -16231,13 +17233,12 @@ dependencies = [ "libp2p", "linked_hash_set", "log", - "multihash 0.17.0", - "multihash-codetable", + "multihash 0.19.1", "parity-scale-codec", - "prost 0.12.4", + "prost 0.12.6", "prost-build 0.12.4", "quickcheck", - "rand 0.8.5", + "rand", "sc-client-api", "sc-network", "sc-network-types", @@ -16261,7 +17262,7 @@ dependencies = [ "futures-timer", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-proposer-metrics", @@ -16299,10 +17300,12 @@ name = "sc-chain-spec" version = "28.0.0" dependencies = [ "array-bytes", + "clap 4.5.11", "docify", "log", "memmap2 0.9.3", "parity-scale-codec", + "regex", "sc-chain-spec-derive", "sc-client-api", "sc-executor", @@ -16328,10 +17331,10 @@ dependencies = [ name = "sc-chain-spec-derive" version = "11.0.0" dependencies = [ - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -16340,7 +17343,7 @@ version = "0.36.0" dependencies = [ "array-bytes", "chrono", - "clap 4.5.3", + "clap 4.5.11", "fdlimit", "futures", "futures-timer", @@ -16350,7 +17353,7 @@ dependencies = [ "names", "parity-bip39", "parity-scale-codec", - "rand 0.8.5", + "rand", "regex", "rpassword", "sc-client-api", @@ -16385,7 +17388,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-executor", "sc-transaction-pool-api", "sc-utils", @@ -16421,9 +17424,9 @@ dependencies = [ "log", "parity-db", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "quickcheck", - "rand 0.8.5", + "rand", "sc-client-api", "sc-state-db", "schnellru", @@ -16445,10 +17448,9 @@ version = "0.33.0" dependencies = [ "async-trait", "futures", - "futures-timer", "log", - "mockall", - "parking_lot 0.12.1", + "mockall 0.11.4", + "parking_lot 0.12.3", "sc-client-api", "sc-network-types", "sc-utils", @@ -16472,7 +17474,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-consensus", @@ -16514,7 +17516,7 @@ dependencies = [ "num-rational", "num-traits", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-consensus", @@ -16583,7 +17585,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-consensus", @@ -16624,11 +17626,12 @@ dependencies = [ "jsonrpsee", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-consensus-beefy", "sc-rpc", "serde", "serde_json", + "sp-application-crypto", "sp-consensus-beefy", "sp-core", "sp-runtime", @@ -16653,7 +17656,7 @@ dependencies = [ name = "sc-consensus-grandpa" version = "0.19.0" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", "array-bytes", "assert_matches", "async-trait", @@ -16664,8 +17667,8 @@ dependencies = [ "futures-timer", "log", "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "sc-block-builder", "sc-chain-spec", "sc-client-api", @@ -16770,7 +17773,7 @@ dependencies = [ "futures-timer", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-client-api", "sc-consensus", "sp-api", @@ -16815,10 +17818,9 @@ dependencies = [ "array-bytes", "assert_matches", "criterion", - "env_logger 0.11.3", "num_cpus", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "paste", "regex", "sc-executor-common", @@ -16852,7 +17854,7 @@ dependencies = [ name = "sc-executor-common" version = "0.29.0" dependencies = [ - "polkavm", + "polkavm 0.9.3", "sc-allocator", "sp-maybe-compressed-blob", "sp-wasm-interface 20.0.0", @@ -16865,7 +17867,7 @@ name = "sc-executor-polkavm" version = "0.29.0" dependencies = [ "log", - "polkavm", + "polkavm 0.9.3", "sc-executor-common", "sp-wasm-interface 20.0.0", ] @@ -16880,7 +17882,7 @@ dependencies = [ "libc", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "paste", "rustix 0.36.15", "sc-allocator", @@ -16898,7 +17900,7 @@ dependencies = [ name = "sc-informant" version = "0.33.0" dependencies = [ - "ansi_term", + "console", "futures", "futures-timer", "log", @@ -16915,7 +17917,7 @@ name = "sc-keystore" version = "25.0.0" dependencies = [ "array-bytes", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "serde_json", "sp-application-crypto", "sp-core", @@ -16936,9 +17938,9 @@ dependencies = [ "futures-timer", "log", "mixnet", - "multiaddr", + "multiaddr 0.18.1", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-client-api", "sc-network", "sc-network-types", @@ -16972,16 +17974,16 @@ dependencies = [ "linked_hash_set", "litep2p", "log", - "mockall", + "mockall 0.11.4", "multistream-select", "once_cell", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "partial_sort", "pin-project", - "prost 0.12.4", + "prost 0.12.6", "prost-build 0.12.4", - "rand 0.8.5", + "rand", "sc-block-builder", "sc-client-api", "sc-network-common", @@ -17010,7 +18012,7 @@ dependencies = [ "tokio-stream", "tokio-test", "tokio-util", - "unsigned-varint", + "unsigned-varint 0.7.2", "void", "wasm-timer", "zeroize", @@ -17038,11 +18040,10 @@ dependencies = [ name = "sc-network-gossip" version = "0.34.0" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", "async-trait", "futures", "futures-timer", - "libp2p", "log", "parity-scale-codec", "quickcheck", @@ -17067,7 +18068,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "prost 0.12.4", + "prost 0.12.6", "prost-build 0.12.4", "sc-client-api", "sc-network", @@ -17085,7 +18086,6 @@ dependencies = [ "array-bytes", "async-channel", "futures", - "libp2p", "log", "parity-scale-codec", "sc-network", @@ -17110,9 +18110,9 @@ dependencies = [ "futures-timer", "libp2p", "log", - "mockall", + "mockall 0.11.4", "parity-scale-codec", - "prost 0.12.4", + "prost 0.12.6", "prost-build 0.12.4", "quickcheck", "sc-block-builder", @@ -17148,8 +18148,8 @@ dependencies = [ "futures-timer", "libp2p", "log", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "sc-block-builder", "sc-client-api", "sc-consensus", @@ -17176,7 +18176,6 @@ version = "0.33.0" dependencies = [ "array-bytes", "futures", - "libp2p", "log", "parity-scale-codec", "sc-network", @@ -17193,13 +18192,17 @@ dependencies = [ name = "sc-network-types" version = "0.10.0" dependencies = [ - "bs58 0.5.0", + "bs58 0.5.1", + "ed25519-dalek", "libp2p-identity", "litep2p", - "multiaddr", - "multihash 0.17.0", - "rand 0.8.5", + "log", + "multiaddr 0.18.1", + "multihash 0.19.1", + "quickcheck", + "rand", "thiserror", + "zeroize", ] [[package]] @@ -17212,16 +18215,15 @@ dependencies = [ "fnv", "futures", "futures-timer", - "hyper", - "hyper-rustls", + "hyper 0.14.29", + "hyper-rustls 0.24.2", "lazy_static", - "libp2p", "log", "num_cpus", "once_cell", "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "sc-block-builder", "sc-client-api", "sc-client-db", @@ -17258,12 +18260,11 @@ name = "sc-rpc" version = "29.0.0" dependencies = [ "assert_matches", - "env_logger 0.11.3", "futures", "jsonrpsee", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pretty_assertions", "sc-block-builder", "sc-chain-spec", @@ -17292,7 +18293,6 @@ dependencies = [ "sp-version", "substrate-test-runtime-client", "tokio", - "tracing-subscriber 0.3.18", ] [[package]] @@ -17318,14 +18318,18 @@ dependencies = [ name = "sc-rpc-server" version = "11.0.0" dependencies = [ + "dyn-clone", "forwarded-header-value", "futures", "governor", - "http", - "hyper", + "http 1.1.0", + "http-body-util", + "hyper 1.3.1", "ip_network", "jsonrpsee", "log", + "sc-rpc-api", + "serde", "serde_json", "substrate-prometheus-endpoint", "tokio", @@ -17345,9 +18349,9 @@ dependencies = [ "jsonrpsee", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pretty_assertions", - "rand 0.8.5", + "rand", "sc-block-builder", "sc-chain-spec", "sc-client-api", @@ -17384,7 +18388,6 @@ dependencies = [ "sp-io", "sp-runtime", "sp-runtime-interface 24.0.0", - "sp-std 14.0.0", "substrate-wasm-builder", ] @@ -17400,9 +18403,9 @@ dependencies = [ "jsonrpsee", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", - "rand 0.8.5", + "rand", "sc-chain-spec", "sc-client-api", "sc-client-db", @@ -17463,7 +18466,7 @@ dependencies = [ "futures", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-client-db", @@ -17495,7 +18498,7 @@ version = "0.30.0" dependencies = [ "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sp-core", ] @@ -17503,10 +18506,9 @@ dependencies = [ name = "sc-statement-store" version = "10.0.0" dependencies = [ - "env_logger 0.11.3", "log", "parity-db", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-client-api", "sc-keystore", "sp-api", @@ -17514,6 +18516,7 @@ dependencies = [ "sp-core", "sp-runtime", "sp-statement-store", + "sp-tracing 16.0.0", "substrate-prometheus-endpoint", "tempfile", "tokio", @@ -17523,7 +18526,7 @@ dependencies = [ name = "sc-storage-monitor" version = "0.16.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "fs4", "log", "sp-core", @@ -17557,7 +18560,7 @@ dependencies = [ "futures", "libc", "log", - "rand 0.8.5", + "rand", "rand_pcg", "regex", "sc-telemetry", @@ -17578,9 +18581,9 @@ dependencies = [ "futures", "libp2p", "log", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", - "rand 0.8.5", + "rand", "sc-network", "sc-utils", "serde", @@ -17593,17 +18596,17 @@ dependencies = [ name = "sc-tracing" version = "28.0.0" dependencies = [ - "ansi_term", "chrono", + "console", "criterion", "is-terminal", "lazy_static", "libc", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "regex", - "rustc-hash", + "rustc-hash 1.1.0", "sc-client-api", "sc-tracing-proc-macro", "serde", @@ -17623,10 +18626,10 @@ dependencies = [ name = "sc-tracing-proc-macro" version = "11.0.0" dependencies = [ - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -17642,7 +18645,7 @@ dependencies = [ "linked-hash-map", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-block-builder", "sc-client-api", "sc-transaction-pool-api", @@ -17688,17 +18691,40 @@ dependencies = [ "futures-timer", "lazy_static", "log", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "prometheus", "sp-arithmetic", "tokio-test", ] +[[package]] +name = "scale-bits" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e57b1e7f6b65ed1f04e79a85a57d755ad56d76fdf1e9bddcc9ae14f71fcdcf54" +dependencies = [ + "parity-scale-codec", + "scale-type-resolver", +] + +[[package]] +name = "scale-decode" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e98f3262c250d90e700bb802eb704e1f841e03331c2eb815e46516c4edbf5b27" +dependencies = [ + "derive_more", + "parity-scale-codec", + "scale-bits", + "scale-type-resolver", + "smallvec", +] + [[package]] name = "scale-info" -version = "2.11.1" +version = "2.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "788745a868b0e751750388f4e6546eb921ef714a4317fa6954f7cde114eb2eb7" +checksum = "eca070c12893629e2cc820a9761bedf6ce1dcddc9852984d1dc734b8bd9bd024" dependencies = [ "bitvec", "cfg-if", @@ -17710,16 +18736,22 @@ dependencies = [ [[package]] name = "scale-info-derive" -version = "2.11.1" +version = "2.11.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7dc2f4e8bc344b9fc3d5f74f72c2e55bfc38d28dc2ebc69c194a3df424e4d9ac" +checksum = "2d35494501194174bda522a32605929eefc9ecf7e0a326c26db1fdd85881eb62" dependencies = [ - "proc-macro-crate 1.3.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] +[[package]] +name = "scale-type-resolver" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0cded6518aa0bd6c1be2b88ac81bf7044992f0f154bfbabd5ad34f43512abcb" + [[package]] name = "schannel" version = "0.1.22" @@ -17747,8 +18779,8 @@ version = "0.8.13" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec0f696e21e10fa546b7ffb1c9672c6de8fbc7a81acf59524386d8639bf12737" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "serde_derive_internals", "syn 1.0.109", ] @@ -17759,7 +18791,7 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "772575a524feeb803e5b0fcbc6dd9f367e579488197c94c6e4023aad2305774d" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", "cfg-if", "hashbrown 0.13.2", ] @@ -17774,7 +18806,7 @@ dependencies = [ "arrayvec 0.7.4", "curve25519-dalek-ng", "merlin", - "rand_core 0.6.4", + "rand_core", "sha2 0.9.9", "subtle-ng", "zeroize", @@ -17789,10 +18821,10 @@ dependencies = [ "aead", "arrayref", "arrayvec 0.7.4", - "curve25519-dalek 4.1.2", + "curve25519-dalek", "getrandom_or_panic", "merlin", - "rand_core 0.6.4", + "rand_core", "serde_bytes", "sha2 0.10.8", "subtle 2.5.0", @@ -17829,15 +18861,15 @@ dependencies = [ [[package]] name = "sctp-proto" -version = "0.1.7" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f64cef148d3295c730c3cb340b0b252a4d570b1c7d4bf0808f88540b0a888bc" +checksum = "b6220f78bb44c15f326b0596113305f6101097a18755d53727a575c97e09fb24" dependencies = [ "bytes", "crc", "fxhash", "log", - "rand 0.8.5", + "rand", "slab", "thiserror", ] @@ -17868,18 +18900,18 @@ dependencies = [ [[package]] name = "secp256k1" -version = "0.28.0" +version = "0.28.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2acea373acb8c21ecb5a23741452acd2593ed44ee3d343e72baaa143bc89d0d5" +checksum = "d24b59d129cdadea20aea4fb2352fa053712e5d713eee47d700cd4b2bc002f10" dependencies = [ "secp256k1-sys", ] [[package]] name = "secp256k1-sys" -version = "0.9.0" +version = "0.9.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09e67c467c38fd24bd5499dc9a18183b31575c12ee549197e3e20d57aa4fe3b7" +checksum = "e5d1746aae42c19d583c3c1a8c646bfad910498e2051c551a7f2e3c0c9fbb7eb" dependencies = [ "cc", ] @@ -17895,22 +18927,23 @@ dependencies = [ [[package]] name = "security-framework" -version = "2.9.2" +version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de" +checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0" dependencies = [ - "bitflags 1.3.2", + "bitflags 2.6.0", "core-foundation", "core-foundation-sys", "libc", + "num-bigint", "security-framework-sys", ] [[package]] name = "security-framework-sys" -version = "2.9.1" +version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a" +checksum = "317936bbbd05227752583946b9e66d7ce3b489f84e11a94a510b4437fef407d7" dependencies = [ "core-foundation-sys", "libc", @@ -17944,7 +18977,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-transaction-pool", "sp-version", "staging-parachain-info", @@ -18002,6 +19034,12 @@ dependencies = [ "pest", ] +[[package]] +name = "send_wrapper" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" + [[package]] name = "separator" version = "0.4.1" @@ -18010,9 +19048,9 @@ checksum = "f97841a747eef040fcd2e7b3b9a220a7205926e60488e673d9e4926d27772ce5" [[package]] name = "serde" -version = "1.0.197" +version = "1.0.206" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2" +checksum = "5b3e4cd94123dd520a128bcd11e34d9e9e423e7e3e50425cb1b4b1e3549d0284" dependencies = [ "serde_derive", ] @@ -18037,13 +19075,13 @@ dependencies = [ [[package]] name = "serde_derive" -version = "1.0.197" +version = "1.0.206" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b" +checksum = "fabfb6138d2383ea8208cf98ccf69cdfb1aff4088460681d84189aa259762f97" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -18052,8 +19090,8 @@ version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -18068,12 +19106,13 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.114" +version = "1.0.124" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0" +checksum = "66ad62847a56b3dba58cc891acd13884b9c61138d330c0d7b6181713d4fce38d" dependencies = [ "indexmap 2.2.3", "itoa", + "memchr", "ryu", "serde", ] @@ -18101,9 +19140,9 @@ dependencies = [ [[package]] name = "serde_yaml" -version = "0.9.33" +version = "0.9.34+deprecated" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0623d197252096520c6f2a5e1171ee436e5af99a5d7caa2891e55e61950e6d9" +checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47" dependencies = [ "indexmap 2.2.3", "itoa", @@ -18132,7 +19171,7 @@ dependencies = [ "futures", "lazy_static", "log", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "serial_test_derive", ] @@ -18142,9 +19181,9 @@ version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "91d129178576168c589c9ec973feedf7d3126c01ac2bf08795109aa35b69fb8f" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -18262,7 +19301,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-transaction-pool", "sp-version", "staging-parachain-info", @@ -18297,12 +19335,6 @@ dependencies = [ "libc", ] -[[package]] -name = "signature" -version = "1.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74233d3b3b2f6d4b006dc19dee745e73e2a6bfb6f93607cd3b02bd5b00797d7c" - [[package]] name = "signature" version = "2.1.0" @@ -18310,7 +19342,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500" dependencies = [ "digest 0.10.7", - "rand_core 0.6.4", + "rand_core", ] [[package]] @@ -18332,9 +19364,14 @@ version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cae9a3fcdadafb6d97f4c0e007e4247b114ee0f119f650c3cbf3a8b3a1479694" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", ] +[[package]] +name = "simple-mermaid" +version = "0.1.0" +source = "git+https://github.com/kianenigma/simple-mermaid.git?branch=main#e48b187bcfd5cc75111acd9d241f1bd36604344b" + [[package]] name = "simple-mermaid" version = "0.1.1" @@ -18370,7 +19407,6 @@ dependencies = [ "parity-scale-codec", "paste", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -18395,9 +19431,9 @@ dependencies = [ [[package]] name = "smallvec" -version = "1.11.2" +version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" +checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67" [[package]] name = "smol" @@ -18408,12 +19444,12 @@ dependencies = [ "async-channel", "async-executor", "async-fs", - "async-io", - "async-lock", + "async-io 1.13.0", + "async-lock 2.8.0", "async-net", "async-process", "blocking", - "futures-lite", + "futures-lite 1.13.0", ] [[package]] @@ -18432,20 +19468,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c0bb30cf57b7b5f6109ce17c3164445e2d6f270af2cb48f6e4d31c2967c9a9f5" dependencies = [ "arrayvec 0.7.4", - "async-lock", + "async-lock 2.8.0", "atomic-take", "base64 0.21.2", "bip39", "blake2-rfc", - "bs58 0.5.0", + "bs58 0.5.1", "chacha20", "crossbeam-queue", "derive_more", "ed25519-zebra", "either", - "event-listener", + "event-listener 2.5.3", "fnv", - "futures-lite", + "futures-lite 1.13.0", "futures-util", "hashbrown 0.14.3", "hex", @@ -18461,8 +19497,8 @@ dependencies = [ "pbkdf2", "pin-project", "poly1305", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "ruzstd", "schnorrkel 0.10.2", "serde", @@ -18472,10 +19508,10 @@ dependencies = [ "siphasher", "slab", "smallvec", - "soketto", + "soketto 0.7.1", "twox-hash", - "wasmi", - "x25519-dalek 2.0.0", + "wasmi 0.31.2", + "x25519-dalek", "zeroize", ] @@ -18486,15 +19522,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "256b5bad1d6b49045e95fe87492ce73d5af81545d8b4d8318a872d2007024c33" dependencies = [ "async-channel", - "async-lock", + "async-lock 2.8.0", "base64 0.21.2", "blake2-rfc", "derive_more", "either", - "event-listener", + "event-listener 2.5.3", "fnv", "futures-channel", - "futures-lite", + "futures-lite 1.13.0", "futures-util", "hashbrown 0.14.3", "hex", @@ -18502,10 +19538,10 @@ dependencies = [ "log", "lru 0.11.0", "no-std-net", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pin-project", - "rand 0.8.5", - "rand_chacha 0.3.1", + "rand", + "rand_chacha", "serde", "serde_json", "siphasher", @@ -18530,8 +19566,8 @@ dependencies = [ "aes-gcm", "blake2 0.10.6", "chacha20poly1305", - "curve25519-dalek 4.1.2", - "rand_core 0.6.4", + "curve25519-dalek", + "rand_core", "ring 0.17.7", "rustc_version 0.4.0", "sha2 0.10.8", @@ -18603,7 +19639,7 @@ dependencies = [ "hex-literal", "parity-bytes", "parity-scale-codec", - "rand 0.8.5", + "rand", "rlp", "scale-info", "serde", @@ -18624,7 +19660,7 @@ dependencies = [ "hex", "lazy_static", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "snowbridge-amcl", "zeroize", @@ -18635,7 +19671,6 @@ name = "snowbridge-outbound-queue-merkle-tree" version = "0.3.0" dependencies = [ "array-bytes", - "env_logger 0.11.3", "hex", "hex-literal", "parity-scale-codec", @@ -18643,6 +19678,7 @@ dependencies = [ "sp-core", "sp-crypto-hashing", "sp-runtime", + "sp-tracing 16.0.0", ] [[package]] @@ -18668,7 +19704,7 @@ dependencies = [ "log", "pallet-timestamp", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "serde", "serde_json", @@ -18792,7 +19828,6 @@ dependencies = [ "hex-literal", "log", "parity-scale-codec", - "rustc-hex", "scale-info", "snowbridge-core", "sp-core", @@ -18871,9 +19906,9 @@ dependencies = [ [[package]] name = "socket2" -version = "0.5.6" +version = "0.5.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871" +checksum = "ce305eb0b4296696835b71df73eb912e0f1ffd2556a501fcede6e0c50349191c" dependencies = [ "libc", "windows-sys 0.52.0", @@ -18887,21 +19922,36 @@ checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2" dependencies = [ "base64 0.13.1", "bytes", - "flate2", "futures", - "http", "httparse", "log", - "rand 0.8.5", + "rand", "sha-1 0.9.8", ] +[[package]] +name = "soketto" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37468c595637c10857701c990f93a40ce0e357cedb0953d1c26c8d8027f9bb53" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures", + "http 1.1.0", + "httparse", + "log", + "rand", + "sha1", +] + [[package]] name = "solochain-template-node" version = "0.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "frame-benchmarking-cli", + "frame-metadata-hash-extension", "frame-system", "futures", "jsonrpsee", @@ -18916,7 +19966,6 @@ dependencies = [ "sc-executor", "sc-network", "sc-offchain", - "sc-rpc-api", "sc-service", "sc-telemetry", "sc-transaction-pool", @@ -18944,6 +19993,7 @@ version = "0.0.0" dependencies = [ "frame-benchmarking", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-benchmarking", @@ -18969,7 +20019,6 @@ dependencies = [ "sp-offchain", "sp-runtime", "sp-session", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-transaction-pool", "sp-version", @@ -18980,6 +20029,7 @@ dependencies = [ name = "sp-api" version = "26.0.0" dependencies = [ + "docify", "hash-db", "log", "parity-scale-codec", @@ -18991,7 +20041,6 @@ dependencies = [ "sp-runtime", "sp-runtime-interface 24.0.0", "sp-state-machine", - "sp-std 14.0.0", "sp-test-primitives", "sp-trie", "sp-version", @@ -19005,11 +20054,11 @@ dependencies = [ "Inflector", "assert_matches", "blake2 0.10.6", - "expander 2.0.0", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "expander", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -19044,7 +20093,6 @@ dependencies = [ "serde", "sp-core", "sp-io", - "sp-std 14.0.0", ] [[package]] @@ -19068,11 +20116,10 @@ dependencies = [ "num-traits", "parity-scale-codec", "primitive-types", - "rand 0.8.5", + "rand", "scale-info", "serde", "sp-crypto-hashing", - "sp-std 14.0.0", "static_assertions", ] @@ -19130,16 +20177,17 @@ name = "sp-blockchain" version = "28.0.0" dependencies = [ "futures", - "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "schnellru", "sp-api", "sp-consensus", + "sp-core", "sp-database", "sp-runtime", "sp-state-machine", "thiserror", + "tracing", ] [[package]] @@ -19206,6 +20254,7 @@ dependencies = [ "sp-keystore", "sp-mmr-primitives", "sp-runtime", + "sp-weights", "strum 0.26.2", "w3f-bls", ] @@ -19269,7 +20318,7 @@ dependencies = [ "bitflags 1.3.2", "blake2 0.10.6", "bounded-collections", - "bs58 0.5.0", + "bs58 0.5.1", "criterion", "dyn-clonable", "ed25519-zebra", @@ -19285,10 +20334,10 @@ dependencies = [ "merlin", "parity-bip39", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "paste", "primitive-types", - "rand 0.8.5", + "rand", "regex", "scale-info", "schnorrkel 0.11.4", @@ -19392,9 +20441,9 @@ dependencies = [ name = "sp-crypto-hashing-proc-macro" version = "0.1.0" dependencies = [ - "quote 1.0.35", + "quote 1.0.36", "sp-crypto-hashing", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -19402,7 +20451,7 @@ name = "sp-database" version = "10.0.0" dependencies = [ "kvdb", - "parking_lot 0.12.1", + "parking_lot 0.12.3", ] [[package]] @@ -19410,18 +20459,18 @@ name = "sp-debug-derive" version = "8.0.0" source = "git+https://github.com/paritytech/polkadot-sdk#82912acb33a9030c0ef3bf590a34fca09b72dc5f" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "sp-debug-derive" version = "14.0.0" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -19473,11 +20522,12 @@ name = "sp-io" version = "30.0.0" dependencies = [ "bytes", - "ed25519-dalek 2.1.0", + "docify", + "ed25519-dalek", "libsecp256k1", "log", "parity-scale-codec", - "polkavm-derive", + "polkavm-derive 0.9.1", "rustversion", "secp256k1", "sp-core", @@ -19486,7 +20536,6 @@ dependencies = [ "sp-keystore", "sp-runtime-interface 24.0.0", "sp-state-machine", - "sp-std 14.0.0", "sp-tracing 16.0.0", "sp-trie", "tracing", @@ -19507,9 +20556,9 @@ name = "sp-keystore" version = "0.34.0" dependencies = [ "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", - "rand_chacha 0.3.1", + "parking_lot 0.12.3", + "rand", + "rand_chacha", "sp-core", "sp-externalities 0.25.0", ] @@ -19546,9 +20595,9 @@ name = "sp-mmr-primitives" version = "26.0.0" dependencies = [ "array-bytes", - "ckb-merkle-mountain-range", "log", "parity-scale-codec", + "polkadot-ckb-merkle-mountain-range", "scale-info", "serde", "sp-api", @@ -19563,7 +20612,7 @@ name = "sp-npos-elections" version = "26.0.0" dependencies = [ "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "serde", "sp-arithmetic", @@ -19576,9 +20625,9 @@ dependencies = [ name = "sp-npos-elections-fuzzer" version = "2.0.0-alpha.5" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "honggfuzz", - "rand 0.8.5", + "rand", "sp-npos-elections", "sp-runtime", ] @@ -19605,7 +20654,7 @@ dependencies = [ name = "sp-rpc" version = "26.0.0" dependencies = [ - "rustc-hash", + "rustc-hash 1.1.0", "serde", "serde_json", "sp-core", @@ -19623,11 +20672,11 @@ dependencies = [ "num-traits", "parity-scale-codec", "paste", - "rand 0.8.5", + "rand", "scale-info", "serde", "serde_json", - "simple-mermaid", + "simple-mermaid 0.1.1", "sp-api", "sp-application-crypto", "sp-arithmetic", @@ -19638,6 +20687,7 @@ dependencies = [ "sp-tracing 16.0.0", "sp-weights", "substrate-test-runtime-client", + "tracing", "zstd 0.12.4", ] @@ -19666,7 +20716,7 @@ dependencies = [ "bytes", "impl-trait-for-tuples", "parity-scale-codec", - "polkavm-derive", + "polkavm-derive 0.9.1", "primitive-types", "rustversion", "sp-core", @@ -19690,9 +20740,9 @@ source = "git+https://github.com/paritytech/polkadot-sdk#82912acb33a9030c0ef3bf5 dependencies = [ "Inflector", "proc-macro-crate 1.3.1", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -19700,11 +20750,11 @@ name = "sp-runtime-interface-proc-macro" version = "17.0.0" dependencies = [ "Inflector", - "expander 2.0.0", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "expander", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -19731,7 +20781,6 @@ dependencies = [ "sp-core", "sp-io", "sp-runtime-interface 24.0.0", - "sp-std 14.0.0", "substrate-wasm-builder", ] @@ -19774,14 +20823,15 @@ dependencies = [ name = "sp-state-machine" version = "0.35.0" dependencies = [ + "arbitrary", "array-bytes", "assert_matches", "hash-db", "log", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "pretty_assertions", - "rand 0.8.5", + "rand", "smallvec", "sp-core", "sp-externalities 0.25.0", @@ -19798,11 +20848,11 @@ name = "sp-statement-store" version = "10.0.0" dependencies = [ "aes-gcm", - "curve25519-dalek 4.1.2", - "ed25519-dalek 2.1.0", + "curve25519-dalek", + "ed25519-dalek", "hkdf", "parity-scale-codec", - "rand 0.8.5", + "rand", "scale-info", "sha2 0.10.8", "sp-api", @@ -19813,7 +20863,7 @@ dependencies = [ "sp-runtime", "sp-runtime-interface 24.0.0", "thiserror", - "x25519-dalek 2.0.0", + "x25519-dalek", ] [[package]] @@ -19919,7 +20969,7 @@ dependencies = [ name = "sp-trie" version = "29.0.0" dependencies = [ - "ahash 0.8.8", + "ahash 0.8.11", "array-bytes", "criterion", "hash-db", @@ -19927,8 +20977,8 @@ dependencies = [ "memory-db", "nohash-hasher", "parity-scale-codec", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "scale-info", "schnellru", "sp-core", @@ -19963,10 +21013,10 @@ name = "sp-version-proc-macro" version = "13.0.0" dependencies = [ "parity-scale-codec", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "sp-version", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -20021,9 +21071,9 @@ checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" [[package]] name = "spinners" -version = "4.1.0" +version = "4.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08615eea740067d9899969bc2891c68a19c315cb1f66640af9a9ecb91b13bcab" +checksum = "a0ef947f358b9c238923f764c72a4a9d42f2d637c46e059dbd319d6e7cfb4f82" dependencies = [ "lazy_static", "maplit", @@ -20048,8 +21098,8 @@ checksum = "5e6915280e2d0db8911e5032a5c275571af6bdded2916abd691a659be25d3439" dependencies = [ "Inflector", "num-format", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "serde", "serde_json", "unicode-xid 0.2.4", @@ -20073,8 +21123,8 @@ version = "0.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f07d54c4d01a1713eb363b55ba51595da15f6f1211435b71466460da022aa140" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -20086,9 +21136,9 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "staging-chain-spec-builder" -version = "3.0.0" +version = "1.6.1" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "log", "sc-chain-spec", "serde_json", @@ -20101,105 +21151,30 @@ version = "3.0.0-dev" dependencies = [ "array-bytes", "assert_cmd", - "clap 4.5.3", + "clap 4.5.11", "clap_complete", "criterion", - "frame-benchmarking", - "frame-benchmarking-cli", - "frame-support", - "frame-system", - "frame-system-rpc-runtime-api", "futures", "jsonrpsee", "kitchensink-runtime", "log", - "mmr-gadget", - "nix 0.27.1", + "nix 0.28.0", "node-primitives", "node-rpc", "node-testing", - "pallet-asset-conversion-tx-payment", - "pallet-asset-tx-payment", - "pallet-assets", - "pallet-balances", - "pallet-contracts", - "pallet-glutton", - "pallet-im-online", - "pallet-root-testing", - "pallet-skip-feeless-payment", - "pallet-sudo", - "pallet-timestamp", - "pallet-transaction-payment", - "pallet-treasury", "parity-scale-codec", "platforms", - "rand 0.8.5", + "polkadot-sdk", + "pretty_assertions", + "rand", "regex", - "sc-authority-discovery", - "sc-basic-authorship", - "sc-block-builder", - "sc-chain-spec", - "sc-cli", - "sc-client-api", - "sc-client-db", - "sc-consensus", - "sc-consensus-babe", - "sc-consensus-beefy", - "sc-consensus-epochs", - "sc-consensus-grandpa", - "sc-consensus-slots", - "sc-executor", - "sc-keystore", - "sc-mixnet", - "sc-network", - "sc-network-common", - "sc-network-statement", - "sc-network-sync", - "sc-offchain", - "sc-rpc", - "sc-service", "sc-service-test", - "sc-statement-store", - "sc-storage-monitor", - "sc-sync-state-rpc", - "sc-sysinfo", - "sc-telemetry", - "sc-transaction-pool", - "sc-transaction-pool-api", "scale-info", "serde", "serde_json", - "soketto", - "sp-api", - "sp-application-crypto", - "sp-authority-discovery", - "sp-blockchain", - "sp-consensus", - "sp-consensus-babe", - "sp-consensus-beefy", - "sp-consensus-grandpa", - "sp-core", - "sp-crypto-hashing", - "sp-externalities 0.25.0", - "sp-genesis-builder", - "sp-inherents", - "sp-io", - "sp-keyring", - "sp-keystore", - "sp-mixnet", - "sp-mmr-primitives", - "sp-runtime", - "sp-state-machine", - "sp-statement-store", - "sp-timestamp", - "sp-tracing 16.0.0", - "sp-transaction-storage-proof", - "sp-trie", + "soketto 0.7.1", "staging-node-inspect", - "substrate-build-script-utils", "substrate-cli-test-utils", - "substrate-frame-cli", - "substrate-rpc-client", "tempfile", "tokio", "tokio-util", @@ -20211,7 +21186,7 @@ dependencies = [ name = "staging-node-inspect" version = "0.12.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "parity-scale-codec", "sc-cli", "sc-client-api", @@ -20234,7 +21209,6 @@ dependencies = [ "parity-scale-codec", "scale-info", "sp-runtime", - "sp-std 14.0.0", ] [[package]] @@ -20258,6 +21232,7 @@ dependencies = [ "schemars", "serde", "sp-io", + "sp-runtime", "sp-weights", "xcm-procedural", ] @@ -20271,6 +21246,7 @@ dependencies = [ "frame-system", "impl-trait-for-tuples", "log", + "pallet-asset-conversion", "pallet-assets", "pallet-balances", "pallet-salary", @@ -20284,9 +21260,9 @@ dependencies = [ "primitive-types", "scale-info", "sp-arithmetic", + "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-weights", "staging-xcm", "staging-xcm-executor", @@ -20300,16 +21276,15 @@ dependencies = [ "frame-benchmarking", "frame-support", "impl-trait-for-tuples", - "log", "parity-scale-codec", "scale-info", "sp-arithmetic", "sp-core", "sp-io", "sp-runtime", - "sp-std 14.0.0", "sp-weights", "staging-xcm", + "tracing", ] [[package]] @@ -20341,24 +21316,24 @@ checksum = "70a2595fc3aa78f2d0e45dd425b22282dd863273761cc77780914b2cf3003acf" dependencies = [ "cfg_aliases", "memchr", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] [[package]] name = "str0m" -version = "0.4.1" +version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3f10d3f68e60168d81110410428a435dbde28cc5525f5f7c6fdec92dbdc2800" +checksum = "6706347e49b13373f7ddfafad47df7583ed52083d6fc8a594eb2c80497ef959d" dependencies = [ "combine", "crc", + "fastrand 2.1.0", "hmac 0.12.1", "once_cell", "openssl", "openssl-sys", - "rand 0.8.5", "sctp-proto", "serde", "sha-1 0.10.1", @@ -20367,16 +21342,14 @@ dependencies = [ ] [[package]] -name = "strobe-rs" -version = "0.8.1" +name = "string-interner" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fabb238a1cccccfa4c4fb703670c0d157e1256c1ba695abf1b93bd2bb14bab2d" +checksum = "1c6a0d765f5807e98a091107bae0a56ea3799f66a5de47b2c84c94a39c09974e" dependencies = [ - "bitflags 1.3.2", - "byteorder", - "keccak", - "subtle 2.5.0", - "zeroize", + "cfg-if", + "hashbrown 0.14.3", + "serde", ] [[package]] @@ -20416,8 +21389,8 @@ checksum = "dcb5ae327f9cc13b68763b5749770cb9e048a99bd9dfdfa58d0cf05d5f64afe0" dependencies = [ "heck 0.3.3", "proc-macro-error", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] @@ -20452,8 +21425,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59" dependencies = [ "heck 0.4.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "rustversion", "syn 1.0.109", ] @@ -20465,10 +21438,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0" dependencies = [ "heck 0.4.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "rustversion", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] @@ -20478,17 +21451,17 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c6cf59daf282c0a494ba14fd21610a0325f9f90ec9d1231dea26bcb1d696c946" dependencies = [ "heck 0.4.1", - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "rustversion", - "syn 2.0.53", + "syn 2.0.61", ] [[package]] name = "subkey" version = "9.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "sc-cli", ] @@ -20515,27 +21488,15 @@ version = "0.1.0" dependencies = [ "assert_cmd", "futures", - "nix 0.27.1", + "nix 0.28.0", "node-primitives", "regex", "sc-cli", - "sc-service", - "sp-rpc", - "staging-node-cli", - "substrate-rpc-client", - "tokio", -] - -[[package]] -name = "substrate-frame-cli" -version = "32.0.0" -dependencies = [ - "clap 4.5.3", - "frame-support", - "frame-system", - "sc-cli", - "sp-core", - "sp-runtime", + "sc-service", + "sp-rpc", + "staging-node-cli", + "substrate-rpc-client", + "tokio", ] [[package]] @@ -20560,6 +21521,7 @@ name = "substrate-frame-rpc-system" version = "28.0.0" dependencies = [ "assert_matches", + "docify", "frame-system-rpc-runtime-api", "futures", "jsonrpsee", @@ -20582,7 +21544,9 @@ dependencies = [ name = "substrate-prometheus-endpoint" version = "0.17.0" dependencies = [ - "hyper", + "http-body-util", + "hyper 1.3.1", + "hyper-util", "log", "prometheus", "thiserror", @@ -20602,9 +21566,7 @@ dependencies = [ "bp-polkadot-core", "bp-relayers", "bp-runtime", - "bridge-runtime-common", "equivocation-detector", - "finality-grandpa", "finality-relay", "frame-support", "frame-system", @@ -20624,9 +21586,11 @@ dependencies = [ "rbtag", "relay-substrate-client", "relay-utils", + "scale-info", "sp-consensus-grandpa", "sp-core", "sp-runtime", + "sp-trie", "structopt", "strum 0.26.2", "thiserror", @@ -20695,11 +21659,11 @@ version = "2.0.0" dependencies = [ "array-bytes", "frame-executive", + "frame-metadata-hash-extension", "frame-support", "frame-system", "frame-system-rpc-runtime-api", "futures", - "hex-literal", "log", "pallet-babe", "pallet-balances", @@ -20737,6 +21701,7 @@ dependencies = [ "sp-version", "substrate-test-runtime-client", "substrate-wasm-builder", + "tracing", "trie-db", ] @@ -20763,7 +21728,7 @@ version = "2.0.0" dependencies = [ "futures", "parity-scale-codec", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "sc-transaction-pool", "sc-transaction-pool-api", "sp-blockchain", @@ -20786,13 +21751,23 @@ dependencies = [ name = "substrate-wasm-builder" version = "17.0.0" dependencies = [ + "array-bytes", "build-helper", "cargo_metadata", "console", "filetime", + "frame-metadata", + "jobserver", + "merkleized-metadata", + "parity-scale-codec", "parity-wasm", - "polkavm-linker", + "polkavm-linker 0.9.2", + "sc-executor", + "sp-core", + "sp-io", "sp-maybe-compressed-blob", + "sp-tracing 16.0.0", + "sp-version", "strum 0.26.2", "tempfile", "toml 0.8.8", @@ -20926,19 +21901,19 @@ version = "1.0.109" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "unicode-ident", ] [[package]] name = "syn" -version = "2.0.53" +version = "2.0.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7383cd0e49fff4b6b90ca5670bfd3e9d6a733b3f90c686605aa7eec8c4996032" +checksum = "c993ed8ccba56ae856363b1845da7266a7cb78e1d146c8a32d54b45a8b831fc9" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "unicode-ident", ] @@ -20949,9 +21924,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "86b837ef12ab88835251726eb12237655e61ec8dc8a280085d1961cdc3dfd047" dependencies = [ "paste", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -20960,12 +21935,23 @@ version = "0.12.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f36bdaa60a83aca3921b5259d5400cbf5e90fc51931376a9bd4a0eb79aa7210f" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", "unicode-xid 0.2.4", ] +[[package]] +name = "synstructure" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + [[package]] name = "sysinfo" version = "0.30.5" @@ -21032,7 +22018,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7ef1adac450ad7f4b3c28589471ade84f25f731a7a0fe30d71dfa9f60fd808e5" dependencies = [ "cfg-if", - "fastrand 2.0.0", + "fastrand 2.1.0", "redox_syscall 0.4.1", "rustix 0.38.21", "windows-sys 0.48.0", @@ -21063,6 +22049,28 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" +[[package]] +name = "test-log" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3dffced63c2b5c7be278154d76b479f9f9920ed34e7574201407f0b14e2bbb93" +dependencies = [ + "env_logger 0.11.3", + "test-log-macros", + "tracing-subscriber 0.3.18", +] + +[[package]] +name = "test-log-macros" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5999e24eaa32083191ba4e425deb75cdf25efefabe5aaccb7446dd0d4122a3f5" +dependencies = [ + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", +] + [[package]] name = "test-parachain-adder" version = "1.0.0" @@ -21071,7 +22079,6 @@ dependencies = [ "parity-scale-codec", "polkadot-parachain-primitives", "sp-io", - "sp-std 14.0.0", "substrate-wasm-builder", "tiny-keccak", ] @@ -21080,7 +22087,7 @@ dependencies = [ name = "test-parachain-adder-collator" version = "1.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "futures", "futures-timer", "log", @@ -21119,7 +22126,6 @@ dependencies = [ "parity-scale-codec", "polkadot-parachain-primitives", "sp-io", - "sp-std 14.0.0", "substrate-wasm-builder", "tiny-keccak", ] @@ -21128,7 +22134,7 @@ dependencies = [ name = "test-parachain-undying-collator" version = "1.0.0" dependencies = [ - "clap 4.5.3", + "clap 4.5.11", "futures", "futures-timer", "log", @@ -21202,9 +22208,9 @@ checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d" [[package]] name = "thiserror" -version = "1.0.50" +version = "1.0.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9a7210f5c9a7156bb50aa36aed4c95afb51df0df00713949448cf9e97d382d2" +checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709" dependencies = [ "thiserror-impl", ] @@ -21224,20 +22230,20 @@ version = "1.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "10ac1c5050e43014d16b2f94d0d2ce79e65ffdd8b38d8048f9c8f6a8a6da62ac" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", "syn 1.0.109", ] [[package]] name = "thiserror-impl" -version = "1.0.50" +version = "1.0.61" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8" +checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -21311,14 +22317,16 @@ dependencies = [ [[package]] name = "time" -version = "0.3.27" +version = "0.3.36" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bb39ee79a6d8de55f48f2293a830e040392f1c5f16e336bdd1788cd0aadce07" +checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" dependencies = [ "deranged", "itoa", "libc", + "num-conv", "num_threads", + "powerfmt", "serde", "time-core", "time-macros", @@ -21326,16 +22334,17 @@ dependencies = [ [[package]] name = "time-core" -version = "0.1.1" +version = "0.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb" +checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" [[package]] name = "time-macros" -version = "0.2.13" +version = "0.2.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "733d258752e9303d392b94b75230d07b0b9c489350c69b851fc6c065fde3e8f9" +checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" dependencies = [ + "num-conv", "time-core", ] @@ -21384,10 +22393,10 @@ dependencies = [ "libc", "mio", "num_cpus", - "parking_lot 0.12.1", - "pin-project-lite 0.2.12", + "parking_lot 0.12.3", + "pin-project-lite", "signal-hook-registry", - "socket2 0.5.6", + "socket2 0.5.7", "tokio-macros", "windows-sys 0.48.0", ] @@ -21398,9 +22407,9 @@ version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -21410,7 +22419,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f57eb36ecbe0fc510036adff84824dd3c24bb781e21bfa67b69d556aa85214f" dependencies = [ "pin-project", - "rand 0.8.5", + "rand", "tokio", ] @@ -21420,17 +22429,17 @@ version = "0.24.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" dependencies = [ - "rustls 0.21.6", + "rustls 0.21.7", "tokio", ] [[package]] name = "tokio-rustls" -version = "0.25.0" +version = "0.26.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f" +checksum = "0c7bc40d0e5a97695bb96e27995cd3a08538541b0a846f65bba7a359f36700d4" dependencies = [ - "rustls 0.22.2", + "rustls 0.23.10", "rustls-pki-types", "tokio", ] @@ -21442,7 +22451,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842" dependencies = [ "futures-core", - "pin-project-lite 0.2.12", + "pin-project-lite", "tokio", "tokio-util", ] @@ -21468,7 +22477,7 @@ checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c" dependencies = [ "futures-util", "log", - "rustls 0.21.6", + "rustls 0.21.7", "rustls-native-certs 0.6.3", "tokio", "tokio-rustls 0.24.1", @@ -21477,17 +22486,16 @@ dependencies = [ [[package]] name = "tokio-util" -version = "0.7.8" +version = "0.7.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d" +checksum = "9cf6b47b3771c49ac75ad09a6162f53ad4b8088b76ac60e8ec1455b31a189fe1" dependencies = [ "bytes", "futures-core", "futures-io", "futures-sink", - "pin-project-lite 0.2.12", + "pin-project-lite", "tokio", - "tracing", ] [[package]] @@ -21553,7 +22561,8 @@ dependencies = [ "futures-core", "futures-util", "pin-project", - "pin-project-lite 0.2.12", + "pin-project-lite", + "tokio", "tower-layer", "tower-service", "tracing", @@ -21561,18 +22570,16 @@ dependencies = [ [[package]] name = "tower-http" -version = "0.4.3" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55ae70283aba8d2a8b411c695c437fe25b8b5e44e23e780662002fc72fb47a82" +checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5" dependencies = [ - "bitflags 2.4.0", + "bitflags 2.6.0", "bytes", - "futures-core", - "futures-util", - "http", - "http-body", - "http-range-header", - "pin-project-lite 0.2.12", + "http 1.1.0", + "http-body 1.0.0", + "http-body-util", + "pin-project-lite", "tower-layer", "tower-service", ] @@ -21596,7 +22603,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" dependencies = [ "log", - "pin-project-lite 0.2.12", + "pin-project-lite", "tracing-attributes", "tracing-core", ] @@ -21607,9 +22614,9 @@ version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -21647,11 +22654,11 @@ name = "tracing-gum-proc-macro" version = "5.0.0" dependencies = [ "assert_matches", - "expander 2.0.0", - "proc-macro-crate 3.0.0", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "expander", + "proc-macro-crate 3.1.0", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] @@ -21718,11 +22725,12 @@ dependencies = [ "matchers 0.1.0", "nu-ansi-term", "once_cell", - "parking_lot 0.12.1", + "parking_lot 0.12.3", "regex", "sharded-slab", "smallvec", "thread_local", + "time", "tracing", "tracing-core", "tracing-log 0.2.0", @@ -21746,9 +22754,9 @@ dependencies = [ [[package]] name = "trie-db" -version = "0.29.0" +version = "0.29.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ed83be775d85ebb0e272914fff6462c39b3ddd6dc67b5c1c41271aad280c69" +checksum = "0c992b4f40c234a074d48a757efeabb1a6be88af84c0c23f7ca158950cb0ae7f" dependencies = [ "hash-db", "log", @@ -21791,7 +22799,7 @@ dependencies = [ "idna 0.2.3", "ipnet", "lazy_static", - "rand 0.8.5", + "rand", "smallvec", "socket2 0.4.9", "thiserror", @@ -21817,7 +22825,7 @@ dependencies = [ "idna 0.4.0", "ipnet", "once_cell", - "rand 0.8.5", + "rand", "smallvec", "thiserror", "tinyvec", @@ -21826,26 +22834,6 @@ dependencies = [ "url", ] -[[package]] -name = "trust-dns-resolver" -version = "0.22.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe" -dependencies = [ - "cfg-if", - "futures-util", - "ipconfig", - "lazy_static", - "lru-cache", - "parking_lot 0.12.1", - "resolv-conf", - "smallvec", - "thiserror", - "tokio", - "tracing", - "trust-dns-proto 0.22.0", -] - [[package]] name = "trust-dns-resolver" version = "0.23.2" @@ -21857,8 +22845,8 @@ dependencies = [ "ipconfig", "lru-cache", "once_cell", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "rand", "resolv-conf", "smallvec", "thiserror", @@ -21904,11 +22892,11 @@ dependencies = [ "byteorder", "bytes", "data-encoding", - "http", + "http 0.2.9", "httparse", "log", - "rand 0.8.5", - "rustls 0.21.6", + "rand", + "rustls 0.21.7", "sha1", "thiserror", "url", @@ -21929,7 +22917,7 @@ checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675" dependencies = [ "cfg-if", "digest 0.10.7", - "rand 0.7.3", + "rand", "static_assertions", ] @@ -22034,6 +23022,15 @@ dependencies = [ "bytes", "futures-io", "futures-util", +] + +[[package]] +name = "unsigned-varint" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06" +dependencies = [ + "bytes", "tokio-util", ] @@ -22051,12 +23048,12 @@ checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" [[package]] name = "url" -version = "2.4.0" +version = "2.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb" +checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c" dependencies = [ "form_urlencoded", - "idna 0.4.0", + "idna 0.5.0", "percent-encoding", ] @@ -22159,9 +23156,9 @@ dependencies = [ "arrayref", "constcat", "digest 0.10.7", - "rand 0.8.5", - "rand_chacha 0.3.1", - "rand_core 0.6.4", + "rand", + "rand_chacha", + "rand_core", "sha2 0.10.8", "sha3", "thiserror", @@ -22185,9 +23182,9 @@ checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca" [[package]] name = "walkdir" -version = "2.4.0" +version = "2.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" +checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b" dependencies = [ "same-file", "winapi-util", @@ -22202,12 +23199,6 @@ dependencies = [ "try-lock", ] -[[package]] -name = "wasi" -version = "0.9.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" - [[package]] name = "wasi" version = "0.11.0+wasi-snapshot-preview1" @@ -22216,11 +23207,12 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" [[package]] name = "wasm-bindgen" -version = "0.2.87" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342" +checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5" dependencies = [ "cfg-if", + "once_cell", "serde", "serde_json", "wasm-bindgen-macro", @@ -22228,16 +23220,16 @@ dependencies = [ [[package]] name = "wasm-bindgen-backend" -version = "0.2.87" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd" +checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b" dependencies = [ "bumpalo", "log", "once_cell", - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", "wasm-bindgen-shared", ] @@ -22255,32 +23247,32 @@ dependencies = [ [[package]] name = "wasm-bindgen-macro" -version = "0.2.87" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d" +checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf" dependencies = [ - "quote 1.0.35", + "quote 1.0.36", "wasm-bindgen-macro-support", ] [[package]] name = "wasm-bindgen-macro-support" -version = "0.2.87" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b" +checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", "wasm-bindgen-backend", "wasm-bindgen-shared", ] [[package]] name = "wasm-bindgen-shared" -version = "0.2.87" +version = "0.2.93" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1" +checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484" [[package]] name = "wasm-bindgen-test" @@ -22302,8 +23294,8 @@ version = "0.3.37" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ecb993dd8c836930ed130e020e77d9b2e65dd0fbab1b67c790b0f5d80b11a575" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", + "proc-macro2 1.0.82", + "quote 1.0.36", ] [[package]] @@ -22388,7 +23380,24 @@ dependencies = [ "smallvec", "spin 0.9.8", "wasmi_arena", - "wasmi_core", + "wasmi_core 0.13.0", + "wasmparser-nostd", +] + +[[package]] +name = "wasmi" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50386c99b9c32bd2ed71a55b6dd4040af2580530fae8bdb9a6576571a80d0cca" +dependencies = [ + "arrayvec 0.7.4", + "multi-stash", + "num-derive", + "num-traits", + "smallvec", + "spin 0.9.8", + "wasmi_collections", + "wasmi_core 0.32.3", "wasmparser-nostd", ] @@ -22398,6 +23407,17 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "104a7f73be44570cac297b3035d76b169d6599637631cf37a1703326a0727073" +[[package]] +name = "wasmi_collections" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c128c039340ffd50d4195c3f8ce31aac357f06804cfc494c8b9508d4b30dca4" +dependencies = [ + "ahash 0.8.11", + "hashbrown 0.14.3", + "string-interner", +] + [[package]] name = "wasmi_core" version = "0.13.0" @@ -22410,6 +23430,18 @@ dependencies = [ "paste", ] +[[package]] +name = "wasmi_core" +version = "0.32.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a23b3a7f6c8c3ceeec6b83531ee61f0013c56e51cbf2b14b0f213548b23a4b41" +dependencies = [ + "downcast-rs", + "libm", + "num-traits", + "paste", +] + [[package]] name = "wasmparser" version = "0.102.0" @@ -22422,9 +23454,9 @@ dependencies = [ [[package]] name = "wasmparser-nostd" -version = "0.100.1" +version = "0.100.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9157cab83003221bfd385833ab587a039f5d6fa7304854042ba358a3b09e0724" +checksum = "d5a015fe95f3504a94bb1462c717aae75253e39b9dd6c3fb1062c934535c64aa" dependencies = [ "indexmap-nostd", ] @@ -22604,7 +23636,7 @@ dependencies = [ "memfd", "memoffset 0.8.0", "paste", - "rand 0.8.5", + "rand", "rustix 0.36.15", "wasmtime-asm-macros", "wasmtime-environ", @@ -22667,18 +23699,18 @@ dependencies = [ [[package]] name = "webpki-roots" -version = "0.22.6" +version = "0.25.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87" -dependencies = [ - "webpki", -] +checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" [[package]] name = "webpki-roots" -version = "0.25.2" +version = "0.26.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc" +checksum = "bd7c23921eeb1713a4e851530e9b9756e4fb0e89978582942612524cf09f01cd" +dependencies = [ + "rustls-pki-types", +] [[package]] name = "westend-emulated-chain" @@ -22697,7 +23729,7 @@ dependencies = [ "staging-xcm", "westend-runtime", "westend-runtime-constants", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -22709,6 +23741,7 @@ dependencies = [ "frame-benchmarking", "frame-election-provider-support", "frame-executive", + "frame-metadata-hash-extension", "frame-remote-externalities", "frame-support", "frame-system", @@ -22727,6 +23760,7 @@ dependencies = [ "pallet-beefy-mmr", "pallet-collective", "pallet-conviction-voting", + "pallet-delegated-staking", "pallet-democracy", "pallet-election-provider-multi-phase", "pallet-election-provider-support-benchmarking", @@ -22744,6 +23778,7 @@ dependencies = [ "pallet-nomination-pools-runtime-api", "pallet-offences", "pallet-offences-benchmarking", + "pallet-parameters", "pallet-preimage", "pallet-proxy", "pallet-recovery", @@ -22754,7 +23789,6 @@ dependencies = [ "pallet-session-benchmarking", "pallet-society", "pallet-staking", - "pallet-staking-reward-curve", "pallet-staking-runtime-api", "pallet-state-trie-migration", "pallet-sudo", @@ -22772,7 +23806,6 @@ dependencies = [ "polkadot-primitives", "polkadot-runtime-common", "polkadot-runtime-parachains", - "rustc-hex", "scale-info", "serde", "serde_derive", @@ -22796,7 +23829,6 @@ dependencies = [ "sp-runtime", "sp-session", "sp-staking", - "sp-std 14.0.0", "sp-storage 19.0.0", "sp-tracing 16.0.0", "sp-transaction-pool", @@ -22808,7 +23840,7 @@ dependencies = [ "tiny-keccak", "tokio", "westend-runtime-constants", - "xcm-fee-payment-runtime-api", + "xcm-runtime-apis", ] [[package]] @@ -22833,6 +23865,7 @@ dependencies = [ "asset-hub-westend-emulated-chain", "bridge-hub-westend-emulated-chain", "collectives-westend-emulated-chain", + "coretime-westend-emulated-chain", "emulated-integration-tests-common", "penpal-emulated-chain", "people-westend-emulated-chain", @@ -22899,23 +23932,20 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] name = "windows" -version = "0.34.0" +version = "0.48.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45296b64204227616fdbf2614cefa4c236b98ee64dfaaaa435207ed99fe7829f" +checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" dependencies = [ - "windows_aarch64_msvc 0.34.0", - "windows_i686_gnu 0.34.0", - "windows_i686_msvc 0.34.0", - "windows_x86_64_gnu 0.34.0", - "windows_x86_64_msvc 0.34.0", + "windows-targets 0.48.5", ] [[package]] name = "windows" -version = "0.48.0" +version = "0.51.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f" +checksum = "ca229916c5ee38c2f2bc1e9d8f04df975b4bd93f9955dc69fabb5d91270045c9" dependencies = [ + "windows-core 0.51.1", "windows-targets 0.48.5", ] @@ -22925,10 +23955,19 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e48a53791691ab099e5e2ad123536d0fff50652600abaf43bbf952894110d0be" dependencies = [ - "windows-core", + "windows-core 0.52.0", "windows-targets 0.52.0", ] +[[package]] +name = "windows-core" +version = "0.51.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1f8cf84f35d2db49a46868f947758c7a1138116f7fac3bc844f43ade1292e64" +dependencies = [ + "windows-targets 0.48.5", +] + [[package]] name = "windows-core" version = "0.52.0" @@ -23043,12 +24082,6 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea" -[[package]] -name = "windows_aarch64_msvc" -version = "0.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "17cffbe740121affb56fad0fc0e421804adf0ae00891205213b5cecd30db881d" - [[package]] name = "windows_aarch64_msvc" version = "0.42.2" @@ -23067,12 +24100,6 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef" -[[package]] -name = "windows_i686_gnu" -version = "0.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2564fde759adb79129d9b4f54be42b32c89970c18ebf93124ca8870a498688ed" - [[package]] name = "windows_i686_gnu" version = "0.42.2" @@ -23091,12 +24118,6 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313" -[[package]] -name = "windows_i686_msvc" -version = "0.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9cd9d32ba70453522332c14d38814bceeb747d80b3958676007acadd7e166956" - [[package]] name = "windows_i686_msvc" version = "0.42.2" @@ -23115,12 +24136,6 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a" -[[package]] -name = "windows_x86_64_gnu" -version = "0.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cfce6deae227ee8d356d19effc141a509cc503dfd1f850622ec4b0f84428e1f4" - [[package]] name = "windows_x86_64_gnu" version = "0.42.2" @@ -23157,12 +24172,6 @@ version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e" -[[package]] -name = "windows_x86_64_msvc" -version = "0.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d19538ccc21819d01deaf88d6a17eae6596a12e9aafdbb97916fb49896d89de9" - [[package]] name = "windows_x86_64_msvc" version = "0.42.2" @@ -23209,42 +24218,30 @@ dependencies = [ "tap", ] -[[package]] -name = "x25519-dalek" -version = "1.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a0c105152107e3b96f6a00a65e86ce82d9b125230e1c4302940eca58ff71f4f" -dependencies = [ - "curve25519-dalek 3.2.0", - "rand_core 0.5.1", - "zeroize", -] - [[package]] name = "x25519-dalek" version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fb66477291e7e8d2b0ff1bcb900bf29489a9692816d79874bea351e7a8b6de96" dependencies = [ - "curve25519-dalek 4.1.2", - "rand_core 0.6.4", + "curve25519-dalek", + "rand_core", "serde", "zeroize", ] [[package]] name = "x509-parser" -version = "0.14.0" +version = "0.15.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e0ecbeb7b67ce215e40e3cc7f2ff902f94a223acf44995934763467e7b1febc8" +checksum = "7069fba5b66b9193bd2c5d3d4ff12b839118f6bcbef5328efafafb5395cf63da" dependencies = [ - "asn1-rs", - "base64 0.13.1", + "asn1-rs 0.5.2", "data-encoding", - "der-parser", + "der-parser 8.2.0", "lazy_static", "nom", - "oid-registry", + "oid-registry 0.6.1", "rusticata-macros", "thiserror", "time", @@ -23252,16 +24249,16 @@ dependencies = [ [[package]] name = "x509-parser" -version = "0.15.1" +version = "0.16.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7069fba5b66b9193bd2c5d3d4ff12b839118f6bcbef5328efafafb5395cf63da" +checksum = "fcbc162f30700d6f3f82a24bf7cc62ffe7caea42c0b2cba8bf7f3ae50cf51f69" dependencies = [ - "asn1-rs", + "asn1-rs 0.6.1", "data-encoding", - "der-parser", + "der-parser 9.0.0", "lazy_static", "nom", - "oid-registry", + "oid-registry 0.7.0", "rusticata-macros", "thiserror", "time", @@ -23276,6 +24273,31 @@ dependencies = [ "libc", ] +[[package]] +name = "xcm-docs" +version = "0.1.0" +dependencies = [ + "docify", + "pallet-balances", + "pallet-message-queue", + "pallet-xcm", + "parity-scale-codec", + "polkadot-parachain-primitives", + "polkadot-primitives", + "polkadot-runtime-parachains", + "polkadot-sdk-frame", + "scale-info", + "simple-mermaid 0.1.0", + "sp-io", + "sp-runtime", + "sp-std 14.0.0", + "staging-xcm", + "staging-xcm-builder", + "staging-xcm-executor", + "test-log", + "xcm-simulator", +] + [[package]] name = "xcm-emulator" version = "0.5.0" @@ -23334,13 +24356,25 @@ dependencies = [ ] [[package]] -name = "xcm-fee-payment-runtime-api" +name = "xcm-procedural" +version = "7.0.0" +dependencies = [ + "Inflector", + "proc-macro2 1.0.82", + "quote 1.0.36", + "staging-xcm", + "syn 2.0.61", + "trybuild", +] + +[[package]] +name = "xcm-runtime-apis" version = "0.1.0" dependencies = [ - "env_logger 0.9.3", "frame-executive", "frame-support", "frame-system", + "hex-literal", "log", "pallet-assets", "pallet-balances", @@ -23349,37 +24383,28 @@ dependencies = [ "scale-info", "sp-api", "sp-io", - "sp-runtime", - "sp-std 14.0.0", + "sp-tracing 16.0.0", "sp-weights", "staging-xcm", "staging-xcm-builder", "staging-xcm-executor", ] -[[package]] -name = "xcm-procedural" -version = "7.0.0" -dependencies = [ - "Inflector", - "proc-macro2 1.0.75", - "quote 1.0.35", - "staging-xcm", - "syn 2.0.53", - "trybuild", -] - [[package]] name = "xcm-simulator" version = "7.0.0" dependencies = [ "frame-support", + "frame-system", "parity-scale-codec", "paste", "polkadot-core-primitives", "polkadot-parachain-primitives", + "polkadot-primitives", "polkadot-runtime-parachains", + "scale-info", "sp-io", + "sp-runtime", "sp-std 14.0.0", "staging-xcm", "staging-xcm-builder", @@ -23441,17 +24466,33 @@ dependencies = [ "xcm-simulator", ] +[[package]] +name = "xml-rs" +version = "0.8.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "791978798f0597cfc70478424c2b4fdc2b7a8024aaff78497ef00f24ef674193" + +[[package]] +name = "xmltree" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7d8a75eaf6557bb84a65ace8609883db44a29951042ada9b393151532e41fcb" +dependencies = [ + "xml-rs", +] + [[package]] name = "yamux" -version = "0.10.2" +version = "0.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e5d9ba232399af1783a58d8eb26f6b5006fbefe2dc9ef36bd283324792d03ea5" +checksum = "9ed0164ae619f2dc144909a9f082187ebb5893693d8c0196e8085283ccd4b776" dependencies = [ "futures", "log", "nohash-hasher", - "parking_lot 0.12.1", - "rand 0.8.5", + "parking_lot 0.12.3", + "pin-project", + "rand", "static_assertions", ] @@ -23485,16 +24526,16 @@ version = "0.7.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] name = "zeroize" -version = "1.7.0" +version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" +checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde" dependencies = [ "zeroize_derive", ] @@ -23505,9 +24546,9 @@ version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" dependencies = [ - "proc-macro2 1.0.75", - "quote 1.0.35", - "syn 2.0.53", + "proc-macro2 1.0.82", + "quote 1.0.36", + "syn 2.0.61", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 1d3f3d8e9ecd137493e72370734378fac9b19a87..7cd18bc8a590a0d21edff5f77e1cfc72c7651bbf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,9 +1,9 @@ [workspace.package] authors = ["Parity Technologies "] 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", @@ -218,13 +225,14 @@ members = [ "polkadot/utils/generate-bags", "polkadot/utils/remote-ext-tests/bags-list", "polkadot/xcm", + "polkadot/xcm/docs", "polkadot/xcm/pallet-xcm", "polkadot/xcm/pallet-xcm-benchmarks", "polkadot/xcm/procedural", "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", @@ -304,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", @@ -328,6 +337,7 @@ members = [ "substrate/frame/contracts/uapi", "substrate/frame/conviction-voting", "substrate/frame/core-fellowship", + "substrate/frame/delegated-staking", "substrate/frame/democracy", "substrate/frame/election-provider-multi-phase", "substrate/frame/election-provider-multi-phase/test-staking-e2e", @@ -359,6 +369,7 @@ members = [ "substrate/frame/membership", "substrate/frame/merkle-mountain-range", "substrate/frame/message-queue", + "substrate/frame/metadata-hash-extension", "substrate/frame/migrations", "substrate/frame/mixnet", "substrate/frame/multisig", @@ -371,7 +382,8 @@ members = [ "substrate/frame/nomination-pools/benchmarking", "substrate/frame/nomination-pools/fuzzer", "substrate/frame/nomination-pools/runtime-api", - "substrate/frame/nomination-pools/test-staking", + "substrate/frame/nomination-pools/test-delegate-stake", + "substrate/frame/nomination-pools/test-transfer-stake", "substrate/frame/offences", "substrate/frame/offences/benchmarking", "substrate/frame/paged-list", @@ -383,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", @@ -500,7 +517,6 @@ members = [ "substrate/utils/build-script-utils", "substrate/utils/fork-tree", "substrate/utils/frame/benchmarking-cli", - "substrate/utils/frame/frame-utilities-cli", "substrate/utils/frame/generate-bags", "substrate/utils/frame/generate-bags/node-runtime", "substrate/utils/frame/omni-bencher", @@ -512,84 +528,864 @@ members = [ "substrate/utils/prometheus", "substrate/utils/substrate-bip39", "substrate/utils/wasm-builder", - - "templates/minimal", "templates/minimal/node", "templates/minimal/pallets/template", "templates/minimal/runtime", - + "templates/parachain/node", + "templates/parachain/pallets/template", + "templates/parachain/runtime", "templates/solochain/node", "templates/solochain/pallets/template", "templates/solochain/runtime", + "umbrella", +] - "templates/parachain/node", - "templates/parachain/pallets/template", - "templates/parachain/runtime", +default-members = [ + "cumulus/polkadot-parachain", + "polkadot", + "substrate/bin/node/cli", ] -default-members = ["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 63743a456f4c8f8561bbeee8c59d63b88d352285..34d657194daa67de18088fb04d3ae878421c6d9f 100644 --- a/README.md +++ b/README.md @@ -1,81 +1,99 @@ -> NOTE: We have recently made significant changes to our repository structure. In order to streamline our development -process and foster better contributions, we have merged three separate repositories Cumulus, Substrate and Polkadot into -this repository. Read more about the changes [ -here](https://polkadot-public.notion.site/Polkadot-SDK-FAQ-fbc4cecc2c46443fb37b9eeec2f0d85f). + +
+ +![SDK Logo](./docs/images/Polkadot_Logo_Horizontal_Pink_White.png#gh-dark-mode-only) +![SDK Logo](./docs/images/Polkadot_Logo_Horizontal_Pink_Black.png#gh-light-mode-only) # Polkadot SDK -![](https://cms.polkadot.network/content/images/2021/06/1-xPcVR_fkITd0ssKBvJ3GMw.png) +![GitHub stars](https://img.shields.io/github/stars/paritytech/polkadot-sdk)  ![GitHub +forks](https://img.shields.io/github/forks/paritytech/polkadot-sdk) + + +[![StackExchange](https://img.shields.io/badge/StackExchange-Community%20&%20Support-222222?logo=stackexchange)](https://substrate.stackexchange.com/)  ![GitHub contributors](https://img.shields.io/github/contributors/paritytech/polkadot-sdk)  ![GitHub commit activity](https://img.shields.io/github/commit-activity/m/paritytech/polkadot-sdk)  ![GitHub last commit](https://img.shields.io/github/last-commit/paritytech/polkadot-sdk) + +> 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 +> different blockchains to interoperate and share information in a secure and scalable way. -[![StackExchange](https://img.shields.io/badge/StackExchange-Community%20&%20Support-222222?logo=stackexchange)](https://substrate.stackexchange.com/) +
-The Polkadot SDK repository provides all the resources needed to start building on the Polkadot network, a multi-chain -blockchain platform that enables different blockchains to interoperate and share information in a secure and scalable -way. The Polkadot SDK comprises three main pieces of software: +## ⚡ 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 +``` -## [Polkadot](./polkadot/) -[![PolkadotForum](https://img.shields.io/badge/Polkadot_Forum-e6007a?logo=polkadot)](https://forum.polkadot.network/) -[![Polkadot-license](https://img.shields.io/badge/License-GPL3-blue)](./polkadot/LICENSE) +## 📚 Documentation -Implementation of a node for the https://polkadot.network in Rust, using the Substrate framework. This directory -currently contains runtimes for the Westend and Rococo test networks. Polkadot, Kusama and their system chain runtimes -are located in the [`runtimes`](https://github.com/polkadot-fellows/runtimes/) repository maintained by -[the Polkadot Technical Fellowship](https://polkadot-fellows.github.io/dashboard/#/overview). +* [🦀 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 + * [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) -## [Substrate](./substrate/) - [![SubstrateRustDocs](https://img.shields.io/badge/Rust_Docs-Substrate-24CC85?logo=rust)](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/substrate/index.html) - [![Substrate-license](https://img.shields.io/badge/License-GPL3%2FApache2.0-blue)](./substrate/README.md#LICENSE) +## 🚀 Releases -Substrate is the primary blockchain SDK used by developers to create the parachains that make up the Polkadot network. -Additionally, it allows for the development of self-sovereign blockchains that operate completely independently of -Polkadot. +> [!NOTE] +> Our release process is still Work-In-Progress and may not yet reflect the aspired outline +> here. -## [Cumulus](./cumulus/) -[![CumulusRustDocs](https://img.shields.io/badge/Rust_Docs-Cumulus-222222?logo=rust)](https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/polkadot_sdk/cumulus/index.html) -[![Cumulus-license](https://img.shields.io/badge/License-GPL3-blue)](./cumulus/LICENSE) +The Polkadot-SDK has two release channels: `stable` and `nightly`. Production software is advised to +only use `stable`. `nightly` is meant for tinkerers to try out the latest features. The detailed +release process is described in [RELEASE.md](docs/RELEASE.md). -Cumulus is a set of tools for writing Substrate-based Polkadot parachains. +You can use [`psvm`](https://github.com/paritytech/psvm) to manage your Polkadot-SDK dependency +versions in downstream projects. -## Releases +### 😌 Stable -> [!NOTE] -> Our release process is still Work-In-Progress and may not yet reflect the aspired outline here. +`stable` releases have a support duration of **three months**. In this period, the release will not +have any breaking changes. It will receive bug fixes, security fixes, performance fixes and new +non-breaking features on a **two week** cadence. -The Polkadot-SDK has two release channels: `stable` and `nightly`. Production software is advised to only use `stable`. -`nightly` is meant for tinkerers to try out the latest features. The detailed release process is described in -[RELEASE.md](docs/RELEASE.md). +### 🤠 Nightly -### Stable +`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`. -`stable` releases have a support duration of **three months**. In this period, the release will not have any breaking -changes. It will receive bug fixes, security fixes, performance fixes and new non-breaking features on a **two week** -cadence. +## 🛠️ Tooling -### Nightly +[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. -`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`. +## 🔐 Security -## Upstream Dependencies +The security policy and procedures can be found in +[docs/contributor/SECURITY.md](./docs/contributor/SECURITY.md). -Below are the primary upstream dependencies utilized in this project: +## 🤍 Contributing & Code of Conduct -- [`parity-scale-codec`](https://crates.io/crates/parity-scale-codec) -- [`parity-db`](https://crates.io/crates/parity-db) -- [`parity-common`](https://github.com/paritytech/parity-common) -- [`trie`](https://github.com/paritytech/trie) +Ensure you follow our [contribution guidelines](./docs/contributor/CONTRIBUTING.md). In every +interaction and contribution, this project adheres to the [Contributor Covenant Code of +Conduct](./docs/contributor/CODE_OF_CONDUCT.md). -## Security +### 👾 Ready to Contribute? -The security policy and procedures can be found in [docs/contributor/SECURITY.md](./docs/contributor/SECURITY.md). +Take a look at the issues labeled with [`mentor`](https://github.com/paritytech/polkadot-sdk/labels/C1-mentor) +(or alternatively [this](https://mentor.tasty.limo/) page, created by one of the maintainers) label to get started! +We always recognize valuable contributions by proposing an on-chain tip to the Polkadot network as a token of our +appreciation. -## Contributing & Code of Conduct +## Polkadot Fellowship -Ensure you follow our [contribution guidelines](./docs/contributor/CONTRIBUTING.md). In every interaction and -contribution, this project adheres to the [Contributor Covenant Code of Conduct](./docs/contributor/CODE_OF_CONDUCT.md). +Development in this repo usually goes hand in hand with the `fellowship` organization. In short, +this repository provides all the SDK pieces needed to build both Polkadot and its parachains. But, +the actual Polkadot runtime lives in the `fellowship/runtimes` repository. Read more about the +fellowship, this separation, the RFC process +[here](https://polkadot-fellows.github.io/dashboard/). -## Additional Resources +## History -- For monitoring upcoming changes and current proposals related to the technical implementation of the Polkadot network, - visit the [`Requests for Comment (RFC)`](https://github.com/polkadot-fellows/RFCs) repository. While it's maintained - by the Polkadot Fellowship, the RFC process welcomes contributions from everyone. +This repository is the amalgamation of 3 separate repositories that used to make up Polkadot SDK, +namely Substrate, Polkadot and Cumulus. Read more about the merge and its history +[here](https://polkadot-public.notion.site/Polkadot-SDK-FAQ-fbc4cecc2c46443fb37b9eeec2f0d85f). diff --git a/bridges/bin/runtime-common/Cargo.toml b/bridges/bin/runtime-common/Cargo.toml index 74049031afe63cf0d2bc95193541a2b1303a1bbf..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.1", 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 . - -//! Types that allow runtime to act as a source/target endpoint of message lanes. -//! -//! Messages are assumed to be encoded `Call`s of the target chain. Call-dispatch -//! pallet is used to dispatch incoming messages. Message identified by a tuple -//! of to elements - message lane id and message nonce. - -pub use bp_runtime::{RangeInclusiveExt, UnderlyingChainOf, UnderlyingChainProvider}; - -use bp_header_chain::HeaderChain; -use bp_messages::{ - source_chain::TargetHeaderChain, - target_chain::{ProvedLaneMessages, ProvedMessages, SourceHeaderChain}, - InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData, - VerificationError, -}; -use bp_runtime::{Chain, RawStorageProof, Size, StorageProofChecker}; -use codec::{Decode, Encode}; -use frame_support::{traits::Get, weights::Weight}; -use hash_db::Hasher; -use scale_info::TypeInfo; -use sp_runtime::RuntimeDebug; -use sp_std::{marker::PhantomData, vec::Vec}; - -/// Bidirectional message bridge. -pub trait MessageBridge { - /// Name of the paired messages pallet instance at the Bridged chain. - /// - /// Should be the name that is used in the `construct_runtime!()` macro. - const BRIDGED_MESSAGES_PALLET_NAME: &'static str; - - /// This chain in context of message bridge. - type ThisChain: ThisChainWithMessages; - /// Bridged chain in context of message bridge. - type BridgedChain: BridgedChainWithMessages; - /// Bridged header chain. - type BridgedHeaderChain: HeaderChain>; -} - -/// 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 0c7a9ad1a83d6a83e0c9fe1f5e77ba2c4cefc17d..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(), @@ -271,7 +278,7 @@ pub fn generate_xcm_builder_bridge_message_sample( move |expected_message_size| -> MessagePayload { // For XCM bridge hubs, it is the message that // will be pushed further to some XCM queue (XCMP/UMP) - let location = xcm::VersionedInteriorLocation::V4(destination.clone()); + let location = xcm::VersionedInteriorLocation::from(destination.clone()); let location_encoded_size = location.encoded_size(); // we don't need to be super-precise with `expected_size` here @@ -294,16 +301,13 @@ pub fn generate_xcm_builder_bridge_message_sample( expected_message_size, location_encoded_size, xcm_size, xcm_data_size, ); - let xcm = xcm::VersionedXcm::<()>::V4( - vec![Instruction::<()>::ExpectPallet { - index: 0, - name: vec![42; xcm_data_size], - module_name: vec![], - crate_major: 0, - min_crate_minor: 0, - }] - .into(), - ); + let xcm = xcm::VersionedXcm::<()>::from(Xcm(vec![Instruction::<()>::ExpectPallet { + index: 0, + name: vec![42; xcm_data_size], + module_name: vec![], + crate_major: 0, + min_crate_minor: 0, + }])); // this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor // or public fields, so just tuple 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 . -//! Signed extension for the `pallet-bridge-messages` that is able to reject obsolete -//! (and some other invalid) transactions. +//! Helpers for easier manipulation of call processing with signed extensions. -use crate::messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, +use bp_messages::{ + target_chain::MessageDispatch, ChainWithMessages, InboundLaneData, LaneId, MessageNonce, }; -use bp_messages::{target_chain::MessageDispatch, InboundLaneData, LaneId, MessageNonce}; -use bp_runtime::OwnedBridgeModule; -use frame_support::{ - dispatch::CallableCallFor, - traits::{Get, IsSubType}, -}; -use pallet_bridge_messages::{Config, Pallet}; +use bp_runtime::{AccountIdOf, OwnedBridgeModule}; +use frame_support::{dispatch::CallableCallFor, traits::IsSubType}; +use pallet_bridge_messages::{BridgedChainOf, Config, Pallet}; use sp_runtime::{transaction_validity::TransactionValidity, RuntimeDebug}; use sp_std::ops::RangeInclusive; @@ -213,18 +208,8 @@ pub trait MessagesCallSubType, 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 e323f1edfc71da8c84fe8cabb977da85ce4d303e..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"; } @@ -148,7 +131,6 @@ impl frame_system::Config for TestRuntime { type AccountId = ThisChainAccountId; type Block = ThisChainBlock; type AccountData = pallet_balances::AccountData; - type BlockHashCount = ConstU32<250>; } impl pallet_utility::Config for TestRuntime { @@ -204,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, (), @@ -222,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 { @@ -263,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; @@ -327,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 } @@ -336,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; @@ -369,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 } @@ -385,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"; @@ -397,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 } @@ -410,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 9a6419a5b4055be348f4f8813e3c1301f14f7142..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.1", 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 1c08ee28e417cb50ce9ef9ded5f17163e1bb30d4..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.1", 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 2db16a00e92492e3a167458343a88a24c2186748..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.1", 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/docs/running-relayer.md b/bridges/docs/running-relayer.md index 710810a476e4df5e4b80fde31f9576be5ad26391..594cbc35a106b1ebd8cc1e9e9c0542c759489197 100644 --- a/bridges/docs/running-relayer.md +++ b/bridges/docs/running-relayer.md @@ -139,7 +139,7 @@ your transactions that are **validated** on top of block, where it is active get becomes expired when the block with the number you have specified during registration is "mined". It is the `validTill` parameter of the `register` call (see below). After that `validTill` block, you may unregister and get your reserved funds back. There's also an intermediate point between those blocks - it is the `validTill - LEASE`, -where `LEASE` is the the chain constant, controlled by the governance. Initially it is set to `300` blocks. +where `LEASE` is the chain constant, controlled by the governance. Initially it is set to `300` blocks. All your transactions, **validated** between the `validTill - LEASE` and `validTill` blocks do not get the priority boost. Also, it is forbidden to specify `validTill` such that the `validTill - currentBlock` is less than the `LEASE`. @@ -156,7 +156,7 @@ than the `LEASE`. | 700 | Inactive | Your message delivery transactions are not boosted | | 701 | Inactive | Your message delivery transactions are not boosted | | ... | Inactive | Your message delivery transactions are not boosted | -| 1000 | Expired | Your may submit a tx with the `deregister` call | +| 1000 | Expired | You may submit a tx with the `deregister` call |
@@ -230,7 +230,7 @@ your relayer account. Then: - set the `bridgedChainId` to `bhpd`; -- check the both variants of the `owner` field: `ThisChain` is used to pay for message delivery transactions +- check both variants of the `owner` field: `ThisChain` is used to pay for message delivery transactions and `BridgedChain` is used to pay for message confirmation transactions. If check shows that you have some rewards, you can craft the claim transaction, with similar parameters. diff --git a/bridges/modules/beefy/Cargo.toml b/bridges/modules/beefy/Cargo.toml index 438f32fb146042f2704deb3092381a2b5cc68394..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.1", 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/lib.rs b/bridges/modules/beefy/src/lib.rs index 27c83921021bb4299b18cbf2d3216427f8c89ccc..ccddcde920f694a87ab22042f44d84707982eefe 100644 --- a/bridges/modules/beefy/src/lib.rs +++ b/bridges/modules/beefy/src/lib.rs @@ -316,7 +316,7 @@ pub mod pallet { /// Pallet owner has the right to halt all pallet operations and then resume it. If it is /// `None`, then there are no direct ways to halt/resume pallet operations, but other /// runtime methods may still be used to do that (i.e. `democracy::referendum` to update halt - /// flag directly or calling `halt_operations`). + /// flag directly or calling `set_operating_mode`). #[pallet::storage] pub type PalletOwner, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>; 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 0db1827211a05f715cd1aed0db93da0f52c9d67c..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.1", 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/README.md b/bridges/modules/grandpa/README.md index 4a3099b8afc654bfced296aaa0ead4a5d113eb7f..df63f4aa639f21186932bde6b2a475b3873a6bf7 100644 --- a/bridges/modules/grandpa/README.md +++ b/bridges/modules/grandpa/README.md @@ -87,7 +87,7 @@ It'd be better for anyone (for chain and for submitters) to reject all transacti already known headers to the pallet. This way, we leave block space to other useful transactions and we don't charge concurrent submitters for their honest actions. -To deal with that, we have a [signed extension](./src/call_ext) that may be added to the runtime. +To deal with that, we have a [signed extension](./src/call_ext.rs) that may be added to the runtime. It does exactly what is required - rejects all transactions with already known headers. The submitter pays nothing for such transactions - they're simply removed from the transaction pool, when the block is built. diff --git a/bridges/modules/grandpa/src/benchmarking.rs b/bridges/modules/grandpa/src/benchmarking.rs index 11033373ce478fa9fefb613a1377449bb77daf1d..fb7354e05c06eeeab17363d5671cd8d636ec48f3 100644 --- a/bridges/modules/grandpa/src/benchmarking.rs +++ b/bridges/modules/grandpa/src/benchmarking.rs @@ -70,11 +70,12 @@ const MAX_VOTE_ANCESTRIES_RANGE_END: u32 = // the same with validators - if there are too much validators, let's run benchmarks on subrange fn precommits_range_end, I: 'static>() -> u32 { let max_bridged_authorities = T::BridgedChain::MAX_AUTHORITIES_COUNT; - if max_bridged_authorities > 128 { + let max_bridged_authorities = if max_bridged_authorities > 128 { sp_std::cmp::max(128, max_bridged_authorities / 5) } else { max_bridged_authorities }; + required_justification_precommits(max_bridged_authorities) } @@ -138,5 +139,19 @@ benchmarks_instance_pallet! { assert!(!>::contains_key(genesis_header.hash())); } + force_set_pallet_state { + let set_id = 100; + let authorities = accounts(T::BridgedChain::MAX_AUTHORITIES_COUNT as u16) + .iter() + .map(|id| (AuthorityId::from(*id), 1)) + .collect::>(); + let (header, _) = prepare_benchmark_data::(1, 1); + let expected_hash = header.hash(); + }: force_set_pallet_state(RawOrigin::Root, set_id, authorities, Box::new(header)) + verify { + assert_eq!(>::get().unwrap().1, expected_hash); + assert_eq!(>::get().set_id, set_id); + } + impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime) } diff --git a/bridges/modules/grandpa/src/call_ext.rs b/bridges/modules/grandpa/src/call_ext.rs index 98fbeaa30bbac4c6bade6dc4b7d2f97d53940c6b..f08eb4c5d1ab5ae231afc388dacb0699d58fbc46 100644 --- a/bridges/modules/grandpa/src/call_ext.rs +++ b/bridges/modules/grandpa/src/call_ext.rs @@ -18,12 +18,8 @@ use crate::{ weights::WeightInfo, BestFinalized, BridgedBlockNumber, BridgedHeader, Config, CurrentAuthoritySet, Error, FreeHeadersRemaining, Pallet, }; -use bp_header_chain::{ - justification::GrandpaJustification, max_expected_submit_finality_proof_arguments_size, - ChainWithGrandpa, GrandpaConsensusLogReader, -}; +use bp_header_chain::{justification::GrandpaJustification, submit_finality_proof_limits_extras}; use bp_runtime::{BlockNumberOf, Chain, OwnedBridgeModule}; -use codec::Encode; use frame_support::{ dispatch::CallableCallFor, traits::{Get, IsSubType}, @@ -303,53 +299,31 @@ pub(crate) fn submit_finality_proof_info_from_args, I: 'static>( current_set_id: Option, is_free_execution_expected: bool, ) -> SubmitFinalityProofInfo> { - let block_number = *finality_target.number(); - - // the `submit_finality_proof` call will reject justifications with invalid, duplicate, - // unknown and extra signatures. It'll also reject justifications with less than necessary - // signatures. So we do not care about extra weight because of additional signatures here. - let precommits_len = justification.commit.precommits.len().saturated_into(); - let required_precommits = precommits_len; + // check if call exceeds limits. In other words - whether some size or weight is included + // in the call + let extras = + submit_finality_proof_limits_extras::(finality_target, justification); // We do care about extra weight because of more-than-expected headers in the votes // ancestries. But we have problems computing extra weight for additional headers (weight of // additional header is too small, so that our benchmarks aren't detecting that). So if there // are more than expected headers in votes ancestries, we will treat the whole call weight // as an extra weight. - let votes_ancestries_len = justification.votes_ancestries.len().saturated_into(); - let extra_weight = - if votes_ancestries_len > T::BridgedChain::REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY { - T::WeightInfo::submit_finality_proof(precommits_len, votes_ancestries_len) - } else { - Weight::zero() - }; - - // check if the `finality_target` is a mandatory header. If so, we are ready to refund larger - // size - let is_mandatory_finality_target = - GrandpaConsensusLogReader::>::find_scheduled_change( - finality_target.digest(), - ) - .is_some(); - - // we can estimate extra call size easily, without any additional significant overhead - let actual_call_size: u32 = finality_target - .encoded_size() - .saturating_add(justification.encoded_size()) - .saturated_into(); - let max_expected_call_size = max_expected_submit_finality_proof_arguments_size::( - is_mandatory_finality_target, - required_precommits, - ); - let extra_size = actual_call_size.saturating_sub(max_expected_call_size); + let extra_weight = if extras.is_weight_limit_exceeded { + let precommits_len = justification.commit.precommits.len().saturated_into(); + let votes_ancestries_len = justification.votes_ancestries.len().saturated_into(); + T::WeightInfo::submit_finality_proof(precommits_len, votes_ancestries_len) + } else { + Weight::zero() + }; SubmitFinalityProofInfo { - block_number, + block_number: *finality_target.number(), current_set_id, - is_mandatory: is_mandatory_finality_target, + is_mandatory: extras.is_mandatory_finality_target, is_free_execution_expected, extra_weight, - extra_size, + extra_size: extras.extra_size, } } diff --git a/bridges/modules/grandpa/src/lib.rs b/bridges/modules/grandpa/src/lib.rs index a927882aaaa27210c4777fa2e99a109b4d8b500b..c62951b74656b052d4858dec2af1393e41553029 100644 --- a/bridges/modules/grandpa/src/lib.rs +++ b/bridges/modules/grandpa/src/lib.rs @@ -44,7 +44,7 @@ use bp_header_chain::{ }; use bp_runtime::{BlockNumberOf, HashOf, HasherOf, HeaderId, HeaderOf, OwnedBridgeModule}; use frame_support::{dispatch::PostDispatchInfo, ensure, DefaultNoBound}; -use sp_consensus_grandpa::SetId; +use sp_consensus_grandpa::{AuthorityList, SetId}; use sp_runtime::{ traits::{Header as HeaderT, Zero}, SaturatedConversion, @@ -360,6 +360,42 @@ pub mod pallet { Ok(PostDispatchInfo { actual_weight: Some(actual_weight), pays_fee }) } + + /// Set current authorities set and best finalized bridged header to given values + /// (almost) without any checks. This call can fail only if: + /// + /// - the call origin is not a root or a pallet owner; + /// + /// - there are too many authorities in the new set. + /// + /// No other checks are made. Previously imported headers stay in the storage and + /// are still accessible after the call. + #[pallet::call_index(5)] + #[pallet::weight(T::WeightInfo::force_set_pallet_state())] + pub fn force_set_pallet_state( + origin: OriginFor, + new_current_set_id: SetId, + new_authorities: AuthorityList, + new_best_header: Box>, + ) -> DispatchResult { + Self::ensure_owner_or_root(origin)?; + + // save new authorities set. It only fails if there are too many authorities + // in the new set + save_authorities_set::( + CurrentAuthoritySet::::get().set_id, + new_current_set_id, + new_authorities, + )?; + + // save new best header. It may be older than the best header that is already + // known to the pallet - it changes nothing (except for the fact that previously + // imported headers may still be used to prove something) + let new_best_header_hash = new_best_header.hash(); + insert_header::(*new_best_header, new_best_header_hash); + + Ok(()) + } } /// Number of free header submissions that we may yet accept in the current block. @@ -423,7 +459,7 @@ pub mod pallet { /// Pallet owner has a right to halt all pallet operations and then resume it. If it is /// `None`, then there are no direct ways to halt/resume pallet operations, but other /// runtime methods may still be used to do that (i.e. democracy::referendum to update halt - /// flag directly or call the `halt_operations`). + /// flag directly or call the `set_operating_mode`). #[pallet::storage] pub type PalletOwner, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>; @@ -592,33 +628,45 @@ pub mod pallet { // GRANDPA only includes a `delay` for forced changes, so this isn't valid. ensure!(change.delay == Zero::zero(), >::UnsupportedScheduledChange); - // TODO [#788]: Stop manually increasing the `set_id` here. - let next_authorities = StoredAuthoritySet:: { - authorities: change - .next_authorities - .try_into() - .map_err(|_| Error::::TooManyAuthoritiesInSet)?, - set_id: current_set_id + 1, - }; - // Since our header schedules a change and we know the delay is 0, it must also enact // the change. - >::put(&next_authorities); - - log::info!( - target: LOG_TARGET, - "Transitioned from authority set {} to {}! New authorities are: {:?}", + // TODO [#788]: Stop manually increasing the `set_id` here. + return save_authorities_set::( current_set_id, current_set_id + 1, - next_authorities, + change.next_authorities, ); - - return Ok(Some(next_authorities.into())) }; Ok(None) } + /// Save new authorities set. + pub(crate) fn save_authorities_set, I: 'static>( + old_current_set_id: SetId, + new_current_set_id: SetId, + new_authorities: AuthorityList, + ) -> Result, DispatchError> { + let next_authorities = StoredAuthoritySet:: { + authorities: new_authorities + .try_into() + .map_err(|_| Error::::TooManyAuthoritiesInSet)?, + set_id: new_current_set_id, + }; + + >::put(&next_authorities); + + log::info!( + target: LOG_TARGET, + "Transitioned from authority set {} to {}! New authorities are: {:?}", + old_current_set_id, + new_current_set_id, + next_authorities, + ); + + Ok(Some(next_authorities.into())) + } + /// Verify a GRANDPA justification (finality proof) for a given header. /// /// Will use the GRANDPA current authorities known to the pallet. @@ -1395,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, ); }); @@ -1417,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(|_| ())); }); } @@ -1700,4 +1749,98 @@ mod tests { assert_eq!(FreeHeadersRemaining::::get(), Some(0)); }) } + + #[test] + fn force_set_pallet_state_works() { + run_test(|| { + let header25 = test_header(25); + let header50 = test_header(50); + let ok_new_set_id = 100; + let ok_new_authorities = authority_list(); + let bad_new_set_id = 100; + let bad_new_authorities: Vec<_> = std::iter::repeat((ALICE.into(), 1)) + .take(MAX_BRIDGED_AUTHORITIES as usize + 1) + .collect(); + + // initialize and import several headers + initialize_substrate_bridge(); + assert_ok!(submit_finality_proof(30)); + + // wrong origin => error + assert_noop!( + Pallet::::force_set_pallet_state( + RuntimeOrigin::signed(1), + ok_new_set_id, + ok_new_authorities.clone(), + Box::new(header50.clone()), + ), + DispatchError::BadOrigin, + ); + + // too many authorities in the set => error + assert_noop!( + Pallet::::force_set_pallet_state( + RuntimeOrigin::root(), + bad_new_set_id, + bad_new_authorities.clone(), + Box::new(header50.clone()), + ), + Error::::TooManyAuthoritiesInSet, + ); + + // force import header 50 => ok + assert_ok!(Pallet::::force_set_pallet_state( + RuntimeOrigin::root(), + ok_new_set_id, + ok_new_authorities.clone(), + Box::new(header50.clone()), + ),); + + // force import header 25 after 50 => ok + assert_ok!(Pallet::::force_set_pallet_state( + RuntimeOrigin::root(), + ok_new_set_id, + ok_new_authorities.clone(), + Box::new(header25.clone()), + ),); + + // we may import better headers + assert_noop!(submit_finality_proof(20), Error::::OldHeader); + assert_ok!(submit_finality_proof_with_set_id(26, ok_new_set_id)); + + // we can even reimport header #50. It **will cause** some issues during pruning + // (see below) + assert_ok!(submit_finality_proof_with_set_id(50, ok_new_set_id)); + + // and all headers are available. Even though there are 4 headers, the ring + // buffer thinks that there are 5, because we've imported header $50 twice + assert!(GrandpaChainHeaders::::finalized_header_state_root( + test_header(30).hash() + ) + .is_some()); + assert!(GrandpaChainHeaders::::finalized_header_state_root( + test_header(50).hash() + ) + .is_some()); + assert!(GrandpaChainHeaders::::finalized_header_state_root( + test_header(25).hash() + ) + .is_some()); + assert!(GrandpaChainHeaders::::finalized_header_state_root( + test_header(26).hash() + ) + .is_some()); + + // next header import will prune header 30 + assert_ok!(submit_finality_proof_with_set_id(70, ok_new_set_id)); + // next header import will prune header 50 + assert_ok!(submit_finality_proof_with_set_id(80, ok_new_set_id)); + // next header import will prune header 25 + assert_ok!(submit_finality_proof_with_set_id(90, ok_new_set_id)); + // next header import will prune header 26 + assert_ok!(submit_finality_proof_with_set_id(100, ok_new_set_id)); + // next header import will prune header 50 again. But it is fine + assert_ok!(submit_finality_proof_with_set_id(110, ok_new_set_id)); + }); + } } 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/grandpa/src/weights.rs b/bridges/modules/grandpa/src/weights.rs index a75e7b5a8e4ada8ce880a040492c904d8035642c..9719bc9c022e2f082307ddf49fc02eb70f4c3497 100644 --- a/bridges/modules/grandpa/src/weights.rs +++ b/bridges/modules/grandpa/src/weights.rs @@ -51,6 +51,7 @@ use sp_std::marker::PhantomData; /// Weight functions needed for pallet_bridge_grandpa. pub trait WeightInfo { fn submit_finality_proof(p: u32, v: u32) -> Weight; + fn force_set_pallet_state() -> Weight; } /// Weights for `pallet_bridge_grandpa` that are generated using one of the Bridge testnets. @@ -109,6 +110,30 @@ impl WeightInfo for BridgeWeight { .saturating_add(T::DbWeight::get().reads(6_u64)) .saturating_add(T::DbWeight::get().writes(6_u64)) } + + /// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: + /// Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: + /// Some(4), added: 499, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHashes` + /// (r:1 w:1) Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), + /// `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1) + /// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), + /// added: 531, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 + /// w:2) Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: + /// Some(68), added: 1553, mode: `MaxEncodedLen`) + fn force_set_pallet_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `452` + // Estimated: `51735` + // Minimum execution time: 62_232_000 picoseconds. + Weight::from_parts(78_755_000, 0) + .saturating_add(Weight::from_parts(0, 51735)) + .saturating_add(RocksDbWeight::get().reads(3)) + .saturating_add(RocksDbWeight::get().writes(6)) + } } // For backwards compatibility and tests @@ -164,4 +189,28 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads(6_u64)) .saturating_add(RocksDbWeight::get().writes(6_u64)) } + + /// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: + /// Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: + /// Some(4), added: 499, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHashes` + /// (r:1 w:1) Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), + /// `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1) + /// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), + /// added: 531, mode: `MaxEncodedLen`) Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 + /// w:2) Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: + /// Some(68), added: 1553, mode: `MaxEncodedLen`) + fn force_set_pallet_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `452` + // Estimated: `51735` + // Minimum execution time: 62_232_000 picoseconds. + Weight::from_parts(78_755_000, 0) + .saturating_add(Weight::from_parts(0, 51735)) + .saturating_add(RocksDbWeight::get().reads(3)) + .saturating_add(RocksDbWeight::get().writes(6)) + } } diff --git a/bridges/modules/messages/Cargo.toml b/bridges/modules/messages/Cargo.toml index df5b92db7402bd048b1afca9c13cfb1dddc74863..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.1", 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 fe62305748cd1d6030a7a8085bff29f24ee4dbc5..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 @@ -187,11 +186,13 @@ There may be a special account in every runtime where the messages module is dep owner', is like a module-level sudo account - he's able to halt and resume all module operations without requiring runtime upgrade. Calls that are related to this account are: - `fn set_owner()`: current module owner may call it to transfer "ownership" to another account; -- `fn halt_operations()`: the module owner (or sudo account) may call this function to stop all module operations. After - this call, all message-related transactions will be rejected until further `resume_operations` call'. This call may be - used when something extraordinary happens with the bridge; -- `fn resume_operations()`: module owner may call this function to resume bridge operations. The module will resume its - regular operations after this call. +- `fn set_operating_mode()`: the module owner (or sudo account) may call this function to pause/resume + pallet operations. Owner may halt the pallet by calling this method with + `MessagesOperatingMode::Basic(BasicOperatingMode::Halted)` argument - all message-related + transactions will be rejected. Owner may then resume pallet operations by passing the + `MessagesOperatingMode::Basic(BasicOperatingMode::Normal)` argument. There's also + `MessagesOperatingMode::RejectingOutboundMessages` pallet mode, where it still accepts all incoming + messages, but all outbound messages are rejected. If pallet owner is not defined, the governance may be used to make those calls. 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: crate::Config { /// Return id of relayer account at the bridged chain. /// /// By default, zero account is returned. - fn bridged_relayer_id() -> Self::InboundRelayer { - Self::InboundRelayer::decode(&mut TrailingZeroInput::zeroes()).unwrap() + fn bridged_relayer_id() -> AccountIdOf> { + Decode::decode(&mut TrailingZeroInput::zeroes()).unwrap() } /// Create given account and give it enough balance for test purposes. Used to create @@ -94,11 +97,11 @@ pub trait Config: crate::Config { /// Prepare messages proof to receive by the module. fn prepare_message_proof( params: MessageProofParams, - ) -> (::MessagesProof, Weight); + ) -> (FromBridgedChainMessagesProof>>, Weight); /// Prepare messages delivery proof to receive by the module. fn prepare_message_delivery_proof( params: MessageDeliveryProofParams, - ) -> >::MessagesDeliveryProof; + ) -> FromBridgedChainMessagesDeliveryProof>>; /// Returns true if message has been successfully dispatched or not. fn is_message_successfully_dispatched(_nonce: MessageNonce) -> bool { @@ -109,174 +112,227 @@ pub trait Config: crate::Config { fn is_relayer_rewarded(relayer: &Self::AccountId) -> bool; } -benchmarks_instance_pallet! { +fn send_regular_message, I: 'static>() { + let mut outbound_lane = outbound_lane::(T::bench_lane_id()); + outbound_lane.send_message(BoundedVec::try_from(vec![]).expect("We craft valid messages")); +} + +fn receive_messages, I: 'static>(nonce: MessageNonce) { + let mut inbound_lane_storage = + RuntimeInboundLaneStorage::::from_lane_id(T::bench_lane_id()); + inbound_lane_storage.set_data(InboundLaneData { + relayers: vec![UnrewardedRelayer { + relayer: T::bridged_relayer_id(), + messages: DeliveredMessages::new(nonce), + }] + .into_iter() + .collect(), + last_confirmed_nonce: 0, + }); +} + +struct ReceiveMessagesProofSetup, I: 'static> { + relayer_id_on_src: AccountIdOf>, + relayer_id_on_tgt: T::AccountId, + msgs_count: u32, + _phantom_data: sp_std::marker::PhantomData, +} + +impl, I: 'static> ReceiveMessagesProofSetup { + const LATEST_RECEIVED_NONCE: MessageNonce = 20; + + fn new(msgs_count: u32) -> Self { + let setup = Self { + relayer_id_on_src: T::bridged_relayer_id(), + relayer_id_on_tgt: account("relayer", 0, SEED), + msgs_count, + _phantom_data: Default::default(), + }; + T::endow_account(&setup.relayer_id_on_tgt); + // mark messages 1..=latest_recvd_nonce as delivered + receive_messages::(Self::LATEST_RECEIVED_NONCE); + + setup + } + + fn relayer_id_on_src(&self) -> AccountIdOf> { + self.relayer_id_on_src.clone() + } + + fn relayer_id_on_tgt(&self) -> T::AccountId { + self.relayer_id_on_tgt.clone() + } + + fn last_nonce(&self) -> MessageNonce { + Self::LATEST_RECEIVED_NONCE + self.msgs_count as u64 + } + + fn nonces(&self) -> RangeInclusive { + (Self::LATEST_RECEIVED_NONCE + 1)..=self.last_nonce() + } + + fn check_last_nonce(&self) { + assert_eq!( + crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), + self.last_nonce(), + ); + } +} + +#[instance_benchmarks] +mod benchmarks { + use super::*; + // // Benchmarks that are used directly by the runtime calls weight formulae. // - // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following conditions: + fn max_msgs, I: 'static>() -> u32 { + T::BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX as u32 - + ReceiveMessagesProofSetup::::LATEST_RECEIVED_NONCE as u32 + } + + // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following + // conditions: // * proof does not include outbound lane state proof; // * inbound lane already has state, so it needs to be read and decoded; // * message is dispatched (reminder: dispatch weight should be minimal); // * message requires all heavy checks done by dispatcher. - // - // This is base benchmark for all other message delivery benchmarks. - receive_single_message_proof { - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - + #[benchmark] + fn receive_single_message_proof() { + // setup code + let setup = ReceiveMessagesProofSetup::::new(1); let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { lane: T::bench_lane_id(), - message_nonces: 21..=21, + message_nonces: setup.nonces(), outbound_lane_data: None, is_successful_dispatch_expected: false, - size: StorageProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH), + proof_params: UnverifiedStorageProofParams::from_db_size( + EXPECTED_DEFAULT_MESSAGE_LENGTH, + ), }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight) - verify { - assert_eq!( - crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), - 21, + + #[extrinsic_call] + receive_messages_proof( + RawOrigin::Signed(setup.relayer_id_on_tgt()), + setup.relayer_id_on_src(), + Box::new(proof), + setup.msgs_count, + dispatch_weight, ); + + // verification code + setup.check_last_nonce(); } - // Benchmark `receive_messages_proof` extrinsic with two minimal-weight messages and following conditions: + // Benchmark `receive_messages_proof` extrinsic with `n` minimal-weight messages and following + // conditions: // * proof does not include outbound lane state proof; // * inbound lane already has state, so it needs to be read and decoded; // * message is dispatched (reminder: dispatch weight should be minimal); // * message requires all heavy checks done by dispatcher. - // - // The weight of single message delivery could be approximated as - // `weight(receive_two_messages_proof) - weight(receive_single_message_proof)`. - // This won't be super-accurate if message has non-zero dispatch weight, but estimation should - // be close enough to real weight. - receive_two_messages_proof { - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - + #[benchmark] + fn receive_n_messages_proof(n: Linear<1, { max_msgs::() }>) { + // setup code + let setup = ReceiveMessagesProofSetup::::new(n); let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { lane: T::bench_lane_id(), - message_nonces: 21..=22, + message_nonces: setup.nonces(), outbound_lane_data: None, is_successful_dispatch_expected: false, - size: StorageProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH), + proof_params: UnverifiedStorageProofParams::from_db_size( + EXPECTED_DEFAULT_MESSAGE_LENGTH, + ), }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 2, dispatch_weight) - verify { - assert_eq!( - crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), - 22, + + #[extrinsic_call] + receive_messages_proof( + RawOrigin::Signed(setup.relayer_id_on_tgt()), + setup.relayer_id_on_src(), + Box::new(proof), + setup.msgs_count, + dispatch_weight, ); + + // verification code + setup.check_last_nonce(); } - // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following conditions: + // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following + // conditions: // * proof includes outbound lane state proof; // * inbound lane already has state, so it needs to be read and decoded; // * message is successfully dispatched (reminder: dispatch weight should be minimal); // * message requires all heavy checks done by dispatcher. // // The weight of outbound lane state delivery would be - // `weight(receive_single_message_proof_with_outbound_lane_state) - weight(receive_single_message_proof)`. - // This won't be super-accurate if message has non-zero dispatch weight, but estimation should - // be close enough to real weight. - receive_single_message_proof_with_outbound_lane_state { - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - + // `weight(receive_single_message_proof_with_outbound_lane_state) - + // weight(receive_single_message_proof)`. This won't be super-accurate if message has non-zero + // dispatch weight, but estimation should be close enough to real weight. + #[benchmark] + fn receive_single_message_proof_with_outbound_lane_state() { + // setup code + let setup = ReceiveMessagesProofSetup::::new(1); let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { lane: T::bench_lane_id(), - message_nonces: 21..=21, + message_nonces: setup.nonces(), outbound_lane_data: Some(OutboundLaneData { - oldest_unpruned_nonce: 21, - latest_received_nonce: 20, - latest_generated_nonce: 21, + oldest_unpruned_nonce: setup.last_nonce(), + latest_received_nonce: ReceiveMessagesProofSetup::::LATEST_RECEIVED_NONCE, + latest_generated_nonce: setup.last_nonce(), }), is_successful_dispatch_expected: false, - size: StorageProofSize::Minimal(EXPECTED_DEFAULT_MESSAGE_LENGTH), + proof_params: UnverifiedStorageProofParams::from_db_size( + EXPECTED_DEFAULT_MESSAGE_LENGTH, + ), }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight) - verify { - let lane_state = crate::InboundLanes::::get(&T::bench_lane_id()); - assert_eq!(lane_state.last_delivered_nonce(), 21); - assert_eq!(lane_state.last_confirmed_nonce, 20); - } - - // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following conditions: - // * the proof has large leaf with total size of approximately 1KB; - // * proof does not include outbound lane state proof; - // * inbound lane already has state, so it needs to be read and decoded; - // * message is dispatched (reminder: dispatch weight should be minimal); - // * message requires all heavy checks done by dispatcher. - // - // With single KB of messages proof, the weight of the call is increased (roughly) by - // `(receive_single_message_proof_16KB - receive_single_message_proof_1_kb) / 15`. - receive_single_message_proof_1_kb { - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { - lane: T::bench_lane_id(), - message_nonces: 21..=21, - outbound_lane_data: None, - is_successful_dispatch_expected: false, - size: StorageProofSize::HasLargeLeaf(1024), - }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight) - verify { - assert_eq!( - crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), - 21, + #[extrinsic_call] + receive_messages_proof( + RawOrigin::Signed(setup.relayer_id_on_tgt()), + setup.relayer_id_on_src(), + Box::new(proof), + setup.msgs_count, + dispatch_weight, ); + + // verification code + setup.check_last_nonce(); } - // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following conditions: - // * the proof has large leaf with total size of approximately 16KB; + // Benchmark `receive_messages_proof` extrinsic with single minimal-weight message and following + // conditions: + // * the proof has large leaf with total size ranging between 1KB and 16KB; // * proof does not include outbound lane state proof; // * inbound lane already has state, so it needs to be read and decoded; // * message is dispatched (reminder: dispatch weight should be minimal); // * message requires all heavy checks done by dispatcher. - // - // Size of proof grows because it contains extra trie nodes in it. - // - // With single KB of messages proof, the weight of the call is increased (roughly) by - // `(receive_single_message_proof_16KB - receive_single_message_proof) / 15`. - receive_single_message_proof_16_kb { - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - + #[benchmark] + fn receive_single_n_bytes_message_proof( + /// Proof size in KB + n: Linear<1, { 16 * 1024 }>, + ) { + // setup code + let setup = ReceiveMessagesProofSetup::::new(1); let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { lane: T::bench_lane_id(), - message_nonces: 21..=21, + message_nonces: setup.nonces(), outbound_lane_data: None, is_successful_dispatch_expected: false, - size: StorageProofSize::HasLargeLeaf(16 * 1024), + proof_params: UnverifiedStorageProofParams::from_db_size(n), }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight) - verify { - assert_eq!( - crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), - 21, + + #[extrinsic_call] + receive_messages_proof( + RawOrigin::Signed(setup.relayer_id_on_tgt()), + setup.relayer_id_on_src(), + Box::new(proof), + setup.msgs_count, + dispatch_weight, ); + + // verification code + setup.check_last_nonce(); } // Benchmark `receive_messages_delivery_proof` extrinsic with following conditions: @@ -284,7 +340,8 @@ benchmarks_instance_pallet! { // * relayer account does not exist (in practice it needs to exist in production environment). // // This is base benchmark for all other confirmations delivery benchmarks. - receive_delivery_proof_for_single_message { + #[benchmark] + fn receive_delivery_proof_for_single_message() { let relayer_id: T::AccountId = account("relayer", 0, SEED); // send message that we're going to confirm @@ -302,13 +359,21 @@ benchmarks_instance_pallet! { relayers: vec![UnrewardedRelayer { relayer: relayer_id.clone(), messages: DeliveredMessages::new(1), - }].into_iter().collect(), + }] + .into_iter() + .collect(), last_confirmed_nonce: 0, }, - size: StorageProofSize::Minimal(0), + proof_params: UnverifiedStorageProofParams::default(), }); - }: receive_messages_delivery_proof(RawOrigin::Signed(relayer_id.clone()), proof, relayers_state) - verify { + + #[extrinsic_call] + receive_messages_delivery_proof( + RawOrigin::Signed(relayer_id.clone()), + proof, + relayers_state, + ); + assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 1); assert!(T::is_relayer_rewarded(&relayer_id)); } @@ -320,7 +385,8 @@ benchmarks_instance_pallet! { // Additional weight for paying single-message reward to the same relayer could be computed // as `weight(receive_delivery_proof_for_two_messages_by_single_relayer) // - weight(receive_delivery_proof_for_single_message)`. - receive_delivery_proof_for_two_messages_by_single_relayer { + #[benchmark] + fn receive_delivery_proof_for_two_messages_by_single_relayer() { let relayer_id: T::AccountId = account("relayer", 0, SEED); // send message that we're going to confirm @@ -341,13 +407,21 @@ benchmarks_instance_pallet! { relayers: vec![UnrewardedRelayer { relayer: relayer_id.clone(), messages: delivered_messages, - }].into_iter().collect(), + }] + .into_iter() + .collect(), last_confirmed_nonce: 0, }, - size: StorageProofSize::Minimal(0), + proof_params: UnverifiedStorageProofParams::default(), }); - }: receive_messages_delivery_proof(RawOrigin::Signed(relayer_id.clone()), proof, relayers_state) - verify { + + #[extrinsic_call] + receive_messages_delivery_proof( + RawOrigin::Signed(relayer_id.clone()), + proof, + relayers_state, + ); + assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 2); assert!(T::is_relayer_rewarded(&relayer_id)); } @@ -359,7 +433,8 @@ benchmarks_instance_pallet! { // Additional weight for paying reward to the next relayer could be computed // as `weight(receive_delivery_proof_for_two_messages_by_two_relayers) // - weight(receive_delivery_proof_for_two_messages_by_single_relayer)`. - receive_delivery_proof_for_two_messages_by_two_relayers { + #[benchmark] + fn receive_delivery_proof_for_two_messages_by_two_relayers() { let relayer1_id: T::AccountId = account("relayer1", 1, SEED); let relayer2_id: T::AccountId = account("relayer2", 2, SEED); @@ -385,13 +460,21 @@ benchmarks_instance_pallet! { relayer: relayer2_id.clone(), messages: DeliveredMessages::new(2), }, - ].into_iter().collect(), + ] + .into_iter() + .collect(), last_confirmed_nonce: 0, }, - size: StorageProofSize::Minimal(0), + proof_params: UnverifiedStorageProofParams::default(), }); - }: receive_messages_delivery_proof(RawOrigin::Signed(relayer1_id.clone()), proof, relayers_state) - verify { + + #[extrinsic_call] + receive_messages_delivery_proof( + RawOrigin::Signed(relayer1_id.clone()), + proof, + relayers_state, + ); + assert_eq!(OutboundLanes::::get(T::bench_lane_id()).latest_received_nonce, 2); assert!(T::is_relayer_rewarded(&relayer1_id)); assert!(T::is_relayer_rewarded(&relayer2_id)); @@ -411,51 +494,38 @@ benchmarks_instance_pallet! { // * inbound lane already has state, so it needs to be read and decoded; // * message is **SUCCESSFULLY** dispatched; // * message requires all heavy checks done by dispatcher. - receive_single_message_proof_with_dispatch { - // maybe dispatch weight relies on the message size too? - let i in EXPECTED_DEFAULT_MESSAGE_LENGTH .. EXPECTED_DEFAULT_MESSAGE_LENGTH * 16; - - let relayer_id_on_source = T::bridged_relayer_id(); - let relayer_id_on_target = account("relayer", 0, SEED); - T::endow_account(&relayer_id_on_target); - - // mark messages 1..=20 as delivered - receive_messages::(20); - + #[benchmark] + fn receive_single_n_bytes_message_proof_with_dispatch( + /// Proof size in KB + n: Linear<1, { 16 * 1024 }>, + ) { + // setup code + let setup = ReceiveMessagesProofSetup::::new(1); let (proof, dispatch_weight) = T::prepare_message_proof(MessageProofParams { lane: T::bench_lane_id(), - message_nonces: 21..=21, + message_nonces: setup.nonces(), outbound_lane_data: None, is_successful_dispatch_expected: true, - size: StorageProofSize::Minimal(i), + proof_params: UnverifiedStorageProofParams::from_db_size(n), }); - }: receive_messages_proof(RawOrigin::Signed(relayer_id_on_target), relayer_id_on_source, proof, 1, dispatch_weight) - verify { - assert_eq!( - crate::InboundLanes::::get(&T::bench_lane_id()).last_delivered_nonce(), - 21, - ); - assert!(T::is_message_successfully_dispatched(21)); - } - impl_benchmark_test_suite!(Pallet, crate::mock::new_test_ext(), crate::mock::TestRuntime) -} + #[extrinsic_call] + receive_messages_proof( + RawOrigin::Signed(setup.relayer_id_on_tgt()), + setup.relayer_id_on_src(), + Box::new(proof), + setup.msgs_count, + dispatch_weight, + ); -fn send_regular_message, I: 'static>() { - let mut outbound_lane = outbound_lane::(T::bench_lane_id()); - outbound_lane.send_message(BoundedVec::try_from(vec![]).expect("We craft valid messages")); -} + // verification code + setup.check_last_nonce(); + assert!(T::is_message_successfully_dispatched(setup.last_nonce())); + } -fn receive_messages, I: 'static>(nonce: MessageNonce) { - let mut inbound_lane_storage = - RuntimeInboundLaneStorage::::from_lane_id(T::bench_lane_id()); - inbound_lane_storage.set_data(InboundLaneData { - relayers: vec![UnrewardedRelayer { - relayer: T::bridged_relayer_id(), - messages: DeliveredMessages::new(nonce), - }] - .into_iter() - .collect(), - last_confirmed_nonce: 0, - }); + impl_benchmark_test_suite!( + Pallet, + crate::tests::mock::new_test_ext(), + crate::tests::mock::TestRuntime + ); } diff --git a/bridges/modules/messages/src/inbound_lane.rs b/bridges/modules/messages/src/inbound_lane.rs index da1698e6e0370f9f84ca8dd53bc1ebc99f696017..7ef4599a93c4823a9be7fa918b35c309cea6611a 100644 --- a/bridges/modules/messages/src/inbound_lane.rs +++ b/bridges/modules/messages/src/inbound_lane.rs @@ -16,15 +16,15 @@ //! Everything about incoming messages receival. -use crate::Config; +use crate::{BridgedChainOf, Config}; use bp_messages::{ target_chain::{DispatchMessage, DispatchMessageData, MessageDispatch}, - DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, OutboundLaneData, - ReceptionResult, UnrewardedRelayer, + ChainWithMessages, DeliveredMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, + OutboundLaneData, ReceptionResult, UnrewardedRelayer, }; +use bp_runtime::AccountIdOf; use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; -use frame_support::traits::Get; use scale_info::{Type, TypeInfo}; use sp_runtime::RuntimeDebug; use sp_std::prelude::PartialEq; @@ -55,10 +55,12 @@ pub trait InboundLaneStorage { /// /// The encoding of this type matches encoding of the corresponding `MessageData`. #[derive(Encode, Decode, Clone, RuntimeDebug, PartialEq, Eq)] -pub struct StoredInboundLaneData, I: 'static>(pub InboundLaneData); +pub struct StoredInboundLaneData, I: 'static>( + pub InboundLaneData>>, +); impl, I: 'static> sp_std::ops::Deref for StoredInboundLaneData { - type Target = InboundLaneData; + type Target = InboundLaneData>>; fn deref(&self) -> &Self::Target { &self.0 @@ -78,7 +80,7 @@ impl, I: 'static> Default for StoredInboundLaneData { } impl, I: 'static> From> - for InboundLaneData + for InboundLaneData>> { fn from(data: StoredInboundLaneData) -> Self { data.0 @@ -86,7 +88,7 @@ impl, I: 'static> From> } impl, I: 'static> EncodeLike> - for InboundLaneData + for InboundLaneData>> { } @@ -94,14 +96,14 @@ impl, I: 'static> TypeInfo for StoredInboundLaneData { type Identity = Self; fn type_info() -> Type { - InboundLaneData::::type_info() + InboundLaneData::>>::type_info() } } impl, I: 'static> MaxEncodedLen for StoredInboundLaneData { fn max_encoded_len() -> usize { - InboundLaneData::::encoded_size_hint( - T::MaxUnrewardedRelayerEntriesAtInboundLane::get() as usize, + InboundLaneData::>>::encoded_size_hint( + BridgedChainOf::::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX as usize, ) .unwrap_or(usize::MAX) } @@ -216,10 +218,10 @@ mod tests { use super::*; use crate::{ inbound_lane, - mock::{ + tests::mock::{ dispatch_result, inbound_message_data, inbound_unrewarded_relayers_state, run_test, - unrewarded_relayer, TestMessageDispatch, TestRuntime, REGULAR_PAYLOAD, TEST_LANE_ID, - TEST_RELAYER_A, TEST_RELAYER_B, TEST_RELAYER_C, + unrewarded_relayer, BridgedChain, TestMessageDispatch, TestRuntime, REGULAR_PAYLOAD, + TEST_LANE_ID, TEST_RELAYER_A, TEST_RELAYER_B, TEST_RELAYER_C, }, RuntimeInboundLaneStorage, }; @@ -372,8 +374,7 @@ mod tests { fn fails_to_receive_messages_above_unrewarded_relayer_entries_limit_per_lane() { run_test(|| { let mut lane = inbound_lane::(TEST_LANE_ID); - let max_nonce = - ::MaxUnrewardedRelayerEntriesAtInboundLane::get(); + let max_nonce = BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX; for current_nonce in 1..max_nonce + 1 { assert_eq!( lane.receive_message::( @@ -409,7 +410,7 @@ mod tests { fn fails_to_receive_messages_above_unconfirmed_messages_limit_per_lane() { run_test(|| { let mut lane = inbound_lane::(TEST_LANE_ID); - let max_nonce = ::MaxUnconfirmedMessagesAtInboundLane::get(); + let max_nonce = BridgedChain::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX; for current_nonce in 1..=max_nonce { assert_eq!( lane.receive_message::( diff --git a/bridges/modules/messages/src/lib.rs b/bridges/modules/messages/src/lib.rs index bc00db9eba5ba12dbdaa0de7008f293a727a7ef5..c36313a147644aa61a8efb900dcc35bbf630ceae 100644 --- a/bridges/modules/messages/src/lib.rs +++ b/bridges/modules/messages/src/lib.rs @@ -41,8 +41,8 @@ pub use outbound_lane::StoredMessagePayload; pub use weights::WeightInfo; pub use weights_ext::{ ensure_able_to_receive_confirmation, ensure_able_to_receive_message, - ensure_weights_are_correct, WeightInfoExt, EXPECTED_DEFAULT_MESSAGE_LENGTH, - EXTRA_STORAGE_PROOF_SIZE, + ensure_maximal_message_dispatch, ensure_weights_are_correct, WeightInfoExt, + EXPECTED_DEFAULT_MESSAGE_LENGTH, EXTRA_STORAGE_PROOF_SIZE, }; use crate::{ @@ -50,28 +50,32 @@ use crate::{ outbound_lane::{OutboundLane, OutboundLaneStorage, ReceptionConfirmationError}, }; +use bp_header_chain::HeaderChain; use bp_messages::{ source_chain::{ - DeliveryConfirmationPayments, OnMessagesDelivered, SendMessageArtifacts, TargetHeaderChain, + DeliveryConfirmationPayments, FromBridgedChainMessagesDeliveryProof, OnMessagesDelivered, + SendMessageArtifacts, }, target_chain::{ - DeliveryPayments, DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages, - SourceHeaderChain, + DeliveryPayments, DispatchMessage, FromBridgedChainMessagesProof, MessageDispatch, + ProvedLaneMessages, ProvedMessages, }, - DeliveredMessages, InboundLaneData, InboundMessageDetails, LaneId, MessageKey, MessageNonce, - MessagePayload, MessagesOperatingMode, OutboundLaneData, OutboundMessageDetails, - UnrewardedRelayersState, VerificationError, + ChainWithMessages, DeliveredMessages, InboundLaneData, InboundMessageDetails, LaneId, + MessageKey, MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData, + OutboundMessageDetails, UnrewardedRelayersState, VerificationError, }; use bp_runtime::{ - BasicOperatingMode, ChainId, OwnedBridgeModule, PreComputedSize, RangeInclusiveExt, Size, + AccountIdOf, BasicOperatingMode, HashOf, OwnedBridgeModule, PreComputedSize, RangeInclusiveExt, + Size, }; use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{dispatch::PostDispatchInfo, ensure, fail, traits::Get, DefaultNoBound}; -use sp_runtime::traits::UniqueSaturatedFrom; use sp_std::{marker::PhantomData, prelude::*}; mod inbound_lane; mod outbound_lane; +mod proofs; +mod tests; mod weights_ext; pub mod weights; @@ -79,10 +83,9 @@ pub mod weights; #[cfg(feature = "runtime-benchmarks")] pub mod benchmarking; -#[cfg(test)] -mod mock; - pub use pallet::*; +#[cfg(feature = "test-helpers")] +pub use tests::*; /// The target that will be used when publishing logs related to this pallet. pub const LOG_TARGET: &str = "runtime::bridge-messages"; @@ -105,76 +108,39 @@ pub mod pallet { /// Benchmarks results from runtime we're plugged into. type WeightInfo: WeightInfoExt; - /// Gets the chain id value from the instance. - #[pallet::constant] - type BridgedChainId: Get; + /// This chain type. + type ThisChain: ChainWithMessages; + /// Bridged chain type. + type BridgedChain: ChainWithMessages; + /// Bridged chain headers provider. + type BridgedHeaderChain: HeaderChain; /// Get all active outbound lanes that the message pallet is serving. type ActiveOutboundLanes: Get<&'static [LaneId]>; - /// Maximal number of unrewarded relayer entries at inbound lane. Unrewarded means that the - /// relayer has delivered messages, but either confirmations haven't been delivered back to - /// the source chain, or we haven't received reward confirmations yet. - /// - /// This constant limits maximal number of entries in the `InboundLaneData::relayers`. Keep - /// in mind that the same relayer account may take several (non-consecutive) entries in this - /// set. - type MaxUnrewardedRelayerEntriesAtInboundLane: Get; - /// Maximal number of unconfirmed messages at inbound lane. Unconfirmed means that the - /// message has been delivered, but either confirmations haven't been delivered back to the - /// source chain, or we haven't received reward confirmations for these messages yet. - /// - /// This constant limits difference between last message from last entry of the - /// `InboundLaneData::relayers` and first message at the first entry. - /// - /// There is no point of making this parameter lesser than - /// MaxUnrewardedRelayerEntriesAtInboundLane, because then maximal number of relayer entries - /// will be limited by maximal number of messages. - /// - /// This value also represents maximal number of messages in single delivery transaction. - /// Transaction that is declaring more messages than this value, will be rejected. Even if - /// these messages are from different lanes. - type MaxUnconfirmedMessagesAtInboundLane: Get; - - /// Maximal encoded size of the outbound payload. - #[pallet::constant] - type MaximalOutboundPayloadSize: Get; + /// Payload type of outbound messages. This payload is dispatched on the bridged chain. type OutboundPayload: Parameter + Size; - /// Payload type of inbound messages. This payload is dispatched on this chain. type InboundPayload: Decode; - /// Identifier of relayer that deliver messages to this chain. Relayer reward is paid on the - /// bridged chain. - type InboundRelayer: Parameter + MaxEncodedLen; - /// Delivery payments. - type DeliveryPayments: DeliveryPayments; - // Types that are used by outbound_lane (on source chain). - - /// Target header chain. - type TargetHeaderChain: TargetHeaderChain; - /// Delivery confirmation payments. + /// Handler for relayer payments that happen during message delivery transaction. + type DeliveryPayments: DeliveryPayments; + /// Handler for relayer payments that happen during message delivery confirmation + /// transaction. type DeliveryConfirmationPayments: DeliveryConfirmationPayments; /// Delivery confirmation callback. type OnMessagesDelivered: OnMessagesDelivered; - // Types that are used by inbound_lane (on target chain). - - /// Source header chain, as it is represented on target chain. - type SourceHeaderChain: SourceHeaderChain; - /// Message dispatch. + /// Message dispatch handler. type MessageDispatch: MessageDispatch; } - /// Shortcut to messages proof type for Config. - pub type MessagesProofOf = - <>::SourceHeaderChain as SourceHeaderChain>::MessagesProof; - /// Shortcut to messages delivery proof type for Config. - pub type MessagesDeliveryProofOf = - <>::TargetHeaderChain as TargetHeaderChain< - >::OutboundPayload, - ::AccountId, - >>::MessagesDeliveryProof; + /// Shortcut to this chain type for Config. + pub type ThisChainOf = >::ThisChain; + /// Shortcut to bridged chain type for Config. + pub type BridgedChainOf = >::BridgedChain; + /// Shortcut to bridged header chain type for Config. + pub type BridgedHeaderChainOf = >::BridgedHeaderChain; #[pallet::pallet] pub struct Pallet(PhantomData<(T, I)>); @@ -186,40 +152,6 @@ pub mod pallet { type OperatingModeStorage = PalletOperatingMode; } - #[pallet::hooks] - impl, I: 'static> Hooks> for Pallet - where - u32: TryFrom>, - { - fn on_idle(_block: BlockNumberFor, remaining_weight: Weight) -> Weight { - // we'll need at least to read outbound lane state, kill a message and update lane state - let db_weight = T::DbWeight::get(); - if !remaining_weight.all_gte(db_weight.reads_writes(1, 2)) { - return Weight::zero() - } - - // messages from lane with index `i` in `ActiveOutboundLanes` are pruned when - // `System::block_number() % lanes.len() == i`. Otherwise we need to read lane states on - // every block, wasting the whole `remaining_weight` for nothing and causing starvation - // of the last lane pruning - let active_lanes = T::ActiveOutboundLanes::get(); - let active_lanes_len = (active_lanes.len() as u32).into(); - let active_lane_index = u32::unique_saturated_from( - frame_system::Pallet::::block_number() % active_lanes_len, - ); - let active_lane_id = active_lanes[active_lane_index as usize]; - - // first db read - outbound lane state - let mut active_lane = outbound_lane::(active_lane_id); - let mut used_weight = db_weight.reads(1); - // and here we'll have writes - used_weight += active_lane.prune_messages(db_weight, remaining_weight - used_weight); - - // we already checked we have enough `remaining_weight` to cover this `used_weight` - used_weight - } - } - #[pallet::call] impl, I: 'static> Pallet { /// Change `PalletOwner`. @@ -265,11 +197,11 @@ pub mod pallet { /// The call may succeed, but some messages may not be delivered e.g. if they are not fit /// into the unrewarded relayers vector. #[pallet::call_index(2)] - #[pallet::weight(T::WeightInfo::receive_messages_proof_weight(proof, *messages_count, *dispatch_weight))] + #[pallet::weight(T::WeightInfo::receive_messages_proof_weight(&**proof, *messages_count, *dispatch_weight))] pub fn receive_messages_proof( origin: OriginFor, - relayer_id_at_bridged_chain: T::InboundRelayer, - proof: MessagesProofOf, + relayer_id_at_bridged_chain: AccountIdOf>, + proof: Box>>>, messages_count: u32, dispatch_weight: Weight, ) -> DispatchResultWithPostInfo { @@ -278,7 +210,8 @@ pub mod pallet { // reject transactions that are declaring too many messages ensure!( - MessageNonce::from(messages_count) <= T::MaxUnconfirmedMessagesAtInboundLane::get(), + MessageNonce::from(messages_count) <= + BridgedChainOf::::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX, Error::::TooManyMessagesInTheProof ); @@ -296,22 +229,19 @@ pub mod pallet { // The DeclaredWeight is exactly what's computed here. Unfortunately it is impossible // to get pre-computed value (and it has been already computed by the executive). let declared_weight = T::WeightInfo::receive_messages_proof_weight( - &proof, + &*proof, messages_count, dispatch_weight, ); let mut actual_weight = declared_weight; // verify messages proof && convert proof into messages - let messages = verify_and_decode_messages_proof::< - T::SourceHeaderChain, - T::InboundPayload, - >(proof, messages_count) - .map_err(|err| { - log::trace!(target: LOG_TARGET, "Rejecting invalid messages proof: {:?}", err,); + let messages = verify_and_decode_messages_proof::(*proof, messages_count) + .map_err(|err| { + log::trace!(target: LOG_TARGET, "Rejecting invalid messages proof: {:?}", err,); - Error::::InvalidMessagesProof - })?; + Error::::InvalidMessagesProof + })?; // dispatch messages and (optionally) update lane(s) state(s) let mut total_messages = 0; @@ -424,14 +354,14 @@ pub mod pallet { ))] pub fn receive_messages_delivery_proof( origin: OriginFor, - proof: MessagesDeliveryProofOf, + proof: FromBridgedChainMessagesDeliveryProof>>, mut relayers_state: UnrewardedRelayersState, ) -> DispatchResultWithPostInfo { Self::ensure_not_halted().map_err(Error::::BridgeModule)?; let proof_size = proof.size(); let confirmation_relayer = ensure_signed(origin)?; - let (lane_id, lane_data) = T::TargetHeaderChain::verify_messages_delivery_proof(proof) + let (lane_id, lane_data) = proofs::verify_messages_delivery_proof::(proof) .map_err(|err| { log::trace!( target: LOG_TARGET, @@ -542,8 +472,6 @@ pub mod pallet { InactiveOutboundLane, /// The inbound message dispatcher is inactive. MessageDispatchInactive, - /// Message has been treated as invalid by chain verifier. - MessageRejectedByChainVerifier(VerificationError), /// Message has been treated as invalid by the pallet logic. MessageRejectedByPallet(VerificationError), /// Submitter has failed to pay fee for delivering and dispatching messages. @@ -573,7 +501,7 @@ pub mod pallet { /// Pallet owner has a right to halt all pallet operations and then resume it. If it is /// `None`, then there are no direct ways to halt/resume pallet operations, but other /// runtime methods may still be used to do that (i.e. democracy::referendum to update halt - /// flag directly or call the `halt_operations`). + /// flag directly or call the `set_operating_mode`). #[pallet::storage] #[pallet::getter(fn module_owner)] pub type PalletOwner, I: 'static = ()> = StorageValue<_, T::AccountId>; @@ -647,6 +575,14 @@ pub mod pallet { } } + #[pallet::hooks] + impl, I: 'static> Hooks> for Pallet { + #[cfg(feature = "try-runtime")] + fn try_state(_n: BlockNumberFor) -> Result<(), sp_runtime::TryRuntimeError> { + Self::do_try_state() + } + } + impl, I: 'static> Pallet { /// Get stored data of the outbound message with given nonce. pub fn outbound_message_data(lane: LaneId, nonce: MessageNonce) -> Option { @@ -674,11 +610,65 @@ pub mod pallet { } /// Return inbound lane data. - pub fn inbound_lane_data(lane: LaneId) -> InboundLaneData { + pub fn inbound_lane_data( + lane: LaneId, + ) -> InboundLaneData>> { InboundLanes::::get(lane).0 } } + #[cfg(any(feature = "try-runtime", test))] + impl, I: 'static> Pallet { + /// Ensure the correctness of the state of this pallet. + pub fn do_try_state() -> Result<(), sp_runtime::TryRuntimeError> { + Self::do_try_state_for_outbound_lanes() + } + + /// Ensure the correctness of the state of outbound lanes. + pub fn do_try_state_for_outbound_lanes() -> Result<(), sp_runtime::TryRuntimeError> { + use sp_runtime::traits::One; + use sp_std::vec::Vec; + + // collect unpruned lanes + let mut unpruned_lanes = Vec::new(); + for (lane_id, lane_data) in OutboundLanes::::iter() { + let Some(expected_last_prunned_nonce) = + lane_data.oldest_unpruned_nonce.checked_sub(One::one()) + else { + continue; + }; + + // collect message_nonces that were supposed to be pruned + let mut unpruned_message_nonces = Vec::new(); + const MAX_MESSAGES_ITERATION: u64 = 16; + let start_nonce = + expected_last_prunned_nonce.checked_sub(MAX_MESSAGES_ITERATION).unwrap_or(0); + for current_nonce in start_nonce..=expected_last_prunned_nonce { + // check a message for current_nonce + if OutboundMessages::::contains_key(MessageKey { + lane_id, + nonce: current_nonce, + }) { + unpruned_message_nonces.push(current_nonce); + } + } + + if !unpruned_message_nonces.is_empty() { + log::warn!( + target: LOG_TARGET, + "do_try_state_for_outbound_lanes for lane_id: {lane_id:?} with lane_data: {lane_data:?} found unpruned_message_nonces: {unpruned_message_nonces:?}", + ); + unpruned_lanes.push((lane_id, lane_data, unpruned_message_nonces)); + } + } + + // ensure messages before `oldest_unpruned_nonce` are really pruned. + ensure!(unpruned_lanes.is_empty(), "Found unpruned lanes!"); + + Ok(()) + } + } + /// Get-parameter that returns number of active outbound lanes that the pallet maintains. pub struct MaybeOutboundLanesCount(PhantomData<(T, I)>); @@ -714,18 +704,6 @@ where // let's check if outbound lane is active ensure!(T::ActiveOutboundLanes::get().contains(&lane), Error::::InactiveOutboundLane); - // let's first check if message can be delivered to target chain - T::TargetHeaderChain::verify_message(message).map_err(|err| { - log::trace!( - target: LOG_TARGET, - "Message to lane {:?} is rejected by target chain: {:?}", - lane, - err, - ); - - Error::::MessageRejectedByChainVerifier(err) - })?; - Ok(SendMessageArgs { lane_id: lane, payload: StoredMessagePayload::::try_from(message.encode()).map_err(|_| { @@ -785,7 +763,7 @@ fn outbound_lane, I: 'static>( /// Runtime inbound lane storage. struct RuntimeInboundLaneStorage, I: 'static = ()> { lane_id: LaneId, - cached_data: Option>, + cached_data: Option>>>, _phantom: PhantomData, } @@ -802,39 +780,39 @@ impl, I: 'static> RuntimeInboundLaneStorage { /// maximal configured. /// /// Maximal inbound lane state set size is configured by the - /// `MaxUnrewardedRelayerEntriesAtInboundLane` constant from the pallet configuration. The PoV + /// `MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` constant from the pallet configuration. The PoV /// of the call includes the maximal size of inbound lane state. If the actual size is smaller, /// we may subtract extra bytes from this component. pub fn extra_proof_size_bytes(&mut self) -> u64 { let max_encoded_len = StoredInboundLaneData::::max_encoded_len(); let relayers_count = self.get_or_init_data().relayers.len(); let actual_encoded_len = - InboundLaneData::::encoded_size_hint(relayers_count) + InboundLaneData::>>::encoded_size_hint(relayers_count) .unwrap_or(usize::MAX); max_encoded_len.saturating_sub(actual_encoded_len) as _ } } impl, I: 'static> InboundLaneStorage for RuntimeInboundLaneStorage { - type Relayer = T::InboundRelayer; + type Relayer = AccountIdOf>; fn id(&self) -> LaneId { self.lane_id } fn max_unrewarded_relayer_entries(&self) -> MessageNonce { - T::MaxUnrewardedRelayerEntriesAtInboundLane::get() + BridgedChainOf::::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX } fn max_unconfirmed_messages(&self) -> MessageNonce { - T::MaxUnconfirmedMessagesAtInboundLane::get() + BridgedChainOf::::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX } - fn get_or_init_data(&mut self) -> InboundLaneData { + fn get_or_init_data(&mut self) -> InboundLaneData>> { match self.cached_data { Some(ref data) => data.clone(), None => { - let data: InboundLaneData = + let data: InboundLaneData>> = InboundLanes::::get(self.lane_id).into(); self.cached_data = Some(data.clone()); data @@ -842,7 +820,7 @@ impl, I: 'static> InboundLaneStorage for RuntimeInboundLaneStorage< } } - fn set_data(&mut self, data: InboundLaneData) { + fn set_data(&mut self, data: InboundLaneData>>) { self.cached_data = Some(data.clone()); InboundLanes::::insert(self.lane_id, StoredInboundLaneData::(data)) } @@ -887,14 +865,14 @@ impl, I: 'static> OutboundLaneStorage for RuntimeOutboundLaneStorag } /// Verify messages proof and return proved messages with decoded payload. -fn verify_and_decode_messages_proof( - proof: Chain::MessagesProof, +fn verify_and_decode_messages_proof, I: 'static>( + proof: FromBridgedChainMessagesProof>>, messages_count: u32, -) -> Result>, VerificationError> { - // `receive_messages_proof` weight formula and `MaxUnconfirmedMessagesAtInboundLane` check - // guarantees that the `message_count` is sane and Vec may be allocated. +) -> Result>, VerificationError> { + // `receive_messages_proof` weight formula and `MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX` + // check guarantees that the `message_count` is sane and Vec may be allocated. // (tx with too many messages will either be rejected from the pool, or will fail earlier) - Chain::verify_messages_proof(proof, messages_count).map(|messages_by_lane| { + proofs::verify_messages_proof::(proof, messages_count).map(|messages_by_lane| { messages_by_lane .into_iter() .map(|(lane, lane_data)| { @@ -909,1209 +887,3 @@ fn verify_and_decode_messages_proof::set_block_number(1); - System::::reset_events(); - } - - fn send_regular_message(lane_id: LaneId) { - get_ready_for_events(); - - let outbound_lane = outbound_lane::(lane_id); - let message_nonce = outbound_lane.data().latest_generated_nonce + 1; - let prev_enqueued_messages = outbound_lane.data().queued_messages().saturating_len(); - let valid_message = Pallet::::validate_message(lane_id, ®ULAR_PAYLOAD) - .expect("validate_message has failed"); - let artifacts = Pallet::::send_message(valid_message); - assert_eq!(artifacts.enqueued_messages, prev_enqueued_messages + 1); - - // check event with assigned nonce - assert_eq!( - System::::events(), - vec![EventRecord { - phase: Phase::Initialization, - event: TestEvent::Messages(Event::MessageAccepted { - lane_id, - nonce: message_nonce - }), - topics: vec![], - }], - ); - } - - fn receive_messages_delivery_proof() { - System::::set_block_number(1); - System::::reset_events(); - - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 1, - relayers: vec![UnrewardedRelayer { - relayer: 0, - messages: DeliveredMessages::new(1), - }] - .into_iter() - .collect(), - }, - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 1, - }, - )); - - assert_eq!( - System::::events(), - vec![EventRecord { - phase: Phase::Initialization, - event: TestEvent::Messages(Event::MessagesDelivered { - lane_id: TEST_LANE_ID, - messages: DeliveredMessages::new(1), - }), - topics: vec![], - }], - ); - } - - #[test] - fn pallet_rejects_transactions_if_halted() { - run_test(|| { - // send message first to be able to check that delivery_proof fails later - send_regular_message(TEST_LANE_ID); - - PalletOperatingMode::::put(MessagesOperatingMode::Basic( - BasicOperatingMode::Halted, - )); - - assert_noop!( - Pallet::::validate_message(TEST_LANE_ID, ®ULAR_PAYLOAD), - Error::::NotOperatingNormally, - ); - - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(2, REGULAR_PAYLOAD)]).into(), - 1, - REGULAR_PAYLOAD.declared_weight, - ), - Error::::BridgeModule(bp_runtime::OwnedBridgeModuleError::Halted), - ); - - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 1, - relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)] - .into_iter() - .collect(), - }, - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 1, - }, - ), - Error::::BridgeModule(bp_runtime::OwnedBridgeModuleError::Halted), - ); - }); - } - - #[test] - fn pallet_rejects_new_messages_in_rejecting_outbound_messages_operating_mode() { - run_test(|| { - // send message first to be able to check that delivery_proof fails later - send_regular_message(TEST_LANE_ID); - - PalletOperatingMode::::put( - MessagesOperatingMode::RejectingOutboundMessages, - ); - - assert_noop!( - Pallet::::validate_message(TEST_LANE_ID, ®ULAR_PAYLOAD), - Error::::NotOperatingNormally, - ); - - assert_ok!(Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(1, REGULAR_PAYLOAD)]).into(), - 1, - REGULAR_PAYLOAD.declared_weight, - ),); - - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 1, - relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)] - .into_iter() - .collect(), - }, - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 1, - }, - )); - }); - } - - #[test] - fn send_message_works() { - run_test(|| { - send_regular_message(TEST_LANE_ID); - }); - } - - #[test] - fn send_message_rejects_too_large_message() { - run_test(|| { - let mut message_payload = message_payload(1, 0); - // the payload isn't simply extra, so it'll definitely overflow - // `MAX_OUTBOUND_PAYLOAD_SIZE` if we add `MAX_OUTBOUND_PAYLOAD_SIZE` bytes to extra - message_payload - .extra - .extend_from_slice(&[0u8; MAX_OUTBOUND_PAYLOAD_SIZE as usize]); - assert_noop!( - Pallet::::validate_message(TEST_LANE_ID, &message_payload.clone(),), - Error::::MessageRejectedByPallet( - VerificationError::MessageTooLarge - ), - ); - - // let's check that we're able to send `MAX_OUTBOUND_PAYLOAD_SIZE` messages - while message_payload.encoded_size() as u32 > MAX_OUTBOUND_PAYLOAD_SIZE { - message_payload.extra.pop(); - } - assert_eq!(message_payload.encoded_size() as u32, MAX_OUTBOUND_PAYLOAD_SIZE); - - let valid_message = - Pallet::::validate_message(TEST_LANE_ID, &message_payload) - .expect("validate_message has failed"); - Pallet::::send_message(valid_message); - }) - } - - #[test] - fn chain_verifier_rejects_invalid_message_in_send_message() { - run_test(|| { - // messages with this payload are rejected by target chain verifier - assert_noop!( - Pallet::::validate_message( - TEST_LANE_ID, - &PAYLOAD_REJECTED_BY_TARGET_CHAIN, - ), - Error::::MessageRejectedByChainVerifier(VerificationError::Other( - mock::TEST_ERROR - )), - ); - }); - } - - #[test] - fn receive_messages_proof_works() { - run_test(|| { - assert_ok!(Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(1, REGULAR_PAYLOAD)]).into(), - 1, - REGULAR_PAYLOAD.declared_weight, - )); - - assert_eq!(InboundLanes::::get(TEST_LANE_ID).0.last_delivered_nonce(), 1); - - assert!(TestDeliveryPayments::is_reward_paid(1)); - }); - } - - #[test] - fn receive_messages_proof_updates_confirmed_message_nonce() { - run_test(|| { - // say we have received 10 messages && last confirmed message is 8 - InboundLanes::::insert( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 8, - relayers: vec![ - unrewarded_relayer(9, 9, TEST_RELAYER_A), - unrewarded_relayer(10, 10, TEST_RELAYER_B), - ] - .into_iter() - .collect(), - }, - ); - assert_eq!( - inbound_unrewarded_relayers_state(TEST_LANE_ID), - UnrewardedRelayersState { - unrewarded_relayer_entries: 2, - messages_in_oldest_entry: 1, - total_messages: 2, - last_delivered_nonce: 10, - }, - ); - - // message proof includes outbound lane state with latest confirmed message updated to 9 - let mut message_proof: TestMessagesProof = - Ok(vec![message(11, REGULAR_PAYLOAD)]).into(); - message_proof.result.as_mut().unwrap()[0].1.lane_state = - Some(OutboundLaneData { latest_received_nonce: 9, ..Default::default() }); - - assert_ok!(Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - message_proof, - 1, - REGULAR_PAYLOAD.declared_weight, - )); - - assert_eq!( - InboundLanes::::get(TEST_LANE_ID).0, - InboundLaneData { - last_confirmed_nonce: 9, - relayers: vec![ - unrewarded_relayer(10, 10, TEST_RELAYER_B), - unrewarded_relayer(11, 11, TEST_RELAYER_A) - ] - .into_iter() - .collect(), - }, - ); - assert_eq!( - inbound_unrewarded_relayers_state(TEST_LANE_ID), - UnrewardedRelayersState { - unrewarded_relayer_entries: 2, - messages_in_oldest_entry: 1, - total_messages: 2, - last_delivered_nonce: 11, - }, - ); - }); - } - - #[test] - fn receive_messages_fails_if_dispatcher_is_inactive() { - run_test(|| { - TestMessageDispatch::deactivate(); - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(1, REGULAR_PAYLOAD)]).into(), - 1, - REGULAR_PAYLOAD.declared_weight, - ), - Error::::MessageDispatchInactive, - ); - }); - } - - #[test] - fn receive_messages_proof_does_not_accept_message_if_dispatch_weight_is_not_enough() { - run_test(|| { - let mut declared_weight = REGULAR_PAYLOAD.declared_weight; - *declared_weight.ref_time_mut() -= 1; - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(1, REGULAR_PAYLOAD)]).into(), - 1, - declared_weight, - ), - Error::::InsufficientDispatchWeight - ); - assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 0); - }); - } - - #[test] - fn receive_messages_proof_rejects_invalid_proof() { - run_test(|| { - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Err(()).into(), - 1, - Weight::zero(), - ), - Error::::InvalidMessagesProof, - ); - }); - } - - #[test] - fn receive_messages_proof_rejects_proof_with_too_many_messages() { - run_test(|| { - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![message(1, REGULAR_PAYLOAD)]).into(), - u32::MAX, - Weight::zero(), - ), - Error::::TooManyMessagesInTheProof, - ); - }); - } - - #[test] - fn receive_messages_delivery_proof_works() { - run_test(|| { - send_regular_message(TEST_LANE_ID); - receive_messages_delivery_proof(); - - assert_eq!( - OutboundLanes::::get(TEST_LANE_ID).latest_received_nonce, - 1, - ); - }); - } - - #[test] - fn receive_messages_delivery_proof_rewards_relayers() { - run_test(|| { - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - - // this reports delivery of message 1 => reward is paid to TEST_RELAYER_A - let single_message_delivery_proof = TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)].into_iter().collect(), - ..Default::default() - }, - ))); - let single_message_delivery_proof_size = single_message_delivery_proof.size(); - let result = Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - single_message_delivery_proof, - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 1, - }, - ); - assert_ok!(result); - assert_eq!( - result.unwrap().actual_weight.unwrap(), - TestWeightInfo::receive_messages_delivery_proof_weight( - &PreComputedSize(single_message_delivery_proof_size as _), - &UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - total_messages: 1, - ..Default::default() - }, - ) - ); - assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); - assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); - assert_eq!(TestOnMessagesDelivered::call_arguments(), Some((TEST_LANE_ID, 1))); - - // this reports delivery of both message 1 and message 2 => reward is paid only to - // TEST_RELAYER_B - let two_messages_delivery_proof = TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - relayers: vec![ - unrewarded_relayer(1, 1, TEST_RELAYER_A), - unrewarded_relayer(2, 2, TEST_RELAYER_B), - ] - .into_iter() - .collect(), - ..Default::default() - }, - ))); - let two_messages_delivery_proof_size = two_messages_delivery_proof.size(); - let result = Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - two_messages_delivery_proof, - UnrewardedRelayersState { - unrewarded_relayer_entries: 2, - messages_in_oldest_entry: 1, - total_messages: 2, - last_delivered_nonce: 2, - }, - ); - assert_ok!(result); - // even though the pre-dispatch weight was for two messages, the actual weight is - // for single message only - assert_eq!( - result.unwrap().actual_weight.unwrap(), - TestWeightInfo::receive_messages_delivery_proof_weight( - &PreComputedSize(two_messages_delivery_proof_size as _), - &UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - total_messages: 1, - ..Default::default() - }, - ) - ); - assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); - assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); - assert_eq!(TestOnMessagesDelivered::call_arguments(), Some((TEST_LANE_ID, 0))); - }); - } - - #[test] - fn receive_messages_delivery_proof_rejects_invalid_proof() { - run_test(|| { - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Err(())), - Default::default(), - ), - Error::::InvalidMessagesDeliveryProof, - ); - }); - } - - #[test] - fn receive_messages_delivery_proof_rejects_proof_if_declared_relayers_state_is_invalid() { - run_test(|| { - // when number of relayers entries is invalid - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - relayers: vec![ - unrewarded_relayer(1, 1, TEST_RELAYER_A), - unrewarded_relayer(2, 2, TEST_RELAYER_B) - ] - .into_iter() - .collect(), - ..Default::default() - } - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - total_messages: 2, - last_delivered_nonce: 2, - ..Default::default() - }, - ), - Error::::InvalidUnrewardedRelayersState, - ); - - // when number of messages is invalid - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - relayers: vec![ - unrewarded_relayer(1, 1, TEST_RELAYER_A), - unrewarded_relayer(2, 2, TEST_RELAYER_B) - ] - .into_iter() - .collect(), - ..Default::default() - } - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 2, - total_messages: 1, - last_delivered_nonce: 2, - ..Default::default() - }, - ), - Error::::InvalidUnrewardedRelayersState, - ); - - // when last delivered nonce is invalid - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - relayers: vec![ - unrewarded_relayer(1, 1, TEST_RELAYER_A), - unrewarded_relayer(2, 2, TEST_RELAYER_B) - ] - .into_iter() - .collect(), - ..Default::default() - } - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 2, - total_messages: 2, - last_delivered_nonce: 8, - ..Default::default() - }, - ), - Error::::InvalidUnrewardedRelayersState, - ); - }); - } - - #[test] - fn receive_messages_accepts_single_message_with_invalid_payload() { - run_test(|| { - let mut invalid_message = message(1, REGULAR_PAYLOAD); - invalid_message.payload = Vec::new(); - - assert_ok!(Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok(vec![invalid_message]).into(), - 1, - Weight::zero(), /* weight may be zero in this case (all messages are - * improperly encoded) */ - ),); - - assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 1,); - }); - } - - #[test] - fn receive_messages_accepts_batch_with_message_with_invalid_payload() { - run_test(|| { - let mut invalid_message = message(2, REGULAR_PAYLOAD); - invalid_message.payload = Vec::new(); - - assert_ok!(Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - Ok( - vec![message(1, REGULAR_PAYLOAD), invalid_message, message(3, REGULAR_PAYLOAD),] - ) - .into(), - 3, - REGULAR_PAYLOAD.declared_weight + REGULAR_PAYLOAD.declared_weight, - ),); - - assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 3,); - }); - } - - #[test] - fn actual_dispatch_weight_does_not_overflow() { - run_test(|| { - let message1 = message(1, message_payload(0, u64::MAX / 2)); - let message2 = message(2, message_payload(0, u64::MAX / 2)); - let message3 = message(3, message_payload(0, u64::MAX / 2)); - - assert_noop!( - Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - // this may cause overflow if source chain storage is invalid - Ok(vec![message1, message2, message3]).into(), - 3, - Weight::MAX, - ), - Error::::InsufficientDispatchWeight - ); - assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 0); - }); - } - - #[test] - fn ref_time_refund_from_receive_messages_proof_works() { - run_test(|| { - fn submit_with_unspent_weight( - nonce: MessageNonce, - unspent_weight: u64, - ) -> (Weight, Weight) { - let mut payload = REGULAR_PAYLOAD; - *payload.dispatch_result.unspent_weight.ref_time_mut() = unspent_weight; - let proof = Ok(vec![message(nonce, payload)]).into(); - let messages_count = 1; - let pre_dispatch_weight = - ::WeightInfo::receive_messages_proof_weight( - &proof, - messages_count, - REGULAR_PAYLOAD.declared_weight, - ); - let result = Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - proof, - messages_count, - REGULAR_PAYLOAD.declared_weight, - ) - .expect("delivery has failed"); - let post_dispatch_weight = - result.actual_weight.expect("receive_messages_proof always returns Some"); - - // message delivery transactions are never free - assert_eq!(result.pays_fee, Pays::Yes); - - (pre_dispatch_weight, post_dispatch_weight) - } - - // when dispatch is returning `unspent_weight < declared_weight` - let (pre, post) = submit_with_unspent_weight(1, 1); - assert_eq!(post.ref_time(), pre.ref_time() - 1); - - // when dispatch is returning `unspent_weight = declared_weight` - let (pre, post) = - submit_with_unspent_weight(2, REGULAR_PAYLOAD.declared_weight.ref_time()); - assert_eq!( - post.ref_time(), - pre.ref_time() - REGULAR_PAYLOAD.declared_weight.ref_time() - ); - - // when dispatch is returning `unspent_weight > declared_weight` - let (pre, post) = - submit_with_unspent_weight(3, REGULAR_PAYLOAD.declared_weight.ref_time() + 1); - assert_eq!( - post.ref_time(), - pre.ref_time() - REGULAR_PAYLOAD.declared_weight.ref_time() - ); - - // when there's no unspent weight - let (pre, post) = submit_with_unspent_weight(4, 0); - assert_eq!(post.ref_time(), pre.ref_time()); - - // when dispatch is returning `unspent_weight < declared_weight` - let (pre, post) = submit_with_unspent_weight(5, 1); - assert_eq!(post.ref_time(), pre.ref_time() - 1); - }); - } - - #[test] - fn proof_size_refund_from_receive_messages_proof_works() { - run_test(|| { - let max_entries = crate::mock::MaxUnrewardedRelayerEntriesAtInboundLane::get() as usize; - - // if there's maximal number of unrewarded relayer entries at the inbound lane, then - // `proof_size` is unchanged in post-dispatch weight - let proof: TestMessagesProof = Ok(vec![message(101, REGULAR_PAYLOAD)]).into(); - let messages_count = 1; - let pre_dispatch_weight = - ::WeightInfo::receive_messages_proof_weight( - &proof, - messages_count, - REGULAR_PAYLOAD.declared_weight, - ); - InboundLanes::::insert( - TEST_LANE_ID, - StoredInboundLaneData(InboundLaneData { - relayers: vec![ - UnrewardedRelayer { - relayer: 42, - messages: DeliveredMessages { begin: 0, end: 100 } - }; - max_entries - ] - .into_iter() - .collect(), - last_confirmed_nonce: 0, - }), - ); - let post_dispatch_weight = Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - proof.clone(), - messages_count, - REGULAR_PAYLOAD.declared_weight, - ) - .unwrap() - .actual_weight - .unwrap(); - assert_eq!(post_dispatch_weight.proof_size(), pre_dispatch_weight.proof_size()); - - // if count of unrewarded relayer entries is less than maximal, then some `proof_size` - // must be refunded - InboundLanes::::insert( - TEST_LANE_ID, - StoredInboundLaneData(InboundLaneData { - relayers: vec![ - UnrewardedRelayer { - relayer: 42, - messages: DeliveredMessages { begin: 0, end: 100 } - }; - max_entries - 1 - ] - .into_iter() - .collect(), - last_confirmed_nonce: 0, - }), - ); - let post_dispatch_weight = Pallet::::receive_messages_proof( - RuntimeOrigin::signed(1), - TEST_RELAYER_A, - proof, - messages_count, - REGULAR_PAYLOAD.declared_weight, - ) - .unwrap() - .actual_weight - .unwrap(); - assert!( - post_dispatch_weight.proof_size() < pre_dispatch_weight.proof_size(), - "Expected post-dispatch PoV {} to be less than pre-dispatch PoV {}", - post_dispatch_weight.proof_size(), - pre_dispatch_weight.proof_size(), - ); - }); - } - - #[test] - fn messages_delivered_callbacks_are_called() { - run_test(|| { - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - - // messages 1+2 are confirmed in 1 tx, message 3 in a separate tx - // dispatch of message 2 has failed - let mut delivered_messages_1_and_2 = DeliveredMessages::new(1); - delivered_messages_1_and_2.note_dispatched_message(); - let messages_1_and_2_proof = Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 0, - relayers: vec![UnrewardedRelayer { - relayer: 0, - messages: delivered_messages_1_and_2.clone(), - }] - .into_iter() - .collect(), - }, - )); - let delivered_message_3 = DeliveredMessages::new(3); - let messages_3_proof = Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 0, - relayers: vec![UnrewardedRelayer { relayer: 0, messages: delivered_message_3 }] - .into_iter() - .collect(), - }, - )); - - // first tx with messages 1+2 - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(messages_1_and_2_proof), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 2, - total_messages: 2, - last_delivered_nonce: 2, - }, - )); - // second tx with message 3 - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(messages_3_proof), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 3, - }, - )); - }); - } - - #[test] - fn receive_messages_delivery_proof_rejects_proof_if_trying_to_confirm_more_messages_than_expected( - ) { - run_test(|| { - // send message first to be able to check that delivery_proof fails later - send_regular_message(TEST_LANE_ID); - - // 1) InboundLaneData declares that the `last_confirmed_nonce` is 1; - // 2) InboundLaneData has no entries => `InboundLaneData::last_delivered_nonce()` - // returns `last_confirmed_nonce`; - // 3) it means that we're going to confirm delivery of messages 1..=1; - // 4) so the number of declared messages (see `UnrewardedRelayersState`) is `0` and - // number of actually confirmed messages is `1`. - assert_noop!( - Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { last_confirmed_nonce: 1, relayers: Default::default() }, - ))), - UnrewardedRelayersState { last_delivered_nonce: 1, ..Default::default() }, - ), - Error::::ReceptionConfirmation( - ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected - ), - ); - }); - } - - #[test] - fn storage_keys_computed_properly() { - assert_eq!( - PalletOperatingMode::::storage_value_final_key().to_vec(), - bp_messages::storage_keys::operating_mode_key("Messages").0, - ); - - assert_eq!( - OutboundMessages::::storage_map_final_key(MessageKey { - lane_id: TEST_LANE_ID, - nonce: 42 - }), - bp_messages::storage_keys::message_key("Messages", &TEST_LANE_ID, 42).0, - ); - - assert_eq!( - OutboundLanes::::storage_map_final_key(TEST_LANE_ID), - bp_messages::storage_keys::outbound_lane_data_key("Messages", &TEST_LANE_ID).0, - ); - - assert_eq!( - InboundLanes::::storage_map_final_key(TEST_LANE_ID), - bp_messages::storage_keys::inbound_lane_data_key("Messages", &TEST_LANE_ID).0, - ); - } - - #[test] - fn inbound_message_details_works() { - run_test(|| { - assert_eq!( - Pallet::::inbound_message_data( - TEST_LANE_ID, - REGULAR_PAYLOAD.encode(), - OutboundMessageDetails { nonce: 0, dispatch_weight: Weight::zero(), size: 0 }, - ), - InboundMessageDetails { dispatch_weight: REGULAR_PAYLOAD.declared_weight }, - ); - }); - } - - #[test] - fn on_idle_callback_respects_remaining_weight() { - run_test(|| { - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - send_regular_message(TEST_LANE_ID); - - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 4, - relayers: vec![unrewarded_relayer(1, 4, TEST_RELAYER_A)] - .into_iter() - .collect(), - }, - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 4, - total_messages: 4, - last_delivered_nonce: 4, - }, - )); - - // all 4 messages may be pruned now - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().latest_received_nonce, - 4 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 1 - ); - System::::set_block_number(2); - - // if passed wight is too low to do anything - let dbw = DbWeight::get(); - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(1, 1)), - Weight::zero(), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 1 - ); - - // if passed wight is enough to prune single message - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(1, 2)), - dbw.reads_writes(1, 2), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 2 - ); - - // if passed wight is enough to prune two more messages - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(1, 3)), - dbw.reads_writes(1, 3), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 4 - ); - - // if passed wight is enough to prune many messages - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(100, 100)), - dbw.reads_writes(1, 2), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 5 - ); - }); - } - - #[test] - fn on_idle_callback_is_rotating_lanes_to_prune() { - run_test(|| { - // send + receive confirmation for lane 1 - send_regular_message(TEST_LANE_ID); - receive_messages_delivery_proof(); - // send + receive confirmation for lane 2 - send_regular_message(TEST_LANE_ID_2); - assert_ok!(Pallet::::receive_messages_delivery_proof( - RuntimeOrigin::signed(1), - TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID_2, - InboundLaneData { - last_confirmed_nonce: 1, - relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)] - .into_iter() - .collect(), - }, - ))), - UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - messages_in_oldest_entry: 1, - total_messages: 1, - last_delivered_nonce: 1, - }, - )); - - // nothing is pruned yet - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().latest_received_nonce, - 1 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 1 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID_2).data().latest_received_nonce, - 1 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID_2).data().oldest_unpruned_nonce, - 1 - ); - - // in block#2.on_idle lane messages of lane 1 are pruned - let dbw = DbWeight::get(); - System::::set_block_number(2); - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(100, 100)), - dbw.reads_writes(1, 2), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 2 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID_2).data().oldest_unpruned_nonce, - 1 - ); - - // in block#3.on_idle lane messages of lane 2 are pruned - System::::set_block_number(3); - - assert_eq!( - Pallet::::on_idle(0, dbw.reads_writes(100, 100)), - dbw.reads_writes(1, 2), - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID).data().oldest_unpruned_nonce, - 2 - ); - assert_eq!( - outbound_lane::(TEST_LANE_ID_2).data().oldest_unpruned_nonce, - 2 - ); - }); - } - - #[test] - fn outbound_message_from_unconfigured_lane_is_rejected() { - run_test(|| { - assert_noop!( - Pallet::::validate_message(TEST_LANE_ID_3, ®ULAR_PAYLOAD,), - Error::::InactiveOutboundLane, - ); - }); - } - - #[test] - fn test_bridge_messages_call_is_correctly_defined() { - let account_id = 1; - let message_proof: TestMessagesProof = Ok(vec![message(1, REGULAR_PAYLOAD)]).into(); - let message_delivery_proof = TestMessagesDeliveryProof(Ok(( - TEST_LANE_ID, - InboundLaneData { - last_confirmed_nonce: 1, - relayers: vec![UnrewardedRelayer { - relayer: 0, - messages: DeliveredMessages::new(1), - }] - .into_iter() - .collect(), - }, - ))); - let unrewarded_relayer_state = UnrewardedRelayersState { - unrewarded_relayer_entries: 1, - total_messages: 1, - last_delivered_nonce: 1, - ..Default::default() - }; - - let direct_receive_messages_proof_call = Call::::receive_messages_proof { - relayer_id_at_bridged_chain: account_id, - proof: message_proof.clone(), - messages_count: 1, - dispatch_weight: REGULAR_PAYLOAD.declared_weight, - }; - let indirect_receive_messages_proof_call = BridgeMessagesCall::< - AccountId, - TestMessagesProof, - TestMessagesDeliveryProof, - >::receive_messages_proof { - relayer_id_at_bridged_chain: account_id, - proof: message_proof, - messages_count: 1, - dispatch_weight: REGULAR_PAYLOAD.declared_weight, - }; - assert_eq!( - direct_receive_messages_proof_call.encode(), - indirect_receive_messages_proof_call.encode() - ); - - let direct_receive_messages_delivery_proof_call = - Call::::receive_messages_delivery_proof { - proof: message_delivery_proof.clone(), - relayers_state: unrewarded_relayer_state.clone(), - }; - let indirect_receive_messages_delivery_proof_call = BridgeMessagesCall::< - AccountId, - TestMessagesProof, - TestMessagesDeliveryProof, - >::receive_messages_delivery_proof { - proof: message_delivery_proof, - relayers_state: unrewarded_relayer_state, - }; - assert_eq!( - direct_receive_messages_delivery_proof_call.encode(), - indirect_receive_messages_delivery_proof_call.encode() - ); - } - - generate_owned_bridge_module_tests!( - MessagesOperatingMode::Basic(BasicOperatingMode::Normal), - MessagesOperatingMode::Basic(BasicOperatingMode::Halted) - ); - - #[test] - fn inbound_storage_extra_proof_size_bytes_works() { - fn relayer_entry() -> UnrewardedRelayer { - UnrewardedRelayer { relayer: 42u64, messages: DeliveredMessages { begin: 0, end: 100 } } - } - - fn storage(relayer_entries: usize) -> RuntimeInboundLaneStorage { - RuntimeInboundLaneStorage { - lane_id: Default::default(), - cached_data: Some(InboundLaneData { - relayers: vec![relayer_entry(); relayer_entries].into_iter().collect(), - last_confirmed_nonce: 0, - }), - _phantom: Default::default(), - } - } - - let max_entries = crate::mock::MaxUnrewardedRelayerEntriesAtInboundLane::get() as usize; - - // when we have exactly `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers - assert_eq!(storage(max_entries).extra_proof_size_bytes(), 0); - - // when we have less than `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers - assert_eq!( - storage(max_entries - 1).extra_proof_size_bytes(), - relayer_entry().encode().len() as u64 - ); - assert_eq!( - storage(max_entries - 2).extra_proof_size_bytes(), - 2 * relayer_entry().encode().len() as u64 - ); - - // when we have more than `MaxUnrewardedRelayerEntriesAtInboundLane` unrewarded relayers - // (shall not happen in practice) - assert_eq!(storage(max_entries + 1).extra_proof_size_bytes(), 0); - } - - #[test] - fn maybe_outbound_lanes_count_returns_correct_value() { - assert_eq!( - MaybeOutboundLanesCount::::get(), - Some(mock::ActiveOutboundLanes::get().len() as u32) - ); - } -} diff --git a/bridges/modules/messages/src/outbound_lane.rs b/bridges/modules/messages/src/outbound_lane.rs index acef5546d2a64fa8a3fb38c6b41ae30819cdeaa2..788a13e82b1b51f02a171288f60c839b3bcd7d3a 100644 --- a/bridges/modules/messages/src/outbound_lane.rs +++ b/bridges/modules/messages/src/outbound_lane.rs @@ -18,16 +18,14 @@ use crate::{Config, LOG_TARGET}; -use bp_messages::{DeliveredMessages, LaneId, MessageNonce, OutboundLaneData, UnrewardedRelayer}; -use codec::{Decode, Encode}; -use frame_support::{ - weights::{RuntimeDbWeight, Weight}, - BoundedVec, PalletError, +use bp_messages::{ + ChainWithMessages, DeliveredMessages, LaneId, MessageNonce, OutboundLaneData, UnrewardedRelayer, }; -use num_traits::Zero; +use codec::{Decode, Encode}; +use frame_support::{traits::Get, BoundedVec, PalletError}; use scale_info::TypeInfo; use sp_runtime::RuntimeDebug; -use sp_std::collections::vec_deque::VecDeque; +use sp_std::{collections::vec_deque::VecDeque, marker::PhantomData}; /// Outbound lane storage. pub trait OutboundLaneStorage { @@ -48,8 +46,17 @@ pub trait OutboundLaneStorage { fn remove_message(&mut self, nonce: &MessageNonce); } +/// Limit for the `StoredMessagePayload` vector. +pub struct StoredMessagePayloadLimit(PhantomData<(T, I)>); + +impl, I: 'static> Get for StoredMessagePayloadLimit { + fn get() -> u32 { + T::BridgedChain::maximal_incoming_message_size() + } +} + /// Outbound message data wrapper that implements `MaxEncodedLen`. -pub type StoredMessagePayload = BoundedVec>::MaximalOutboundPayloadSize>; +pub type StoredMessagePayload = BoundedVec>; /// Result of messages receival confirmation. #[derive(Encode, Decode, RuntimeDebug, PartialEq, Eq, PalletError, TypeInfo)] @@ -132,41 +139,17 @@ impl OutboundLane { ensure_unrewarded_relayers_are_correct(confirmed_messages.end, relayers)?; + // prune all confirmed messages + for nonce in confirmed_messages.begin..=confirmed_messages.end { + self.storage.remove_message(&nonce); + } + data.latest_received_nonce = confirmed_messages.end; + data.oldest_unpruned_nonce = data.latest_received_nonce.saturating_add(1); self.storage.set_data(data); Ok(Some(confirmed_messages)) } - - /// Prune at most `max_messages_to_prune` already received messages. - /// - /// Returns weight, consumed by messages pruning and lane state update. - pub fn prune_messages( - &mut self, - db_weight: RuntimeDbWeight, - mut remaining_weight: Weight, - ) -> Weight { - let write_weight = db_weight.writes(1); - let two_writes_weight = write_weight + write_weight; - let mut spent_weight = Weight::zero(); - let mut data = self.storage.data(); - while remaining_weight.all_gte(two_writes_weight) && - data.oldest_unpruned_nonce <= data.latest_received_nonce - { - self.storage.remove_message(&data.oldest_unpruned_nonce); - - spent_weight += write_weight; - remaining_weight -= write_weight; - data.oldest_unpruned_nonce += 1; - } - - if !spent_weight.is_zero() { - spent_weight += write_weight; - self.storage.set_data(data); - } - - spent_weight - } } /// Verifies unrewarded relayers vec. @@ -204,13 +187,12 @@ fn ensure_unrewarded_relayers_are_correct( mod tests { use super::*; use crate::{ - mock::{ + outbound_lane, + tests::mock::{ outbound_message_data, run_test, unrewarded_relayer, TestRelayer, TestRuntime, REGULAR_PAYLOAD, TEST_LANE_ID, }, - outbound_lane, }; - use frame_support::weights::constants::RocksDbWeight; use sp_std::ops::RangeInclusive; fn unrewarded_relayers( @@ -263,12 +245,43 @@ mod tests { assert_eq!(lane.send_message(outbound_message_data(REGULAR_PAYLOAD)), 3); assert_eq!(lane.storage.data().latest_generated_nonce, 3); assert_eq!(lane.storage.data().latest_received_nonce, 0); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 1); assert_eq!( lane.confirm_delivery(3, 3, &unrewarded_relayers(1..=3)), Ok(Some(delivered_messages(1..=3))), ); assert_eq!(lane.storage.data().latest_generated_nonce, 3); assert_eq!(lane.storage.data().latest_received_nonce, 3); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 4); + }); + } + + #[test] + fn confirm_partial_delivery_works() { + run_test(|| { + let mut lane = outbound_lane::(TEST_LANE_ID); + assert_eq!(lane.send_message(outbound_message_data(REGULAR_PAYLOAD)), 1); + assert_eq!(lane.send_message(outbound_message_data(REGULAR_PAYLOAD)), 2); + assert_eq!(lane.send_message(outbound_message_data(REGULAR_PAYLOAD)), 3); + assert_eq!(lane.storage.data().latest_generated_nonce, 3); + assert_eq!(lane.storage.data().latest_received_nonce, 0); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 1); + + assert_eq!( + lane.confirm_delivery(3, 2, &unrewarded_relayers(1..=2)), + Ok(Some(delivered_messages(1..=2))), + ); + assert_eq!(lane.storage.data().latest_generated_nonce, 3); + assert_eq!(lane.storage.data().latest_received_nonce, 2); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 3); + + assert_eq!( + lane.confirm_delivery(3, 3, &unrewarded_relayers(3..=3)), + Ok(Some(delivered_messages(3..=3))), + ); + assert_eq!(lane.storage.data().latest_generated_nonce, 3); + assert_eq!(lane.storage.data().latest_received_nonce, 3); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 4); }); } @@ -281,6 +294,7 @@ mod tests { lane.send_message(outbound_message_data(REGULAR_PAYLOAD)); assert_eq!(lane.storage.data().latest_generated_nonce, 3); assert_eq!(lane.storage.data().latest_received_nonce, 0); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 1); assert_eq!( lane.confirm_delivery(3, 3, &unrewarded_relayers(1..=3)), Ok(Some(delivered_messages(1..=3))), @@ -288,10 +302,12 @@ mod tests { assert_eq!(lane.confirm_delivery(3, 3, &unrewarded_relayers(1..=3)), Ok(None),); assert_eq!(lane.storage.data().latest_generated_nonce, 3); assert_eq!(lane.storage.data().latest_received_nonce, 3); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 4); assert_eq!(lane.confirm_delivery(1, 2, &unrewarded_relayers(1..=1)), Ok(None),); assert_eq!(lane.storage.data().latest_generated_nonce, 3); assert_eq!(lane.storage.data().latest_received_nonce, 3); + assert_eq!(lane.storage.data().oldest_unpruned_nonce, 4); }); } @@ -310,8 +326,8 @@ mod tests { 3, &unrewarded_relayers(1..=1) .into_iter() - .chain(unrewarded_relayers(2..=30).into_iter()) - .chain(unrewarded_relayers(3..=3).into_iter()) + .chain(unrewarded_relayers(2..=30)) + .chain(unrewarded_relayers(3..=3)) .collect(), ), Err(ReceptionConfirmationError::FailedToConfirmFutureMessages), @@ -326,8 +342,8 @@ mod tests { 3, &unrewarded_relayers(1..=1) .into_iter() - .chain(unrewarded_relayers(2..=1).into_iter()) - .chain(unrewarded_relayers(2..=3).into_iter()) + .chain(unrewarded_relayers(2..=1)) + .chain(unrewarded_relayers(2..=3)) .collect(), ), Err(ReceptionConfirmationError::EmptyUnrewardedRelayerEntry), @@ -341,65 +357,14 @@ mod tests { 3, &unrewarded_relayers(1..=1) .into_iter() - .chain(unrewarded_relayers(3..=3).into_iter()) - .chain(unrewarded_relayers(2..=2).into_iter()) + .chain(unrewarded_relayers(3..=3)) + .chain(unrewarded_relayers(2..=2)) .collect(), ), Err(ReceptionConfirmationError::NonConsecutiveUnrewardedRelayerEntries), ); } - #[test] - fn prune_messages_works() { - run_test(|| { - let mut lane = outbound_lane::(TEST_LANE_ID); - // when lane is empty, nothing is pruned - assert_eq!( - lane.prune_messages(RocksDbWeight::get(), RocksDbWeight::get().writes(101)), - Weight::zero() - ); - assert_eq!(lane.storage.data().oldest_unpruned_nonce, 1); - // when nothing is confirmed, nothing is pruned - lane.send_message(outbound_message_data(REGULAR_PAYLOAD)); - lane.send_message(outbound_message_data(REGULAR_PAYLOAD)); - lane.send_message(outbound_message_data(REGULAR_PAYLOAD)); - assert!(lane.storage.message(&1).is_some()); - assert!(lane.storage.message(&2).is_some()); - assert!(lane.storage.message(&3).is_some()); - assert_eq!( - lane.prune_messages(RocksDbWeight::get(), RocksDbWeight::get().writes(101)), - Weight::zero() - ); - assert_eq!(lane.storage.data().oldest_unpruned_nonce, 1); - // after confirmation, some messages are received - assert_eq!( - lane.confirm_delivery(2, 2, &unrewarded_relayers(1..=2)), - Ok(Some(delivered_messages(1..=2))), - ); - assert_eq!( - lane.prune_messages(RocksDbWeight::get(), RocksDbWeight::get().writes(101)), - RocksDbWeight::get().writes(3), - ); - assert!(lane.storage.message(&1).is_none()); - assert!(lane.storage.message(&2).is_none()); - assert!(lane.storage.message(&3).is_some()); - assert_eq!(lane.storage.data().oldest_unpruned_nonce, 3); - // after last message is confirmed, everything is pruned - assert_eq!( - lane.confirm_delivery(1, 3, &unrewarded_relayers(3..=3)), - Ok(Some(delivered_messages(3..=3))), - ); - assert_eq!( - lane.prune_messages(RocksDbWeight::get(), RocksDbWeight::get().writes(101)), - RocksDbWeight::get().writes(2), - ); - assert!(lane.storage.message(&1).is_none()); - assert!(lane.storage.message(&2).is_none()); - assert!(lane.storage.message(&3).is_none()); - assert_eq!(lane.storage.data().oldest_unpruned_nonce, 4); - }); - } - #[test] fn confirm_delivery_detects_when_more_than_expected_messages_are_confirmed() { run_test(|| { diff --git a/bridges/modules/messages/src/proofs.rs b/bridges/modules/messages/src/proofs.rs new file mode 100644 index 0000000000000000000000000000000000000000..a3318833fa611a6515469172dcc24f114bbbf4ad --- /dev/null +++ b/bridges/modules/messages/src/proofs.rs @@ -0,0 +1,562 @@ +// Copyright 2019-2021 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 . + +//! Tools for messages and delivery proof verification. + +use crate::{BridgedChainOf, BridgedHeaderChainOf, Config}; + +use bp_header_chain::{HeaderChain, HeaderChainError}; +use bp_messages::{ + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::{FromBridgedChainMessagesProof, ProvedLaneMessages, ProvedMessages}, + ChainWithMessages, InboundLaneData, LaneId, Message, MessageKey, MessageNonce, MessagePayload, + OutboundLaneData, VerificationError, +}; +use bp_runtime::{ + HashOf, HasherOf, RangeInclusiveExt, RawStorageProof, StorageProofChecker, StorageProofError, +}; +use codec::Decode; +use sp_std::vec::Vec; + +/// 'Parsed' message delivery proof - inbound lane id and its state. +pub(crate) type ParsedMessagesDeliveryProofFromBridgedChain = + (LaneId, InboundLaneData<::AccountId>); + +/// 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, I: 'static>( + proof: FromBridgedChainMessagesProof>>, + messages_count: u32, +) -> Result, VerificationError> { + let FromBridgedChainMessagesProof { + bridged_header_hash, + storage_proof, + lane, + nonces_start, + nonces_end, + } = proof; + let mut parser: MessagesStorageProofAdapter = + MessagesStorageProofAdapter::try_new_with_verified_storage_proof( + bridged_header_hash, + storage_proof, + ) + .map_err(VerificationError::HeaderChain)?; + 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.saturating_len(); + 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) + .map_err(VerificationError::MessageStorage)?; + 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) + .map_err(VerificationError::OutboundLaneStorage)?, + 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 keys. + parser.ensure_no_unused_keys().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) +} + +/// Verify proof of This -> Bridged chain messages delivery. +pub fn verify_messages_delivery_proof, I: 'static>( + proof: FromBridgedChainMessagesDeliveryProof>>, +) -> Result, VerificationError> { + let FromBridgedChainMessagesDeliveryProof { bridged_header_hash, storage_proof, lane } = proof; + let mut parser: MessagesStorageProofAdapter = + MessagesStorageProofAdapter::try_new_with_verified_storage_proof( + 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( + T::ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, + &lane, + ); + let inbound_lane_data = parser + .read_and_decode_mandatory_value(&storage_inbound_lane_data_key) + .map_err(VerificationError::InboundLaneStorage)?; + + // check that the storage proof doesn't have any untouched trie nodes + parser.ensure_no_unused_keys().map_err(VerificationError::StorageProof)?; + + Ok((lane, inbound_lane_data)) +} + +/// Abstraction over storage proof manipulation, hiding implementation details of actual storage +/// proofs. +trait StorageProofAdapter, I: 'static> { + fn read_and_decode_mandatory_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result; + fn read_and_decode_optional_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result, StorageProofError>; + fn ensure_no_unused_keys(self) -> Result<(), StorageProofError>; + + fn read_and_decode_outbound_lane_data( + &mut self, + lane_id: &LaneId, + ) -> Result, StorageProofError> { + let storage_outbound_lane_data_key = bp_messages::storage_keys::outbound_lane_data_key( + T::ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, + lane_id, + ); + self.read_and_decode_optional_value(&storage_outbound_lane_data_key) + } + + fn read_and_decode_message_payload( + &mut self, + message_key: &MessageKey, + ) -> Result { + let storage_message_key = bp_messages::storage_keys::message_key( + T::ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, + &message_key.lane_id, + message_key.nonce, + ); + self.read_and_decode_mandatory_value(&storage_message_key) + } +} + +/// Actual storage proof adapter for messages proofs. +type MessagesStorageProofAdapter = StorageProofCheckerAdapter; + +/// A `StorageProofAdapter` implementation for raw storage proofs. +struct StorageProofCheckerAdapter, I: 'static> { + storage: StorageProofChecker>>, + _dummy: sp_std::marker::PhantomData<(T, I)>, +} + +impl, I: 'static> StorageProofCheckerAdapter { + fn try_new_with_verified_storage_proof( + bridged_header_hash: HashOf>, + storage_proof: RawStorageProof, + ) -> Result { + BridgedHeaderChainOf::::verify_storage_proof(bridged_header_hash, storage_proof).map( + |storage| StorageProofCheckerAdapter:: { storage, _dummy: Default::default() }, + ) + } +} + +impl, I: 'static> StorageProofAdapter for StorageProofCheckerAdapter { + fn read_and_decode_optional_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result, StorageProofError> { + self.storage.read_and_decode_opt_value(key.as_ref()) + } + + fn read_and_decode_mandatory_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result { + self.storage.read_and_decode_mandatory_value(key.as_ref()) + } + + fn ensure_no_unused_keys(self) -> Result<(), StorageProofError> { + self.storage.ensure_no_unused_nodes() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::tests::{ + messages_generation::{ + encode_all_messages, encode_lane_data, generate_dummy_message, + prepare_messages_storage_proof, + }, + mock::*, + }; + + use bp_header_chain::StoredHeaderDataBuilder; + use bp_runtime::{HeaderId, StorageProofError}; + use codec::Encode; + use sp_runtime::traits::Header; + + 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, + add_duplicate_key: bool, + add_unused_key: bool, + test: impl Fn(FromBridgedChainMessagesProof) -> R, + ) -> R { + let (state_root, storage_proof) = prepare_messages_storage_proof::( + TEST_LANE_ID, + 1..=nonces_end, + outbound_lane_data, + bp_runtime::UnverifiedStorageProofParams::default(), + generate_dummy_message, + encode_message, + encode_outbound_lane_data, + add_duplicate_key, + add_unused_key, + ); + + 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(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, + false, + false, + |proof| { 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, + false, + false, + |proof| { 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, + false, + false, + |proof| { + let bridged_header_hash = + pallet_bridge_grandpa::BestFinalized::::get().unwrap().1; + pallet_bridge_grandpa::ImportedHeaders::::remove( + bridged_header_hash, + ); + 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, + false, + false, + |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(), + ); + 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, + true, + false, + |proof| { verify_messages_proof::(proof, 10) }, + ), + Err(VerificationError::HeaderChain(HeaderChainError::StorageProof( + StorageProofError::DuplicateNodes + ))), + ); + } + + #[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, + false, + true, + |proof| { verify_messages_proof::(proof, 10) }, + ), + Err(VerificationError::StorageProof(StorageProofError::UnusedKey)), + ); + } + + #[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, + false, + false, + |proof| verify_messages_proof::(proof, 10) + ), + Err(VerificationError::MessageStorage(StorageProofError::EmptyVal)), + ); + } + + #[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, + false, + false, + |proof| verify_messages_proof::(proof, 10), + ), + Err(VerificationError::MessageStorage(StorageProofError::DecodeError)), + ); + } + + #[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 + }, + false, + false, + |proof| verify_messages_proof::(proof, 10), + ), + Err(VerificationError::OutboundLaneStorage(StorageProofError::DecodeError)), + ); + } + + #[test] + fn message_proof_is_rejected_if_it_is_empty() { + assert_eq!( + using_messages_proof( + 0, + None, + encode_all_messages, + encode_lane_data, + false, + false, + |proof| { 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, + false, + false, + |proof| 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, + false, + false, + |proof| 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, + false, + false, + |mut proof| { + proof.nonces_end = u64::MAX; + verify_messages_proof::(proof, u32::MAX) + }, + ), + Err(VerificationError::MessagesCountMismatch), + ); + } +} diff --git a/bridges/bin/runtime-common/src/messages_generation.rs b/bridges/modules/messages/src/tests/messages_generation.rs similarity index 62% rename from bridges/bin/runtime-common/src/messages_generation.rs rename to bridges/modules/messages/src/tests/messages_generation.rs index c37aaa5d4d5378a1b76507e017c73aec3c7aabbd..6c4867fa6de39fa97b35cbd1f270bdeff4c76dff 100644 --- a/bridges/bin/runtime-common/src/messages_generation.rs +++ b/bridges/modules/messages/src/tests/messages_generation.rs @@ -16,17 +16,23 @@ //! Helpers for generating message storage proofs, that are used by tests and by benchmarks. -use crate::messages::{AccountIdOf, BridgedChain, HashOf, HasherOf, MessageBridge, ThisChain}; - use bp_messages::{ - storage_keys, InboundLaneData, LaneId, MessageKey, MessageNonce, MessagePayload, - OutboundLaneData, + storage_keys, ChainWithMessages, InboundLaneData, LaneId, MessageKey, MessageNonce, + MessagePayload, OutboundLaneData, +}; +use bp_runtime::{ + grow_storage_value, record_all_trie_keys, AccountIdOf, Chain, HashOf, HasherOf, + RawStorageProof, UnverifiedStorageProofParams, }; -use bp_runtime::{record_all_trie_keys, RawStorageProof, StorageProofSize}; use codec::Encode; use sp_std::{ops::RangeInclusive, prelude::*}; use sp_trie::{trie_types::TrieDBMutBuilderV1, LayoutV1, MemoryDB, TrieMut}; +/// Dummy message generation function. +pub fn generate_dummy_message(_: MessageNonce) -> MessagePayload { + vec![42] +} + /// Simple and correct message data encode function. pub fn encode_all_messages(_: MessageNonce, m: &MessagePayload) -> Option> { Some(m.encode()) @@ -40,18 +46,20 @@ pub fn encode_lane_data(d: &OutboundLaneData) -> Vec { /// Prepare storage proof of given messages. /// /// Returns state trie root and nodes with prepared messages. -pub fn prepare_messages_storage_proof( +#[allow(clippy::too_many_arguments)] +pub fn prepare_messages_storage_proof( lane: LaneId, message_nonces: RangeInclusive, outbound_lane_data: Option, - size: StorageProofSize, - message_payload: MessagePayload, + proof_params: UnverifiedStorageProofParams, + generate_message: impl Fn(MessageNonce) -> MessagePayload, encode_message: impl Fn(MessageNonce, &MessagePayload) -> Option>, encode_outbound_lane_data: impl Fn(&OutboundLaneData) -> Vec, -) -> (HashOf>, RawStorageProof) + add_duplicate_key: bool, + add_unused_key: bool, +) -> (HashOf, RawStorageProof) where - B: MessageBridge, - HashOf>: Copy + Default, + HashOf: Copy + Default, { // prepare Bridged chain storage with messages and (optionally) outbound lane state let message_count = message_nonces.end().saturating_sub(*message_nonces.start()) + 1; @@ -60,22 +68,22 @@ where let mut mdb = MemoryDB::default(); { let mut trie = - TrieDBMutBuilderV1::>>::new(&mut mdb, &mut root).build(); + TrieDBMutBuilderV1::>::new(&mut mdb, &mut root).build(); // insert messages for (i, nonce) in message_nonces.into_iter().enumerate() { let message_key = MessageKey { lane_id: lane, nonce }; - let message_payload = match encode_message(nonce, &message_payload) { + let message_payload = match encode_message(nonce, &generate_message(nonce)) { Some(message_payload) => if i == 0 { - grow_trie_leaf_value(message_payload, size) + grow_storage_value(message_payload, &proof_params) } else { message_payload }, None => continue, }; let storage_key = storage_keys::message_key( - B::BRIDGED_MESSAGES_PALLET_NAME, + ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &message_key.lane_id, message_key.nonce, ) @@ -89,8 +97,11 @@ where // insert outbound lane state if let Some(outbound_lane_data) = outbound_lane_data.as_ref().map(encode_outbound_lane_data) { - let storage_key = - storage_keys::outbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane).0; + let storage_key = storage_keys::outbound_lane_data_key( + ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, + &lane, + ) + .0; trie.insert(&storage_key, &outbound_lane_data) .map_err(|_| "TrieMut::insert has failed") .expect("TrieMut::insert should not fail in benchmarks"); @@ -99,52 +110,54 @@ where } // generate storage proof to be delivered to This chain - let storage_proof = record_all_trie_keys::>>, _>(&mdb, &root) - .map_err(|_| "record_all_trie_keys has failed") - .expect("record_all_trie_keys should not fail in benchmarks"); + let mut storage_proof = + record_all_trie_keys::>, _>(&mdb, &root) + .map_err(|_| "record_all_trie_keys has failed") + .expect("record_all_trie_keys should not fail in benchmarks"); + + if add_duplicate_key { + assert!(!storage_proof.is_empty()); + let node = storage_proof.pop().unwrap(); + storage_proof.push(node.clone()); + storage_proof.push(node); + } + + if add_unused_key { + storage_proof.push(b"unused_value".to_vec()); + } + (root, storage_proof) } /// Prepare storage proof of given messages delivery. /// /// Returns state trie root and nodes with prepared messages. -pub fn prepare_message_delivery_storage_proof( +pub fn prepare_message_delivery_storage_proof( lane: LaneId, - inbound_lane_data: InboundLaneData>>, - size: StorageProofSize, -) -> (HashOf>, RawStorageProof) + inbound_lane_data: InboundLaneData>, + proof_params: UnverifiedStorageProofParams, +) -> (HashOf, RawStorageProof) where - B: MessageBridge, + HashOf: Copy + Default, { // prepare Bridged chain storage with inbound lane state - let storage_key = storage_keys::inbound_lane_data_key(B::BRIDGED_MESSAGES_PALLET_NAME, &lane).0; + let storage_key = + storage_keys::inbound_lane_data_key(ThisChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &lane).0; let mut root = Default::default(); let mut mdb = MemoryDB::default(); { let mut trie = - TrieDBMutBuilderV1::>>::new(&mut mdb, &mut root).build(); - let inbound_lane_data = grow_trie_leaf_value(inbound_lane_data.encode(), size); + TrieDBMutBuilderV1::>::new(&mut mdb, &mut root).build(); + let inbound_lane_data = grow_storage_value(inbound_lane_data.encode(), &proof_params); trie.insert(&storage_key, &inbound_lane_data) .map_err(|_| "TrieMut::insert has failed") .expect("TrieMut::insert should not fail in benchmarks"); } // generate storage proof to be delivered to This chain - let storage_proof = record_all_trie_keys::>>, _>(&mdb, &root) + let storage_proof = record_all_trie_keys::>, _>(&mdb, &root) .map_err(|_| "record_all_trie_keys has failed") .expect("record_all_trie_keys should not fail in benchmarks"); (root, storage_proof) } - -/// Add extra data to the trie leaf value so that it'll be of given size. -pub fn grow_trie_leaf_value(mut value: Vec, size: StorageProofSize) -> Vec { - match size { - StorageProofSize::Minimal(_) => (), - StorageProofSize::HasLargeLeaf(size) if size as usize > value.len() => { - value.extend(sp_std::iter::repeat(42u8).take(size as usize - value.len())); - }, - StorageProofSize::HasLargeLeaf(_) => (), - } - value -} diff --git a/bridges/modules/messages/src/mock.rs b/bridges/modules/messages/src/tests/mock.rs similarity index 63% rename from bridges/modules/messages/src/mock.rs rename to bridges/modules/messages/src/tests/mock.rs index ec63f15b94b5205d744b1379bd6697a4ae43534a..99da019dc0847d0787c30ada8e614270e83ddfdb 100644 --- a/bridges/modules/messages/src/mock.rs +++ b/bridges/modules/messages/src/tests/mock.rs @@ -17,30 +17,43 @@ // From construct_runtime macro #![allow(clippy::from_over_into)] -use crate::{Config, StoredMessagePayload}; +use crate::{ + tests::messages_generation::{ + encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof, + prepare_messages_storage_proof, + }, + Config, StoredMessagePayload, +}; +use bp_header_chain::{ChainWithGrandpa, StoredHeaderData}; use bp_messages::{ calc_relayers_rewards, - source_chain::{DeliveryConfirmationPayments, OnMessagesDelivered, TargetHeaderChain}, + source_chain::{ + DeliveryConfirmationPayments, FromBridgedChainMessagesDeliveryProof, OnMessagesDelivered, + }, target_chain::{ - DeliveryPayments, DispatchMessage, DispatchMessageData, MessageDispatch, - ProvedLaneMessages, ProvedMessages, SourceHeaderChain, + DeliveryPayments, DispatchMessage, DispatchMessageData, FromBridgedChainMessagesProof, + MessageDispatch, }, - DeliveredMessages, InboundLaneData, LaneId, Message, MessageKey, MessageNonce, - UnrewardedRelayer, UnrewardedRelayersState, VerificationError, + ChainWithMessages, DeliveredMessages, InboundLaneData, LaneId, Message, MessageKey, + MessageNonce, OutboundLaneData, UnrewardedRelayer, UnrewardedRelayersState, +}; +use bp_runtime::{ + messages::MessageDispatchResult, Chain, ChainId, Size, UnverifiedStorageProofParams, }; -use bp_runtime::{messages::MessageDispatchResult, Size}; use codec::{Decode, Encode}; use frame_support::{ derive_impl, parameter_types, weights::{constants::RocksDbWeight, Weight}, }; use scale_info::TypeInfo; -use sp_runtime::BuildStorage; -use std::{ - collections::{BTreeMap, VecDeque}, - ops::RangeInclusive, +use sp_core::H256; +use sp_runtime::{ + testing::Header as SubstrateHeader, + traits::{BlakeTwo256, ConstU32}, + BuildStorage, StateVersion, }; +use std::{collections::VecDeque, ops::RangeInclusive}; pub type AccountId = u64; pub type Balance = u64; @@ -62,6 +75,77 @@ pub type TestMessageFee = u64; pub type TestRelayer = u64; pub type TestDispatchLevelResult = (); +pub struct ThisChain; + +impl Chain for ThisChain { + const ID: ChainId = *b"ttch"; + + type BlockNumber = u64; + type Hash = H256; + type Hasher = BlakeTwo256; + type Header = SubstrateHeader; + type AccountId = AccountId; + type Balance = Balance; + type Nonce = u64; + type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + + fn max_extrinsic_size() -> u32 { + u32::MAX + } + + fn max_extrinsic_weight() -> Weight { + Weight::MAX + } +} + +impl ChainWithMessages for ThisChain { + const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "WithThisChainBridgeMessages"; + const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16; + const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 128; +} + +pub struct BridgedChain; + +pub type BridgedHeaderHash = H256; +pub type BridgedChainHeader = SubstrateHeader; + +impl Chain for BridgedChain { + const ID: ChainId = *b"tbch"; + + type BlockNumber = u64; + type Hash = BridgedHeaderHash; + type Hasher = BlakeTwo256; + type Header = BridgedChainHeader; + type AccountId = TestRelayer; + type Balance = Balance; + type Nonce = u64; + type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + + fn max_extrinsic_size() -> u32 { + 4096 + } + + fn max_extrinsic_weight() -> Weight { + Weight::MAX + } +} + +impl ChainWithGrandpa for BridgedChain { + const WITH_CHAIN_GRANDPA_PALLET_NAME: &'static str = "WithBridgedChainBridgeGrandpa"; + const MAX_AUTHORITIES_COUNT: u32 = 16; + const REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY: u32 = 4; + const MAX_MANDATORY_HEADER_SIZE: u32 = 4096; + const AVERAGE_HEADER_SIZE: u32 = 4096; +} + +impl ChainWithMessages for BridgedChain { + const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str = "WithBridgedChainBridgeMessages"; + const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce = 16; + const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce = 128; +} + type Block = frame_system::mocking::MockBlock; use crate as pallet_bridge_messages; @@ -71,6 +155,7 @@ frame_support::construct_runtime! { { System: frame_system::{Pallet, Call, Config, Storage, Event}, Balances: pallet_balances::{Pallet, Call, Event}, + BridgedChainGrandpa: pallet_bridge_grandpa::{Pallet, Call, Event}, Messages: pallet_bridge_messages::{Pallet, Call, Event}, } } @@ -86,14 +171,20 @@ impl frame_system::Config for TestRuntime { #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for TestRuntime { - type ReserveIdentifier = [u8; 8]; type AccountStore = System; } +impl pallet_bridge_grandpa::Config for TestRuntime { + type RuntimeEvent = RuntimeEvent; + type BridgedChain = BridgedChain; + type MaxFreeHeadersPerBlock = ConstU32<4>; + type FreeHeadersInterval = ConstU32<1_024>; + type HeadersToKeep = ConstU32<8>; + type WeightInfo = pallet_bridge_grandpa::weights::BridgeWeight; +} + parameter_types! { pub const MaxMessagesToPruneAtOnce: u64 = 10; - pub const MaxUnrewardedRelayerEntriesAtInboundLane: u64 = 16; - pub const MaxUnconfirmedMessagesAtInboundLane: u64 = 128; pub const TestBridgedChainId: bp_runtime::ChainId = *b"test"; pub const ActiveOutboundLanes: &'static [LaneId] = &[TEST_LANE_ID, TEST_LANE_ID_2]; } @@ -104,24 +195,22 @@ pub type TestWeightInfo = (); impl Config for TestRuntime { type RuntimeEvent = RuntimeEvent; type WeightInfo = TestWeightInfo; + + type ThisChain = ThisChain; + type BridgedChain = BridgedChain; + type BridgedHeaderChain = BridgedChainGrandpa; + type ActiveOutboundLanes = ActiveOutboundLanes; - type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; - type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; - type MaximalOutboundPayloadSize = frame_support::traits::ConstU32; type OutboundPayload = TestPayload; type InboundPayload = TestPayload; - type InboundRelayer = TestRelayer; type DeliveryPayments = TestDeliveryPayments; - type TargetHeaderChain = TestTargetHeaderChain; type DeliveryConfirmationPayments = TestDeliveryConfirmationPayments; type OnMessagesDelivered = TestOnMessagesDelivered; - type SourceHeaderChain = TestSourceHeaderChain; type MessageDispatch = TestMessageDispatch; - type BridgedChainId = TestBridgedChainId; } #[cfg(feature = "runtime-benchmarks")] @@ -132,29 +221,26 @@ impl crate::benchmarking::Config<()> for TestRuntime { fn prepare_message_proof( params: crate::benchmarking::MessageProofParams, - ) -> (TestMessagesProof, Weight) { - // in mock run we only care about benchmarks correctness, not the benchmark results - // => ignore size related arguments - let (messages, total_dispatch_weight) = - params.message_nonces.into_iter().map(|n| message(n, REGULAR_PAYLOAD)).fold( - (Vec::new(), Weight::zero()), - |(mut messages, total_dispatch_weight), message| { - let weight = REGULAR_PAYLOAD.declared_weight; - messages.push(message); - (messages, total_dispatch_weight.saturating_add(weight)) - }, - ); - let mut proof: TestMessagesProof = Ok(messages).into(); - proof.result.as_mut().unwrap().get_mut(0).unwrap().1.lane_state = params.outbound_lane_data; - (proof, total_dispatch_weight) + ) -> (FromBridgedChainMessagesProof, Weight) { + use bp_runtime::RangeInclusiveExt; + + let dispatch_weight = + REGULAR_PAYLOAD.declared_weight * params.message_nonces.saturating_len(); + ( + *prepare_messages_proof( + params.message_nonces.into_iter().map(|n| message(n, REGULAR_PAYLOAD)).collect(), + params.outbound_lane_data, + ), + dispatch_weight, + ) } fn prepare_message_delivery_proof( params: crate::benchmarking::MessageDeliveryProofParams, - ) -> TestMessagesDeliveryProof { + ) -> FromBridgedChainMessagesDeliveryProof { // in mock run we only care about benchmarks correctness, not the benchmark results // => ignore size related arguments - TestMessagesDeliveryProof(Ok((params.lane, params.inbound_lane_data))) + prepare_messages_delivery_proof(params.lane, params.inbound_lane_data) } fn is_relayer_rewarded(_relayer: &AccountId) -> bool { @@ -168,9 +254,6 @@ impl Size for TestPayload { } } -/// Maximal outbound payload size. -pub const MAX_OUTBOUND_PAYLOAD_SIZE: u32 = 4096; - /// Account that has balance to use in tests. pub const ENDOWED_ACCOUNT: AccountId = 0xDEAD; @@ -183,9 +266,6 @@ pub const TEST_RELAYER_B: AccountId = 101; /// Account id of additional test relayer - C. pub const TEST_RELAYER_C: AccountId = 102; -/// Error that is returned by all test implementations. -pub const TEST_ERROR: &str = "Test error"; - /// Lane that we're using in tests. pub const TEST_LANE_ID: LaneId = LaneId([0, 0, 0, 1]); @@ -198,71 +278,6 @@ pub const TEST_LANE_ID_3: LaneId = LaneId([0, 0, 0, 3]); /// Regular message payload. pub const REGULAR_PAYLOAD: TestPayload = message_payload(0, 50); -/// Payload that is rejected by `TestTargetHeaderChain`. -pub const PAYLOAD_REJECTED_BY_TARGET_CHAIN: TestPayload = message_payload(1, 50); - -/// Vec of proved messages, grouped by lane. -pub type MessagesByLaneVec = Vec<(LaneId, ProvedLaneMessages)>; - -/// Test messages proof. -#[derive(Debug, Encode, Decode, Clone, PartialEq, Eq, TypeInfo)] -pub struct TestMessagesProof { - pub result: Result, -} - -impl Size for TestMessagesProof { - fn size(&self) -> u32 { - 0 - } -} - -impl From, ()>> for TestMessagesProof { - fn from(result: Result, ()>) -> Self { - Self { - result: result.map(|messages| { - let mut messages_by_lane: BTreeMap> = - BTreeMap::new(); - for message in messages { - messages_by_lane.entry(message.key.lane_id).or_default().messages.push(message); - } - messages_by_lane.into_iter().collect() - }), - } - } -} - -/// Messages delivery proof used in tests. -#[derive(Debug, Encode, Decode, Eq, Clone, PartialEq, TypeInfo)] -pub struct TestMessagesDeliveryProof(pub Result<(LaneId, InboundLaneData), ()>); - -impl Size for TestMessagesDeliveryProof { - fn size(&self) -> u32 { - 0 - } -} - -/// Target header chain that is used in tests. -#[derive(Debug, Default)] -pub struct TestTargetHeaderChain; - -impl TargetHeaderChain for TestTargetHeaderChain { - type MessagesDeliveryProof = TestMessagesDeliveryProof; - - fn verify_message(payload: &TestPayload) -> Result<(), VerificationError> { - if *payload == PAYLOAD_REJECTED_BY_TARGET_CHAIN { - Err(VerificationError::Other(TEST_ERROR)) - } else { - Ok(()) - } - } - - fn verify_messages_delivery_proof( - proof: Self::MessagesDeliveryProof, - ) -> Result<(LaneId, InboundLaneData), VerificationError> { - proof.0.map_err(|_| VerificationError::Other(TEST_ERROR)) - } -} - /// Reward payments at the target chain during delivery transaction. #[derive(Debug, Default)] pub struct TestDeliveryPayments; @@ -323,24 +338,6 @@ impl DeliveryConfirmationPayments for TestDeliveryConfirmationPayment } } -/// Source header chain that is used in tests. -#[derive(Debug)] -pub struct TestSourceHeaderChain; - -impl SourceHeaderChain for TestSourceHeaderChain { - type MessagesProof = TestMessagesProof; - - fn verify_messages_proof( - proof: Self::MessagesProof, - _messages_count: u32, - ) -> Result, VerificationError> { - proof - .result - .map(|proof| proof.into_iter().collect()) - .map_err(|_| VerificationError::Other(TEST_ERROR)) - } -} - /// Test message dispatcher. #[derive(Debug)] pub struct TestMessageDispatch; @@ -459,3 +456,75 @@ pub fn new_test_ext() -> sp_io::TestExternalities { pub fn run_test(test: impl FnOnce() -> T) -> T { new_test_ext().execute_with(test) } + +/// Prepare valid storage proof for given messages and insert appropriate header to the +/// bridged header chain. +/// +/// Since this function changes the runtime storage, you can't "inline" it in the +/// `asset_noop` macro calls. +pub fn prepare_messages_proof( + messages: Vec, + outbound_lane_data: Option, +) -> Box> { + // first - let's generate storage proof + let lane = messages.first().unwrap().key.lane_id; + let nonces_start = messages.first().unwrap().key.nonce; + let nonces_end = messages.last().unwrap().key.nonce; + let (storage_root, storage_proof) = prepare_messages_storage_proof::( + TEST_LANE_ID, + nonces_start..=nonces_end, + outbound_lane_data, + UnverifiedStorageProofParams::default(), + |nonce| messages[(nonce - nonces_start) as usize].payload.clone(), + encode_all_messages, + encode_lane_data, + false, + false, + ); + + // let's now insert bridged chain header into the storage + let bridged_header_hash = Default::default(); + pallet_bridge_grandpa::ImportedHeaders::::insert( + bridged_header_hash, + StoredHeaderData { number: 0, state_root: storage_root }, + ); + + Box::new(FromBridgedChainMessagesProof:: { + bridged_header_hash, + storage_proof, + lane, + nonces_start, + nonces_end, + }) +} + +/// Prepare valid storage proof for given messages and insert appropriate header to the +/// bridged header chain. +/// +/// Since this function changes the runtime storage, you can't "inline" it in the +/// `asset_noop` macro calls. +pub fn prepare_messages_delivery_proof( + lane: LaneId, + inbound_lane_data: InboundLaneData, +) -> FromBridgedChainMessagesDeliveryProof { + // first - let's generate storage proof + let (storage_root, storage_proof) = + prepare_message_delivery_storage_proof::( + lane, + inbound_lane_data, + UnverifiedStorageProofParams::default(), + ); + + // let's now insert bridged chain header into the storage + let bridged_header_hash = Default::default(); + pallet_bridge_grandpa::ImportedHeaders::::insert( + bridged_header_hash, + StoredHeaderData { number: 0, state_root: storage_root }, + ); + + FromBridgedChainMessagesDeliveryProof:: { + bridged_header_hash, + storage_proof, + lane, + } +} diff --git a/bridges/modules/messages/src/tests/mod.rs b/bridges/modules/messages/src/tests/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c3bde5fc275849fab930ad0b1ec9f0b4e80ce4ea --- /dev/null +++ b/bridges/modules/messages/src/tests/mod.rs @@ -0,0 +1,26 @@ +// Copyright 2019-2021 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 . + +//! Tests and test helpers for messages pallet. + +#![cfg(any(feature = "test-helpers", test))] + +#[cfg(test)] +pub(crate) mod mock; +#[cfg(test)] +mod pallet_tests; + +pub mod messages_generation; diff --git a/bridges/modules/messages/src/tests/pallet_tests.rs b/bridges/modules/messages/src/tests/pallet_tests.rs new file mode 100644 index 0000000000000000000000000000000000000000..f7a288d649a936b8931ea3ac629b0757927debba --- /dev/null +++ b/bridges/modules/messages/src/tests/pallet_tests.rs @@ -0,0 +1,1015 @@ +// Copyright 2019-2021 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 . + +//! Pallet-level tests. + +use crate::{ + outbound_lane, + outbound_lane::ReceptionConfirmationError, + tests::mock::{self, RuntimeEvent as TestEvent, *}, + weights_ext::WeightInfoExt, + Call, Config, Error, Event, InboundLanes, MaybeOutboundLanesCount, OutboundLanes, + OutboundMessages, Pallet, PalletOperatingMode, PalletOwner, RuntimeInboundLaneStorage, + StoredInboundLaneData, +}; + +use bp_messages::{ + source_chain::{FromBridgedChainMessagesDeliveryProof, MessagesBridge}, + target_chain::FromBridgedChainMessagesProof, + BridgeMessagesCall, ChainWithMessages, DeliveredMessages, InboundLaneData, + InboundMessageDetails, LaneId, MessageKey, MessageNonce, MessagesOperatingMode, + OutboundLaneData, OutboundMessageDetails, UnrewardedRelayer, UnrewardedRelayersState, + VerificationError, +}; +use bp_runtime::{BasicOperatingMode, PreComputedSize, RangeInclusiveExt, Size}; +use bp_test_utils::generate_owned_bridge_module_tests; +use codec::Encode; +use frame_support::{ + assert_err, assert_noop, assert_ok, + dispatch::Pays, + storage::generator::{StorageMap, StorageValue}, + weights::Weight, +}; +use frame_system::{EventRecord, Pallet as System, Phase}; +use sp_core::Get; +use sp_runtime::{BoundedVec, DispatchError}; + +fn get_ready_for_events() { + System::::set_block_number(1); + System::::reset_events(); +} + +fn send_regular_message(lane_id: LaneId) { + get_ready_for_events(); + + let outbound_lane = outbound_lane::(lane_id); + let message_nonce = outbound_lane.data().latest_generated_nonce + 1; + let prev_enqueued_messages = outbound_lane.data().queued_messages().saturating_len(); + let valid_message = Pallet::::validate_message(lane_id, ®ULAR_PAYLOAD) + .expect("validate_message has failed"); + let artifacts = Pallet::::send_message(valid_message); + assert_eq!(artifacts.enqueued_messages, prev_enqueued_messages + 1); + + // check event with assigned nonce + assert_eq!( + System::::events(), + vec![EventRecord { + phase: Phase::Initialization, + event: TestEvent::Messages(Event::MessageAccepted { lane_id, nonce: message_nonce }), + topics: vec![], + }], + ); +} + +fn receive_messages_delivery_proof() { + System::::set_block_number(1); + System::::reset_events(); + + assert_ok!(Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + last_confirmed_nonce: 1, + relayers: vec![UnrewardedRelayer { + relayer: 0, + messages: DeliveredMessages::new(1), + }] + .into(), + }, + ), + UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + messages_in_oldest_entry: 1, + total_messages: 1, + last_delivered_nonce: 1, + }, + )); + assert_ok!(Pallet::::do_try_state()); + + assert_eq!( + System::::events(), + vec![EventRecord { + phase: Phase::Initialization, + event: TestEvent::Messages(Event::MessagesDelivered { + lane_id: TEST_LANE_ID, + messages: DeliveredMessages::new(1), + }), + topics: vec![], + }], + ); +} + +#[test] +fn pallet_rejects_transactions_if_halted() { + run_test(|| { + // send message first to be able to check that delivery_proof fails later + send_regular_message(TEST_LANE_ID); + + PalletOperatingMode::::put(MessagesOperatingMode::Basic( + BasicOperatingMode::Halted, + )); + + assert_noop!( + Pallet::::validate_message(TEST_LANE_ID, ®ULAR_PAYLOAD), + Error::::NotOperatingNormally, + ); + + let messages_proof = prepare_messages_proof(vec![message(2, REGULAR_PAYLOAD)], None); + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + messages_proof, + 1, + REGULAR_PAYLOAD.declared_weight, + ), + Error::::BridgeModule(bp_runtime::OwnedBridgeModuleError::Halted), + ); + + let delivery_proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + last_confirmed_nonce: 1, + relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)].into(), + }, + ); + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + delivery_proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + messages_in_oldest_entry: 1, + total_messages: 1, + last_delivered_nonce: 1, + }, + ), + Error::::BridgeModule(bp_runtime::OwnedBridgeModuleError::Halted), + ); + assert_ok!(Pallet::::do_try_state()); + }); +} + +#[test] +fn receive_messages_fails_if_dispatcher_is_inactive() { + run_test(|| { + TestMessageDispatch::deactivate(); + let proof = prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None); + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + 1, + REGULAR_PAYLOAD.declared_weight, + ), + Error::::MessageDispatchInactive, + ); + }); +} + +#[test] +fn pallet_rejects_new_messages_in_rejecting_outbound_messages_operating_mode() { + run_test(|| { + // send message first to be able to check that delivery_proof fails later + send_regular_message(TEST_LANE_ID); + + PalletOperatingMode::::put( + MessagesOperatingMode::RejectingOutboundMessages, + ); + + assert_noop!( + Pallet::::validate_message(TEST_LANE_ID, ®ULAR_PAYLOAD), + Error::::NotOperatingNormally, + ); + + assert_ok!(Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None), + 1, + REGULAR_PAYLOAD.declared_weight, + ),); + + assert_ok!(Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + last_confirmed_nonce: 1, + relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)].into(), + }, + ), + UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + messages_in_oldest_entry: 1, + total_messages: 1, + last_delivered_nonce: 1, + }, + )); + assert_ok!(Pallet::::do_try_state()); + }); +} + +#[test] +fn send_message_works() { + run_test(|| { + send_regular_message(TEST_LANE_ID); + }); +} + +#[test] +fn send_message_rejects_too_large_message() { + run_test(|| { + let mut message_payload = message_payload(1, 0); + // the payload isn't simply extra, so it'll definitely overflow + // `max_outbound_payload_size` if we add `max_outbound_payload_size` bytes to extra + let max_outbound_payload_size = BridgedChain::maximal_incoming_message_size(); + message_payload + .extra + .extend_from_slice(&vec![0u8; max_outbound_payload_size as usize]); + assert_noop!( + Pallet::::validate_message(TEST_LANE_ID, &message_payload.clone(),), + Error::::MessageRejectedByPallet(VerificationError::MessageTooLarge), + ); + + // let's check that we're able to send `max_outbound_payload_size` messages + while message_payload.encoded_size() as u32 > max_outbound_payload_size { + message_payload.extra.pop(); + } + assert_eq!(message_payload.encoded_size() as u32, max_outbound_payload_size); + + let valid_message = + Pallet::::validate_message(TEST_LANE_ID, &message_payload) + .expect("validate_message has failed"); + Pallet::::send_message(valid_message); + }) +} + +#[test] +fn receive_messages_proof_works() { + run_test(|| { + assert_ok!(Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None), + 1, + REGULAR_PAYLOAD.declared_weight, + )); + + assert_eq!(InboundLanes::::get(TEST_LANE_ID).0.last_delivered_nonce(), 1); + + assert!(TestDeliveryPayments::is_reward_paid(1)); + }); +} + +#[test] +fn receive_messages_proof_updates_confirmed_message_nonce() { + run_test(|| { + // say we have received 10 messages && last confirmed message is 8 + InboundLanes::::insert( + TEST_LANE_ID, + InboundLaneData { + last_confirmed_nonce: 8, + relayers: vec![ + unrewarded_relayer(9, 9, TEST_RELAYER_A), + unrewarded_relayer(10, 10, TEST_RELAYER_B), + ] + .into(), + }, + ); + assert_eq!( + inbound_unrewarded_relayers_state(TEST_LANE_ID), + UnrewardedRelayersState { + unrewarded_relayer_entries: 2, + messages_in_oldest_entry: 1, + total_messages: 2, + last_delivered_nonce: 10, + }, + ); + + // message proof includes outbound lane state with latest confirmed message updated to 9 + assert_ok!(Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + prepare_messages_proof( + vec![message(11, REGULAR_PAYLOAD)], + Some(OutboundLaneData { latest_received_nonce: 9, ..Default::default() }), + ), + 1, + REGULAR_PAYLOAD.declared_weight, + )); + + assert_eq!( + InboundLanes::::get(TEST_LANE_ID).0, + InboundLaneData { + last_confirmed_nonce: 9, + relayers: vec![ + unrewarded_relayer(10, 10, TEST_RELAYER_B), + unrewarded_relayer(11, 11, TEST_RELAYER_A) + ] + .into(), + }, + ); + assert_eq!( + inbound_unrewarded_relayers_state(TEST_LANE_ID), + UnrewardedRelayersState { + unrewarded_relayer_entries: 2, + messages_in_oldest_entry: 1, + total_messages: 2, + last_delivered_nonce: 11, + }, + ); + }); +} + +#[test] +fn receive_messages_proof_does_not_accept_message_if_dispatch_weight_is_not_enough() { + run_test(|| { + let proof = prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None); + let mut declared_weight = REGULAR_PAYLOAD.declared_weight; + *declared_weight.ref_time_mut() -= 1; + + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + 1, + declared_weight, + ), + Error::::InsufficientDispatchWeight + ); + assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 0); + }); +} + +#[test] +fn receive_messages_proof_rejects_invalid_proof() { + run_test(|| { + let mut proof = prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None); + proof.nonces_end += 1; + + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + 1, + Weight::zero(), + ), + Error::::InvalidMessagesProof, + ); + }); +} + +#[test] +fn receive_messages_proof_rejects_proof_with_too_many_messages() { + run_test(|| { + let proof = prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None); + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + u32::MAX, + Weight::zero(), + ), + Error::::TooManyMessagesInTheProof, + ); + }); +} + +#[test] +fn receive_messages_delivery_proof_works() { + run_test(|| { + assert_eq!(OutboundLanes::::get(TEST_LANE_ID).latest_received_nonce, 0); + assert_eq!(OutboundLanes::::get(TEST_LANE_ID).oldest_unpruned_nonce, 1); + + send_regular_message(TEST_LANE_ID); + receive_messages_delivery_proof(); + + assert_eq!(OutboundLanes::::get(TEST_LANE_ID).latest_received_nonce, 1); + assert_eq!(OutboundLanes::::get(TEST_LANE_ID).oldest_unpruned_nonce, 2); + }); +} + +#[test] +fn receive_messages_delivery_proof_rewards_relayers() { + run_test(|| { + send_regular_message(TEST_LANE_ID); + send_regular_message(TEST_LANE_ID); + + // this reports delivery of message 1 => reward is paid to TEST_RELAYER_A + let single_message_delivery_proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + relayers: vec![unrewarded_relayer(1, 1, TEST_RELAYER_A)].into(), + ..Default::default() + }, + ); + let single_message_delivery_proof_size = single_message_delivery_proof.size(); + let result = Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + single_message_delivery_proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + messages_in_oldest_entry: 1, + total_messages: 1, + last_delivered_nonce: 1, + }, + ); + assert_ok!(result); + assert_ok!(Pallet::::do_try_state()); + assert_eq!( + result.unwrap().actual_weight.unwrap(), + TestWeightInfo::receive_messages_delivery_proof_weight( + &PreComputedSize(single_message_delivery_proof_size as _), + &UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + total_messages: 1, + ..Default::default() + }, + ) + ); + assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); + assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); + + // this reports delivery of both message 1 and message 2 => reward is paid only to + // TEST_RELAYER_B + let two_messages_delivery_proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + relayers: vec![ + unrewarded_relayer(1, 1, TEST_RELAYER_A), + unrewarded_relayer(2, 2, TEST_RELAYER_B), + ] + .into(), + ..Default::default() + }, + ); + let two_messages_delivery_proof_size = two_messages_delivery_proof.size(); + let result = Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + two_messages_delivery_proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 2, + messages_in_oldest_entry: 1, + total_messages: 2, + last_delivered_nonce: 2, + }, + ); + assert_ok!(result); + assert_ok!(Pallet::::do_try_state()); + // even though the pre-dispatch weight was for two messages, the actual weight is + // for single message only + assert_eq!( + result.unwrap().actual_weight.unwrap(), + TestWeightInfo::receive_messages_delivery_proof_weight( + &PreComputedSize(two_messages_delivery_proof_size as _), + &UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + total_messages: 1, + ..Default::default() + }, + ) + ); + assert!(!TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_A, 1)); + assert!(TestDeliveryConfirmationPayments::is_reward_paid(TEST_RELAYER_B, 1)); + assert_eq!(TestOnMessagesDelivered::call_arguments(), Some((TEST_LANE_ID, 0))); + }); +} + +#[test] +fn receive_messages_delivery_proof_rejects_invalid_proof() { + run_test(|| { + let mut proof = prepare_messages_delivery_proof(TEST_LANE_ID, Default::default()); + proof.lane = bp_messages::LaneId([42, 42, 42, 42]); + + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + proof, + Default::default(), + ), + Error::::InvalidMessagesDeliveryProof, + ); + }); +} + +#[test] +fn receive_messages_delivery_proof_rejects_proof_if_declared_relayers_state_is_invalid() { + run_test(|| { + // when number of relayers entries is invalid + let proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + relayers: vec![ + unrewarded_relayer(1, 1, TEST_RELAYER_A), + unrewarded_relayer(2, 2, TEST_RELAYER_B), + ] + .into(), + ..Default::default() + }, + ); + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + total_messages: 2, + last_delivered_nonce: 2, + ..Default::default() + }, + ), + Error::::InvalidUnrewardedRelayersState, + ); + + // when number of messages is invalid + let proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + relayers: vec![ + unrewarded_relayer(1, 1, TEST_RELAYER_A), + unrewarded_relayer(2, 2, TEST_RELAYER_B), + ] + .into(), + ..Default::default() + }, + ); + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 2, + total_messages: 1, + last_delivered_nonce: 2, + ..Default::default() + }, + ), + Error::::InvalidUnrewardedRelayersState, + ); + + // when last delivered nonce is invalid + let proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + relayers: vec![ + unrewarded_relayer(1, 1, TEST_RELAYER_A), + unrewarded_relayer(2, 2, TEST_RELAYER_B), + ] + .into(), + ..Default::default() + }, + ); + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + proof, + UnrewardedRelayersState { + unrewarded_relayer_entries: 2, + total_messages: 2, + last_delivered_nonce: 8, + ..Default::default() + }, + ), + Error::::InvalidUnrewardedRelayersState, + ); + }); +} + +#[test] +fn receive_messages_accepts_single_message_with_invalid_payload() { + run_test(|| { + let mut invalid_message = message(1, REGULAR_PAYLOAD); + invalid_message.payload = Vec::new(); + + assert_ok!(Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + prepare_messages_proof(vec![invalid_message], None), + 1, + Weight::zero(), /* weight may be zero in this case (all messages are + * improperly encoded) */ + ),); + + assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 1,); + }); +} + +#[test] +fn receive_messages_accepts_batch_with_message_with_invalid_payload() { + run_test(|| { + let mut invalid_message = message(2, REGULAR_PAYLOAD); + invalid_message.payload = Vec::new(); + + assert_ok!(Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + prepare_messages_proof( + vec![message(1, REGULAR_PAYLOAD), invalid_message, message(3, REGULAR_PAYLOAD),], + None + ), + 3, + REGULAR_PAYLOAD.declared_weight + REGULAR_PAYLOAD.declared_weight, + ),); + + assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 3,); + }); +} + +#[test] +fn actual_dispatch_weight_does_not_overflow() { + run_test(|| { + let message1 = message(1, message_payload(0, u64::MAX / 2)); + let message2 = message(2, message_payload(0, u64::MAX / 2)); + let message3 = message(3, message_payload(0, u64::MAX / 2)); + + let proof = prepare_messages_proof(vec![message1, message2, message3], None); + assert_noop!( + Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + // this may cause overflow if source chain storage is invalid + proof, + 3, + Weight::MAX, + ), + Error::::InsufficientDispatchWeight + ); + assert_eq!(InboundLanes::::get(TEST_LANE_ID).last_delivered_nonce(), 0); + }); +} + +#[test] +fn ref_time_refund_from_receive_messages_proof_works() { + run_test(|| { + fn submit_with_unspent_weight( + nonce: MessageNonce, + unspent_weight: u64, + ) -> (Weight, Weight) { + let mut payload = REGULAR_PAYLOAD; + *payload.dispatch_result.unspent_weight.ref_time_mut() = unspent_weight; + let proof = prepare_messages_proof(vec![message(nonce, payload)], None); + let messages_count = 1; + let pre_dispatch_weight = + ::WeightInfo::receive_messages_proof_weight( + &*proof, + messages_count, + REGULAR_PAYLOAD.declared_weight, + ); + let result = Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + messages_count, + REGULAR_PAYLOAD.declared_weight, + ) + .expect("delivery has failed"); + let post_dispatch_weight = + result.actual_weight.expect("receive_messages_proof always returns Some"); + + // message delivery transactions are never free + assert_eq!(result.pays_fee, Pays::Yes); + + (pre_dispatch_weight, post_dispatch_weight) + } + + // when dispatch is returning `unspent_weight < declared_weight` + let (pre, post) = submit_with_unspent_weight(1, 1); + assert_eq!(post.ref_time(), pre.ref_time() - 1); + + // when dispatch is returning `unspent_weight = declared_weight` + let (pre, post) = submit_with_unspent_weight(2, REGULAR_PAYLOAD.declared_weight.ref_time()); + assert_eq!(post.ref_time(), pre.ref_time() - REGULAR_PAYLOAD.declared_weight.ref_time()); + + // when dispatch is returning `unspent_weight > declared_weight` + let (pre, post) = + submit_with_unspent_weight(3, REGULAR_PAYLOAD.declared_weight.ref_time() + 1); + assert_eq!(post.ref_time(), pre.ref_time() - REGULAR_PAYLOAD.declared_weight.ref_time()); + + // when there's no unspent weight + let (pre, post) = submit_with_unspent_weight(4, 0); + assert_eq!(post.ref_time(), pre.ref_time()); + + // when dispatch is returning `unspent_weight < declared_weight` + let (pre, post) = submit_with_unspent_weight(5, 1); + assert_eq!(post.ref_time(), pre.ref_time() - 1); + }); +} + +#[test] +fn proof_size_refund_from_receive_messages_proof_works() { + run_test(|| { + let max_entries = BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX as usize; + + // if there's maximal number of unrewarded relayer entries at the inbound lane, then + // `proof_size` is unchanged in post-dispatch weight + let proof = prepare_messages_proof(vec![message(101, REGULAR_PAYLOAD)], None); + let messages_count = 1; + let pre_dispatch_weight = + ::WeightInfo::receive_messages_proof_weight( + &*proof, + messages_count, + REGULAR_PAYLOAD.declared_weight, + ); + InboundLanes::::insert( + TEST_LANE_ID, + StoredInboundLaneData(InboundLaneData { + relayers: vec![ + UnrewardedRelayer { + relayer: 42, + messages: DeliveredMessages { begin: 0, end: 100 } + }; + max_entries + ] + .into(), + last_confirmed_nonce: 0, + }), + ); + let post_dispatch_weight = Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof.clone(), + messages_count, + REGULAR_PAYLOAD.declared_weight, + ) + .unwrap() + .actual_weight + .unwrap(); + assert_eq!(post_dispatch_weight.proof_size(), pre_dispatch_weight.proof_size()); + + // if count of unrewarded relayer entries is less than maximal, then some `proof_size` + // must be refunded + InboundLanes::::insert( + TEST_LANE_ID, + StoredInboundLaneData(InboundLaneData { + relayers: vec![ + UnrewardedRelayer { + relayer: 42, + messages: DeliveredMessages { begin: 0, end: 100 } + }; + max_entries - 1 + ] + .into(), + last_confirmed_nonce: 0, + }), + ); + let post_dispatch_weight = Pallet::::receive_messages_proof( + RuntimeOrigin::signed(1), + TEST_RELAYER_A, + proof, + messages_count, + REGULAR_PAYLOAD.declared_weight, + ) + .unwrap() + .actual_weight + .unwrap(); + assert!( + post_dispatch_weight.proof_size() < pre_dispatch_weight.proof_size(), + "Expected post-dispatch PoV {} to be less than pre-dispatch PoV {}", + post_dispatch_weight.proof_size(), + pre_dispatch_weight.proof_size(), + ); + }); +} + +#[test] +fn receive_messages_delivery_proof_rejects_proof_if_trying_to_confirm_more_messages_than_expected() +{ + run_test(|| { + // send message first to be able to check that delivery_proof fails later + send_regular_message(TEST_LANE_ID); + + // 1) InboundLaneData declares that the `last_confirmed_nonce` is 1; + // 2) InboundLaneData has no entries => `InboundLaneData::last_delivered_nonce()` returns + // `last_confirmed_nonce`; + // 3) it means that we're going to confirm delivery of messages 1..=1; + // 4) so the number of declared messages (see `UnrewardedRelayersState`) is `0` and numer of + // actually confirmed messages is `1`. + let proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { last_confirmed_nonce: 1, relayers: Default::default() }, + ); + assert_noop!( + Pallet::::receive_messages_delivery_proof( + RuntimeOrigin::signed(1), + proof, + UnrewardedRelayersState { last_delivered_nonce: 1, ..Default::default() }, + ), + Error::::ReceptionConfirmation( + ReceptionConfirmationError::TryingToConfirmMoreMessagesThanExpected + ), + ); + }); +} + +#[test] +fn storage_keys_computed_properly() { + assert_eq!( + PalletOperatingMode::::storage_value_final_key().to_vec(), + bp_messages::storage_keys::operating_mode_key("Messages").0, + ); + + assert_eq!( + OutboundMessages::::storage_map_final_key(MessageKey { + lane_id: TEST_LANE_ID, + nonce: 42 + }), + bp_messages::storage_keys::message_key("Messages", &TEST_LANE_ID, 42).0, + ); + + assert_eq!( + OutboundLanes::::storage_map_final_key(TEST_LANE_ID), + bp_messages::storage_keys::outbound_lane_data_key("Messages", &TEST_LANE_ID).0, + ); + + assert_eq!( + InboundLanes::::storage_map_final_key(TEST_LANE_ID), + bp_messages::storage_keys::inbound_lane_data_key("Messages", &TEST_LANE_ID).0, + ); +} + +#[test] +fn inbound_message_details_works() { + run_test(|| { + assert_eq!( + Pallet::::inbound_message_data( + TEST_LANE_ID, + REGULAR_PAYLOAD.encode(), + OutboundMessageDetails { nonce: 0, dispatch_weight: Weight::zero(), size: 0 }, + ), + InboundMessageDetails { dispatch_weight: REGULAR_PAYLOAD.declared_weight }, + ); + }); +} + +#[test] +fn outbound_message_from_unconfigured_lane_is_rejected() { + run_test(|| { + assert_noop!( + Pallet::::validate_message(TEST_LANE_ID_3, ®ULAR_PAYLOAD,), + Error::::InactiveOutboundLane, + ); + }); +} + +#[test] +fn test_bridge_messages_call_is_correctly_defined() { + run_test(|| { + let account_id = 1; + let message_proof = prepare_messages_proof(vec![message(1, REGULAR_PAYLOAD)], None); + let message_delivery_proof = prepare_messages_delivery_proof( + TEST_LANE_ID, + InboundLaneData { + last_confirmed_nonce: 1, + relayers: vec![UnrewardedRelayer { + relayer: 0, + messages: DeliveredMessages::new(1), + }] + .into(), + }, + ); + let unrewarded_relayer_state = UnrewardedRelayersState { + unrewarded_relayer_entries: 1, + total_messages: 1, + last_delivered_nonce: 1, + ..Default::default() + }; + + let direct_receive_messages_proof_call = Call::::receive_messages_proof { + relayer_id_at_bridged_chain: account_id, + proof: message_proof.clone(), + messages_count: 1, + dispatch_weight: REGULAR_PAYLOAD.declared_weight, + }; + let indirect_receive_messages_proof_call = BridgeMessagesCall::< + AccountId, + FromBridgedChainMessagesProof, + FromBridgedChainMessagesDeliveryProof, + >::receive_messages_proof { + relayer_id_at_bridged_chain: account_id, + proof: *message_proof, + messages_count: 1, + dispatch_weight: REGULAR_PAYLOAD.declared_weight, + }; + assert_eq!( + direct_receive_messages_proof_call.encode(), + indirect_receive_messages_proof_call.encode() + ); + + let direct_receive_messages_delivery_proof_call = + Call::::receive_messages_delivery_proof { + proof: message_delivery_proof.clone(), + relayers_state: unrewarded_relayer_state.clone(), + }; + let indirect_receive_messages_delivery_proof_call = BridgeMessagesCall::< + AccountId, + FromBridgedChainMessagesProof, + FromBridgedChainMessagesDeliveryProof, + >::receive_messages_delivery_proof { + proof: message_delivery_proof, + relayers_state: unrewarded_relayer_state, + }; + assert_eq!( + direct_receive_messages_delivery_proof_call.encode(), + indirect_receive_messages_delivery_proof_call.encode() + ); + }); +} + +generate_owned_bridge_module_tests!( + MessagesOperatingMode::Basic(BasicOperatingMode::Normal), + MessagesOperatingMode::Basic(BasicOperatingMode::Halted) +); + +#[test] +fn inbound_storage_extra_proof_size_bytes_works() { + fn relayer_entry() -> UnrewardedRelayer { + UnrewardedRelayer { relayer: 42u64, messages: DeliveredMessages { begin: 0, end: 100 } } + } + + fn storage(relayer_entries: usize) -> RuntimeInboundLaneStorage { + RuntimeInboundLaneStorage { + lane_id: Default::default(), + cached_data: Some(InboundLaneData { + relayers: vec![relayer_entry(); relayer_entries].into(), + last_confirmed_nonce: 0, + }), + _phantom: Default::default(), + } + } + + let max_entries = BridgedChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX as usize; + + // when we have exactly `MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` unrewarded relayers + assert_eq!(storage(max_entries).extra_proof_size_bytes(), 0); + + // when we have less than `MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` unrewarded relayers + assert_eq!( + storage(max_entries - 1).extra_proof_size_bytes(), + relayer_entry().encode().len() as u64 + ); + assert_eq!( + storage(max_entries - 2).extra_proof_size_bytes(), + 2 * relayer_entry().encode().len() as u64 + ); + + // when we have more than `MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` unrewarded relayers + // (shall not happen in practice) + assert_eq!(storage(max_entries + 1).extra_proof_size_bytes(), 0); +} + +#[test] +fn maybe_outbound_lanes_count_returns_correct_value() { + assert_eq!( + MaybeOutboundLanesCount::::get(), + Some(mock::ActiveOutboundLanes::get().len() as u32) + ); +} + +#[test] +fn do_try_state_for_outbound_lanes_works() { + run_test(|| { + let lane_id = TEST_LANE_ID; + + // setup delivered nonce 1 + OutboundLanes::::insert( + lane_id, + OutboundLaneData { + oldest_unpruned_nonce: 2, + latest_received_nonce: 1, + latest_generated_nonce: 0, + }, + ); + // store message for nonce 1 + OutboundMessages::::insert( + MessageKey { lane_id, nonce: 1 }, + BoundedVec::default(), + ); + assert_err!( + Pallet::::do_try_state(), + sp_runtime::TryRuntimeError::Other("Found unpruned lanes!") + ); + + // remove message for nonce 1 + OutboundMessages::::remove(MessageKey { lane_id, nonce: 1 }); + assert_ok!(Pallet::::do_try_state()); + }) +} diff --git a/bridges/modules/messages/src/weights.rs b/bridges/modules/messages/src/weights.rs index 5bf7d56756079df8a5e469b9c50ba7607b65d983..72a06599b1655c52b9761c1b9af7c8d798631ddf 100644 --- a/bridges/modules/messages/src/weights.rs +++ b/bridges/modules/messages/src/weights.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for pallet_bridge_messages //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-23, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-06-22, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `covid`, CPU: `11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz` +//! HOSTNAME: `serban-ROG-Zephyrus`, CPU: `12th Gen Intel(R) Core(TM) i7-12700H` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: @@ -51,14 +51,13 @@ use sp_std::marker::PhantomData; /// Weight functions needed for pallet_bridge_messages. pub trait WeightInfo { fn receive_single_message_proof() -> Weight; - fn receive_two_messages_proof() -> Weight; + fn receive_n_messages_proof(n: u32) -> Weight; fn receive_single_message_proof_with_outbound_lane_state() -> Weight; - fn receive_single_message_proof_1_kb() -> Weight; - fn receive_single_message_proof_16_kb() -> Weight; + fn receive_single_n_bytes_message_proof(n: u32) -> Weight; fn receive_delivery_proof_for_single_message() -> Weight; fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight; fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight; - fn receive_single_message_proof_with_dispatch(i: u32) -> Weight; + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32) -> Weight; } /// Weights for `pallet_bridge_messages` that are generated using one of the Bridge testnets. @@ -82,56 +81,39 @@ impl WeightInfo for BridgeWeight { /// 51655, mode: MaxEncodedLen) fn receive_single_message_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 52_321 nanoseconds. - Weight::from_parts(54_478_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_724 nanoseconds. + Weight::from_parts(40_650_000, 52673) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } - /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) + /// Storage: BridgeRialtoMessages PalletOperatingMode (r:1 w:0) /// - /// Proof: BridgeUnknownMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), + /// Proof: BridgeRialtoMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), /// added: 497, mode: MaxEncodedLen) /// - /// Storage: BridgeUnknownGrandpa ImportedHeaders (r:1 w:0) + /// Storage: BridgeRialtoGrandpa ImportedHeaders (r:1 w:0) /// - /// Proof: BridgeUnknownGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), + /// Proof: BridgeRialtoGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), /// added: 2048, mode: MaxEncodedLen) /// - /// Storage: BridgeUnknownMessages InboundLanes (r:1 w:1) - /// - /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: - /// 51655, mode: MaxEncodedLen) - fn receive_two_messages_proof() -> Weight { - // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 64_597 nanoseconds. - Weight::from_parts(69_267_000, 57170) - .saturating_add(T::DbWeight::get().reads(3_u64)) - .saturating_add(T::DbWeight::get().writes(1_u64)) - } - /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) + /// Storage: BridgeRialtoMessages InboundLanes (r:1 w:1) /// - /// Proof: BridgeUnknownMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), - /// added: 497, mode: MaxEncodedLen) + /// Proof: BridgeRialtoMessages InboundLanes (max_values: None, max_size: Some(49208), added: + /// 51683, mode: MaxEncodedLen) /// - /// Storage: BridgeUnknownGrandpa ImportedHeaders (r:1 w:0) + /// The range of component `n` is `[1, 1004]`. /// - /// Proof: BridgeUnknownGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), - /// added: 2048, mode: MaxEncodedLen) - /// - /// Storage: BridgeUnknownMessages InboundLanes (r:1 w:1) - /// - /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: - /// 51655, mode: MaxEncodedLen) - fn receive_single_message_proof_with_outbound_lane_state() -> Weight { + /// The range of component `n` is `[1, 1004]`. + fn receive_n_messages_proof(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 64_079 nanoseconds. - Weight::from_parts(65_905_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 39_354 nanoseconds. + Weight::from_parts(29_708_543, 52673) + // Standard Error: 1_185 + .saturating_add(Weight::from_parts(7_648_787, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -149,12 +131,12 @@ impl WeightInfo for BridgeWeight { /// /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: /// 51655, mode: MaxEncodedLen) - fn receive_single_message_proof_1_kb() -> Weight { + fn receive_single_message_proof_with_outbound_lane_state() -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 50_588 nanoseconds. - Weight::from_parts(53_544_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 45_578 nanoseconds. + Weight::from_parts(47_161_000, 52673) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -172,12 +154,16 @@ impl WeightInfo for BridgeWeight { /// /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: /// 51655, mode: MaxEncodedLen) - fn receive_single_message_proof_16_kb() -> Weight { + /// + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 78_269 nanoseconds. - Weight::from_parts(81_748_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_702 nanoseconds. + Weight::from_parts(41_040_143, 52673) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_174, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -198,16 +184,21 @@ impl WeightInfo for BridgeWeight { /// /// Storage: BridgeRelayers RelayerRewards (r:1 w:1) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:1) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_single_message() -> Weight { // Proof Size summary in bytes: - // Measured: `579` - // Estimated: `9584` - // Minimum execution time: 45_786 nanoseconds. - Weight::from_parts(47_382_000, 9584) + // Measured: `701` + // Estimated: `3558` + // Minimum execution time: 37_197 nanoseconds. + Weight::from_parts(38_371_000, 3558) .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -226,16 +217,21 @@ impl WeightInfo for BridgeWeight { /// /// Storage: BridgeRelayers RelayerRewards (r:1 w:1) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:2) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { // Proof Size summary in bytes: - // Measured: `596` - // Estimated: `9584` - // Minimum execution time: 44_544 nanoseconds. - Weight::from_parts(45_451_000, 9584) + // Measured: `701` + // Estimated: `3558` + // Minimum execution time: 38_684 nanoseconds. + Weight::from_parts(39_929_000, 3558) .saturating_add(T::DbWeight::get().reads(4_u64)) - .saturating_add(T::DbWeight::get().writes(2_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -254,16 +250,21 @@ impl WeightInfo for BridgeWeight { /// /// Storage: BridgeRelayers RelayerRewards (r:2 w:2) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:2) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { // Proof Size summary in bytes: - // Measured: `596` - // Estimated: `12124` - // Minimum execution time: 47_344 nanoseconds. - Weight::from_parts(48_311_000, 12124) + // Measured: `701` + // Estimated: `6126` + // Minimum execution time: 41_363 nanoseconds. + Weight::from_parts(42_621_000, 6126) .saturating_add(T::DbWeight::get().reads(5_u64)) - .saturating_add(T::DbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().writes(5_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -280,15 +281,15 @@ impl WeightInfo for BridgeWeight { /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: /// 51655, mode: MaxEncodedLen) /// - /// The range of component `i` is `[128, 2048]`. - fn receive_single_message_proof_with_dispatch(i: u32) -> Weight { + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 52_385 nanoseconds. - Weight::from_parts(54_919_468, 57170) - // Standard Error: 108 - .saturating_add(Weight::from_parts(3_286, 0).saturating_mul(i.into())) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_925 nanoseconds. + Weight::from_parts(39_617_000, 52673) + // Standard Error: 612 + .saturating_add(Weight::from_parts(372_813, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(3_u64)) .saturating_add(T::DbWeight::get().writes(1_u64)) } @@ -312,33 +313,39 @@ impl WeightInfo for () { /// 51655, mode: MaxEncodedLen) fn receive_single_message_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 52_321 nanoseconds. - Weight::from_parts(54_478_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_724 nanoseconds. + Weight::from_parts(40_650_000, 52673) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } - /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) + /// Storage: BridgeRialtoMessages PalletOperatingMode (r:1 w:0) /// - /// Proof: BridgeUnknownMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), + /// Proof: BridgeRialtoMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), /// added: 497, mode: MaxEncodedLen) /// - /// Storage: BridgeUnknownGrandpa ImportedHeaders (r:1 w:0) + /// Storage: BridgeRialtoGrandpa ImportedHeaders (r:1 w:0) /// - /// Proof: BridgeUnknownGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), + /// Proof: BridgeRialtoGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), /// added: 2048, mode: MaxEncodedLen) /// - /// Storage: BridgeUnknownMessages InboundLanes (r:1 w:1) + /// Storage: BridgeRialtoMessages InboundLanes (r:1 w:1) /// - /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: - /// 51655, mode: MaxEncodedLen) - fn receive_two_messages_proof() -> Weight { + /// Proof: BridgeRialtoMessages InboundLanes (max_values: None, max_size: Some(49208), added: + /// 51683, mode: MaxEncodedLen) + /// + /// The range of component `n` is `[1, 1004]`. + /// + /// The range of component `n` is `[1, 1004]`. + fn receive_n_messages_proof(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 64_597 nanoseconds. - Weight::from_parts(69_267_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 39_354 nanoseconds. + Weight::from_parts(29_708_543, 52673) + // Standard Error: 1_185 + .saturating_add(Weight::from_parts(7_648_787, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -358,10 +365,10 @@ impl WeightInfo for () { /// 51655, mode: MaxEncodedLen) fn receive_single_message_proof_with_outbound_lane_state() -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 64_079 nanoseconds. - Weight::from_parts(65_905_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 45_578 nanoseconds. + Weight::from_parts(47_161_000, 52673) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -377,37 +384,20 @@ impl WeightInfo for () { /// /// Storage: BridgeUnknownMessages InboundLanes (r:1 w:1) /// - /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: - /// 51655, mode: MaxEncodedLen) - fn receive_single_message_proof_1_kb() -> Weight { - // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 50_588 nanoseconds. - Weight::from_parts(53_544_000, 57170) - .saturating_add(RocksDbWeight::get().reads(3_u64)) - .saturating_add(RocksDbWeight::get().writes(1_u64)) - } - /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) - /// - /// Proof: BridgeUnknownMessages PalletOperatingMode (max_values: Some(1), max_size: Some(2), - /// added: 497, mode: MaxEncodedLen) - /// - /// Storage: BridgeUnknownGrandpa ImportedHeaders (r:1 w:0) + /// Proof: BridgeRialtoMessages InboundLanes (max_values: None, max_size: Some(49208), added: + /// 51683, mode: MaxEncodedLen) /// - /// Proof: BridgeUnknownGrandpa ImportedHeaders (max_values: Some(14400), max_size: Some(68), - /// added: 2048, mode: MaxEncodedLen) + /// The range of component `n` is `[1, 16384]`. /// - /// Storage: BridgeUnknownMessages InboundLanes (r:1 w:1) - /// - /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: - /// 51655, mode: MaxEncodedLen) - fn receive_single_message_proof_16_kb() -> Weight { + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 78_269 nanoseconds. - Weight::from_parts(81_748_000, 57170) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_702 nanoseconds. + Weight::from_parts(41_040_143, 52673) + // Standard Error: 5 + .saturating_add(Weight::from_parts(1_174, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } @@ -428,16 +418,21 @@ impl WeightInfo for () { /// /// Storage: BridgeRelayers RelayerRewards (r:1 w:1) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:1) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_single_message() -> Weight { // Proof Size summary in bytes: - // Measured: `579` - // Estimated: `9584` - // Minimum execution time: 45_786 nanoseconds. - Weight::from_parts(47_382_000, 9584) + // Measured: `701` + // Estimated: `3558` + // Minimum execution time: 37_197 nanoseconds. + Weight::from_parts(38_371_000, 3558) .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(2_u64)) + .saturating_add(RocksDbWeight::get().writes(3_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -456,16 +451,21 @@ impl WeightInfo for () { /// /// Storage: BridgeRelayers RelayerRewards (r:1 w:1) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:2) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { // Proof Size summary in bytes: - // Measured: `596` - // Estimated: `9584` - // Minimum execution time: 44_544 nanoseconds. - Weight::from_parts(45_451_000, 9584) + // Measured: `701` + // Estimated: `3558` + // Minimum execution time: 38_684 nanoseconds. + Weight::from_parts(39_929_000, 3558) .saturating_add(RocksDbWeight::get().reads(4_u64)) - .saturating_add(RocksDbWeight::get().writes(2_u64)) + .saturating_add(RocksDbWeight::get().writes(4_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -484,16 +484,21 @@ impl WeightInfo for () { /// /// Storage: BridgeRelayers RelayerRewards (r:2 w:2) /// - /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(65), added: 2540, + /// Proof: BridgeRelayers RelayerRewards (max_values: None, max_size: Some(93), added: 2568, /// mode: MaxEncodedLen) + /// + /// Storage: BridgeRialtoMessages OutboundMessages (r:0 w:2) + /// + /// Proof: BridgeRialtoMessages OutboundMessages (max_values: None, max_size: Some(65596), + /// added: 68071, mode: MaxEncodedLen) fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { // Proof Size summary in bytes: - // Measured: `596` - // Estimated: `12124` - // Minimum execution time: 47_344 nanoseconds. - Weight::from_parts(48_311_000, 12124) + // Measured: `701` + // Estimated: `6126` + // Minimum execution time: 41_363 nanoseconds. + Weight::from_parts(42_621_000, 6126) .saturating_add(RocksDbWeight::get().reads(5_u64)) - .saturating_add(RocksDbWeight::get().writes(3_u64)) + .saturating_add(RocksDbWeight::get().writes(5_u64)) } /// Storage: BridgeUnknownMessages PalletOperatingMode (r:1 w:0) /// @@ -510,15 +515,15 @@ impl WeightInfo for () { /// Proof: BridgeUnknownMessages InboundLanes (max_values: None, max_size: Some(49180), added: /// 51655, mode: MaxEncodedLen) /// - /// The range of component `i` is `[128, 2048]`. - fn receive_single_message_proof_with_dispatch(i: u32) -> Weight { + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `618` - // Estimated: `57170` - // Minimum execution time: 52_385 nanoseconds. - Weight::from_parts(54_919_468, 57170) - // Standard Error: 108 - .saturating_add(Weight::from_parts(3_286, 0).saturating_mul(i.into())) + // Measured: `653` + // Estimated: `52673` + // Minimum execution time: 38_925 nanoseconds. + Weight::from_parts(39_617_000, 52673) + // Standard Error: 612 + .saturating_add(Weight::from_parts(372_813, 0).saturating_mul(n.into())) .saturating_add(RocksDbWeight::get().reads(3_u64)) .saturating_add(RocksDbWeight::get().writes(1_u64)) } diff --git a/bridges/modules/messages/src/weights_ext.rs b/bridges/modules/messages/src/weights_ext.rs index c12e04f692bf8304fb58d7c97ec50d1b860ccb56..7711e212efb06da0421f57b01ab4d1eef8b48f16 100644 --- a/bridges/modules/messages/src/weights_ext.rs +++ b/bridges/modules/messages/src/weights_ext.rs @@ -40,13 +40,6 @@ pub fn ensure_weights_are_correct() { // benchmarked using `MaxEncodedLen` approach and there are no components that cause additional // db reads - // verify `receive_messages_proof` weight components - assert_ne!(W::receive_messages_proof_overhead().ref_time(), 0); - assert_ne!(W::receive_messages_proof_overhead().proof_size(), 0); - // W::receive_messages_proof_messages_overhead(1).ref_time() may be zero because: - // the message processing code (`InboundLane::receive_message`) is minimal and may not be - // accounted by our benchmarks - assert_eq!(W::receive_messages_proof_messages_overhead(1).proof_size(), 0); // W::receive_messages_proof_outbound_lane_state_overhead().ref_time() may be zero because: // the outbound lane state processing code (`InboundLane::receive_state_update`) is minimal and // may not be accounted by our benchmarks @@ -86,6 +79,19 @@ pub fn ensure_weights_are_correct() { total_messages_in_delivery_proof_does_not_affect_proof_size::(); } +/// Ensure that we are able to dispatch maximal size messages. +pub fn ensure_maximal_message_dispatch( + max_incoming_message_size: u32, + max_incoming_message_dispatch_weight: Weight, +) { + let message_dispatch_weight = W::message_dispatch_weight(max_incoming_message_size); + assert!( + message_dispatch_weight.all_lte(max_incoming_message_dispatch_weight), + "Dispatch weight of maximal message {message_dispatch_weight:?} must be lower \ + than the hardcoded {max_incoming_message_dispatch_weight:?}", + ); +} + /// Ensure that we're able to receive maximal (by-size and by-weight) message from other chain. pub fn ensure_able_to_receive_message( max_extrinsic_size: u32, @@ -98,7 +104,8 @@ pub fn ensure_able_to_receive_message( max_incoming_message_proof_size.saturating_add(SIGNED_EXTENSIONS_SIZE); assert!( max_delivery_transaction_size <= max_extrinsic_size, - "Size of maximal message delivery transaction {max_incoming_message_proof_size} + {SIGNED_EXTENSIONS_SIZE} is larger than maximal possible transaction size {max_extrinsic_size}", + "Size of maximal message delivery transaction {max_incoming_message_proof_size} + \ + {SIGNED_EXTENSIONS_SIZE} is larger than maximal possible transaction size {max_extrinsic_size}", ); // verify that we're able to receive proof of maximal-size message with maximal dispatch weight @@ -297,13 +304,11 @@ pub trait WeightInfoExt: WeightInfo { dispatch_weight: Weight, ) -> Weight { // basic components of extrinsic weight - let transaction_overhead = Self::receive_messages_proof_overhead(); + let base_weight = Self::receive_n_messages_proof(messages_count); let transaction_overhead_from_runtime = Self::receive_messages_proof_overhead_from_runtime(); let outbound_state_delivery_weight = Self::receive_messages_proof_outbound_lane_state_overhead(); - let messages_delivery_weight = - Self::receive_messages_proof_messages_overhead(MessageNonce::from(messages_count)); let messages_dispatch_weight = dispatch_weight; // proof size overhead weight @@ -315,10 +320,9 @@ pub trait WeightInfoExt: WeightInfo { actual_proof_size.saturating_sub(expected_proof_size), ); - transaction_overhead + base_weight .saturating_add(transaction_overhead_from_runtime) .saturating_add(outbound_state_delivery_weight) - .saturating_add(messages_delivery_weight) .saturating_add(messages_dispatch_weight) .saturating_add(proof_size_overhead) } @@ -354,25 +358,6 @@ pub trait WeightInfoExt: WeightInfo { // Functions that are used by extrinsics weights formulas. - /// Returns weight overhead of message delivery transaction (`receive_messages_proof`). - fn receive_messages_proof_overhead() -> Weight { - let weight_of_two_messages_and_two_tx_overheads = - Self::receive_single_message_proof().saturating_mul(2); - let weight_of_two_messages_and_single_tx_overhead = Self::receive_two_messages_proof(); - weight_of_two_messages_and_two_tx_overheads - .saturating_sub(weight_of_two_messages_and_single_tx_overhead) - } - - /// Returns weight that needs to be accounted when receiving given a number of messages with - /// message delivery transaction (`receive_messages_proof`). - fn receive_messages_proof_messages_overhead(messages: MessageNonce) -> Weight { - let weight_of_two_messages_and_single_tx_overhead = Self::receive_two_messages_proof(); - let weight_of_single_message_and_single_tx_overhead = Self::receive_single_message_proof(); - weight_of_two_messages_and_single_tx_overhead - .saturating_sub(weight_of_single_message_and_single_tx_overhead) - .saturating_mul(messages as _) - } - /// Returns weight that needs to be accounted when message delivery transaction /// (`receive_messages_proof`) is carrying outbound lane state proof. fn receive_messages_proof_outbound_lane_state_overhead() -> Weight { @@ -426,9 +411,8 @@ pub trait WeightInfoExt: WeightInfo { /// is less than that cost). fn storage_proof_size_overhead(proof_size: u32) -> Weight { let proof_size_in_bytes = proof_size; - let byte_weight = (Self::receive_single_message_proof_16_kb() - - Self::receive_single_message_proof_1_kb()) / - (15 * 1024); + let byte_weight = Self::receive_single_n_bytes_message_proof(2) - + Self::receive_single_n_bytes_message_proof(1); proof_size_in_bytes * byte_weight } @@ -440,11 +424,9 @@ pub trait WeightInfoExt: WeightInfo { /// `receive_single_message_proof_with_dispatch` benchmark. See its requirements for /// details. fn message_dispatch_weight(message_size: u32) -> Weight { - // There may be a tiny overweight/underweight here, because we don't account how message - // size affects all steps before dispatch. But the effect should be small enough and we - // may ignore it. - Self::receive_single_message_proof_with_dispatch(message_size) - .saturating_sub(Self::receive_single_message_proof()) + let message_size_in_bytes = message_size; + Self::receive_single_n_bytes_message_proof_with_dispatch(message_size_in_bytes) + .saturating_sub(Self::receive_single_n_bytes_message_proof(message_size_in_bytes)) } } @@ -479,7 +461,7 @@ impl WeightInfoExt for crate::weights::BridgeWeight #[cfg(test)] mod tests { use super::*; - use crate::{mock::TestRuntime, weights::BridgeWeight}; + use crate::{tests::mock::TestRuntime, weights::BridgeWeight}; #[test] fn ensure_default_weights_are_correct() { diff --git a/bridges/modules/parachains/Cargo.toml b/bridges/modules/parachains/Cargo.toml index 35213be0674a8c8d31de79afb720fbf457f3445a..cda0ee8106d5400c33e186265d672f1b9282dc0d 100644 --- a/bridges/modules/parachains/Cargo.toml +++ b/bridges/modules/parachains/Cargo.toml @@ -11,32 +11,31 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", 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-header-chain = { path = "../../primitives/header-chain", default-features = false } -bp-parachains = { path = "../../primitives/parachains", default-features = false } -bp-polkadot-core = { path = "../../primitives/polkadot-core", default-features = false } -bp-runtime = { path = "../../primitives/runtime", default-features = false } -pallet-bridge-grandpa = { path = "../grandpa", default-features = false } +bp-header-chain = { workspace = true } +bp-parachains = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-runtime = { workspace = true } +pallet-bridge-grandpa = { 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 } -sp-trie = { path = "../../../substrate/primitives/trie", 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 } [dev-dependencies] -bp-header-chain = { path = "../../primitives/header-chain" } -bp-test-utils = { path = "../../primitives/test-utils" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-io = { path = "../../../substrate/primitives/io" } +bp-header-chain = { workspace = true, default-features = true } +bp-test-utils = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } [features] default = ["std"] @@ -54,7 +53,6 @@ std = [ "scale-info/std", "sp-runtime/std", "sp-std/std", - "sp-trie/std", ] runtime-benchmarks = [ "frame-benchmarking/runtime-benchmarks", diff --git a/bridges/modules/parachains/src/benchmarking.rs b/bridges/modules/parachains/src/benchmarking.rs index 27e06a12a1d93486d93aa258afc1d7de4713df2c..92ece6d688cbea3bed2e5d489163f2416bef9bbc 100644 --- a/bridges/modules/parachains/src/benchmarking.rs +++ b/bridges/modules/parachains/src/benchmarking.rs @@ -22,7 +22,7 @@ use crate::{ }; use bp_polkadot_core::parachains::{ParaHash, ParaHeadsProof, ParaId}; -use bp_runtime::StorageProofSize; +use bp_runtime::UnverifiedStorageProofParams; use frame_benchmarking::{account, benchmarks_instance_pallet}; use frame_system::RawOrigin; use sp_std::prelude::*; @@ -38,7 +38,7 @@ pub trait Config: crate::Config { fn prepare_parachain_heads_proof( parachains: &[ParaId], parachain_head_size: u32, - proof_size: StorageProofSize, + proof_params: UnverifiedStorageProofParams, ) -> (RelayBlockNumber, RelayBlockHash, ParaHeadsProof, Vec<(ParaId, ParaHash)>); } @@ -68,7 +68,7 @@ benchmarks_instance_pallet! { let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof( ¶chains, DEFAULT_PARACHAIN_HEAD_SIZE, - StorageProofSize::Minimal(0), + UnverifiedStorageProofParams::default(), ); let at_relay_block = (relay_block_number, relay_block_hash); }: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof) @@ -85,7 +85,7 @@ benchmarks_instance_pallet! { let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof( ¶chains, DEFAULT_PARACHAIN_HEAD_SIZE, - StorageProofSize::HasLargeLeaf(1024), + UnverifiedStorageProofParams::from_db_size(1024), ); let at_relay_block = (relay_block_number, relay_block_hash); }: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof) @@ -102,7 +102,7 @@ benchmarks_instance_pallet! { let (relay_block_number, relay_block_hash, parachain_heads_proof, parachains_heads) = T::prepare_parachain_heads_proof( ¶chains, DEFAULT_PARACHAIN_HEAD_SIZE, - StorageProofSize::HasLargeLeaf(16 * 1024), + UnverifiedStorageProofParams::from_db_size(16 * 1024), ); let at_relay_block = (relay_block_number, relay_block_hash); }: submit_parachain_heads(RawOrigin::Signed(sender), at_relay_block, parachains_heads, parachain_heads_proof) diff --git a/bridges/modules/parachains/src/call_ext.rs b/bridges/modules/parachains/src/call_ext.rs index fe6b319205d41491ce2df36d8a1d112eb37f94b4..0f77eaf2c5a93d372cab8af0857f10fa40ca920f 100644 --- a/bridges/modules/parachains/src/call_ext.rs +++ b/bridges/modules/parachains/src/call_ext.rs @@ -289,7 +289,7 @@ mod tests { RuntimeCall::Parachains(crate::Call::::submit_parachain_heads_ex { at_relay_block: (num, [num as u8; 32].into()), parachains, - parachain_heads_proof: ParaHeadsProof { storage_proof: Vec::new() }, + parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() }, is_free_execution_expected: false, }) .check_obsolete_submit_parachain_heads() @@ -303,7 +303,7 @@ mod tests { RuntimeCall::Parachains(crate::Call::::submit_parachain_heads_ex { at_relay_block: (num, [num as u8; 32].into()), parachains, - parachain_heads_proof: ParaHeadsProof { storage_proof: Vec::new() }, + parachain_heads_proof: ParaHeadsProof { storage_proof: Default::default() }, is_free_execution_expected: true, }) .check_obsolete_submit_parachain_heads() diff --git a/bridges/modules/parachains/src/lib.rs b/bridges/modules/parachains/src/lib.rs index 61e04aed3770dcaa9cb611dc754aad21325e1b39..e2c30ce9aecc1eb3b39fc588cc6386481f82fa7f 100644 --- a/bridges/modules/parachains/src/lib.rs +++ b/bridges/modules/parachains/src/lib.rs @@ -28,11 +28,12 @@ pub use weights::WeightInfo; pub use weights_ext::WeightInfoExt; use bp_header_chain::{HeaderChain, HeaderChainError}; -use bp_parachains::{parachain_head_storage_key_at_source, ParaInfo, ParaStoredHeaderData}; -use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId}; -use bp_runtime::{Chain, HashOf, HeaderId, HeaderIdOf, Parachain, StorageProofError}; +use bp_parachains::{ParaInfo, ParaStoredHeaderData}; +use bp_polkadot_core::parachains::{ParaHash, ParaHeadsProof, ParaId}; +use bp_runtime::{Chain, HashOf, HeaderId, HeaderIdOf, Parachain}; use frame_support::{dispatch::PostDispatchInfo, DefaultNoBound}; use pallet_bridge_grandpa::SubmitFinalityProofHelper; +use proofs::{ParachainsStorageProofAdapter, StorageProofAdapter}; use sp_std::{marker::PhantomData, vec::Vec}; #[cfg(feature = "runtime-benchmarks")] @@ -55,6 +56,7 @@ pub mod benchmarking; mod call_ext; #[cfg(test)] mod mock; +mod proofs; /// The target that will be used when publishing logs related to this pallet. pub const LOG_TARGET: &str = "runtime::bridge-parachains"; @@ -260,7 +262,7 @@ pub mod pallet { /// Pallet owner has a right to halt all pallet operations and then resume them. If it is /// `None`, then there are no direct ways to halt/resume pallet operations, but other /// runtime methods may still be used to do that (i.e. democracy::referendum to update halt - /// flag directly or call the `halt_operations`). + /// flag directly or call the `set_operating_mode`). #[pallet::storage] pub type PalletOwner, I: 'static = ()> = StorageValue<_, T::AccountId, OptionQuery>; @@ -448,15 +450,15 @@ pub mod pallet { parachains.len() as _, ); - let mut is_updated_something = false; - let mut storage = GrandpaPalletOf::::storage_proof_checker( - relay_block_hash, - parachain_heads_proof.storage_proof, - ) - .map_err(Error::::HeaderChainStorageProof)?; + let mut storage: ParachainsStorageProofAdapter = + ParachainsStorageProofAdapter::try_new_with_verified_storage_proof( + relay_block_hash, + parachain_heads_proof.storage_proof, + ) + .map_err(Error::::HeaderChainStorageProof)?; for (parachain, parachain_head_hash) in parachains { - let parachain_head = match Self::read_parachain_head(&mut storage, parachain) { + let parachain_head = match storage.read_parachain_head(parachain) { Ok(Some(parachain_head)) => parachain_head, Ok(None) => { log::trace!( @@ -541,7 +543,6 @@ pub mod pallet { parachain_head_hash, )?; - is_updated_something = true; if is_free { free_parachain_heads = free_parachain_heads + 1; } @@ -572,7 +573,7 @@ pub mod pallet { // => treat this as an error // // (we can throw error here, because now all our calls are transactional) - storage.ensure_no_unused_nodes().map_err(|e| { + storage.ensure_no_unused_keys().map_err(|e| { Error::::HeaderChainStorageProof(HeaderChainError::StorageProof(e)) })?; @@ -633,16 +634,6 @@ pub mod pallet { ImportedParaHeads::::get(parachain, hash).map(|h| h.into_inner()) } - /// Read parachain head from storage proof. - fn read_parachain_head( - storage: &mut bp_runtime::StorageProofChecker, - parachain: ParaId, - ) -> Result, StorageProofError> { - let parachain_head_key = - parachain_head_storage_key_at_source(T::ParasPalletName::get(), parachain); - storage.read_and_decode_value(parachain_head_key.0.as_ref()) - } - /// Try to update parachain head. pub(super) fn update_parachain_head( parachain: ParaId, @@ -801,6 +792,7 @@ impl, I: 'static, C: Parachain> HeaderChain pub fn initialize_for_benchmarks, I: 'static, PC: Parachain>( header: HeaderOf, ) { + use bp_polkadot_core::parachains::ParaHead; use bp_runtime::HeaderIdProvider; use sp_runtime::traits::Header; @@ -844,9 +836,10 @@ pub(crate) mod tests { use bp_parachains::{ BestParaHeadHash, BridgeParachainCall, ImportedParaHeadsKeyProvider, ParasInfoKeyProvider, }; + use bp_polkadot_core::parachains::ParaHead; use bp_runtime::{ BasicOperatingMode, OwnedBridgeModuleError, StorageDoubleMapKeyProvider, - StorageMapKeyProvider, + StorageMapKeyProvider, StorageProofError, }; use bp_test_utils::{ authority_list, generate_owned_bridge_module_tests, make_default_justification, diff --git a/bridges/modules/parachains/src/mock.rs b/bridges/modules/parachains/src/mock.rs index dbb62845392d5fd2f408744f4f8a2321ec4bd34d..c49b5939093c50a17fbf369533d5ff9c01b625bc 100644 --- a/bridges/modules/parachains/src/mock.rs +++ b/bridges/modules/parachains/src/mock.rs @@ -23,7 +23,7 @@ use frame_support::{ use sp_runtime::{ testing::H256, traits::{BlakeTwo256, Header as HeaderT}, - MultiSignature, + MultiSignature, StateVersion, }; use crate as pallet_bridge_parachains; @@ -60,6 +60,8 @@ impl Chain for Parachain1 { type Nonce = u64; type Signature = MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 0 } @@ -87,6 +89,8 @@ impl Chain for Parachain2 { type Nonce = u64; type Signature = MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 0 } @@ -114,6 +118,8 @@ impl Chain for Parachain3 { type Nonce = u64; type Signature = MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 0 } @@ -142,6 +148,8 @@ impl Chain for BigParachain { type Nonce = u64; type Signature = MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 0 } @@ -222,7 +230,7 @@ impl pallet_bridge_parachains::benchmarking::Config<()> for TestRuntime { fn prepare_parachain_heads_proof( parachains: &[ParaId], _parachain_head_size: u32, - _proof_size: bp_runtime::StorageProofSize, + _proof_params: bp_runtime::UnverifiedStorageProofParams, ) -> ( crate::RelayBlockNumber, crate::RelayBlockHash, @@ -256,38 +264,7 @@ impl Chain for TestBridgedChain { type Nonce = u32; type Signature = sp_runtime::testing::TestSignature; - fn max_extrinsic_size() -> u32 { - unreachable!() - } - - fn max_extrinsic_weight() -> Weight { - unreachable!() - } -} - -impl ChainWithGrandpa for TestBridgedChain { - const WITH_CHAIN_GRANDPA_PALLET_NAME: &'static str = ""; - const MAX_AUTHORITIES_COUNT: u32 = 16; - const REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY: u32 = 8; - const MAX_MANDATORY_HEADER_SIZE: u32 = 256; - const AVERAGE_HEADER_SIZE: u32 = 64; -} - -#[derive(Debug)] -pub struct OtherBridgedChain; - -impl Chain for OtherBridgedChain { - const ID: ChainId = *b"obch"; - - type BlockNumber = u64; - type Hash = crate::RelayBlockHash; - type Hasher = crate::RelayBlockHasher; - type Header = sp_runtime::generic::Header; - - type AccountId = AccountId; - type Balance = u32; - type Nonce = u32; - type Signature = sp_runtime::testing::TestSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; fn max_extrinsic_size() -> u32 { unreachable!() @@ -298,7 +275,7 @@ impl Chain for OtherBridgedChain { } } -impl ChainWithGrandpa for OtherBridgedChain { +impl ChainWithGrandpa for TestBridgedChain { const WITH_CHAIN_GRANDPA_PALLET_NAME: &'static str = ""; const MAX_AUTHORITIES_COUNT: u32 = 16; const REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY: u32 = 8; diff --git a/bridges/modules/parachains/src/proofs.rs b/bridges/modules/parachains/src/proofs.rs new file mode 100644 index 0000000000000000000000000000000000000000..dcf22229f3423a9a75f4be68d1af2b1bf2e7ea1e --- /dev/null +++ b/bridges/modules/parachains/src/proofs.rs @@ -0,0 +1,81 @@ +// Copyright 2019-2021 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 . + +//! Tools for parachain head proof verification. + +use crate::{Config, GrandpaPalletOf, RelayBlockHash, RelayBlockHasher}; +use bp_header_chain::{HeaderChain, HeaderChainError}; +use bp_parachains::parachain_head_storage_key_at_source; +use bp_polkadot_core::parachains::{ParaHead, ParaId}; +use bp_runtime::{RawStorageProof, StorageProofChecker, StorageProofError}; +use codec::Decode; +use frame_support::traits::Get; + +/// Abstraction over storage proof manipulation, hiding implementation details of actual storage +/// proofs. +pub trait StorageProofAdapter, I: 'static> { + /// Read and decode optional value from the proof. + fn read_and_decode_optional_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result, StorageProofError>; + + /// Checks if each key was read. + fn ensure_no_unused_keys(self) -> Result<(), StorageProofError>; + + /// Read parachain head from storage proof. + fn read_parachain_head( + &mut self, + parachain: ParaId, + ) -> Result, StorageProofError> { + let parachain_head_key = + parachain_head_storage_key_at_source(T::ParasPalletName::get(), parachain); + self.read_and_decode_optional_value(¶chain_head_key) + } +} + +/// Actual storage proof adapter for parachain proofs. +pub type ParachainsStorageProofAdapter = RawStorageProofAdapter; + +/// A `StorageProofAdapter` implementation for raw storage proofs. +pub struct RawStorageProofAdapter, I: 'static> { + storage: StorageProofChecker, + _dummy: sp_std::marker::PhantomData<(T, I)>, +} + +impl, I: 'static> RawStorageProofAdapter { + /// Try to create a new instance of `RawStorageProofAdapter`. + pub fn try_new_with_verified_storage_proof( + relay_block_hash: RelayBlockHash, + storage_proof: RawStorageProof, + ) -> Result { + GrandpaPalletOf::::verify_storage_proof(relay_block_hash, storage_proof) + .map(|storage| RawStorageProofAdapter:: { storage, _dummy: Default::default() }) + } +} + +impl, I: 'static> StorageProofAdapter for RawStorageProofAdapter { + fn read_and_decode_optional_value( + &mut self, + key: &impl AsRef<[u8]>, + ) -> Result, StorageProofError> { + self.storage.read_and_decode_opt_value(key.as_ref()) + } + + fn ensure_no_unused_keys(self) -> Result<(), StorageProofError> { + self.storage.ensure_no_unused_nodes() + } +} diff --git a/bridges/modules/parachains/src/weights.rs b/bridges/modules/parachains/src/weights.rs index abddc8768947006e574bf6bca4d2301c2047199a..1f92b7ff763c3f572efef1acf141a9eba0d3eb0e 100644 --- a/bridges/modules/parachains/src/weights.rs +++ b/bridges/modules/parachains/src/weights.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for pallet_bridge_parachains //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-03-02, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2023-06-22, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `covid`, CPU: `11th Gen Intel(R) Core(TM) i7-11800H @ 2.30GHz` +//! HOSTNAME: `serban-ROG-Zephyrus`, CPU: `12th Gen Intel(R) Core(TM) i7-12700H` //! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 // Executed Command: @@ -86,14 +86,12 @@ impl WeightInfo for BridgeWeight { /// Some(196), added: 1681, mode: MaxEncodedLen) /// /// The range of component `p` is `[1, 2]`. - fn submit_parachain_heads_with_n_parachains(p: u32) -> Weight { + fn submit_parachain_heads_with_n_parachains(_p: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 36_701 nanoseconds. - Weight::from_parts(38_597_828, 4648) - // Standard Error: 190_859 - .saturating_add(Weight::from_parts(60_685, 0).saturating_mul(p.into())) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 30_211 nanoseconds. + Weight::from_parts(32_633_893, 3038) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -123,10 +121,10 @@ impl WeightInfo for BridgeWeight { /// Some(196), added: 1681, mode: MaxEncodedLen) fn submit_parachain_heads_with_1kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 38_189 nanoseconds. - Weight::from_parts(39_252_000, 4648) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 30_830 nanoseconds. + Weight::from_parts(31_801_000, 3038) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -156,10 +154,10 @@ impl WeightInfo for BridgeWeight { /// Some(196), added: 1681, mode: MaxEncodedLen) fn submit_parachain_heads_with_16kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 62_868 nanoseconds. - Weight::from_parts(63_581_000, 4648) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 44_736 nanoseconds. + Weight::from_parts(45_296_000, 3038) .saturating_add(T::DbWeight::get().reads(4_u64)) .saturating_add(T::DbWeight::get().writes(3_u64)) } @@ -193,14 +191,12 @@ impl WeightInfo for () { /// Some(196), added: 1681, mode: MaxEncodedLen) /// /// The range of component `p` is `[1, 2]`. - fn submit_parachain_heads_with_n_parachains(p: u32) -> Weight { + fn submit_parachain_heads_with_n_parachains(_p: u32) -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 36_701 nanoseconds. - Weight::from_parts(38_597_828, 4648) - // Standard Error: 190_859 - .saturating_add(Weight::from_parts(60_685, 0).saturating_mul(p.into())) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 30_211 nanoseconds. + Weight::from_parts(32_633_893, 3038) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -230,10 +226,10 @@ impl WeightInfo for () { /// Some(196), added: 1681, mode: MaxEncodedLen) fn submit_parachain_heads_with_1kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 38_189 nanoseconds. - Weight::from_parts(39_252_000, 4648) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 30_830 nanoseconds. + Weight::from_parts(31_801_000, 3038) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } @@ -263,10 +259,10 @@ impl WeightInfo for () { /// Some(196), added: 1681, mode: MaxEncodedLen) fn submit_parachain_heads_with_16kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `366` - // Estimated: `4648` - // Minimum execution time: 62_868 nanoseconds. - Weight::from_parts(63_581_000, 4648) + // Measured: `302` + // Estimated: `3038` + // Minimum execution time: 44_736 nanoseconds. + Weight::from_parts(45_296_000, 3038) .saturating_add(RocksDbWeight::get().reads(4_u64)) .saturating_add(RocksDbWeight::get().writes(3_u64)) } diff --git a/bridges/modules/relayers/Cargo.toml b/bridges/modules/relayers/Cargo.toml index e2b7aca92249c19096bf129be6fab1be08a5357a..27a28546afb482851040cbe16bd40071e86a70cb 100644 --- a/bridges/modules/relayers/Cargo.toml +++ b/bridges/modules/relayers/Cargo.toml @@ -11,31 +11,31 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", 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-messages = { path = "../../primitives/messages", default-features = false } -bp-relayers = { path = "../../primitives/relayers", default-features = false } -bp-runtime = { path = "../../primitives/runtime", default-features = false } -pallet-bridge-messages = { path = "../messages", default-features = false } +bp-messages = { workspace = true } +bp-relayers = { workspace = true } +bp-runtime = { workspace = true } +pallet-bridge-messages = { 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-arithmetic = { path = "../../../substrate/primitives/arithmetic", 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-arithmetic = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } [dev-dependencies] -bp-runtime = { path = "../../primitives/runtime" } -pallet-balances = { path = "../../../substrate/frame/balances" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } +bp-runtime = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/modules/relayers/src/lib.rs b/bridges/modules/relayers/src/lib.rs index 7a3a0f9ea94cbe5768bf6ee8c850355193ea44f0..2c86ec01f5b915bc3b3b1e65c15adae7c45e1819 100644 --- a/bridges/modules/relayers/src/lib.rs +++ b/bridges/modules/relayers/src/lib.rs @@ -63,7 +63,7 @@ pub mod pallet { /// The overarching event type. type RuntimeEvent: From> + IsType<::RuntimeEvent>; /// Type of relayer reward. - type Reward: AtLeast32BitUnsigned + Copy + Parameter + MaxEncodedLen; + type Reward: AtLeast32BitUnsigned + Copy + Member + Parameter + MaxEncodedLen; /// Pay rewards scheme. type PaymentProcedure: PaymentProcedure; /// Stake and slash scheme. diff --git a/bridges/modules/relayers/src/payment_adapter.rs b/bridges/modules/relayers/src/payment_adapter.rs index b2d9c676bddc493700a45fc957235dbb9516296b..f75c409aca4f3ef85fab748e4dc41af12b545562 100644 --- a/bridges/modules/relayers/src/payment_adapter.rs +++ b/bridges/modules/relayers/src/payment_adapter.rs @@ -23,6 +23,7 @@ use bp_messages::{ LaneId, MessageNonce, }; use bp_relayers::{RewardsAccountOwner, RewardsAccountParams}; +use bp_runtime::Chain; use frame_support::{sp_runtime::SaturatedConversion, traits::Get}; use sp_arithmetic::traits::{Saturating, Zero}; use sp_std::{collections::vec_deque::VecDeque, marker::PhantomData, ops::RangeInclusive}; @@ -57,7 +58,7 @@ where relayers_rewards, RewardsAccountParams::new( lane_id, - T::BridgedChainId::get(), + T::BridgedChain::ID, RewardsAccountOwner::BridgedChain, ), DeliveryReward::get(), diff --git a/bridges/modules/xcm-bridge-hub-router/Cargo.toml b/bridges/modules/xcm-bridge-hub-router/Cargo.toml index 06f2a339bed9d07b5615ca047177228d6585cfc2..ec7c3b5628327f6cbb3d5b3920dba59521c6c209 100644 --- a/bridges/modules/xcm-bridge-hub-router/Cargo.toml +++ b/bridges/modules/xcm-bridge-hub-router/Cargo.toml @@ -11,31 +11,31 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } +codec = { workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive", "serde"] } +scale-info = { features = ["bit-vec", "derive", "serde"], 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 } # 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-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-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { 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] -sp-io = { path = "../../../substrate/primitives/io" } -sp-std = { path = "../../../substrate/primitives/std" } +sp-io = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/modules/xcm-bridge-hub/Cargo.toml b/bridges/modules/xcm-bridge-hub/Cargo.toml index 4483a3790900f975030e8c820f9b42442a747262..8fbf61a0a5354e808ad4a5c74094c907eb29470d 100644 --- a/bridges/modules/xcm-bridge-hub/Cargo.toml +++ b/bridges/modules/xcm-bridge-hub/Cargo.toml @@ -11,33 +11,35 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", 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-messages = { path = "../../primitives/messages", default-features = false } -bp-runtime = { path = "../../primitives/runtime", default-features = false } -bp-xcm-bridge-hub = { path = "../../primitives/xcm-bridge-hub", default-features = false } -pallet-bridge-messages = { path = "../messages", default-features = false } -bridge-runtime-common = { path = "../../bin/runtime-common", default-features = false } +bp-messages = { workspace = true } +bp-runtime = { workspace = true } +bp-xcm-bridge-hub = { workspace = true } +pallet-bridge-messages = { workspace = true } +bridge-runtime-common = { 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 } # 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-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } [dev-dependencies] -bp-header-chain = { path = "../../primitives/header-chain" } -pallet-balances = { path = "../../../substrate/frame/balances" } -sp-io = { path = "../../../substrate/primitives/io" } +bp-header-chain = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +bp-runtime = { features = ["test-helpers"], workspace = true } +pallet-xcm-bridge-hub-router = { workspace = true } [features] default = ["std"] @@ -51,6 +53,7 @@ std = [ "frame-system/std", "log/std", "pallet-bridge-messages/std", + "pallet-xcm-bridge-hub-router/std", "scale-info/std", "sp-core/std", "sp-runtime/std", @@ -65,6 +68,7 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-bridge-messages/runtime-benchmarks", + "pallet-xcm-bridge-hub-router/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", @@ -74,5 +78,6 @@ try-runtime = [ "frame-system/try-runtime", "pallet-balances/try-runtime", "pallet-bridge-messages/try-runtime", + "pallet-xcm-bridge-hub-router/try-runtime", "sp-runtime/try-runtime", ] diff --git a/bridges/modules/xcm-bridge-hub/src/exporter.rs b/bridges/modules/xcm-bridge-hub/src/exporter.rs index 94ec8b5f106fdb9ce5e229a41579d26e789b5673..5bca3ad8e2777c2e9243867fa491922592482c9e 100644 --- a/bridges/modules/xcm-bridge-hub/src/exporter.rs +++ b/bridges/modules/xcm-bridge-hub/src/exporter.rs @@ -131,6 +131,7 @@ impl HaulBlob for DummyHaulBlob { mod tests { use super::*; use crate::mock::*; + use bp_runtime::RangeInclusiveExt; use frame_support::assert_ok; use xcm_executor::traits::export_xcm; @@ -138,8 +139,8 @@ mod tests { [GlobalConsensus(RelayNetwork::get()), Parachain(SIBLING_ASSET_HUB_ID)].into() } - fn universal_destination() -> InteriorLocation { - BridgedDestination::get() + fn bridged_relative_destination() -> InteriorLocation { + BridgedRelativeDestination::get() } #[test] @@ -149,7 +150,7 @@ mod tests { BridgedRelayNetwork::get(), 0, universal_source(), - universal_destination(), + bridged_relative_destination(), vec![Instruction::ClearOrigin].into(), )); }) @@ -163,7 +164,7 @@ mod tests { BridgedRelayNetwork::get(), 0, &mut None, - &mut Some(universal_destination()), + &mut Some(bridged_relative_destination()), &mut Some(Vec::new().into()), ), Err(SendError::MissingArgument), @@ -192,7 +193,7 @@ mod tests { BridgedRelayNetwork::get(), 0, &mut Some(universal_source()), - &mut Some(universal_destination()), + &mut Some(bridged_relative_destination()), &mut Some(Vec::new().into()), ) .unwrap() @@ -203,4 +204,37 @@ mod tests { ); }) } + + #[test] + fn exporter_is_compatible_with_pallet_xcm_bridge_hub_router() { + run_test(|| { + // valid routable destination + let dest = Location::new(2, BridgedUniversalDestination::get()); + let expected_lane_id = TEST_LANE_ID; + + // check before - no messages + assert_eq!( + pallet_bridge_messages::Pallet::::outbound_lane_data( + expected_lane_id + ) + .queued_messages() + .saturating_len(), + 0 + ); + + // send `ExportMessage(message)` by `pallet_xcm_bridge_hub_router`. + TestExportXcmWithXcmOverBridge::set_origin_for_execute(SiblingLocation::get()); + assert_ok!(send_xcm::(dest, Xcm::<()>::default())); + + // check after - a message ready to be relayed + assert_eq!( + pallet_bridge_messages::Pallet::::outbound_lane_data( + expected_lane_id + ) + .queued_messages() + .saturating_len(), + 1 + ); + }) + } } diff --git a/bridges/modules/xcm-bridge-hub/src/mock.rs b/bridges/modules/xcm-bridge-hub/src/mock.rs index 4c09bce56d73eea717ad5149084e2ae337e48e87..0cca32ba9e5f55a80baa4168f483ea33ba69ce58 100644 --- a/bridges/modules/xcm-bridge-hub/src/mock.rs +++ b/bridges/modules/xcm-bridge-hub/src/mock.rs @@ -20,25 +20,29 @@ use crate as pallet_xcm_bridge_hub; use bp_messages::{ target_chain::{DispatchMessage, MessageDispatch}, - LaneId, -}; -use bp_runtime::{messages::MessageDispatchResult, Chain, ChainId, UnderlyingChainProvider}; -use bridge_runtime_common::{ - messages::{ - source::TargetHeaderChainAdapter, target::SourceHeaderChainAdapter, - BridgedChainWithMessages, HashOf, MessageBridge, ThisChainWithMessages, - }, - messages_xcm_extension::{SenderAndLane, XcmBlobHauler}, + ChainWithMessages, LaneId, MessageNonce, }; +use bp_runtime::{messages::MessageDispatchResult, Chain, ChainId, HashOf}; +use bridge_runtime_common::messages_xcm_extension::{SenderAndLane, XcmBlobHauler}; use codec::Encode; -use frame_support::{derive_impl, parameter_types, traits::ConstU32, weights::RuntimeDbWeight}; +use frame_support::{ + assert_ok, derive_impl, parameter_types, + traits::{Everything, NeverEnsureOrigin}, + weights::RuntimeDbWeight, +}; use sp_core::H256; use sp_runtime::{ testing::Header as SubstrateHeader, - traits::{BlakeTwo256, IdentityLookup}, - AccountId32, BuildStorage, + traits::{BlakeTwo256, ConstU128, ConstU32, IdentityLookup}, + AccountId32, BuildStorage, StateVersion, }; +use sp_std::cell::RefCell; use xcm::prelude::*; +use xcm_builder::{ + AllowUnpaidExecutionFrom, FixedWeightBounds, InspectMessageQueues, NetworkExportTable, + NetworkExportTableItem, +}; +use xcm_executor::XcmExecutor; pub type AccountId = AccountId32; pub type Balance = u64; @@ -56,6 +60,7 @@ frame_support::construct_runtime! { Balances: pallet_balances::{Pallet, Event}, Messages: pallet_bridge_messages::{Pallet, Call, Event}, XcmOverBridge: pallet_xcm_bridge_hub::{Pallet}, + XcmOverBridgeRouter: pallet_xcm_bridge_hub_router, } } @@ -85,20 +90,17 @@ impl pallet_bridge_messages::Config for TestRuntime { type RuntimeEvent = RuntimeEvent; type WeightInfo = TestMessagesWeights; - type BridgedChainId = (); type ActiveOutboundLanes = ActiveOutboundLanes; - type MaxUnrewardedRelayerEntriesAtInboundLane = (); - type MaxUnconfirmedMessagesAtInboundLane = (); - type MaximalOutboundPayloadSize = ConstU32<2048>; type OutboundPayload = Vec; type InboundPayload = Vec; - type InboundRelayer = (); type DeliveryPayments = (); - type TargetHeaderChain = TargetHeaderChainAdapter; type DeliveryConfirmationPayments = (); type OnMessagesDelivered = (); - type SourceHeaderChain = SourceHeaderChainAdapter; type MessageDispatch = TestMessageDispatch; + + type ThisChain = ThisUnderlyingChain; + type BridgedChain = BridgedUnderlyingChain; + type BridgedHeaderChain = BridgedHeaderChain; } pub struct TestMessagesWeights; @@ -107,34 +109,27 @@ impl pallet_bridge_messages::WeightInfo for TestMessagesWeights { fn receive_single_message_proof() -> Weight { Weight::zero() } - fn receive_single_message_proof_with_outbound_lane_state() -> Weight { + fn receive_n_messages_proof(_: u32) -> Weight { Weight::zero() } - fn receive_delivery_proof_for_single_message() -> Weight { + fn receive_single_message_proof_with_outbound_lane_state() -> Weight { Weight::zero() } - fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { + fn receive_single_n_bytes_message_proof(_: u32) -> Weight { Weight::zero() } - fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { + fn receive_delivery_proof_for_single_message() -> Weight { Weight::zero() } - - fn receive_two_messages_proof() -> Weight { + fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { Weight::zero() } - - fn receive_single_message_proof_1_kb() -> Weight { + fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { Weight::zero() } - - fn receive_single_message_proof_16_kb() -> Weight { + fn receive_single_n_bytes_message_proof_with_dispatch(_: u32) -> Weight { Weight::zero() } - - fn receive_single_message_proof_with_dispatch(_: u32) -> Weight { - Weight::from_parts(1, 0) - } } impl pallet_bridge_messages::WeightInfoExt for TestMessagesWeights { @@ -153,15 +148,34 @@ impl pallet_bridge_messages::WeightInfoExt for TestMessagesWeights { parameter_types! { pub const RelayNetwork: NetworkId = NetworkId::Kusama; - pub const BridgedRelayNetwork: NetworkId = NetworkId::Polkadot; - pub BridgedRelayNetworkLocation: Location = (Parent, GlobalConsensus(BridgedRelayNetwork::get())).into(); - pub const NonBridgedRelayNetwork: NetworkId = NetworkId::Rococo; - pub const BridgeReserve: Balance = 100_000; pub UniversalLocation: InteriorLocation = [ GlobalConsensus(RelayNetwork::get()), Parachain(THIS_BRIDGE_HUB_ID), ].into(); + pub SiblingLocation: Location = Location::new(1, [Parachain(SIBLING_ASSET_HUB_ID)]); + + pub const BridgedRelayNetwork: NetworkId = NetworkId::Polkadot; + pub BridgedRelayNetworkLocation: Location = (Parent, GlobalConsensus(BridgedRelayNetwork::get())).into(); + pub BridgedRelativeDestination: InteriorLocation = [Parachain(BRIDGED_ASSET_HUB_ID)].into(); + pub BridgedUniversalDestination: InteriorLocation = [GlobalConsensus(BridgedRelayNetwork::get()), Parachain(BRIDGED_ASSET_HUB_ID)].into(); + pub const NonBridgedRelayNetwork: NetworkId = NetworkId::Rococo; + + pub const BridgeDeposit: Balance = 100_000; pub const Penalty: Balance = 1_000; + + // configuration for pallet_xcm_bridge_hub_router + pub BridgeHubLocation: Location = Here.into(); + pub BridgeFeeAsset: AssetId = Location::here().into(); + pub BridgeTable: Vec + = vec![ + NetworkExportTableItem::new( + BridgedRelayNetwork::get(), + None, + BridgeHubLocation::get(), + None + ) + ]; + pub UnitWeightCost: Weight = Weight::from_parts(10, 10); } impl pallet_xcm_bridge_hub::Config for TestRuntime { @@ -176,16 +190,114 @@ impl pallet_xcm_bridge_hub::Config for TestRuntime { type LanesSupport = TestXcmBlobHauler; } +impl pallet_xcm_bridge_hub_router::Config<()> for TestRuntime { + type WeightInfo = (); + + type UniversalLocation = UniversalLocation; + type BridgedNetworkId = BridgedRelayNetwork; + type Bridges = NetworkExportTable; + type DestinationVersion = AlwaysLatest; + + type BridgeHubOrigin = NeverEnsureOrigin; + type ToBridgeHubSender = TestExportXcmWithXcmOverBridge; + + type ByteFee = ConstU128<0>; + type FeeAsset = BridgeFeeAsset; + + type WithBridgeHubChannel = (); +} + +pub struct XcmConfig; +impl xcm_executor::Config for XcmConfig { + type RuntimeCall = RuntimeCall; + type XcmSender = (); + type AssetTransactor = (); + type OriginConverter = (); + type IsReserve = (); + type IsTeleporter = (); + type UniversalLocation = UniversalLocation; + type Barrier = AllowUnpaidExecutionFrom; + type Weigher = FixedWeightBounds>; + type Trader = (); + type ResponseHandler = (); + type AssetTrap = (); + type AssetClaims = (); + type SubscriptionService = (); + type PalletInstancesInfo = (); + type MaxAssetsIntoHolding = (); + type AssetLocker = (); + type AssetExchanger = (); + type FeeManager = (); + // We just set `MessageExporter` as our `pallet_xcm_bridge_hub` instance. + type MessageExporter = (XcmOverBridge,); + type UniversalAliases = (); + type CallDispatcher = RuntimeCall; + type SafeCallFilter = Everything; + type Aliasers = (); + type TransactionalProcessor = (); + type HrmpNewChannelOpenRequestHandler = (); + type HrmpChannelAcceptedHandler = (); + type HrmpChannelClosingHandler = (); + type XcmRecorder = (); +} + +thread_local! { + pub static EXECUTE_XCM_ORIGIN: RefCell> = RefCell::new(None); +} + +/// The `SendXcm` implementation directly executes XCM using `XcmExecutor`. +/// +/// We ensure that the `ExportMessage` produced by `pallet_xcm_bridge_hub_router` is compatible with +/// the `ExportXcm` implementation of `pallet_xcm_bridge_hub`. +/// +/// Note: The crucial part is that `ExportMessage` is processed by `XcmExecutor`, which calls the +/// `ExportXcm` implementation of `pallet_xcm_bridge_hub` as `MessageExporter`. +pub struct TestExportXcmWithXcmOverBridge; +impl SendXcm for TestExportXcmWithXcmOverBridge { + type Ticket = Xcm<()>; + + fn validate( + _: &mut Option, + message: &mut Option>, + ) -> SendResult { + Ok((message.take().unwrap(), Assets::new())) + } + + fn deliver(ticket: Self::Ticket) -> Result { + let xcm: Xcm = ticket.into(); + + let origin = EXECUTE_XCM_ORIGIN.with(|o| o.borrow().clone().unwrap()); + let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256); + let outcome = XcmExecutor::::prepare_and_execute( + origin, + xcm, + &mut hash, + Weight::MAX, + Weight::zero(), + ); + assert_ok!(outcome.ensure_complete()); + + Ok(hash) + } +} +impl InspectMessageQueues for TestExportXcmWithXcmOverBridge { + fn get_messages() -> Vec<(VersionedLocation, Vec>)> { + todo!() + } +} +impl TestExportXcmWithXcmOverBridge { + pub fn set_origin_for_execute(origin: Location) { + EXECUTE_XCM_ORIGIN.with(|o| *o.borrow_mut() = Some(origin)); + } +} + parameter_types! { pub TestSenderAndLane: SenderAndLane = SenderAndLane { - location: Location::new(1, [Parachain(SIBLING_ASSET_HUB_ID)]), + location: SiblingLocation::get(), lane: TEST_LANE_ID, }; - pub BridgedDestination: InteriorLocation = [ - Parachain(BRIDGED_ASSET_HUB_ID) - ].into(); pub TestLanes: sp_std::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = sp_std::vec![ - (TestSenderAndLane::get(), (BridgedRelayNetwork::get(), BridgedDestination::get())) + (TestSenderAndLane::get(), (BridgedRelayNetwork::get(), BridgedRelativeDestination::get())) ]; } @@ -198,9 +310,9 @@ impl XcmBlobHauler for TestXcmBlobHauler { type UncongestedMessage = (); } -pub struct ThisChain; +pub struct ThisUnderlyingChain; -impl Chain for ThisChain { +impl Chain for ThisUnderlyingChain { const ID: ChainId = *b"tuch"; type BlockNumber = u64; type Hash = H256; @@ -211,6 +323,8 @@ impl Chain for ThisChain { type Nonce = u64; type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { u32::MAX } @@ -220,12 +334,19 @@ impl Chain for ThisChain { } } -pub struct BridgedChain; +impl ChainWithMessages for ThisUnderlyingChain { + 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; +} + +pub struct BridgedUnderlyingChain; pub type BridgedHeaderHash = H256; pub type BridgedChainHeader = SubstrateHeader; -impl Chain for BridgedChain { - const ID: ChainId = *b"tuch"; +impl Chain for BridgedUnderlyingChain { + const ID: ChainId = *b"bgdc"; type BlockNumber = u64; type Hash = BridgedHeaderHash; type Hasher = BlakeTwo256; @@ -235,6 +356,8 @@ impl Chain for BridgedChain { type Nonce = u64; type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 4096 } @@ -244,6 +367,12 @@ impl Chain for BridgedChain { } } +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; +} + /// Test message dispatcher. pub struct TestMessageDispatch; @@ -272,42 +401,15 @@ impl MessageDispatch for TestMessageDispatch { } } -pub struct WrappedThisChain; -impl UnderlyingChainProvider for WrappedThisChain { - type Chain = ThisChain; -} -impl ThisChainWithMessages for WrappedThisChain { - type RuntimeOrigin = RuntimeOrigin; -} - -pub struct WrappedBridgedChain; -impl UnderlyingChainProvider for WrappedBridgedChain { - type Chain = BridgedChain; -} -impl BridgedChainWithMessages for WrappedBridgedChain {} - pub struct BridgedHeaderChain; -impl bp_header_chain::HeaderChain for BridgedHeaderChain { +impl bp_header_chain::HeaderChain for BridgedHeaderChain { fn finalized_header_state_root( - _hash: HashOf, - ) -> Option> { + _hash: HashOf, + ) -> Option> { unreachable!() } } -/// 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 = WrappedThisChain; - type BridgedChain = WrappedBridgedChain; - type BridgedHeaderChain = BridgedHeaderChain; -} - /// Run pallet test. pub fn run_test(test: impl FnOnce() -> T) -> T { sp_io::TestExternalities::new( diff --git a/bridges/primitives/beefy/Cargo.toml b/bridges/primitives/beefy/Cargo.toml index 2a13685207cc633fe18633525231866511afd01e..404acaff30af252f6e5c52d9b28e8ccc72d542ce 100644 --- a/bridges/primitives/beefy/Cargo.toml +++ b/bridges/primitives/beefy/Cargo.toml @@ -12,23 +12,23 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive"] } -serde = { default-features = false, features = ["alloc", "derive"], workspace = true } +codec = { features = ["bit-vec", "derive"], workspace = true } +scale-info = { features = ["bit-vec", "derive"], workspace = true } +serde = { features = ["alloc", "derive"], workspace = true } # Bridge Dependencies -bp-runtime = { path = "../runtime", default-features = false } +bp-runtime = { workspace = true } # Substrate Dependencies -binary-merkle-tree = { path = "../../../substrate/utils/binary-merkle-tree", default-features = false } -sp-consensus-beefy = { path = "../../../substrate/primitives/consensus/beefy", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -pallet-beefy-mmr = { path = "../../../substrate/frame/beefy-mmr", default-features = false } -pallet-mmr = { path = "../../../substrate/frame/merkle-mountain-range", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } +binary-merkle-tree = { workspace = true } +sp-consensus-beefy = { workspace = true } +frame-support = { workspace = true } +pallet-beefy-mmr = { workspace = true } +pallet-mmr = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } [features] default = ["std"] diff --git a/bridges/primitives/beefy/src/lib.rs b/bridges/primitives/beefy/src/lib.rs index 0441781e79a66f785b985047ad56da70c0f13d49..2494706818ef14c11a8193983164e65a510a80e6 100644 --- a/bridges/primitives/beefy/src/lib.rs +++ b/bridges/primitives/beefy/src/lib.rs @@ -22,7 +22,7 @@ pub use binary_merkle_tree::merkle_root; pub use pallet_beefy_mmr::BeefyEcdsaToEthereum; pub use pallet_mmr::{ - primitives::{DataOrHash as MmrDataOrHash, Proof as MmrProof}, + primitives::{DataOrHash as MmrDataOrHash, LeafProof as MmrProof}, verify_leaves_proof as verify_mmr_leaves_proof, }; pub use sp_consensus_beefy::{ diff --git a/bridges/primitives/header-chain/Cargo.toml b/bridges/primitives/header-chain/Cargo.toml index f7a61a9ff32bd42f4199859834b6296aeaa18f4a..081bda479495f5bbd4599b4230d45f5c4e3c5e85 100644 --- a/bridges/primitives/header-chain/Cargo.toml +++ b/bridges/primitives/header-chain/Cargo.toml @@ -11,27 +11,27 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -finality-grandpa = { version = "0.16.2", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { workspace = true } +finality-grandpa = { workspace = true } +scale-info = { features = ["derive"], workspace = true } serde = { features = ["alloc", "derive"], workspace = true } # Bridge dependencies -bp-runtime = { path = "../runtime", default-features = false } +bp-runtime = { workspace = true } # Substrate Dependencies -frame-support = { path = "../../../substrate/frame/support", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false, features = ["serde"] } -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 } +frame-support = { workspace = true } +sp-core = { features = ["serde"], workspace = true } +sp-consensus-grandpa = { features = ["serde"], workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-std = { workspace = true } [dev-dependencies] -bp-test-utils = { path = "../test-utils" } -hex = "0.4" -hex-literal = "0.4" +bp-test-utils = { workspace = true, default-features = true } +hex = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/primitives/header-chain/src/lib.rs b/bridges/primitives/header-chain/src/lib.rs index ad496012c6a3f95d636a2c1ae52fcb5f4ec5434d..26295dee1801a127f455ed3288bd5232cb60bc10 100644 --- a/bridges/primitives/header-chain/src/lib.rs +++ b/bridges/primitives/header-chain/src/lib.rs @@ -24,8 +24,8 @@ use crate::justification::{ GrandpaJustification, JustificationVerificationContext, JustificationVerificationError, }; use bp_runtime::{ - BasicOperatingMode, Chain, HashOf, HasherOf, HeaderOf, RawStorageProof, StorageProofChecker, - StorageProofError, UnderlyingChainProvider, + BasicOperatingMode, BlockNumberOf, Chain, HashOf, HasherOf, HeaderOf, RawStorageProof, + StorageProofChecker, StorageProofError, UnderlyingChainProvider, }; use codec::{Codec, Decode, Encode, EncodeLike, MaxEncodedLen}; use core::{clone::Clone, cmp::Eq, default::Default, fmt::Debug}; @@ -35,7 +35,7 @@ use serde::{Deserialize, Serialize}; use sp_consensus_grandpa::{ AuthorityList, ConsensusLog, ScheduledChange, SetId, GRANDPA_ENGINE_ID, }; -use sp_runtime::{traits::Header as HeaderT, Digest, RuntimeDebug}; +use sp_runtime::{traits::Header as HeaderT, Digest, RuntimeDebug, SaturatedConversion}; use sp_std::{boxed::Box, vec::Vec}; pub mod justification; @@ -46,7 +46,7 @@ pub mod storage_keys; pub enum HeaderChainError { /// Header with given hash is missing from the chain. UnknownHeader, - /// Storage proof related error. + /// Error generated by the `storage_proof` module. StorageProof(StorageProofError), } @@ -78,8 +78,9 @@ impl StoredHeaderDataBuilder for H { pub trait HeaderChain { /// Returns state (storage) root of given finalized header. fn finalized_header_state_root(header_hash: HashOf) -> Option>; + /// Get storage proof checker using finalized header. - fn storage_proof_checker( + fn verify_storage_proof( header_hash: HashOf, storage_proof: RawStorageProof, ) -> Result>, HeaderChainError> { @@ -325,6 +326,68 @@ where const AVERAGE_HEADER_SIZE: u32 = ::AVERAGE_HEADER_SIZE; } +/// Result of checking maximal expected submit finality proof call weight and size. +#[derive(Debug)] +pub struct SubmitFinalityProofCallExtras { + /// If true, the call weight is larger than what we have assumed. + /// + /// We have some assumptions about headers and justifications of the bridged chain. + /// We know that if our assumptions are correct, then the call must not have the + /// weight above some limit. The fee paid for weight above that limit, is never refunded. + pub is_weight_limit_exceeded: bool, + /// Extra size (in bytes) that we assume are included in the call. + /// + /// We have some assumptions about headers and justifications of the bridged chain. + /// We know that if our assumptions are correct, then the call must not have the + /// weight above some limit. The fee paid for bytes above that limit, is never refunded. + pub extra_size: u32, + /// A flag that is true if the header is the mandatory header that enacts new + /// authorities set. + pub is_mandatory_finality_target: bool, +} + +/// Checks whether the given `header` and its finality `proof` fit the maximal expected +/// call limits (size and weight). The submission may be refunded sometimes (see pallet +/// configuration for details), but it should fit some limits. If the call has some extra +/// weight and/or size included, though, we won't refund it or refund will be partial. +pub fn submit_finality_proof_limits_extras( + header: &C::Header, + proof: &justification::GrandpaJustification, +) -> SubmitFinalityProofCallExtras { + // the `submit_finality_proof` call will reject justifications with invalid, duplicate, + // unknown and extra signatures. It'll also reject justifications with less than necessary + // signatures. So we do not care about extra weight because of additional signatures here. + let precommits_len = proof.commit.precommits.len().saturated_into(); + let required_precommits = precommits_len; + + // the weight check is simple - we assume that there are no more than the `limit` + // headers in the ancestry proof + let votes_ancestries_len: u32 = proof.votes_ancestries.len().saturated_into(); + let is_weight_limit_exceeded = + votes_ancestries_len > C::REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY; + + // check if the `finality_target` is a mandatory header. If so, we are ready to refund larger + // size + let is_mandatory_finality_target = + GrandpaConsensusLogReader::>::find_scheduled_change(header.digest()) + .is_some(); + + // we can estimate extra call size easily, without any additional significant overhead + let actual_call_size: u32 = + header.encoded_size().saturating_add(proof.encoded_size()).saturated_into(); + let max_expected_call_size = max_expected_submit_finality_proof_arguments_size::( + is_mandatory_finality_target, + required_precommits, + ); + let extra_size = actual_call_size.saturating_sub(max_expected_call_size); + + SubmitFinalityProofCallExtras { + is_weight_limit_exceeded, + extra_size, + is_mandatory_finality_target, + } +} + /// Returns maximal expected size of `submit_finality_proof` call arguments. pub fn max_expected_submit_finality_proof_arguments_size( is_mandatory_finality_target: bool, @@ -347,7 +410,9 @@ mod tests { use super::*; use bp_runtime::ChainId; use frame_support::weights::Weight; - use sp_runtime::{testing::H256, traits::BlakeTwo256, DigestItem, MultiSignature}; + use sp_runtime::{ + testing::H256, traits::BlakeTwo256, DigestItem, MultiSignature, StateVersion, + }; struct TestChain; @@ -363,6 +428,8 @@ mod tests { type Nonce = u64; type Signature = MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 0 } diff --git a/bridges/primitives/messages/Cargo.toml b/bridges/primitives/messages/Cargo.toml index d41acfb9d32863d14e56e095755791a420fd3ce6..4a9037342bcea66d813cdb79969c4ff3172f0bab 100644 --- a/bridges/primitives/messages/Cargo.toml +++ b/bridges/primitives/messages/Cargo.toml @@ -11,24 +11,24 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive"] } +codec = { features = ["bit-vec", "derive"], workspace = true } +scale-info = { features = ["bit-vec", "derive"], workspace = true } serde = { features = ["alloc", "derive"], workspace = true } # Bridge dependencies -bp-runtime = { path = "../runtime", default-features = false } -bp-header-chain = { path = "../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 } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } +frame-support = { workspace = true } +sp-core = { workspace = true } +sp-std = { workspace = true } [dev-dependencies] -hex = "0.4" -hex-literal = "0.4" +hex = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/primitives/messages/src/lib.rs b/bridges/primitives/messages/src/lib.rs index c3f79b3ee388c4584def56056f6cdf6328032e18..9984f8ac3222780ea2fd6af56dd896beb264b2d5 100644 --- a/bridges/primitives/messages/src/lib.rs +++ b/bridges/primitives/messages/src/lib.rs @@ -38,6 +38,9 @@ pub mod source_chain; pub mod storage_keys; pub mod target_chain; +/// Hard limit on message size that can be sent over the bridge. +pub const HARD_MESSAGE_SIZE_LIMIT: u32 = 64 * 1024; + /// Substrate-based chain with messaging support. pub trait ChainWithMessages: Chain { /// Name of the bridge messages pallet (used in `construct_runtime` macro call) that is @@ -48,11 +51,63 @@ pub trait ChainWithMessages: Chain { const WITH_CHAIN_MESSAGES_PALLET_NAME: &'static str; /// Maximal number of unrewarded relayers in a single confirmation transaction at this - /// `ChainWithMessages`. + /// `ChainWithMessages`. Unrewarded means that the relayer has delivered messages, but + /// either confirmations haven't been delivered back to the source chain, or we haven't + /// received reward confirmations yet. + /// + /// This constant limits maximal number of entries in the `InboundLaneData::relayers`. Keep + /// in mind that the same relayer account may take several (non-consecutive) entries in this + /// set. const MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX: MessageNonce; /// Maximal number of unconfirmed messages in a single confirmation transaction at this - /// `ChainWithMessages`. + /// `ChainWithMessages`. Unconfirmed means that the + /// message has been delivered, but either confirmations haven't been delivered back to the + /// source chain, or we haven't received reward confirmations for these messages yet. + /// + /// This constant limits difference between last message from last entry of the + /// `InboundLaneData::relayers` and first message at the first entry. + /// + /// There is no point of making this parameter lesser than + /// `MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX`, because then maximal number of relayer entries + /// will be limited by maximal number of messages. + /// + /// This value also represents maximal number of messages in single delivery transaction. + /// Transaction that is declaring more messages than this value, will be rejected. Even if + /// these messages are from different lanes. const MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX: MessageNonce; + + /// Return maximal dispatch weight of the message we're able to receive. + fn maximal_incoming_message_dispatch_weight() -> Weight { + // we leave 1/2 of `max_extrinsic_weight` for the delivery transaction itself + Self::max_extrinsic_weight() / 2 + } + + /// Return maximal size of the message we're able to receive. + fn maximal_incoming_message_size() -> u32 { + maximal_incoming_message_size(Self::max_extrinsic_size()) + } +} + +/// Return maximal size of the message the chain with `max_extrinsic_size` is able to receive. +pub fn maximal_incoming_message_size(max_extrinsic_size: u32) -> u32 { + // 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. + // + // **ANOTHER IMPORTANT NOTE**: large message means not only larger proofs and heavier + // proof verification, but also heavier message decoding and dispatch. So we have a hard + // limit of `64Kb`, which in practice limits the message size on all chains. Without this + // limit the **weight** (not the size) of the message will be higher than the + // `Self::maximal_incoming_message_dispatch_weight()`. + + sp_std::cmp::min(max_extrinsic_size / 3 * 2, HARD_MESSAGE_SIZE_LIMIT) } impl ChainWithMessages for T @@ -112,7 +167,19 @@ impl OperatingMode for MessagesOperatingMode { /// Lane id which implements `TypeId`. #[derive( - Clone, Copy, Decode, Default, Encode, Eq, Ord, PartialOrd, PartialEq, TypeInfo, MaxEncodedLen, + Clone, + Copy, + Decode, + Default, + Encode, + Eq, + Ord, + PartialOrd, + PartialEq, + TypeInfo, + MaxEncodedLen, + Serialize, + Deserialize, )] pub struct LaneId(pub [u8; 4]); @@ -435,7 +502,7 @@ where AccountId: sp_std::cmp::Ord, { // remember to reward relayers that have delivered messages - // this loop is bounded by `T::MaxUnrewardedRelayerEntriesAtInboundLane` on the bridged chain + // this loop is bounded by `T::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX` on the bridged chain let mut relayers_rewards = RelayersRewards::new(); for entry in messages_relayers { let nonce_begin = sp_std::cmp::max(entry.messages.begin, *received_range.start()); @@ -486,11 +553,11 @@ pub enum VerificationError { InvalidMessageWeight, /// Declared messages count doesn't match actual value. MessagesCountMismatch, - /// Error returned while reading/decoding message data from the storage proof. + /// Error returned while reading/decoding message data from the `VerifiedStorageProof`. MessageStorage(StorageProofError), /// The message is too large. MessageTooLarge, - /// Error returned while reading/decoding outbound lane data from the storage proof. + /// Error returned while reading/decoding outbound lane data from the `VerifiedStorageProof`. OutboundLaneStorage(StorageProofError), /// Storage proof related error. StorageProof(StorageProofError), diff --git a/bridges/primitives/messages/src/source_chain.rs b/bridges/primitives/messages/src/source_chain.rs index f4aefd9735583e265c3e44713f13f81ae63ba276..64f015bdb822eb25ff42a3fdb52bf6405a5424bf 100644 --- a/bridges/primitives/messages/src/source_chain.rs +++ b/bridges/primitives/messages/src/source_chain.rs @@ -16,11 +16,11 @@ //! Primitives of messages module, that are used on the source chain. -use crate::{InboundLaneData, LaneId, MessageNonce, VerificationError}; +use crate::{LaneId, MessageNonce, UnrewardedRelayer}; -use crate::UnrewardedRelayer; -use bp_runtime::Size; -use frame_support::Parameter; +use bp_runtime::{raw_storage_proof_size, RawStorageProof, Size}; +use codec::{Decode, Encode}; +use scale_info::TypeInfo; use sp_core::RuntimeDebug; use sp_std::{ collections::{btree_map::BTreeMap, vec_deque::VecDeque}, @@ -28,42 +28,36 @@ use sp_std::{ ops::RangeInclusive, }; -/// Number of messages, delivered by relayers. -pub type RelayersRewards = BTreeMap; - -/// Target chain API. Used by source chain to verify target chain proofs. +/// Messages delivery proof from the bridged chain. /// -/// All implementations of this trait should only work with finalized data that -/// can't change. Wrong implementation may lead to invalid lane states (i.e. lane -/// that's stuck) and/or processing messages without paying fees. +/// It contains everything required to prove that our (this chain) messages have been +/// delivered to the bridged (target) chain: /// -/// The `Payload` type here means the payload of the message that is sent from the -/// source chain to the target chain. The `AccountId` type here means the account -/// type used by the source chain. -pub trait TargetHeaderChain { - /// Proof that messages have been received by target chain. - type MessagesDeliveryProof: Parameter + Size; - - /// Verify message payload before we accept it. - /// - /// **CAUTION**: this is very important function. Incorrect implementation may lead - /// to stuck lanes and/or relayers loses. - /// - /// The proper implementation must ensure that the delivery-transaction with this - /// payload would (at least) be accepted into target chain transaction pool AND - /// eventually will be successfully mined. The most obvious incorrect implementation - /// example would be implementation for BTC chain that accepts payloads larger than - /// 1MB. BTC nodes aren't accepting transactions that are larger than 1MB, so relayer - /// will be unable to craft valid transaction => this (and all subsequent) messages will - /// never be delivered. - fn verify_message(payload: &Payload) -> Result<(), VerificationError>; - - /// Verify messages delivery proof and return lane && nonce of the latest received message. - fn verify_messages_delivery_proof( - proof: Self::MessagesDeliveryProof, - ) -> Result<(LaneId, InboundLaneData), VerificationError>; +/// - hash of finalized header; +/// +/// - storage proof of the 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 { + use frame_support::sp_runtime::SaturatedConversion; + raw_storage_proof_size(&self.storage_proof).saturated_into() + } } +/// Number of messages, delivered by relayers. +pub type RelayersRewards = BTreeMap; + /// Manages payments that are happening at the source chain during delivery confirmation /// transaction. pub trait DeliveryConfirmationPayments { @@ -143,28 +137,10 @@ pub trait MessagesBridge { fn send_message(message: Self::SendMessageArgs) -> SendMessageArtifacts; } -/// Structure that may be used in place of `TargetHeaderChain` and -/// `MessageDeliveryAndDispatchPayment` on chains, where outbound messages are forbidden. +/// Structure that may be used in place `MessageDeliveryAndDispatchPayment` on chains, +/// where outbound messages are forbidden. pub struct ForbidOutboundMessages; -/// Error message that is used in `ForbidOutboundMessages` implementation. -const ALL_OUTBOUND_MESSAGES_REJECTED: &str = - "This chain is configured to reject all outbound messages"; - -impl TargetHeaderChain for ForbidOutboundMessages { - type MessagesDeliveryProof = (); - - fn verify_message(_payload: &Payload) -> Result<(), VerificationError> { - Err(VerificationError::Other(ALL_OUTBOUND_MESSAGES_REJECTED)) - } - - fn verify_messages_delivery_proof( - _proof: Self::MessagesDeliveryProof, - ) -> Result<(LaneId, InboundLaneData), VerificationError> { - Err(VerificationError::Other(ALL_OUTBOUND_MESSAGES_REJECTED)) - } -} - impl DeliveryConfirmationPayments for ForbidOutboundMessages { type Error = &'static str; diff --git a/bridges/primitives/messages/src/target_chain.rs b/bridges/primitives/messages/src/target_chain.rs index 388ce16ccdc06d3e2c42c3a094aae4d6180a0d09..74fecb9d9f0d89420d2ca54a4356e23c9130e614 100644 --- a/bridges/primitives/messages/src/target_chain.rs +++ b/bridges/primitives/messages/src/target_chain.rs @@ -16,17 +16,48 @@ //! Primitives of messages module, that are used on the target chain. -use crate::{ - LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData, VerificationError, -}; +use crate::{LaneId, Message, MessageKey, MessageNonce, MessagePayload, OutboundLaneData}; -use bp_runtime::{messages::MessageDispatchResult, Size}; +use bp_runtime::{messages::MessageDispatchResult, raw_storage_proof_size, RawStorageProof, Size}; use codec::{Decode, Encode, Error as CodecError}; -use frame_support::{weights::Weight, Parameter}; +use frame_support::weights::Weight; use scale_info::TypeInfo; use sp_core::RuntimeDebug; use sp_std::{collections::btree_map::BTreeMap, fmt::Debug, marker::PhantomData, prelude::*}; +/// Messages proof from bridged chain. +/// +/// It contains everything required to prove that bridged (source) chain has +/// sent us some messages: +/// +/// - 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 { + use frame_support::sp_runtime::SaturatedConversion; + raw_storage_proof_size(&self.storage_proof).saturated_into() + } +} + /// Proved messages from the source chain. pub type ProvedMessages = BTreeMap>; @@ -55,33 +86,6 @@ pub struct DispatchMessage { pub data: DispatchMessageData, } -/// Source chain API. Used by target chain, to verify source chain proofs. -/// -/// All implementations of this trait should only work with finalized data that -/// can't change. Wrong implementation may lead to invalid lane states (i.e. lane -/// that's stuck) and/or processing messages without paying fees. -pub trait SourceHeaderChain { - /// Proof that messages are sent from source chain. This may also include proof - /// of corresponding outbound lane states. - type MessagesProof: Parameter + Size; - - /// Verify messages proof and return proved messages. - /// - /// Returns error if either proof is incorrect, or the number of messages in the proof - /// is not matching the `messages_count`. - /// - /// Messages vector is required to be sorted by nonce within each lane. Out-of-order - /// messages will be rejected. - /// - /// The `messages_count` argument verification (sane limits) is supposed to be made - /// outside this function. This function only verifies that the proof declares exactly - /// `messages_count` messages. - fn verify_messages_proof( - proof: Self::MessagesProof, - messages_count: u32, - ) -> Result, VerificationError>; -} - /// Called when inbound message is received. pub trait MessageDispatch { /// Decoded message payload type. Valid message may contain invalid payload. In this case @@ -167,32 +171,11 @@ impl DeliveryPayments for () { } } -/// Structure that may be used in place of `SourceHeaderChain` and `MessageDispatch` on chains, +/// Structure that may be used in place of `MessageDispatch` on chains, /// where inbound messages are forbidden. -pub struct ForbidInboundMessages( - PhantomData<(MessagesProof, DispatchPayload)>, -); - -/// Error message that is used in `ForbidInboundMessages` implementation. -const ALL_INBOUND_MESSAGES_REJECTED: &str = - "This chain is configured to reject all inbound messages"; - -impl SourceHeaderChain - for ForbidInboundMessages -{ - type MessagesProof = MessagesProof; - - fn verify_messages_proof( - _proof: Self::MessagesProof, - _messages_count: u32, - ) -> Result, VerificationError> { - Err(VerificationError::Other(ALL_INBOUND_MESSAGES_REJECTED)) - } -} +pub struct ForbidInboundMessages(PhantomData); -impl MessageDispatch - for ForbidInboundMessages -{ +impl MessageDispatch for ForbidInboundMessages { type DispatchPayload = DispatchPayload; type DispatchLevelResult = (); diff --git a/bridges/primitives/parachains/Cargo.toml b/bridges/primitives/parachains/Cargo.toml index 2e7000b86a5e4ba21ccadf74b1c2d5374db5c545..173380c8224d2855e2022cc6b6f9266fc8094ecd 100644 --- a/bridges/primitives/parachains/Cargo.toml +++ b/bridges/primitives/parachains/Cargo.toml @@ -11,22 +11,22 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } -impl-trait-for-tuples = "0.2" -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } +impl-trait-for-tuples = { workspace = true } +scale-info = { features = ["derive"], workspace = true } # Bridge dependencies -bp-header-chain = { path = "../header-chain", default-features = false } -bp-polkadot-core = { path = "../polkadot-core", default-features = false } -bp-runtime = { path = "../runtime", default-features = false } +bp-header-chain = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-runtime = { workspace = true } # Substrate dependencies -frame-support = { path = "../../../substrate/frame/support", 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 } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } [features] default = ["std"] diff --git a/bridges/primitives/polkadot-core/Cargo.toml b/bridges/primitives/polkadot-core/Cargo.toml index 53b1e574cb1997e556f17b7f21f6a28d9eb84400..acae2f431bf20aa8babf57e586cd4bb726fe2ec8 100644 --- a/bridges/primitives/polkadot-core/Cargo.toml +++ b/bridges/primitives/polkadot-core/Cargo.toml @@ -11,26 +11,26 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } -parity-util-mem = { version = "0.12.0", optional = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } +parity-util-mem = { optional = true, workspace = true } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } # Bridge Dependencies -bp-messages = { path = "../messages", default-features = false } -bp-runtime = { path = "../runtime", default-features = false } +bp-messages = { 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-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] -hex = "0.4" +hex = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/primitives/polkadot-core/src/parachains.rs b/bridges/primitives/polkadot-core/src/parachains.rs index 433cd2845abd9ae95687d6f1d024765ee3bd2ebb..d54ee108386edf50865c500eb1062c24b01c0c3e 100644 --- a/bridges/primitives/polkadot-core/src/parachains.rs +++ b/bridges/primitives/polkadot-core/src/parachains.rs @@ -22,7 +22,7 @@ //! parachains. Having pallets that are referencing polkadot, would mean that there may //! be two versions of polkadot crates included in the runtime. Which is bad. -use bp_runtime::{RawStorageProof, Size}; +use bp_runtime::{raw_storage_proof_size, RawStorageProof, Size}; use codec::{CompactAs, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use sp_core::Hasher; @@ -96,11 +96,7 @@ pub struct ParaHeadsProof { impl Size for ParaHeadsProof { fn size(&self) -> u32 { - u32::try_from( - self.storage_proof - .iter() - .fold(0usize, |sum, node| sum.saturating_add(node.len())), - ) - .unwrap_or(u32::MAX) + use frame_support::sp_runtime::SaturatedConversion; + raw_storage_proof_size(&self.storage_proof).saturated_into() } } diff --git a/bridges/primitives/relayers/Cargo.toml b/bridges/primitives/relayers/Cargo.toml index 1be7f1dc6ebd38061e98865b45d4f85d8f3f7448..3448e8a4096339966023d0f5ddd0e158380ab12a 100644 --- a/bridges/primitives/relayers/Cargo.toml +++ b/bridges/primitives/relayers/Cargo.toml @@ -11,23 +11,23 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive"] } +codec = { features = ["bit-vec", "derive"], workspace = true } +scale-info = { features = ["bit-vec", "derive"], workspace = true } # Bridge Dependencies -bp-messages = { path = "../messages", default-features = false } -bp-runtime = { path = "../runtime", default-features = false } +bp-messages = { workspace = true } +bp-runtime = { workspace = true } # Substrate Dependencies -frame-support = { path = "../../../substrate/frame/support", 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-runtime = { workspace = true } +sp-std = { workspace = true } [dev-dependencies] -hex = "0.4" -hex-literal = "0.4" +hex = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/primitives/relayers/src/lib.rs b/bridges/primitives/relayers/src/lib.rs index 2a9ef6a8e1e9aba999ea90045447f7a87fb3813b..436f33db4008013572592939b63c0e02e92b8e99 100644 --- a/bridges/primitives/relayers/src/lib.rs +++ b/bridges/primitives/relayers/src/lib.rs @@ -140,8 +140,8 @@ pub struct RelayerRewardsKeyProvider(PhantomData<(AccountId, impl StorageDoubleMapKeyProvider for RelayerRewardsKeyProvider where - AccountId: Codec + EncodeLike, - Reward: Codec + EncodeLike, + AccountId: 'static + Codec + EncodeLike + Send + Sync, + Reward: 'static + Codec + EncodeLike + Send + Sync, { const MAP_NAME: &'static str = "RelayerRewards"; diff --git a/bridges/primitives/runtime/Cargo.toml b/bridges/primitives/runtime/Cargo.toml index 9a9b0291687d19ac0b5698ce3ef6a591da9f86c9..117409b37b9457f93194585b12aabd0de00d5c7f 100644 --- a/bridges/primitives/runtime/Cargo.toml +++ b/bridges/primitives/runtime/Cargo.toml @@ -11,28 +11,28 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -hash-db = { version = "0.16.0", default-features = false } -impl-trait-for-tuples = "0.2.2" +codec = { workspace = true } +hash-db = { workspace = true } +impl-trait-for-tuples = { workspace = true } log = { workspace = true } -num-traits = { version = "0.2", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +num-traits = { workspace = true } +scale-info = { features = ["derive"], workspace = true } serde = { features = ["alloc", "derive"], 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-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] } -sp-state-machine = { path = "../../../substrate/primitives/state-machine", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } -trie-db = { version = "0.29.0", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-state-machine = { workspace = true } +sp-std = { workspace = true } +sp-trie = { workspace = true } +trie-db = { workspace = true } [dev-dependencies] -hex-literal = "0.4" +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] @@ -53,3 +53,4 @@ std = [ "sp-trie/std", "trie-db/std", ] +test-helpers = [] diff --git a/bridges/primitives/runtime/src/chain.rs b/bridges/primitives/runtime/src/chain.rs index 369386e41b0cf9f2d911ca40fc9e6ccfb3de6e52..0db4eac79a7500bf295756efaef514f5a4429e6c 100644 --- a/bridges/primitives/runtime/src/chain.rs +++ b/bridges/primitives/runtime/src/chain.rs @@ -24,7 +24,7 @@ use sp_runtime::{ AtLeast32Bit, AtLeast32BitUnsigned, Hash as HashT, Header as HeaderT, MaybeDisplay, MaybeSerialize, MaybeSerializeDeserialize, Member, SimpleBitOps, Verify, }, - FixedPointOperand, + FixedPointOperand, StateVersion, }; use sp_std::{fmt::Debug, hash::Hash, str::FromStr, vec, vec::Vec}; @@ -196,6 +196,10 @@ pub trait Chain: Send + Sync + 'static { /// Signature type, used on this chain. type Signature: Parameter + Verify; + /// Version of the state implementation used by this chain. This is directly related with the + /// `TrieLayout` configuration used by the storage. + const STATE_VERSION: StateVersion; + /// Get the maximum size (in bytes) of a Normal extrinsic at this chain. fn max_extrinsic_size() -> u32; /// Get the maximum weight (compute time) that a Normal extrinsic at this chain can use. @@ -223,6 +227,8 @@ where type Nonce = ::Nonce; type Signature = ::Signature; + const STATE_VERSION: StateVersion = ::STATE_VERSION; + fn max_extrinsic_size() -> u32 { ::max_extrinsic_size() } diff --git a/bridges/primitives/runtime/src/lib.rs b/bridges/primitives/runtime/src/lib.rs index 5daba0351ad48f0ae39b870990b6f5ccea1bec1e..8f5040ad9a1bee5efad995b4e62d5e883dfb0c9f 100644 --- a/bridges/primitives/runtime/src/lib.rs +++ b/bridges/primitives/runtime/src/lib.rs @@ -40,15 +40,18 @@ pub use chain::{ }; pub use frame_support::storage::storage_prefix as storage_value_final_key; use num_traits::{CheckedAdd, CheckedSub, One, SaturatingAdd, Zero}; +#[cfg(feature = "std")] +pub use storage_proof::craft_valid_storage_proof; +#[cfg(feature = "test-helpers")] pub use storage_proof::{ - record_all_keys as record_all_trie_keys, Error as StorageProofError, - ProofSize as StorageProofSize, RawStorageProof, StorageProofChecker, + grow_storage_proof, grow_storage_value, record_all_keys as record_all_trie_keys, + UnverifiedStorageProofParams, +}; +pub use storage_proof::{ + raw_storage_proof_size, RawStorageProof, StorageProofChecker, StorageProofError, }; pub use storage_types::BoundedStorageValue; -#[cfg(feature = "std")] -pub use storage_proof::craft_valid_storage_proof; - pub mod extensions; pub mod messages; @@ -255,9 +258,9 @@ pub trait StorageMapKeyProvider { /// The same as `StorageMap::Hasher1`. type Hasher: StorageHasher; /// The same as `StorageMap::Key1`. - type Key: FullCodec; + type Key: FullCodec + Send + Sync; /// The same as `StorageMap::Value`. - type Value: FullCodec; + type Value: 'static + FullCodec; /// This is a copy of the /// `frame_support::storage::generator::StorageMap::storage_map_final_key`. @@ -277,13 +280,13 @@ pub trait StorageDoubleMapKeyProvider { /// The same as `StorageDoubleMap::Hasher1`. type Hasher1: StorageHasher; /// The same as `StorageDoubleMap::Key1`. - type Key1: FullCodec; + type Key1: FullCodec + Send + Sync; /// The same as `StorageDoubleMap::Hasher2`. type Hasher2: StorageHasher; /// The same as `StorageDoubleMap::Key2`. - type Key2: FullCodec; + type Key2: FullCodec + Send + Sync; /// The same as `StorageDoubleMap::Value`. - type Value: FullCodec; + type Value: 'static + FullCodec; /// This is a copy of the /// `frame_support::storage::generator::StorageDoubleMap::storage_double_map_final_key`. @@ -461,38 +464,6 @@ macro_rules! generate_static_str_provider { }; } -/// Error message that is only displayable in `std` environment. -#[derive(Encode, Decode, Clone, Eq, PartialEq, PalletError, TypeInfo)] -#[scale_info(skip_type_params(T))] -pub struct StrippableError { - _phantom_data: sp_std::marker::PhantomData, - #[codec(skip)] - #[cfg(feature = "std")] - message: String, -} - -impl From for StrippableError { - fn from(_err: T) -> Self { - Self { - _phantom_data: Default::default(), - #[cfg(feature = "std")] - message: format!("{:?}", _err), - } - } -} - -impl Debug for StrippableError { - #[cfg(feature = "std")] - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { - f.write_str(&self.message) - } - - #[cfg(not(feature = "std"))] - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { - f.write_str("Stripped error") - } -} - /// A trait defining helper methods for `RangeInclusive` (start..=end) pub trait RangeInclusiveExt { /// Computes the length of the `RangeInclusive`, checking for underflow and overflow. diff --git a/bridges/primitives/runtime/src/storage_proof.rs b/bridges/primitives/runtime/src/storage_proof.rs index 1b706aa66c16fc73a21ce83f550bea8a8fe128e5..7bfa0d6fde01186f1fe09e66dd3ba1accf286ce5 100644 --- a/bridges/primitives/runtime/src/storage_proof.rs +++ b/bridges/primitives/runtime/src/storage_proof.rs @@ -14,33 +14,91 @@ // You should have received a copy of the GNU General Public License // along with Parity Bridges Common. If not, see . -//! Logic for checking Substrate storage proofs. +//! Logic for working with storage proofs. -use crate::StrippableError; -use codec::{Decode, Encode}; use frame_support::PalletError; -use hash_db::{HashDB, Hasher, EMPTY_PREFIX}; -use scale_info::TypeInfo; -use sp_std::{boxed::Box, collections::btree_set::BTreeSet, vec::Vec}; +use sp_core::RuntimeDebug; +use sp_std::{default::Default, vec::Vec}; use sp_trie::{ - read_trie_value, LayoutV1, MemoryDB, Recorder, StorageProof, Trie, TrieConfiguration, - TrieDBBuilder, TrieError, TrieHash, + accessed_nodes_tracker::AccessedNodesTracker, read_trie_value, LayoutV1, MemoryDB, StorageProof, }; +use codec::{Decode, Encode}; +use hash_db::{HashDB, Hasher, EMPTY_PREFIX}; +use scale_info::TypeInfo; +#[cfg(feature = "test-helpers")] +use sp_trie::{recorder_ext::RecorderExt, Recorder, TrieDBBuilder, TrieError, TrieHash}; +#[cfg(feature = "test-helpers")] +use trie_db::{Trie, TrieConfiguration, TrieDBMut}; + +/// Errors that can occur when interacting with `UnverifiedStorageProof` and `VerifiedStorageProof`. +#[derive(Clone, Encode, Decode, RuntimeDebug, PartialEq, Eq, PalletError, TypeInfo)] +pub enum StorageProofError { + /// Call to `generate_trie_proof()` failed. + UnableToGenerateTrieProof, + /// Call to `verify_trie_proof()` failed. + InvalidProof, + /// The `Vec` entries weren't sorted as expected. + UnsortedEntries, + /// The provided key wasn't found. + UnavailableKey, + /// The value associated to the provided key is `None`. + EmptyVal, + /// Error decoding value associated to a provided key. + DecodeError, + /// At least one key or node wasn't read. + UnusedKey, + + /// Expected storage root is missing from the proof. (for non-compact proofs) + StorageRootMismatch, + /// Unable to reach expected storage value using provided trie nodes. (for non-compact proofs) + StorageValueUnavailable, + /// The proof contains duplicate nodes. (for non-compact proofs) + DuplicateNodes, +} + +impl From for StorageProofError { + fn from(e: sp_trie::StorageProofError) -> Self { + match e { + sp_trie::StorageProofError::DuplicateNodes => StorageProofError::DuplicateNodes, + } + } +} + +impl From for StorageProofError { + fn from(e: sp_trie::accessed_nodes_tracker::Error) -> Self { + match e { + sp_trie::accessed_nodes_tracker::Error::UnusedNodes => StorageProofError::UnusedKey, + } + } +} + /// Raw storage proof type (just raw trie nodes). -pub type RawStorageProof = Vec>; +pub type RawStorageProof = sp_trie::RawStorageProof; + +/// Calculates size for `RawStorageProof`. +pub fn raw_storage_proof_size(raw_storage_proof: &RawStorageProof) -> usize { + raw_storage_proof + .iter() + .fold(0usize, |sum, node| sum.saturating_add(node.len())) +} -/// Storage proof size requirements. +/// Storage values size requirements. /// /// This is currently used by benchmarks when generating storage proofs. -#[derive(Clone, Copy, Debug)] -pub enum ProofSize { - /// The proof is expected to be minimal. If value size may be changed, then it is expected to - /// have given size. - Minimal(u32), - /// The proof is expected to have at least given size and grow by increasing value that is - /// stored in the trie. - HasLargeLeaf(u32), +#[cfg(feature = "test-helpers")] +#[derive(Clone, Copy, Debug, Default)] +pub struct UnverifiedStorageProofParams { + /// Expected storage proof size in bytes. + pub db_size: Option, +} + +#[cfg(feature = "test-helpers")] +impl UnverifiedStorageProofParams { + /// Make storage proof parameters that require proof of at least `db_size` bytes. + pub fn from_db_size(db_size: u32) -> Self { + Self { db_size: Some(db_size) } + } } /// This struct is used to read storage values from a subset of a Merklized database. The "proof" @@ -51,10 +109,9 @@ pub struct StorageProofChecker where H: Hasher, { - proof_nodes_count: usize, root: H::Out, db: MemoryDB, - recorder: Recorder>, + accessed_nodes_tracker: AccessedNodesTracker, } impl StorageProofChecker @@ -64,99 +121,161 @@ where /// Constructs a new storage proof checker. /// /// This returns an error if the given proof is invalid with respect to the given root. - pub fn new(root: H::Out, proof: RawStorageProof) -> Result { - // 1. we don't want extra items in the storage proof - // 2. `StorageProof` is storing all trie nodes in the `BTreeSet` - // - // => someone could simply add duplicate items to the proof and we won't be - // able to detect that by just using `StorageProof` - // - // => let's check it when we are converting our "raw proof" into `StorageProof` - let proof_nodes_count = proof.len(); - let proof = StorageProof::new(proof); - if proof_nodes_count != proof.iter_nodes().count() { - return Err(Error::DuplicateNodesInProof) - } + pub fn new(root: H::Out, proof: RawStorageProof) -> Result { + let proof = StorageProof::new_with_duplicate_nodes_check(proof)?; + + let recorder = AccessedNodesTracker::new(proof.len()); let db = proof.into_memory_db(); if !db.contains(&root, EMPTY_PREFIX) { - return Err(Error::StorageRootMismatch) + return Err(StorageProofError::StorageRootMismatch) } - let recorder = Recorder::default(); - let checker = StorageProofChecker { proof_nodes_count, root, db, recorder }; - Ok(checker) + Ok(StorageProofChecker { root, db, accessed_nodes_tracker: recorder }) } /// Returns error if the proof has some nodes that are left intact by previous `read_value` /// calls. - pub fn ensure_no_unused_nodes(mut self) -> Result<(), Error> { - let visited_nodes = self - .recorder - .drain() - .into_iter() - .map(|record| record.data) - .collect::>(); - let visited_nodes_count = visited_nodes.len(); - if self.proof_nodes_count == visited_nodes_count { - Ok(()) - } else { - Err(Error::UnusedNodesInTheProof) - } + pub fn ensure_no_unused_nodes(self) -> Result<(), StorageProofError> { + self.accessed_nodes_tracker.ensure_no_unused_nodes().map_err(Into::into) } /// Reads a value from the available subset of storage. If the value cannot be read due to an /// incomplete or otherwise invalid proof, this function returns an error. - pub fn read_value(&mut self, key: &[u8]) -> Result>, Error> { + pub fn read_value(&mut self, key: &[u8]) -> Result>, StorageProofError> { // LayoutV1 or LayoutV0 is identical for proof that only read values. - read_trie_value::, _>(&self.db, &self.root, key, Some(&mut self.recorder), None) - .map_err(|_| Error::StorageValueUnavailable) + read_trie_value::, _>( + &self.db, + &self.root, + key, + Some(&mut self.accessed_nodes_tracker), + None, + ) + .map_err(|_| StorageProofError::StorageValueUnavailable) } /// Reads and decodes a value from the available subset of storage. If the value cannot be read /// due to an incomplete or otherwise invalid proof, this function returns an error. If value is /// read, but decoding fails, this function returns an error. - pub fn read_and_decode_value(&mut self, key: &[u8]) -> Result, Error> { + pub fn read_and_decode_value( + &mut self, + key: &[u8], + ) -> Result, StorageProofError> { self.read_value(key).and_then(|v| { - v.map(|v| T::decode(&mut &v[..]).map_err(|e| Error::StorageValueDecodeFailed(e.into()))) - .transpose() + v.map(|v| { + T::decode(&mut &v[..]).map_err(|e| { + log::warn!(target: "bridge-storage-proofs", "read_and_decode_value error: {e:?}"); + StorageProofError::DecodeError + }) + }) + .transpose() }) } /// Reads and decodes a value from the available subset of storage. If the value cannot be read /// due to an incomplete or otherwise invalid proof, or if the value is `None`, this function /// returns an error. If value is read, but decoding fails, this function returns an error. - pub fn read_and_decode_mandatory_value(&mut self, key: &[u8]) -> Result { - self.read_and_decode_value(key)?.ok_or(Error::StorageValueEmpty) + pub fn read_and_decode_mandatory_value( + &mut self, + key: &[u8], + ) -> Result { + self.read_and_decode_value(key)?.ok_or(StorageProofError::EmptyVal) } /// Reads and decodes a value from the available subset of storage. If the value cannot be read /// due to an incomplete or otherwise invalid proof, this function returns `Ok(None)`. /// If value is read, but decoding fails, this function returns an error. - pub fn read_and_decode_opt_value(&mut self, key: &[u8]) -> Result, Error> { + pub fn read_and_decode_opt_value( + &mut self, + key: &[u8], + ) -> Result, StorageProofError> { match self.read_and_decode_value(key) { Ok(outbound_lane_data) => Ok(outbound_lane_data), - Err(Error::StorageValueUnavailable) => Ok(None), + Err(StorageProofError::StorageValueUnavailable) => Ok(None), Err(e) => Err(e), } } } -/// Storage proof related errors. -#[derive(Encode, Decode, Clone, Eq, PartialEq, PalletError, Debug, TypeInfo)] -pub enum Error { - /// Duplicate trie nodes are found in the proof. - DuplicateNodesInProof, - /// Unused trie nodes are found in the proof. - UnusedNodesInTheProof, - /// Expected storage root is missing from the proof. - StorageRootMismatch, - /// Unable to reach expected storage value using provided trie nodes. - StorageValueUnavailable, - /// The storage value is `None`. - StorageValueEmpty, - /// Failed to decode storage value. - StorageValueDecodeFailed(StrippableError), +/// Add extra data to the storage value so that it'll be of given size. +#[cfg(feature = "test-helpers")] +pub fn grow_storage_value(mut value: Vec, params: &UnverifiedStorageProofParams) -> Vec { + if let Some(db_size) = params.db_size { + if db_size as usize > value.len() { + value.extend(sp_std::iter::repeat(42u8).take(db_size as usize - value.len())); + } + } + value +} + +/// Insert values in the provided trie at common-prefix keys in order to inflate the resulting +/// storage proof. +/// +/// This function can add at most 15 common-prefix keys per prefix nibble (4 bits). +/// Each such key adds about 33 bytes (a node) to the proof. +#[cfg(feature = "test-helpers")] +pub fn grow_storage_proof( + trie: &mut TrieDBMut, + prefix: Vec, + num_extra_nodes: usize, +) { + use sp_trie::TrieMut; + + let mut added_nodes = 0; + for i in 0..prefix.len() { + let mut prefix = prefix[0..=i].to_vec(); + // 1 byte has 2 nibbles (4 bits each) + let first_nibble = (prefix[i] & 0xf0) >> 4; + let second_nibble = prefix[i] & 0x0f; + + // create branches at the 1st nibble + for branch in 1..=15 { + if added_nodes >= num_extra_nodes { + return + } + + // create branches at the 1st nibble + prefix[i] = (first_nibble.wrapping_add(branch) % 16) << 4; + trie.insert(&prefix, &[0; 32]) + .map_err(|_| "TrieMut::insert has failed") + .expect("TrieMut::insert should not fail in benchmarks"); + added_nodes += 1; + } + + // create branches at the 2nd nibble + for branch in 1..=15 { + if added_nodes >= num_extra_nodes { + return + } + + prefix[i] = (first_nibble << 4) | (second_nibble.wrapping_add(branch) % 16); + trie.insert(&prefix, &[0; 32]) + .map_err(|_| "TrieMut::insert has failed") + .expect("TrieMut::insert should not fail in benchmarks"); + added_nodes += 1; + } + } + + assert_eq!(added_nodes, num_extra_nodes) +} + +/// Record all keys for a given root. +#[cfg(feature = "test-helpers")] +pub fn record_all_keys( + db: &DB, + root: &TrieHash, +) -> Result>> +where + DB: hash_db::HashDBRef, +{ + let mut recorder = Recorder::::new(); + let trie = TrieDBBuilder::::new(db, root).with_recorder(&mut recorder).build(); + for x in trie.iter()? { + let (key, _) = x?; + trie.get(&key)?; + } + + Ok(recorder.into_raw_storage_proof()) } /// Return valid storage proof and state root. @@ -170,7 +289,7 @@ pub fn craft_valid_storage_proof() -> (sp_core::H256, RawStorageProof) { // construct storage proof let backend = >::from(( - vec![ + sp_std::vec![ (None, vec![(b"key1".to_vec(), Some(b"value1".to_vec()))]), (None, vec![(b"key2".to_vec(), Some(b"value2".to_vec()))]), (None, vec![(b"key3".to_vec(), Some(b"value3".to_vec()))]), @@ -180,41 +299,15 @@ pub fn craft_valid_storage_proof() -> (sp_core::H256, RawStorageProof) { ], state_version, )); - let root = backend.storage_root(std::iter::empty(), state_version).0; + let root = backend.storage_root(sp_std::iter::empty(), state_version).0; let proof = prove_read(backend, &[&b"key1"[..], &b"key2"[..], &b"key4"[..], &b"key22"[..]]).unwrap(); (root, proof.into_nodes().into_iter().collect()) } -/// Record all keys for a given root. -pub fn record_all_keys( - db: &DB, - root: &TrieHash, -) -> Result>> -where - DB: hash_db::HashDBRef, -{ - let mut recorder = Recorder::::new(); - let trie = TrieDBBuilder::::new(db, root).with_recorder(&mut recorder).build(); - for x in trie.iter()? { - let (key, _) = x?; - trie.get(&key)?; - } - - // recorder may record the same trie node multiple times and we don't want duplicate nodes - // in our proofs => let's deduplicate it by collecting to the BTreeSet first - Ok(recorder - .drain() - .into_iter() - .map(|n| n.data.to_vec()) - .collect::>() - .into_iter() - .collect()) -} - #[cfg(test)] -pub mod tests { +pub mod tests_for_storage_proof_checker { use super::*; use codec::Encode; @@ -228,29 +321,21 @@ pub mod tests { assert_eq!(checker.read_value(b"key1"), Ok(Some(b"value1".to_vec()))); assert_eq!(checker.read_value(b"key2"), Ok(Some(b"value2".to_vec()))); assert_eq!(checker.read_value(b"key4"), Ok(Some((42u64, 42u32, 42u16, 42u8).encode()))); - assert_eq!(checker.read_value(b"key11111"), Err(Error::StorageValueUnavailable)); + assert_eq!( + checker.read_value(b"key11111"), + Err(StorageProofError::StorageValueUnavailable) + ); assert_eq!(checker.read_value(b"key22"), Ok(None)); assert_eq!(checker.read_and_decode_value(b"key4"), Ok(Some((42u64, 42u32, 42u16, 42u8))),); assert!(matches!( checker.read_and_decode_value::<[u8; 64]>(b"key4"), - Err(Error::StorageValueDecodeFailed(_)), + Err(StorageProofError::DecodeError), )); // checking proof against invalid commitment fails assert_eq!( >::new(sp_core::H256::random(), proof).err(), - Some(Error::StorageRootMismatch) - ); - } - - #[test] - fn proof_with_duplicate_items_is_rejected() { - let (root, mut proof) = craft_valid_storage_proof(); - proof.push(proof.first().unwrap().clone()); - - assert_eq!( - StorageProofChecker::::new(root, proof).map(drop), - Err(Error::DuplicateNodesInProof), + Some(StorageProofError::StorageRootMismatch) ); } @@ -260,13 +345,13 @@ pub mod tests { let mut checker = StorageProofChecker::::new(root, proof.clone()).unwrap(); - checker.read_value(b"key1").unwrap(); + checker.read_value(b"key1").unwrap().unwrap(); checker.read_value(b"key2").unwrap(); checker.read_value(b"key4").unwrap(); checker.read_value(b"key22").unwrap(); assert_eq!(checker.ensure_no_unused_nodes(), Ok(())); let checker = StorageProofChecker::::new(root, proof).unwrap(); - assert_eq!(checker.ensure_no_unused_nodes(), Err(Error::UnusedNodesInTheProof)); + assert_eq!(checker.ensure_no_unused_nodes(), Err(StorageProofError::UnusedKey)); } } diff --git a/bridges/primitives/test-utils/Cargo.toml b/bridges/primitives/test-utils/Cargo.toml index d314c38683cdbc8b40cfda3a14c64f91854e5d7f..5e6e3893393534aa828f323d8a28748742a7b5bb 100644 --- a/bridges/primitives/test-utils/Cargo.toml +++ b/bridges/primitives/test-utils/Cargo.toml @@ -11,19 +11,19 @@ repository.workspace = true workspace = true [dependencies] -bp-header-chain = { path = "../header-chain", default-features = false } -bp-parachains = { path = "../parachains", default-features = false } -bp-polkadot-core = { path = "../polkadot-core", default-features = false } -bp-runtime = { path = "../runtime", default-features = false } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -ed25519-dalek = { version = "2.1", default-features = false } -finality-grandpa = { version = "0.16.2", default-features = false } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto", default-features = false } -sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa", 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 } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } +bp-header-chain = { workspace = true } +bp-parachains = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-runtime = { features = ["test-helpers"], workspace = true } +codec = { workspace = true } +ed25519-dalek = { workspace = true } +finality-grandpa = { workspace = true } +sp-application-crypto = { workspace = true } +sp-consensus-grandpa = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } +sp-trie = { workspace = true } [features] default = ["std"] diff --git a/bridges/primitives/test-utils/src/lib.rs b/bridges/primitives/test-utils/src/lib.rs index f4fe4a242e79c0e1c8a499c4dd18ed4a2164c656..9855c32a468954dd0f3011c029c793e5cd2cbc35 100644 --- a/bridges/primitives/test-utils/src/lib.rs +++ b/bridges/primitives/test-utils/src/lib.rs @@ -177,6 +177,7 @@ pub fn prepare_parachain_heads_proof( let mut parachains = Vec::with_capacity(heads.len()); let mut root = Default::default(); let mut mdb = MemoryDB::default(); + let mut storage_keys = vec![]; { let mut trie = TrieDBMutBuilderV1::::new(&mut mdb, &mut root).build(); for (parachain, head) in heads { @@ -185,11 +186,12 @@ pub fn prepare_parachain_heads_proof( trie.insert(&storage_key.0, &head.encode()) .map_err(|_| "TrieMut::insert has failed") .expect("TrieMut::insert should not fail in tests"); + storage_keys.push(storage_key.0); parachains.push((ParaId(parachain), head.hash())); } } - // generate storage proof to be delivered to This chain + // generate storage proof to be delivered to this chain let storage_proof = record_all_trie_keys::, _>(&mdb, &root) .map_err(|_| "record_all_trie_keys has failed") .expect("record_all_trie_keys should not fail in benchmarks"); diff --git a/bridges/primitives/xcm-bridge-hub-router/Cargo.toml b/bridges/primitives/xcm-bridge-hub-router/Cargo.toml index 94eece16d5797eb23dd12af5b8b5aeb7d283d862..c3cf3356184be676ffae0c212fc20455395d6d09 100644 --- a/bridges/primitives/xcm-bridge-hub-router/Cargo.toml +++ b/bridges/primitives/xcm-bridge-hub-router/Cargo.toml @@ -11,12 +11,12 @@ repository.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive"] } +codec = { features = ["bit-vec", "derive"], workspace = true } +scale-info = { features = ["bit-vec", "derive"], workspace = true } # Substrate Dependencies -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } +sp-runtime = { workspace = true } +sp-core = { workspace = true } [features] default = ["std"] diff --git a/bridges/primitives/xcm-bridge-hub/Cargo.toml b/bridges/primitives/xcm-bridge-hub/Cargo.toml index 27881bc99d1f838bb5a72c02fe565ef5dc0307fd..932e9ade019741dbc6a99fcea317aaee539ed9c9 100644 --- a/bridges/primitives/xcm-bridge-hub/Cargo.toml +++ b/bridges/primitives/xcm-bridge-hub/Cargo.toml @@ -13,7 +13,7 @@ workspace = true [dependencies] # Substrate Dependencies -sp-std = { path = "../../../substrate/primitives/std", default-features = false } +sp-std = { workspace = true } [features] default = ["std"] diff --git a/bridges/relays/client-substrate/Cargo.toml b/bridges/relays/client-substrate/Cargo.toml index 2c98441fc3017e8bcd4a213b27d5f5d2fee3223d..969cd73d6194fcf42e03f54ae14029cfdf73d877 100644 --- a/bridges/relays/client-substrate/Cargo.toml +++ b/bridges/relays/client-substrate/Cargo.toml @@ -11,50 +11,49 @@ publish = false workspace = true [dependencies] -async-std = { version = "1.9.0", features = ["attributes"] } -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" -jsonrpsee = { version = "0.22", features = ["macros", "ws-client"] } +async-std = { features = ["attributes"], workspace = true } +async-trait = { workspace = true } +codec = { workspace = true, default-features = true } +futures = { workspace = true } +jsonrpsee = { features = ["macros", "ws-client"], workspace = true } log = { workspace = true } -num-traits = "0.2" -rand = "0.8.5" -scale-info = { version = "2.11.1", features = ["derive"] } -tokio = { version = "1.37", features = ["rt-multi-thread"] } +num-traits = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } +serde_json = { workspace = true } +scale-info = { features = ["derive"], workspace = true, default-features = true } +tokio = { features = ["rt-multi-thread"], workspace = true, default-features = true } thiserror = { workspace = true } +quick_cache = { workspace = true } # Bridge dependencies -bp-header-chain = { path = "../../primitives/header-chain" } -bp-messages = { path = "../../primitives/messages" } -bp-polkadot-core = { path = "../../primitives/polkadot-core" } -bp-runtime = { path = "../../primitives/runtime" } -pallet-bridge-messages = { path = "../../modules/messages" } -finality-relay = { path = "../finality" } -relay-utils = { path = "../utils" } +bp-header-chain = { workspace = true, default-features = true } +bp-messages = { workspace = true, default-features = true } +bp-polkadot-core = { workspace = true, default-features = true } +bp-runtime = { workspace = true, default-features = true } +finality-relay = { workspace = true } +relay-utils = { workspace = true } # Substrate Dependencies -frame-support = { path = "../../../substrate/frame/support" } -frame-system = { path = "../../../substrate/frame/system" } -pallet-balances = { path = "../../../substrate/frame/balances" } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment" } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api" } -pallet-utility = { path = "../../../substrate/frame/utility" } -sc-chain-spec = { path = "../../../substrate/client/chain-spec" } -sc-rpc-api = { path = "../../../substrate/client/rpc-api" } -sc-transaction-pool-api = { path = "../../../substrate/client/transaction-pool/api" } -sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-rpc = { path = "../../../substrate/primitives/rpc" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-std = { path = "../../../substrate/primitives/std" } -sp-trie = { path = "../../../substrate/primitives/trie" } -sp-version = { path = "../../../substrate/primitives/version" } +frame-support = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true, default-features = true } +pallet-utility = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-rpc-api = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-rpc = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } # Polkadot Dependencies -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm" } +xcm = { workspace = true, default-features = true } [features] default = [] diff --git a/bridges/relays/client-substrate/src/chain.rs b/bridges/relays/client-substrate/src/chain.rs index 40269fe64c879249e9f0ed5ffe070d9fc606bdb6..227e9c31c5bfc6a93df88bb117f29bdb1b7c61d3 100644 --- a/bridges/relays/client-substrate/src/chain.rs +++ b/bridges/relays/client-substrate/src/chain.rs @@ -36,6 +36,9 @@ use sp_runtime::{ }; use std::{fmt::Debug, time::Duration}; +/// Signed block type of given chain. +pub type SignedBlockOf = ::SignedBlock; + /// Substrate-based chain from minimal relay-client point of view. pub trait Chain: ChainBase + Clone { /// Chain name. diff --git a/bridges/relays/client-substrate/src/client.rs b/bridges/relays/client-substrate/src/client.rs deleted file mode 100644 index afbda8599b2aa03c4ed4a7c33a93fdd429646516..0000000000000000000000000000000000000000 --- a/bridges/relays/client-substrate/src/client.rs +++ /dev/null @@ -1,990 +0,0 @@ -// Copyright 2019-2021 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 . - -//! Substrate node client. - -use crate::{ - chain::{Chain, ChainWithTransactions}, - guard::Environment, - rpc::{ - SubstrateAuthorClient, SubstrateChainClient, SubstrateFinalityClient, - SubstrateFrameSystemClient, SubstrateStateClient, SubstrateSystemClient, - }, - transaction_stall_timeout, AccountKeyPairOf, ChainWithGrandpa, ConnectionParams, Error, HashOf, - HeaderIdOf, Result, SignParam, TransactionTracker, UnsignedTransaction, -}; - -use async_std::sync::{Arc, Mutex, RwLock}; -use async_trait::async_trait; -use bp_runtime::{HeaderIdProvider, StorageDoubleMapKeyProvider, StorageMapKeyProvider}; -use codec::{Decode, Encode}; -use frame_support::weights::Weight; -use futures::{SinkExt, StreamExt}; -use jsonrpsee::{ - core::DeserializeOwned, - ws_client::{WsClient as RpcClient, WsClientBuilder as RpcClientBuilder}, -}; -use num_traits::{Saturating, Zero}; -use pallet_transaction_payment::RuntimeDispatchInfo; -use relay_utils::{relay_loop::RECONNECT_DELAY, STALL_TIMEOUT}; -use sp_core::{ - storage::{StorageData, StorageKey}, - Bytes, Hasher, Pair, -}; -use sp_runtime::{ - traits::Header as HeaderT, - transaction_validity::{TransactionSource, TransactionValidity}, -}; -use sp_trie::StorageProof; -use sp_version::RuntimeVersion; -use std::{cmp::Ordering, future::Future}; - -const SUB_API_GRANDPA_AUTHORITIES: &str = "GrandpaApi_grandpa_authorities"; -const SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF: &str = - "GrandpaApi_generate_key_ownership_proof"; -const SUB_API_TXPOOL_VALIDATE_TRANSACTION: &str = "TaggedTransactionQueue_validate_transaction"; -const SUB_API_TX_PAYMENT_QUERY_INFO: &str = "TransactionPaymentApi_query_info"; -const MAX_SUBSCRIPTION_CAPACITY: usize = 4096; - -/// The difference between best block number and number of its ancestor, that is enough -/// for us to consider that ancestor an "ancient" block with dropped state. -/// -/// The relay does not assume that it is connected to the archive node, so it always tries -/// to use the best available chain state. But sometimes it still may use state of some -/// old block. If the state of that block is already dropped, relay will see errors when -/// e.g. it tries to prove something. -/// -/// By default Substrate-based nodes are storing state for last 256 blocks. We'll use -/// half of this value. -pub const ANCIENT_BLOCK_THRESHOLD: u32 = 128; - -/// Returns `true` if we think that the state is already discarded for given block. -pub fn is_ancient_block + PartialOrd + Saturating>(block: N, best: N) -> bool { - best.saturating_sub(block) >= N::from(ANCIENT_BLOCK_THRESHOLD) -} - -/// Opaque justifications subscription type. -pub struct Subscription(pub(crate) Mutex>>); - -/// Opaque GRANDPA authorities set. -pub type OpaqueGrandpaAuthoritiesSet = Vec; - -/// A simple runtime version. It only includes the `spec_version` and `transaction_version`. -#[derive(Copy, Clone, Debug)] -pub struct SimpleRuntimeVersion { - /// Version of the runtime specification. - pub spec_version: u32, - /// All existing dispatches are fully compatible when this number doesn't change. - pub transaction_version: u32, -} - -impl SimpleRuntimeVersion { - /// Create a new instance of `SimpleRuntimeVersion` from a `RuntimeVersion`. - pub const fn from_runtime_version(runtime_version: &RuntimeVersion) -> Self { - Self { - spec_version: runtime_version.spec_version, - transaction_version: runtime_version.transaction_version, - } - } -} - -/// Chain runtime version in client -#[derive(Copy, Clone, Debug)] -pub enum ChainRuntimeVersion { - /// Auto query from chain. - Auto, - /// Custom runtime version, defined by user. - Custom(SimpleRuntimeVersion), -} - -/// Substrate client type. -/// -/// Cloning `Client` is a cheap operation that only clones internal references. Different -/// clones of the same client are guaranteed to use the same references. -pub struct Client { - // Lock order: `submit_signed_extrinsic_lock`, `data` - /// Client connection params. - params: Arc, - /// Saved chain runtime version. - chain_runtime_version: ChainRuntimeVersion, - /// If several tasks are submitting their transactions simultaneously using - /// `submit_signed_extrinsic` method, they may get the same transaction nonce. So one of - /// transactions will be rejected from the pool. This lock is here to prevent situations like - /// that. - submit_signed_extrinsic_lock: Arc>, - /// Genesis block hash. - genesis_hash: HashOf, - /// Shared dynamic data. - data: Arc>, -} - -/// Client data, shared by all `Client` clones. -struct ClientData { - /// Tokio runtime handle. - tokio: Arc, - /// Substrate RPC client. - client: Arc, -} - -/// Already encoded value. -struct PreEncoded(Vec); - -impl Encode for PreEncoded { - fn encode(&self) -> Vec { - self.0.clone() - } -} - -#[async_trait] -impl relay_utils::relay_loop::Client for Client { - type Error = Error; - - async fn reconnect(&mut self) -> Result<()> { - let mut data = self.data.write().await; - let (tokio, client) = Self::build_client(&self.params).await?; - data.tokio = tokio; - data.client = client; - Ok(()) - } -} - -impl Clone for Client { - fn clone(&self) -> Self { - Client { - params: self.params.clone(), - chain_runtime_version: self.chain_runtime_version, - submit_signed_extrinsic_lock: self.submit_signed_extrinsic_lock.clone(), - genesis_hash: self.genesis_hash, - data: self.data.clone(), - } - } -} - -impl std::fmt::Debug for Client { - fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { - fmt.debug_struct("Client").field("genesis_hash", &self.genesis_hash).finish() - } -} - -impl Client { - /// Returns client that is able to call RPCs on Substrate node over websocket connection. - /// - /// This function will keep connecting to given Substrate node until connection is established - /// and is functional. If attempt fail, it will wait for `RECONNECT_DELAY` and retry again. - pub async fn new(params: ConnectionParams) -> Self { - let params = Arc::new(params); - loop { - match Self::try_connect(params.clone()).await { - Ok(client) => return client, - Err(error) => log::error!( - target: "bridge", - "Failed to connect to {} node: {:?}. Going to retry in {}s", - C::NAME, - error, - RECONNECT_DELAY.as_secs(), - ), - } - - async_std::task::sleep(RECONNECT_DELAY).await; - } - } - - /// Try to connect to Substrate node over websocket. Returns Substrate RPC client if connection - /// has been established or error otherwise. - pub async fn try_connect(params: Arc) -> Result { - let (tokio, client) = Self::build_client(¶ms).await?; - - let number: C::BlockNumber = Zero::zero(); - let genesis_hash_client = client.clone(); - let genesis_hash = tokio - .spawn(async move { - SubstrateChainClient::::block_hash(&*genesis_hash_client, Some(number)).await - }) - .await??; - - let chain_runtime_version = params.chain_runtime_version; - let mut client = Self { - params, - chain_runtime_version, - submit_signed_extrinsic_lock: Arc::new(Mutex::new(())), - genesis_hash, - data: Arc::new(RwLock::new(ClientData { tokio, client })), - }; - Self::ensure_correct_runtime_version(&mut client, chain_runtime_version).await?; - Ok(client) - } - - // Check runtime version to understand if we need are connected to expected version, or we - // need to wait for upgrade, we need to abort immediately. - async fn ensure_correct_runtime_version>( - env: &mut E, - expected: ChainRuntimeVersion, - ) -> Result<()> { - // we are only interested if version mode is bundled or passed using CLI - let expected = match expected { - ChainRuntimeVersion::Auto => return Ok(()), - ChainRuntimeVersion::Custom(expected) => expected, - }; - - // we need to wait if actual version is < than expected, we are OK of versions are the - // same and we need to abort if actual version is > than expected - let actual = SimpleRuntimeVersion::from_runtime_version(&env.runtime_version().await?); - match actual.spec_version.cmp(&expected.spec_version) { - Ordering::Less => - Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual }), - Ordering::Equal => Ok(()), - Ordering::Greater => { - log::error!( - target: "bridge", - "The {} client is configured to use runtime version {expected:?} and actual \ - version is {actual:?}. Aborting", - C::NAME, - ); - env.abort().await; - Err(Error::Custom("Aborted".into())) - }, - } - } - - /// Build client to use in connection. - async fn build_client( - params: &ConnectionParams, - ) -> Result<(Arc, Arc)> { - let tokio = tokio::runtime::Runtime::new()?; - - let uri = match params.uri { - Some(ref uri) => uri.clone(), - None => { - format!( - "{}://{}:{}{}", - if params.secure { "wss" } else { "ws" }, - params.host, - params.port, - match params.path { - Some(ref path) => format!("/{}", path), - None => String::new(), - }, - ) - }, - }; - log::info!(target: "bridge", "Connecting to {} node at {}", C::NAME, uri); - - let client = tokio - .spawn(async move { - RpcClientBuilder::default() - .max_buffer_capacity_per_subscription(MAX_SUBSCRIPTION_CAPACITY) - .build(&uri) - .await - }) - .await??; - - Ok((Arc::new(tokio), Arc::new(client))) - } -} - -impl Client { - /// Return simple runtime version, only include `spec_version` and `transaction_version`. - pub async fn simple_runtime_version(&self) -> Result { - Ok(match &self.chain_runtime_version { - ChainRuntimeVersion::Auto => { - let runtime_version = self.runtime_version().await?; - SimpleRuntimeVersion::from_runtime_version(&runtime_version) - }, - ChainRuntimeVersion::Custom(version) => *version, - }) - } - - /// Returns true if client is connected to at least one peer and is in synced state. - pub async fn ensure_synced(&self) -> Result<()> { - self.jsonrpsee_execute(|client| async move { - let health = SubstrateSystemClient::::health(&*client).await?; - let is_synced = !health.is_syncing && (!health.should_have_peers || health.peers > 0); - if is_synced { - Ok(()) - } else { - Err(Error::ClientNotSynced(health)) - } - }) - .await - } - - /// Return hash of the genesis block. - pub fn genesis_hash(&self) -> &C::Hash { - &self.genesis_hash - } - - /// Return hash of the best finalized block. - pub async fn best_finalized_header_hash(&self) -> Result { - self.jsonrpsee_execute(|client| async move { - Ok(SubstrateChainClient::::finalized_head(&*client).await?) - }) - .await - .map_err(|e| Error::FailedToReadBestFinalizedHeaderHash { - chain: C::NAME.into(), - error: e.boxed(), - }) - } - - /// Return number of the best finalized block. - pub async fn best_finalized_header_number(&self) -> Result { - Ok(*self.best_finalized_header().await?.number()) - } - - /// Return header of the best finalized block. - pub async fn best_finalized_header(&self) -> Result { - self.header_by_hash(self.best_finalized_header_hash().await?).await - } - - /// Returns the best Substrate header. - pub async fn best_header(&self) -> Result - where - C::Header: DeserializeOwned, - { - self.jsonrpsee_execute(|client| async move { - Ok(SubstrateChainClient::::header(&*client, None).await?) - }) - .await - .map_err(|e| Error::FailedToReadBestHeader { chain: C::NAME.into(), error: e.boxed() }) - } - - /// Get a Substrate block from its hash. - pub async fn get_block(&self, block_hash: Option) -> Result { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateChainClient::::block(&*client, block_hash).await?) - }) - .await - } - - /// Get a Substrate header by its hash. - pub async fn header_by_hash(&self, block_hash: C::Hash) -> Result - where - C::Header: DeserializeOwned, - { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateChainClient::::header(&*client, Some(block_hash)).await?) - }) - .await - .map_err(|e| Error::FailedToReadHeaderByHash { - chain: C::NAME.into(), - hash: format!("{block_hash}"), - error: e.boxed(), - }) - } - - /// Get a Substrate block hash by its number. - pub async fn block_hash_by_number(&self, number: C::BlockNumber) -> Result { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateChainClient::::block_hash(&*client, Some(number)).await?) - }) - .await - } - - /// Get a Substrate header by its number. - pub async fn header_by_number(&self, block_number: C::BlockNumber) -> Result - where - C::Header: DeserializeOwned, - { - let block_hash = Self::block_hash_by_number(self, block_number).await?; - let header_by_hash = Self::header_by_hash(self, block_hash).await?; - Ok(header_by_hash) - } - - /// Return runtime version. - pub async fn runtime_version(&self) -> Result { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateStateClient::::runtime_version(&*client).await?) - }) - .await - } - - /// Read value from runtime storage. - pub async fn storage_value( - &self, - storage_key: StorageKey, - block_hash: Option, - ) -> Result> { - self.raw_storage_value(storage_key, block_hash) - .await? - .map(|encoded_value| { - T::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed) - }) - .transpose() - } - - /// Read `MapStorage` value from runtime storage. - pub async fn storage_map_value( - &self, - pallet_prefix: &str, - key: &T::Key, - block_hash: Option, - ) -> Result> { - let storage_key = T::final_key(pallet_prefix, key); - - self.raw_storage_value(storage_key, block_hash) - .await? - .map(|encoded_value| { - T::Value::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed) - }) - .transpose() - } - - /// Read `DoubleMapStorage` value from runtime storage. - pub async fn storage_double_map_value( - &self, - pallet_prefix: &str, - key1: &T::Key1, - key2: &T::Key2, - block_hash: Option, - ) -> Result> { - let storage_key = T::final_key(pallet_prefix, key1, key2); - - self.raw_storage_value(storage_key, block_hash) - .await? - .map(|encoded_value| { - T::Value::decode(&mut &encoded_value.0[..]).map_err(Error::ResponseParseFailed) - }) - .transpose() - } - - /// Read raw value from runtime storage. - pub async fn raw_storage_value( - &self, - storage_key: StorageKey, - block_hash: Option, - ) -> Result> { - let cloned_storage_key = storage_key.clone(); - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateStateClient::::storage(&*client, storage_key.clone(), block_hash) - .await?) - }) - .await - .map_err(|e| Error::FailedToReadRuntimeStorageValue { - chain: C::NAME.into(), - key: cloned_storage_key, - error: e.boxed(), - }) - } - - /// Get the nonce of the given Substrate account. - /// - /// Note: It's the caller's responsibility to make sure `account` is a valid SS58 address. - pub async fn next_account_index(&self, account: C::AccountId) -> Result { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateFrameSystemClient::::account_next_index(&*client, account).await?) - }) - .await - } - - /// Submit unsigned extrinsic for inclusion in a block. - /// - /// Note: The given transaction needs to be SCALE encoded beforehand. - pub async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result { - // one last check that the transaction is valid. Most of checks happen in the relay loop and - // it is the "final" check before submission. - let best_header_hash = self.best_header().await?.hash(); - self.validate_transaction(best_header_hash, PreEncoded(transaction.0.clone())) - .await - .map_err(|e| { - log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e); - e - })??; - - self.jsonrpsee_execute(move |client| async move { - let tx_hash = SubstrateAuthorClient::::submit_extrinsic(&*client, transaction) - .await - .map_err(|e| { - log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e); - e - })?; - log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash); - Ok(tx_hash) - }) - .await - } - - async fn build_sign_params(&self, signer: AccountKeyPairOf) -> Result> - where - C: ChainWithTransactions, - { - let runtime_version = self.simple_runtime_version().await?; - Ok(SignParam:: { - spec_version: runtime_version.spec_version, - transaction_version: runtime_version.transaction_version, - genesis_hash: self.genesis_hash, - signer, - }) - } - - /// Submit an extrinsic signed by given account. - /// - /// All calls of this method are synchronized, so there can't be more than one active - /// `submit_signed_extrinsic()` call. This guarantees that no nonces collision may happen - /// if all client instances are clones of the same initial `Client`. - /// - /// Note: The given transaction needs to be SCALE encoded beforehand. - pub async fn submit_signed_extrinsic( - &self, - signer: &AccountKeyPairOf, - prepare_extrinsic: impl FnOnce(HeaderIdOf, C::Nonce) -> Result> - + Send - + 'static, - ) -> Result - where - C: ChainWithTransactions, - C::AccountId: From<::Public>, - { - let _guard = self.submit_signed_extrinsic_lock.lock().await; - let transaction_nonce = self.next_account_index(signer.public().into()).await?; - let best_header = self.best_header().await?; - let signing_data = self.build_sign_params(signer.clone()).await?; - - // By using parent of best block here, we are protecing again best-block reorganizations. - // E.g. transaction may have been submitted when the best block was `A[num=100]`. Then it - // has been changed to `B[num=100]`. Hash of `A` has been included into transaction - // signature payload. So when signature will be checked, the check will fail and transaction - // will be dropped from the pool. - let best_header_id = best_header.parent_id().unwrap_or_else(|| best_header.id()); - - let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?; - let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode(); - - // one last check that the transaction is valid. Most of checks happen in the relay loop and - // it is the "final" check before submission. - self.validate_transaction(best_header_id.1, PreEncoded(signed_extrinsic.clone())) - .await - .map_err(|e| { - log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e); - e - })??; - - self.jsonrpsee_execute(move |client| async move { - let tx_hash = - SubstrateAuthorClient::::submit_extrinsic(&*client, Bytes(signed_extrinsic)) - .await - .map_err(|e| { - log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e); - e - })?; - log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash); - Ok(tx_hash) - }) - .await - } - - /// Does exactly the same as `submit_signed_extrinsic`, but keeps watching for extrinsic status - /// after submission. - pub async fn submit_and_watch_signed_extrinsic( - &self, - signer: &AccountKeyPairOf, - prepare_extrinsic: impl FnOnce(HeaderIdOf, C::Nonce) -> Result> - + Send - + 'static, - ) -> Result> - where - C: ChainWithTransactions, - C::AccountId: From<::Public>, - { - let self_clone = self.clone(); - let signing_data = self.build_sign_params(signer.clone()).await?; - let _guard = self.submit_signed_extrinsic_lock.lock().await; - let transaction_nonce = self.next_account_index(signer.public().into()).await?; - let best_header = self.best_header().await?; - let best_header_id = best_header.id(); - - let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?; - let stall_timeout = transaction_stall_timeout( - extrinsic.era.mortality_period(), - C::AVERAGE_BLOCK_INTERVAL, - STALL_TIMEOUT, - ); - let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode(); - - // one last check that the transaction is valid. Most of checks happen in the relay loop and - // it is the "final" check before submission. - self.validate_transaction(best_header_id.1, PreEncoded(signed_extrinsic.clone())) - .await - .map_err(|e| { - log::error!(target: "bridge", "Pre-submit {} transaction validation failed: {:?}", C::NAME, e); - e - })??; - - let (sender, receiver) = futures::channel::mpsc::channel(MAX_SUBSCRIPTION_CAPACITY); - let (tracker, subscription) = self - .jsonrpsee_execute(move |client| async move { - let tx_hash = C::Hasher::hash(&signed_extrinsic); - let subscription = SubstrateAuthorClient::::submit_and_watch_extrinsic( - &*client, - Bytes(signed_extrinsic), - ) - .await - .map_err(|e| { - log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e); - e - })?; - log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash); - let tracker = TransactionTracker::new( - self_clone, - stall_timeout, - tx_hash, - Subscription(Mutex::new(receiver)), - ); - Ok((tracker, subscription)) - }) - .await?; - self.data.read().await.tokio.spawn(Subscription::background_worker( - C::NAME.into(), - "extrinsic".into(), - subscription, - sender, - )); - Ok(tracker) - } - - /// Returns pending extrinsics from transaction pool. - pub async fn pending_extrinsics(&self) -> Result> { - self.jsonrpsee_execute(move |client| async move { - Ok(SubstrateAuthorClient::::pending_extrinsics(&*client).await?) - }) - .await - } - - /// Validate transaction at given block state. - pub async fn validate_transaction( - &self, - at_block: C::Hash, - transaction: SignedTransaction, - ) -> Result { - self.jsonrpsee_execute(move |client| async move { - let call = SUB_API_TXPOOL_VALIDATE_TRANSACTION.to_string(); - let data = Bytes((TransactionSource::External, transaction, at_block).encode()); - - let encoded_response = - SubstrateStateClient::::call(&*client, call, data, Some(at_block)).await?; - let validity = TransactionValidity::decode(&mut &encoded_response.0[..]) - .map_err(Error::ResponseParseFailed)?; - - Ok(validity) - }) - .await - } - - /// Returns weight of the given transaction. - pub async fn extimate_extrinsic_weight( - &self, - transaction: SignedTransaction, - ) -> Result { - self.jsonrpsee_execute(move |client| async move { - let transaction_len = transaction.encoded_size() as u32; - - let call = SUB_API_TX_PAYMENT_QUERY_INFO.to_string(); - let data = Bytes((transaction, transaction_len).encode()); - - let encoded_response = - SubstrateStateClient::::call(&*client, call, data, None).await?; - let dispatch_info = - RuntimeDispatchInfo::::decode(&mut &encoded_response.0[..]) - .map_err(Error::ResponseParseFailed)?; - - Ok(dispatch_info.weight) - }) - .await - } - - /// Get the GRANDPA authority set at given block. - pub async fn grandpa_authorities_set( - &self, - block: C::Hash, - ) -> Result { - self.jsonrpsee_execute(move |client| async move { - let call = SUB_API_GRANDPA_AUTHORITIES.to_string(); - let data = Bytes(Vec::new()); - - let encoded_response = - SubstrateStateClient::::call(&*client, call, data, Some(block)).await?; - let authority_list = encoded_response.0; - - Ok(authority_list) - }) - .await - } - - /// Execute runtime call at given block, provided the input and output types. - /// It also performs the input encode and output decode. - pub async fn typed_state_call( - &self, - method_name: String, - input: Input, - at_block: Option, - ) -> Result { - let encoded_output = self - .state_call(method_name.clone(), Bytes(input.encode()), at_block) - .await - .map_err(|e| Error::ErrorExecutingRuntimeCall { - chain: C::NAME.into(), - method: method_name, - error: e.boxed(), - })?; - Output::decode(&mut &encoded_output.0[..]).map_err(Error::ResponseParseFailed) - } - - /// Execute runtime call at given block. - pub async fn state_call( - &self, - method: String, - data: Bytes, - at_block: Option, - ) -> Result { - self.jsonrpsee_execute(move |client| async move { - SubstrateStateClient::::call(&*client, method, data, at_block) - .await - .map_err(Into::into) - }) - .await - } - - /// Returns storage proof of given storage keys. - pub async fn prove_storage( - &self, - keys: Vec, - at_block: C::Hash, - ) -> Result { - self.jsonrpsee_execute(move |client| async move { - SubstrateStateClient::::prove_storage(&*client, keys, Some(at_block)) - .await - .map(|proof| { - StorageProof::new(proof.proof.into_iter().map(|b| b.0).collect::>()) - }) - .map_err(Into::into) - }) - .await - } - - /// Return `tokenDecimals` property from the set of chain properties. - pub async fn token_decimals(&self) -> Result> { - self.jsonrpsee_execute(move |client| async move { - let system_properties = SubstrateSystemClient::::properties(&*client).await?; - Ok(system_properties.get("tokenDecimals").and_then(|v| v.as_u64())) - }) - .await - } - - /// Return new finality justifications stream. - pub async fn subscribe_finality_justifications>( - &self, - ) -> Result> { - let subscription = self - .jsonrpsee_execute(move |client| async move { - Ok(FC::subscribe_justifications(&client).await?) - }) - .await?; - let (sender, receiver) = futures::channel::mpsc::channel(MAX_SUBSCRIPTION_CAPACITY); - self.data.read().await.tokio.spawn(Subscription::background_worker( - C::NAME.into(), - "justification".into(), - subscription, - sender, - )); - Ok(Subscription(Mutex::new(receiver))) - } - - /// Generates a proof of key ownership for the given authority in the given set. - pub async fn generate_grandpa_key_ownership_proof( - &self, - at: HashOf, - set_id: sp_consensus_grandpa::SetId, - authority_id: sp_consensus_grandpa::AuthorityId, - ) -> Result> - where - C: ChainWithGrandpa, - { - self.typed_state_call( - SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF.into(), - (set_id, authority_id), - Some(at), - ) - .await - } - - /// Execute jsonrpsee future in tokio context. - async fn jsonrpsee_execute(&self, make_jsonrpsee_future: MF) -> Result - where - MF: FnOnce(Arc) -> F + Send + 'static, - F: Future> + Send + 'static, - T: Send + 'static, - { - let data = self.data.read().await; - let client = data.client.clone(); - data.tokio.spawn(make_jsonrpsee_future(client)).await? - } - - /// Returns `true` if version guard can be started. - /// - /// There's no reason to run version guard when version mode is set to `Auto`. It can - /// lead to relay shutdown when chain is upgraded, even though we have explicitly - /// said that we don't want to shutdown. - pub fn can_start_version_guard(&self) -> bool { - !matches!(self.chain_runtime_version, ChainRuntimeVersion::Auto) - } -} - -impl Subscription { - /// Consumes subscription and returns future statuses stream. - pub fn into_stream(self) -> impl futures::Stream { - futures::stream::unfold(self, |this| async { - let item = this.0.lock().await.next().await.unwrap_or(None); - item.map(|i| (i, this)) - }) - } - - /// Return next item from the subscription. - pub async fn next(&self) -> Result> { - let mut receiver = self.0.lock().await; - let item = receiver.next().await; - Ok(item.unwrap_or(None)) - } - - /// Background worker that is executed in tokio context as `jsonrpsee` requires. - async fn background_worker( - chain_name: String, - item_type: String, - mut subscription: jsonrpsee::core::client::Subscription, - mut sender: futures::channel::mpsc::Sender>, - ) { - loop { - match subscription.next().await { - Some(Ok(item)) => - if sender.send(Some(item)).await.is_err() { - break - }, - Some(Err(e)) => { - log::trace!( - target: "bridge", - "{} {} subscription stream has returned '{:?}'. Stream needs to be restarted.", - chain_name, - item_type, - e, - ); - let _ = sender.send(None).await; - break - }, - None => { - log::trace!( - target: "bridge", - "{} {} subscription stream has returned None. Stream needs to be restarted.", - chain_name, - item_type, - ); - let _ = sender.send(None).await; - break - }, - } - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{guard::tests::TestEnvironment, test_chain::TestChain}; - use futures::{channel::mpsc::unbounded, FutureExt}; - - async fn run_ensure_correct_runtime_version( - expected: ChainRuntimeVersion, - actual: RuntimeVersion, - ) -> Result<()> { - let ( - (mut runtime_version_tx, runtime_version_rx), - (slept_tx, _slept_rx), - (aborted_tx, mut aborted_rx), - ) = (unbounded(), unbounded(), unbounded()); - runtime_version_tx.send(actual).await.unwrap(); - let mut env = TestEnvironment { runtime_version_rx, slept_tx, aborted_tx }; - - let ensure_correct_runtime_version = - Client::::ensure_correct_runtime_version(&mut env, expected).boxed(); - let aborted = aborted_rx.next().map(|_| Err(Error::Custom("".into()))).boxed(); - futures::pin_mut!(ensure_correct_runtime_version, aborted); - futures::future::select(ensure_correct_runtime_version, aborted) - .await - .into_inner() - .0 - } - - #[async_std::test] - async fn ensure_correct_runtime_version_works() { - // when we are configured to use auto version - assert!(matches!( - run_ensure_correct_runtime_version( - ChainRuntimeVersion::Auto, - RuntimeVersion { - spec_version: 100, - transaction_version: 100, - ..Default::default() - }, - ) - .await, - Ok(()), - )); - // when actual == expected - assert!(matches!( - run_ensure_correct_runtime_version( - ChainRuntimeVersion::Custom(SimpleRuntimeVersion { - spec_version: 100, - transaction_version: 100 - }), - RuntimeVersion { - spec_version: 100, - transaction_version: 100, - ..Default::default() - }, - ) - .await, - Ok(()), - )); - // when actual spec version < expected spec version - assert!(matches!( - run_ensure_correct_runtime_version( - ChainRuntimeVersion::Custom(SimpleRuntimeVersion { - spec_version: 100, - transaction_version: 100 - }), - RuntimeVersion { spec_version: 99, transaction_version: 100, ..Default::default() }, - ) - .await, - Err(Error::WaitingForRuntimeUpgrade { - expected: SimpleRuntimeVersion { spec_version: 100, transaction_version: 100 }, - actual: SimpleRuntimeVersion { spec_version: 99, transaction_version: 100 }, - .. - }), - )); - // when actual spec version > expected spec version - assert!(matches!( - run_ensure_correct_runtime_version( - ChainRuntimeVersion::Custom(SimpleRuntimeVersion { - spec_version: 100, - transaction_version: 100 - }), - RuntimeVersion { - spec_version: 101, - transaction_version: 100, - ..Default::default() - }, - ) - .await, - Err(Error::Custom(_)), - )); - } -} diff --git a/bridges/relays/client-substrate/src/client/caching.rs b/bridges/relays/client-substrate/src/client/caching.rs new file mode 100644 index 0000000000000000000000000000000000000000..a574e5985bc8280e030cfad08308a2c9bebe33a4 --- /dev/null +++ b/bridges/relays/client-substrate/src/client/caching.rs @@ -0,0 +1,472 @@ +// Copyright 2019-2021 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 . + +//! Client implementation that is caching (whenever possible) results of its backend +//! method calls. + +use crate::{ + client::{Client, SubscriptionBroadcaster}, + error::{Error, Result}, + AccountIdOf, AccountKeyPairOf, BlockNumberOf, Chain, ChainWithGrandpa, ChainWithTransactions, + HashOf, HeaderIdOf, HeaderOf, NonceOf, SignedBlockOf, SimpleRuntimeVersion, Subscription, + TransactionTracker, UnsignedTransaction, ANCIENT_BLOCK_THRESHOLD, +}; +use std::{cmp::Ordering, future::Future, task::Poll}; + +use async_std::{ + sync::{Arc, Mutex, RwLock}, + task::JoinHandle, +}; +use async_trait::async_trait; +use codec::Encode; +use frame_support::weights::Weight; +use futures::{FutureExt, StreamExt}; +use quick_cache::unsync::Cache; +use sp_consensus_grandpa::{AuthorityId, OpaqueKeyOwnershipProof, SetId}; +use sp_core::{ + storage::{StorageData, StorageKey}, + Bytes, Pair, +}; +use sp_runtime::{traits::Header as _, transaction_validity::TransactionValidity}; +use sp_trie::StorageProof; +use sp_version::RuntimeVersion; + +/// `quick_cache::unsync::Cache` wrapped in async-aware synchronization primitives. +type SyncCache = Arc>>; + +/// Client implementation that is caching (whenever possible) results of its backend +/// method calls. Apart from caching call results, it also supports some (at the +/// moment: justifications) subscription sharing, meaning that the single server +/// subscription may be shared by multiple subscribers at the client side. +#[derive(Clone)] +pub struct CachingClient> { + backend: B, + data: Arc>, +} + +/// Client data, shared by all `CachingClient` clones. +struct ClientData { + grandpa_justifications: Arc>>>, + beefy_justifications: Arc>>>, + background_task_handle: Arc>>>, + best_header: Arc>>>, + best_finalized_header: Arc>>>, + // `quick_cache::sync::Cache` has the `get_or_insert_async` method, which fits our needs, + // but it uses synchronization primitives that are not aware of async execution. They + // can block the executor threads and cause deadlocks => let's use primitives from + // `async_std` crate around `quick_cache::unsync::Cache` + header_hash_by_number_cache: SyncCache, HashOf>, + header_by_hash_cache: SyncCache, HeaderOf>, + block_by_hash_cache: SyncCache, SignedBlockOf>, + raw_storage_value_cache: SyncCache<(HashOf, StorageKey), Option>, + state_call_cache: SyncCache<(HashOf, String, Bytes), Bytes>, +} + +impl> CachingClient { + /// Creates new `CachingClient` on top of given `backend`. + pub async fn new(backend: B) -> Self { + // most of relayer operations will never touch more than `ANCIENT_BLOCK_THRESHOLD` + // headers, so we'll use this as a cache capacity for all chain-related caches + let chain_state_capacity = ANCIENT_BLOCK_THRESHOLD as usize; + let best_header = Arc::new(RwLock::new(None)); + let best_finalized_header = Arc::new(RwLock::new(None)); + let header_by_hash_cache = Arc::new(RwLock::new(Cache::new(chain_state_capacity))); + let background_task_handle = Self::start_background_task( + backend.clone(), + best_header.clone(), + best_finalized_header.clone(), + header_by_hash_cache.clone(), + ) + .await; + CachingClient { + backend, + data: Arc::new(ClientData { + grandpa_justifications: Arc::new(Mutex::new(None)), + beefy_justifications: Arc::new(Mutex::new(None)), + background_task_handle: Arc::new(Mutex::new(background_task_handle)), + best_header, + best_finalized_header, + header_hash_by_number_cache: Arc::new(RwLock::new(Cache::new( + chain_state_capacity, + ))), + header_by_hash_cache, + block_by_hash_cache: Arc::new(RwLock::new(Cache::new(chain_state_capacity))), + raw_storage_value_cache: Arc::new(RwLock::new(Cache::new(1_024))), + state_call_cache: Arc::new(RwLock::new(Cache::new(1_024))), + }), + } + } + + /// Try to get value from the cache, or compute and insert it using given future. + async fn get_or_insert_async( + &self, + cache: &Arc>>, + key: &K, + with: impl std::future::Future>, + ) -> Result { + // try to get cached value first using read lock + { + let cache = cache.read().await; + if let Some(value) = cache.get(key) { + return Ok(value.clone()) + } + } + + // let's compute the value without holding any locks - it may cause additional misses and + // double insertions, but that's better than holding a lock for a while + let value = with.await?; + + // insert/update the value in the cache + cache.write().await.insert(key.clone(), value.clone()); + Ok(value) + } + + /// Subscribe to finality justifications, trying to reuse existing subscription. + async fn subscribe_finality_justifications<'a>( + &'a self, + maybe_broadcaster: &Mutex>>, + do_subscribe: impl Future>> + 'a, + ) -> Result> { + let mut maybe_broadcaster = maybe_broadcaster.lock().await; + let broadcaster = match maybe_broadcaster.as_ref() { + Some(justifications) => justifications, + None => { + let broadcaster = match SubscriptionBroadcaster::new(do_subscribe.await?) { + Ok(broadcaster) => broadcaster, + Err(subscription) => return Ok(subscription), + }; + maybe_broadcaster.get_or_insert(broadcaster) + }, + }; + + broadcaster.subscribe().await + } + + /// Start background task that reads best (and best finalized) headers from subscriptions. + async fn start_background_task( + backend: B, + best_header: Arc>>>, + best_finalized_header: Arc>>>, + header_by_hash_cache: SyncCache, HeaderOf>, + ) -> JoinHandle> { + async_std::task::spawn(async move { + // initialize by reading headers directly from backend to avoid doing that in the + // high-level code + let mut last_finalized_header = + backend.header_by_hash(backend.best_finalized_header_hash().await?).await?; + *best_header.write().await = Some(backend.best_header().await?); + *best_finalized_header.write().await = Some(last_finalized_header.clone()); + + // ...and then continue with subscriptions + let mut best_headers = backend.subscribe_best_headers().await?; + let mut finalized_headers = backend.subscribe_finalized_headers().await?; + loop { + futures::select! { + new_best_header = best_headers.next().fuse() => { + // we assume that the best header is always the actual best header, even if its + // number is lower than the number of previous-best-header (chain may use its own + // best header selection algorithms) + let new_best_header = new_best_header + .ok_or_else(|| Error::ChannelError(format!("Mandatory best headers subscription for {} has finished", C::NAME)))?; + let new_best_header_hash = new_best_header.hash(); + header_by_hash_cache.write().await.insert(new_best_header_hash, new_best_header.clone()); + *best_header.write().await = Some(new_best_header); + }, + new_finalized_header = finalized_headers.next().fuse() => { + // in theory we'll always get finalized headers in order, but let's double check + let new_finalized_header = new_finalized_header. + ok_or_else(|| Error::ChannelError(format!("Finalized headers subscription for {} has finished", C::NAME)))?; + let new_finalized_header_number = *new_finalized_header.number(); + let last_finalized_header_number = *last_finalized_header.number(); + match new_finalized_header_number.cmp(&last_finalized_header_number) { + Ordering::Greater => { + let new_finalized_header_hash = new_finalized_header.hash(); + header_by_hash_cache.write().await.insert(new_finalized_header_hash, new_finalized_header.clone()); + *best_finalized_header.write().await = Some(new_finalized_header.clone()); + last_finalized_header = new_finalized_header; + }, + Ordering::Less => { + return Err(Error::unordered_finalized_headers::( + new_finalized_header_number, + last_finalized_header_number, + )); + }, + _ => (), + } + }, + } + } + }) + } + + /// Ensure that the background task is active. + async fn ensure_background_task_active(&self) -> Result<()> { + let mut background_task_handle = self.data.background_task_handle.lock().await; + if let Poll::Ready(result) = futures::poll!(&mut *background_task_handle) { + return Err(Error::ChannelError(format!( + "Background task of {} client has exited with result: {:?}", + C::NAME, + result + ))) + } + + Ok(()) + } + + /// Try to get header, read elsewhere by background task through subscription. + async fn read_header_from_background<'a>( + &'a self, + header: &Arc>>>, + read_header_from_backend: impl Future>> + 'a, + ) -> Result> { + // ensure that the background task is active + self.ensure_background_task_active().await?; + + // now we know that the background task is active, so we could trust that the + // `header` has the most recent updates from it + match header.read().await.clone() { + Some(header) => Ok(header), + None => { + // header has not yet been read from the subscription, which means that + // we are just starting - let's read header directly from backend this time + read_header_from_backend.await + }, + } + } +} + +impl> std::fmt::Debug for CachingClient { + fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { + fmt.write_fmt(format_args!("CachingClient<{:?}>", self.backend)) + } +} + +#[async_trait] +impl> Client for CachingClient { + async fn ensure_synced(&self) -> Result<()> { + self.backend.ensure_synced().await + } + + async fn reconnect(&self) -> Result<()> { + self.backend.reconnect().await?; + // since we have new underlying client, we need to restart subscriptions too + *self.data.grandpa_justifications.lock().await = None; + *self.data.beefy_justifications.lock().await = None; + // also restart background task too + *self.data.best_header.write().await = None; + *self.data.best_finalized_header.write().await = None; + *self.data.background_task_handle.lock().await = Self::start_background_task( + self.backend.clone(), + self.data.best_header.clone(), + self.data.best_finalized_header.clone(), + self.data.header_by_hash_cache.clone(), + ) + .await; + Ok(()) + } + + fn genesis_hash(&self) -> HashOf { + self.backend.genesis_hash() + } + + async fn header_hash_by_number(&self, number: BlockNumberOf) -> Result> { + self.get_or_insert_async( + &self.data.header_hash_by_number_cache, + &number, + self.backend.header_hash_by_number(number), + ) + .await + } + + async fn header_by_hash(&self, hash: HashOf) -> Result> { + self.get_or_insert_async( + &self.data.header_by_hash_cache, + &hash, + self.backend.header_by_hash(hash), + ) + .await + } + + async fn block_by_hash(&self, hash: HashOf) -> Result> { + self.get_or_insert_async( + &self.data.block_by_hash_cache, + &hash, + self.backend.block_by_hash(hash), + ) + .await + } + + async fn best_finalized_header_hash(&self) -> Result> { + self.read_header_from_background( + &self.data.best_finalized_header, + self.backend.best_finalized_header(), + ) + .await + .map(|h| h.hash()) + } + + async fn best_header(&self) -> Result> { + self.read_header_from_background(&self.data.best_header, self.backend.best_header()) + .await + } + + async fn subscribe_best_headers(&self) -> Result>> { + // we may share the sunbscription here, but atm there's no callers of this method + self.backend.subscribe_best_headers().await + } + + async fn subscribe_finalized_headers(&self) -> Result>> { + // we may share the sunbscription here, but atm there's no callers of this method + self.backend.subscribe_finalized_headers().await + } + + async fn subscribe_grandpa_finality_justifications(&self) -> Result> + where + C: ChainWithGrandpa, + { + self.subscribe_finality_justifications( + &self.data.grandpa_justifications, + self.backend.subscribe_grandpa_finality_justifications(), + ) + .await + } + + async fn generate_grandpa_key_ownership_proof( + &self, + at: HashOf, + set_id: SetId, + authority_id: AuthorityId, + ) -> Result> { + self.backend + .generate_grandpa_key_ownership_proof(at, set_id, authority_id) + .await + } + + async fn subscribe_beefy_finality_justifications(&self) -> Result> { + self.subscribe_finality_justifications( + &self.data.beefy_justifications, + self.backend.subscribe_beefy_finality_justifications(), + ) + .await + } + + async fn token_decimals(&self) -> Result> { + self.backend.token_decimals().await + } + + async fn runtime_version(&self) -> Result { + self.backend.runtime_version().await + } + + async fn simple_runtime_version(&self) -> Result { + self.backend.simple_runtime_version().await + } + + fn can_start_version_guard(&self) -> bool { + self.backend.can_start_version_guard() + } + + async fn raw_storage_value( + &self, + at: HashOf, + storage_key: StorageKey, + ) -> Result> { + self.get_or_insert_async( + &self.data.raw_storage_value_cache, + &(at, storage_key.clone()), + self.backend.raw_storage_value(at, storage_key), + ) + .await + } + + async fn pending_extrinsics(&self) -> Result> { + self.backend.pending_extrinsics().await + } + + async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result> { + self.backend.submit_unsigned_extrinsic(transaction).await + } + + async fn submit_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>, + { + self.backend.submit_signed_extrinsic(signer, prepare_extrinsic).await + } + + async fn submit_and_watch_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>, + { + self.backend + .submit_and_watch_signed_extrinsic(signer, prepare_extrinsic) + .await + .map(|t| t.switch_environment(self.clone())) + } + + async fn validate_transaction( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result { + self.backend.validate_transaction(at, transaction).await + } + + async fn estimate_extrinsic_weight( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result { + self.backend.estimate_extrinsic_weight(at, transaction).await + } + + async fn raw_state_call( + &self, + at: HashOf, + method: String, + arguments: Args, + ) -> Result { + let encoded_arguments = Bytes(arguments.encode()); + self.get_or_insert_async( + &self.data.state_call_cache, + &(at, method.clone(), encoded_arguments), + self.backend.raw_state_call(at, method, arguments), + ) + .await + } + + async fn prove_storage( + &self, + at: HashOf, + keys: Vec, + ) -> Result<(StorageProof, HashOf)> { + self.backend.prove_storage(at, keys).await + } +} diff --git a/bridges/relays/client-substrate/src/client/mod.rs b/bridges/relays/client-substrate/src/client/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..62a1119d718ff79fa45800166c01762e2044f781 --- /dev/null +++ b/bridges/relays/client-substrate/src/client/mod.rs @@ -0,0 +1,91 @@ +// Copyright 2019-2021 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 . + +//! Layered Substrate client implementation. + +use crate::{Chain, ConnectionParams}; + +use caching::CachingClient; +use num_traits::Saturating; +use rpc::RpcClient; +use sp_version::RuntimeVersion; + +pub mod caching; +pub mod rpc; + +mod rpc_api; +mod subscription; +mod traits; + +pub use subscription::{StreamDescription, Subscription, SubscriptionBroadcaster}; +pub use traits::Client; + +/// Type of RPC client with caching support. +pub type RpcWithCachingClient = CachingClient>; + +/// Creates new RPC client with caching support. +pub async fn rpc_with_caching(params: ConnectionParams) -> RpcWithCachingClient { + let rpc = rpc::RpcClient::::new(params).await; + caching::CachingClient::new(rpc).await +} + +/// The difference between best block number and number of its ancestor, that is enough +/// for us to consider that ancestor an "ancient" block with dropped state. +/// +/// The relay does not assume that it is connected to the archive node, so it always tries +/// to use the best available chain state. But sometimes it still may use state of some +/// old block. If the state of that block is already dropped, relay will see errors when +/// e.g. it tries to prove something. +/// +/// By default Substrate-based nodes are storing state for last 256 blocks. We'll use +/// half of this value. +pub const ANCIENT_BLOCK_THRESHOLD: u32 = 128; + +/// Returns `true` if we think that the state is already discarded for given block. +pub fn is_ancient_block + PartialOrd + Saturating>(block: N, best: N) -> bool { + best.saturating_sub(block) >= N::from(ANCIENT_BLOCK_THRESHOLD) +} + +/// Opaque GRANDPA authorities set. +pub type OpaqueGrandpaAuthoritiesSet = Vec; + +/// A simple runtime version. It only includes the `spec_version` and `transaction_version`. +#[derive(Copy, Clone, Debug)] +pub struct SimpleRuntimeVersion { + /// Version of the runtime specification. + pub spec_version: u32, + /// All existing dispatches are fully compatible when this number doesn't change. + pub transaction_version: u32, +} + +impl SimpleRuntimeVersion { + /// Create a new instance of `SimpleRuntimeVersion` from a `RuntimeVersion`. + pub const fn from_runtime_version(runtime_version: &RuntimeVersion) -> Self { + Self { + spec_version: runtime_version.spec_version, + transaction_version: runtime_version.transaction_version, + } + } +} + +/// Chain runtime version in client +#[derive(Copy, Clone, Debug)] +pub enum ChainRuntimeVersion { + /// Auto query from chain. + Auto, + /// Custom runtime version, defined by user. + Custom(SimpleRuntimeVersion), +} diff --git a/bridges/relays/client-substrate/src/client/rpc.rs b/bridges/relays/client-substrate/src/client/rpc.rs new file mode 100644 index 0000000000000000000000000000000000000000..9c7f769462e5693bc944ed6a6525439f00311ee7 --- /dev/null +++ b/bridges/relays/client-substrate/src/client/rpc.rs @@ -0,0 +1,755 @@ +// Copyright 2019-2021 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 . + +//! Client implementation that connects to the Substrate node over `ws`/`wss` connection +//! and is using RPC methods to get required data and submit transactions. + +use crate::{ + client::{ + rpc_api::{ + SubstrateAuthorClient, SubstrateBeefyClient, SubstrateChainClient, + SubstrateFrameSystemClient, SubstrateGrandpaClient, SubstrateStateClient, + SubstrateSystemClient, + }, + subscription::{StreamDescription, Subscription}, + Client, + }, + error::{Error, Result}, + guard::Environment, + transaction_stall_timeout, AccountIdOf, AccountKeyPairOf, BalanceOf, BlockNumberOf, Chain, + ChainRuntimeVersion, ChainWithGrandpa, ChainWithTransactions, ConnectionParams, HashOf, + HeaderIdOf, HeaderOf, NonceOf, SignParam, SignedBlockOf, SimpleRuntimeVersion, + TransactionTracker, UnsignedTransaction, +}; + +use async_std::sync::{Arc, Mutex, RwLock}; +use async_trait::async_trait; +use bp_runtime::HeaderIdProvider; +use codec::Encode; +use frame_support::weights::Weight; +use futures::TryFutureExt; +use jsonrpsee::{ + core::{client::Subscription as RpcSubscription, ClientError}, + ws_client::{WsClient, WsClientBuilder}, +}; +use num_traits::Zero; +use pallet_transaction_payment::RuntimeDispatchInfo; +use relay_utils::{relay_loop::RECONNECT_DELAY, STALL_TIMEOUT}; +use sp_core::{ + storage::{StorageData, StorageKey}, + Bytes, Hasher, Pair, +}; +use sp_runtime::{ + traits::Header, + transaction_validity::{TransactionSource, TransactionValidity}, +}; +use sp_trie::StorageProof; +use sp_version::RuntimeVersion; +use std::{cmp::Ordering, future::Future, marker::PhantomData}; + +const MAX_SUBSCRIPTION_CAPACITY: usize = 4096; + +const SUB_API_TXPOOL_VALIDATE_TRANSACTION: &str = "TaggedTransactionQueue_validate_transaction"; +const SUB_API_TX_PAYMENT_QUERY_INFO: &str = "TransactionPaymentApi_query_info"; +const SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF: &str = + "GrandpaApi_generate_key_ownership_proof"; + +/// Client implementation that connects to the Substrate node over `ws`/`wss` connection +/// and is using RPC methods to get required data and submit transactions. +pub struct RpcClient { + // Lock order: `submit_signed_extrinsic_lock`, `data` + /// Client connection params. + params: Arc, + /// If several tasks are submitting their transactions simultaneously using + /// `submit_signed_extrinsic` method, they may get the same transaction nonce. So one of + /// transactions will be rejected from the pool. This lock is here to prevent situations like + /// that. + submit_signed_extrinsic_lock: Arc>, + /// Genesis block hash. + genesis_hash: HashOf, + /// Shared dynamic data. + data: Arc>, + /// Generic arguments dump. + _phantom: PhantomData, +} + +/// Client data, shared by all `RpcClient` clones. +struct ClientData { + /// Tokio runtime handle. + tokio: Arc, + /// Substrate RPC client. + client: Arc, +} + +/// Already encoded value. +struct PreEncoded(Vec); + +impl Encode for PreEncoded { + fn encode(&self) -> Vec { + self.0.clone() + } +} + +impl std::fmt::Debug for RpcClient { + fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { + fmt.write_fmt(format_args!("RpcClient<{}>", C::NAME)) + } +} + +impl RpcClient { + /// Returns client that is able to call RPCs on Substrate node over websocket connection. + /// + /// This function will keep connecting to given Substrate node until connection is established + /// and is functional. If attempt fail, it will wait for `RECONNECT_DELAY` and retry again. + pub async fn new(params: ConnectionParams) -> Self { + let params = Arc::new(params); + loop { + match Self::try_connect(params.clone()).await { + Ok(client) => return client, + Err(error) => log::error!( + target: "bridge", + "Failed to connect to {} node: {:?}. Going to retry in {}s", + C::NAME, + error, + RECONNECT_DELAY.as_secs(), + ), + } + + async_std::task::sleep(RECONNECT_DELAY).await; + } + } + + /// Try to connect to Substrate node over websocket. Returns Substrate RPC client if connection + /// has been established or error otherwise. + async fn try_connect(params: Arc) -> Result { + let (tokio, client) = Self::build_client(¶ms).await?; + + let genesis_hash_client = client.clone(); + let genesis_hash = tokio + .spawn(async move { + SubstrateChainClient::::block_hash(&*genesis_hash_client, Some(Zero::zero())) + .await + }) + .await??; + + let chain_runtime_version = params.chain_runtime_version; + let mut client = Self { + params, + submit_signed_extrinsic_lock: Arc::new(Mutex::new(())), + genesis_hash, + data: Arc::new(RwLock::new(ClientData { tokio, client })), + _phantom: PhantomData, + }; + Self::ensure_correct_runtime_version(&mut client, chain_runtime_version).await?; + Ok(client) + } + + // Check runtime version to understand if we need are connected to expected version, or we + // need to wait for upgrade, we need to abort immediately. + async fn ensure_correct_runtime_version>( + env: &mut E, + expected: ChainRuntimeVersion, + ) -> Result<()> { + // we are only interested if version mode is bundled or passed using CLI + let expected = match expected { + ChainRuntimeVersion::Auto => return Ok(()), + ChainRuntimeVersion::Custom(expected) => expected, + }; + + // we need to wait if actual version is < than expected, we are OK of versions are the + // same and we need to abort if actual version is > than expected + let actual = SimpleRuntimeVersion::from_runtime_version(&env.runtime_version().await?); + match actual.spec_version.cmp(&expected.spec_version) { + Ordering::Less => + Err(Error::WaitingForRuntimeUpgrade { chain: C::NAME.into(), expected, actual }), + Ordering::Equal => Ok(()), + Ordering::Greater => { + log::error!( + target: "bridge", + "The {} client is configured to use runtime version {expected:?} and actual \ + version is {actual:?}. Aborting", + C::NAME, + ); + env.abort().await; + Err(Error::Custom("Aborted".into())) + }, + } + } + + /// Build client to use in connection. + async fn build_client( + params: &ConnectionParams, + ) -> Result<(Arc, Arc)> { + let tokio = tokio::runtime::Runtime::new()?; + let uri = match params.uri { + Some(ref uri) => uri.clone(), + None => { + format!( + "{}://{}:{}{}", + if params.secure { "wss" } else { "ws" }, + params.host, + params.port, + match params.path { + Some(ref path) => format!("/{}", path), + None => String::new(), + }, + ) + }, + }; + log::info!(target: "bridge", "Connecting to {} node at {}", C::NAME, uri); + + let client = tokio + .spawn(async move { + WsClientBuilder::default() + .max_buffer_capacity_per_subscription(MAX_SUBSCRIPTION_CAPACITY) + .build(&uri) + .await + }) + .await??; + + Ok((Arc::new(tokio), Arc::new(client))) + } + + /// Execute jsonrpsee future in tokio context. + async fn jsonrpsee_execute(&self, make_jsonrpsee_future: MF) -> Result + where + MF: FnOnce(Arc) -> F + Send + 'static, + F: Future> + Send + 'static, + T: Send + 'static, + { + let data = self.data.read().await; + let client = data.client.clone(); + data.tokio.spawn(make_jsonrpsee_future(client)).await? + } + + /// Prepare parameters used to sign chain transactions. + async fn build_sign_params(&self, signer: AccountKeyPairOf) -> Result> + where + C: ChainWithTransactions, + { + let runtime_version = self.simple_runtime_version().await?; + Ok(SignParam:: { + spec_version: runtime_version.spec_version, + transaction_version: runtime_version.transaction_version, + genesis_hash: self.genesis_hash, + signer, + }) + } + + /// Get the nonce of the given Substrate account. + pub async fn next_account_index(&self, account: AccountIdOf) -> Result> { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateFrameSystemClient::::account_next_index(&*client, account).await?) + }) + .await + } + + /// Subscribe to finality justifications. + async fn subscribe_finality_justifications( + &self, + gadget_name: &str, + do_subscribe: impl FnOnce(Arc) -> Fut + Send + 'static, + ) -> Result> + where + Fut: Future, ClientError>> + Send, + { + let subscription = self + .jsonrpsee_execute(move |client| async move { Ok(do_subscribe(client).await?) }) + .map_err(|e| Error::failed_to_subscribe_justification::(e)) + .await?; + + Ok(Subscription::new_forwarded( + StreamDescription::new(format!("{} justifications", gadget_name), C::NAME.into()), + subscription, + )) + } + + /// Subscribe to headers stream. + async fn subscribe_headers( + &self, + stream_name: &str, + do_subscribe: impl FnOnce(Arc) -> Fut + Send + 'static, + map_err: impl FnOnce(Error) -> Error, + ) -> Result>> + where + Fut: Future>, ClientError>> + Send, + { + let subscription = self + .jsonrpsee_execute(move |client| async move { Ok(do_subscribe(client).await?) }) + .map_err(map_err) + .await?; + + Ok(Subscription::new_forwarded( + StreamDescription::new(format!("{} headers", stream_name), C::NAME.into()), + subscription, + )) + } +} + +impl Clone for RpcClient { + fn clone(&self) -> Self { + RpcClient { + params: self.params.clone(), + submit_signed_extrinsic_lock: self.submit_signed_extrinsic_lock.clone(), + genesis_hash: self.genesis_hash, + data: self.data.clone(), + _phantom: PhantomData, + } + } +} + +#[async_trait] +impl Client for RpcClient { + async fn ensure_synced(&self) -> Result<()> { + let health = self + .jsonrpsee_execute(|client| async move { + Ok(SubstrateSystemClient::::health(&*client).await?) + }) + .await + .map_err(|e| Error::failed_to_get_system_health::(e))?; + + let is_synced = !health.is_syncing && (!health.should_have_peers || health.peers > 0); + if is_synced { + Ok(()) + } else { + Err(Error::ClientNotSynced(health)) + } + } + + async fn reconnect(&self) -> Result<()> { + let mut data = self.data.write().await; + let (tokio, client) = Self::build_client(&self.params).await?; + data.tokio = tokio; + data.client = client; + Ok(()) + } + + fn genesis_hash(&self) -> HashOf { + self.genesis_hash + } + + async fn header_hash_by_number(&self, number: BlockNumberOf) -> Result> { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateChainClient::::block_hash(&*client, Some(number)).await?) + }) + .await + .map_err(|e| Error::failed_to_read_header_hash_by_number::(number, e)) + } + + async fn header_by_hash(&self, hash: HashOf) -> Result> { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateChainClient::::header(&*client, Some(hash)).await?) + }) + .await + .map_err(|e| Error::failed_to_read_header_by_hash::(hash, e)) + } + + async fn block_by_hash(&self, hash: HashOf) -> Result> { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateChainClient::::block(&*client, Some(hash)).await?) + }) + .await + .map_err(|e| Error::failed_to_read_block_by_hash::(hash, e)) + } + + async fn best_finalized_header_hash(&self) -> Result> { + self.jsonrpsee_execute(|client| async move { + Ok(SubstrateChainClient::::finalized_head(&*client).await?) + }) + .await + .map_err(|e| Error::failed_to_read_best_finalized_header_hash::(e)) + } + + async fn best_header(&self) -> Result> { + self.jsonrpsee_execute(|client| async move { + Ok(SubstrateChainClient::::header(&*client, None).await?) + }) + .await + .map_err(|e| Error::failed_to_read_best_header::(e)) + } + + async fn subscribe_best_headers(&self) -> Result>> { + self.subscribe_headers( + "best headers", + move |client| async move { SubstrateChainClient::::subscribe_new_heads(&*client).await }, + |e| Error::failed_to_subscribe_best_headers::(e), + ) + .await + } + + async fn subscribe_finalized_headers(&self) -> Result>> { + self.subscribe_headers( + "best finalized headers", + move |client| async move { + SubstrateChainClient::::subscribe_finalized_heads(&*client).await + }, + |e| Error::failed_to_subscribe_finalized_headers::(e), + ) + .await + } + + async fn subscribe_grandpa_finality_justifications(&self) -> Result> + where + C: ChainWithGrandpa, + { + self.subscribe_finality_justifications("GRANDPA", move |client| async move { + SubstrateGrandpaClient::::subscribe_justifications(&*client).await + }) + .await + } + + async fn generate_grandpa_key_ownership_proof( + &self, + at: HashOf, + set_id: sp_consensus_grandpa::SetId, + authority_id: sp_consensus_grandpa::AuthorityId, + ) -> Result> { + self.state_call( + at, + SUB_API_GRANDPA_GENERATE_KEY_OWNERSHIP_PROOF.into(), + (set_id, authority_id), + ) + .await + } + + async fn subscribe_beefy_finality_justifications(&self) -> Result> { + self.subscribe_finality_justifications("BEEFY", move |client| async move { + SubstrateBeefyClient::::subscribe_justifications(&*client).await + }) + .await + } + + async fn token_decimals(&self) -> Result> { + self.jsonrpsee_execute(move |client| async move { + let system_properties = SubstrateSystemClient::::properties(&*client).await?; + Ok(system_properties.get("tokenDecimals").and_then(|v| v.as_u64())) + }) + .await + } + + async fn runtime_version(&self) -> Result { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateStateClient::::runtime_version(&*client).await?) + }) + .await + .map_err(|e| Error::failed_to_read_runtime_version::(e)) + } + + async fn simple_runtime_version(&self) -> Result { + Ok(match self.params.chain_runtime_version { + ChainRuntimeVersion::Auto => { + let runtime_version = self.runtime_version().await?; + SimpleRuntimeVersion::from_runtime_version(&runtime_version) + }, + ChainRuntimeVersion::Custom(ref version) => *version, + }) + } + + fn can_start_version_guard(&self) -> bool { + !matches!(self.params.chain_runtime_version, ChainRuntimeVersion::Auto) + } + + async fn raw_storage_value( + &self, + at: HashOf, + storage_key: StorageKey, + ) -> Result> { + let cloned_storage_key = storage_key.clone(); + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateStateClient::::storage(&*client, cloned_storage_key, Some(at)).await?) + }) + .await + .map_err(|e| Error::failed_to_read_storage_value::(at, storage_key, e)) + } + + async fn pending_extrinsics(&self) -> Result> { + self.jsonrpsee_execute(move |client| async move { + Ok(SubstrateAuthorClient::::pending_extrinsics(&*client).await?) + }) + .await + .map_err(|e| Error::failed_to_get_pending_extrinsics::(e)) + } + + async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result> { + // one last check that the transaction is valid. Most of checks happen in the relay loop and + // it is the "final" check before submission. + let best_header_hash = self.best_header_hash().await?; + self.validate_transaction(best_header_hash, PreEncoded(transaction.0.clone())) + .await + .map_err(|e| Error::failed_to_submit_transaction::(e))? + .map_err(|e| Error::failed_to_submit_transaction::(Error::TransactionInvalid(e)))?; + + self.jsonrpsee_execute(move |client| async move { + let tx_hash = SubstrateAuthorClient::::submit_extrinsic(&*client, transaction) + .await + .map_err(|e| { + log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e); + e + })?; + log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash); + Ok(tx_hash) + }) + .await + .map_err(|e| Error::failed_to_submit_transaction::(e)) + } + + async fn submit_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>, + { + let _guard = self.submit_signed_extrinsic_lock.lock().await; + let transaction_nonce = self.next_account_index(signer.public().into()).await?; + let best_header = self.best_header().await?; + let signing_data = self.build_sign_params(signer.clone()).await?; + + // By using parent of best block here, we are protecting again best-block reorganizations. + // E.g. transaction may have been submitted when the best block was `A[num=100]`. Then it + // has been changed to `B[num=100]`. Hash of `A` has been included into transaction + // signature payload. So when signature will be checked, the check will fail and transaction + // will be dropped from the pool. + let best_header_id = best_header.parent_id().unwrap_or_else(|| best_header.id()); + + let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?; + let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode(); + self.submit_unsigned_extrinsic(Bytes(signed_extrinsic)).await + } + + async fn submit_and_watch_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>, + { + let self_clone = self.clone(); + let signing_data = self.build_sign_params(signer.clone()).await?; + let _guard = self.submit_signed_extrinsic_lock.lock().await; + let transaction_nonce = self.next_account_index(signer.public().into()).await?; + let best_header = self.best_header().await?; + let best_header_id = best_header.id(); + + let extrinsic = prepare_extrinsic(best_header_id, transaction_nonce)?; + let stall_timeout = transaction_stall_timeout( + extrinsic.era.mortality_period(), + C::AVERAGE_BLOCK_INTERVAL, + STALL_TIMEOUT, + ); + let signed_extrinsic = C::sign_transaction(signing_data, extrinsic)?.encode(); + + // one last check that the transaction is valid. Most of checks happen in the relay loop and + // it is the "final" check before submission. + self.validate_transaction(best_header_id.hash(), PreEncoded(signed_extrinsic.clone())) + .await + .map_err(|e| Error::failed_to_submit_transaction::(e))? + .map_err(|e| Error::failed_to_submit_transaction::(Error::TransactionInvalid(e)))?; + + self.jsonrpsee_execute(move |client| async move { + let tx_hash = C::Hasher::hash(&signed_extrinsic); + let subscription: jsonrpsee::core::client::Subscription<_> = + SubstrateAuthorClient::::submit_and_watch_extrinsic( + &*client, + Bytes(signed_extrinsic), + ) + .await + .map_err(|e| { + log::error!(target: "bridge", "Failed to send transaction to {} node: {:?}", C::NAME, e); + e + })?; + log::trace!(target: "bridge", "Sent transaction to {} node: {:?}", C::NAME, tx_hash); + Ok(TransactionTracker::new( + self_clone, + stall_timeout, + tx_hash, + Subscription::new_forwarded( + StreamDescription::new("transaction events".into(), C::NAME.into()), + subscription, + ), + )) + }) + .await + .map_err(|e| Error::failed_to_submit_transaction::(e)) + } + + async fn validate_transaction( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result { + self.state_call( + at, + SUB_API_TXPOOL_VALIDATE_TRANSACTION.into(), + (TransactionSource::External, transaction, at), + ) + .await + } + + async fn estimate_extrinsic_weight( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result { + let transaction_len = transaction.encoded_size() as u32; + let dispatch_info: RuntimeDispatchInfo> = self + .state_call(at, SUB_API_TX_PAYMENT_QUERY_INFO.into(), (transaction, transaction_len)) + .await?; + + Ok(dispatch_info.weight) + } + + async fn raw_state_call( + &self, + at: HashOf, + method: String, + arguments: Args, + ) -> Result { + let arguments = Bytes(arguments.encode()); + let arguments_clone = arguments.clone(); + let method_clone = method.clone(); + self.jsonrpsee_execute(move |client| async move { + SubstrateStateClient::::call(&*client, method, arguments, Some(at)) + .await + .map_err(Into::into) + }) + .await + .map_err(|e| Error::failed_state_call::(at, method_clone, arguments_clone, e)) + } + + async fn prove_storage( + &self, + at: HashOf, + keys: Vec, + ) -> Result<(StorageProof, HashOf)> { + let state_root = *self.header_by_hash(at).await?.state_root(); + + let keys_clone = keys.clone(); + let read_proof = self + .jsonrpsee_execute(move |client| async move { + SubstrateStateClient::::prove_storage(&*client, keys_clone, Some(at)) + .await + .map(|proof| StorageProof::new(proof.proof.into_iter().map(|b| b.0))) + .map_err(Into::into) + }) + .await + .map_err(|e| Error::failed_to_prove_storage::(at, keys.clone(), e))?; + + Ok((read_proof, state_root)) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{guard::tests::TestEnvironment, test_chain::TestChain}; + use futures::{channel::mpsc::unbounded, FutureExt, SinkExt, StreamExt}; + + async fn run_ensure_correct_runtime_version( + expected: ChainRuntimeVersion, + actual: RuntimeVersion, + ) -> Result<()> { + let ( + (mut runtime_version_tx, runtime_version_rx), + (slept_tx, _slept_rx), + (aborted_tx, mut aborted_rx), + ) = (unbounded(), unbounded(), unbounded()); + runtime_version_tx.send(actual).await.unwrap(); + let mut env = TestEnvironment { runtime_version_rx, slept_tx, aborted_tx }; + + let ensure_correct_runtime_version = + RpcClient::::ensure_correct_runtime_version(&mut env, expected).boxed(); + let aborted = aborted_rx.next().map(|_| Err(Error::Custom("".into()))).boxed(); + futures::pin_mut!(ensure_correct_runtime_version, aborted); + futures::future::select(ensure_correct_runtime_version, aborted) + .await + .into_inner() + .0 + } + + #[async_std::test] + async fn ensure_correct_runtime_version_works() { + // when we are configured to use auto version + assert!(matches!( + run_ensure_correct_runtime_version( + ChainRuntimeVersion::Auto, + RuntimeVersion { + spec_version: 100, + transaction_version: 100, + ..Default::default() + }, + ) + .await, + Ok(()), + )); + // when actual == expected + assert!(matches!( + run_ensure_correct_runtime_version( + ChainRuntimeVersion::Custom(SimpleRuntimeVersion { + spec_version: 100, + transaction_version: 100 + }), + RuntimeVersion { + spec_version: 100, + transaction_version: 100, + ..Default::default() + }, + ) + .await, + Ok(()), + )); + // when actual spec version < expected spec version + assert!(matches!( + run_ensure_correct_runtime_version( + ChainRuntimeVersion::Custom(SimpleRuntimeVersion { + spec_version: 100, + transaction_version: 100 + }), + RuntimeVersion { spec_version: 99, transaction_version: 100, ..Default::default() }, + ) + .await, + Err(Error::WaitingForRuntimeUpgrade { + expected: SimpleRuntimeVersion { spec_version: 100, transaction_version: 100 }, + actual: SimpleRuntimeVersion { spec_version: 99, transaction_version: 100 }, + .. + }), + )); + // when actual spec version > expected spec version + assert!(matches!( + run_ensure_correct_runtime_version( + ChainRuntimeVersion::Custom(SimpleRuntimeVersion { + spec_version: 100, + transaction_version: 100 + }), + RuntimeVersion { + spec_version: 101, + transaction_version: 100, + ..Default::default() + }, + ) + .await, + Err(Error::Custom(_)), + )); + } +} diff --git a/bridges/relays/client-substrate/src/rpc.rs b/bridges/relays/client-substrate/src/client/rpc_api.rs similarity index 80% rename from bridges/relays/client-substrate/src/rpc.rs rename to bridges/relays/client-substrate/src/client/rpc_api.rs index 60c29cdeb5c7707619b65d23800dcd7dfdfd840a..9cac69f7a13d06bf772fb9493520113d8e066681 100644 --- a/bridges/relays/client-substrate/src/rpc.rs +++ b/bridges/relays/client-substrate/src/client/rpc_api.rs @@ -16,15 +16,9 @@ //! The most generic Substrate node RPC interface. -use async_trait::async_trait; - use crate::{Chain, ChainWithGrandpa, TransactionStatusOf}; -use jsonrpsee::{ - core::{client::Subscription, ClientError}, - proc_macros::rpc, - ws_client::WsClient, -}; +use jsonrpsee::proc_macros::rpc; use pallet_transaction_payment_rpc_runtime_api::FeeDetails; use sc_rpc_api::{state::ReadProof, system::Health}; use sp_core::{ @@ -60,6 +54,20 @@ pub(crate) trait SubstrateChain { /// Return signed block (with justifications) by its hash. #[method(name = "getBlock")] async fn block(&self, block_hash: Option) -> RpcResult; + /// Subscribe to best headers. + #[subscription( + name = "subscribeNewHeads" => "newHead", + unsubscribe = "unsubscribeNewHeads", + item = C::Header + )] + async fn subscribe_new_heads(&self); + /// Subscribe to finalized headers. + #[subscription( + name = "subscribeFinalizedHeads" => "finalizedHead", + unsubscribe = "unsubscribeFinalizedHeads", + item = C::Header + )] + async fn subscribe_finalized_heads(&self); } /// RPC methods of Substrate `author` namespace, that we are using. @@ -106,15 +114,6 @@ pub(crate) trait SubstrateState { ) -> RpcResult>; } -/// RPC methods that we are using for a certain finality gadget. -#[async_trait] -pub trait SubstrateFinalityClient { - /// Subscribe to finality justifications. - async fn subscribe_justifications( - client: &WsClient, - ) -> Result, ClientError>; -} - /// RPC methods of Substrate `grandpa` namespace, that we are using. #[rpc(client, client_bounds(C: ChainWithGrandpa), namespace = "grandpa")] pub(crate) trait SubstrateGrandpa { @@ -123,17 +122,6 @@ pub(crate) trait SubstrateGrandpa { async fn subscribe_justifications(&self); } -/// RPC finality methods of Substrate `grandpa` namespace, that we are using. -pub struct SubstrateGrandpaFinalityClient; -#[async_trait] -impl SubstrateFinalityClient for SubstrateGrandpaFinalityClient { - async fn subscribe_justifications( - client: &WsClient, - ) -> Result, ClientError> { - SubstrateGrandpaClient::::subscribe_justifications(client).await - } -} - // TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged /// RPC methods of Substrate `beefy` namespace, that we are using. #[rpc(client, client_bounds(C: Chain), namespace = "beefy")] @@ -143,18 +131,6 @@ pub(crate) trait SubstrateBeefy { async fn subscribe_justifications(&self); } -/// RPC finality methods of Substrate `beefy` namespace, that we are using. -pub struct SubstrateBeefyFinalityClient; -// TODO: Use `ChainWithBeefy` instead of `Chain` after #1606 is merged -#[async_trait] -impl SubstrateFinalityClient for SubstrateBeefyFinalityClient { - async fn subscribe_justifications( - client: &WsClient, - ) -> Result, ClientError> { - SubstrateBeefyClient::::subscribe_justifications(client).await - } -} - /// RPC methods of Substrate `system` frame pallet, that we are using. #[rpc(client, client_bounds(C: Chain), namespace = "system")] pub(crate) trait SubstrateFrameSystem { diff --git a/bridges/relays/client-substrate/src/client/subscription.rs b/bridges/relays/client-substrate/src/client/subscription.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f08097cb583a57a28885a7aa59a1731e997d023 --- /dev/null +++ b/bridges/relays/client-substrate/src/client/subscription.rs @@ -0,0 +1,238 @@ +// Copyright 2019-2021 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 . + +use crate::error::Result as ClientResult; + +use async_std::{ + channel::{bounded, Receiver, Sender}, + stream::StreamExt, +}; +use futures::{FutureExt, Stream}; +use sp_runtime::DeserializeOwned; +use std::{ + fmt::Debug, + pin::Pin, + result::Result as StdResult, + task::{Context, Poll}, +}; + +/// Once channel reaches this capacity, the subscription breaks. +const CHANNEL_CAPACITY: usize = 128; + +/// Structure describing a stream. +#[derive(Clone)] +pub struct StreamDescription { + stream_name: String, + chain_name: String, +} + +impl StreamDescription { + /// Create a new instance of `StreamDescription`. + pub fn new(stream_name: String, chain_name: String) -> Self { + Self { stream_name, chain_name } + } + + /// Get a stream description. + fn get(&self) -> String { + format!("{} stream of {}", self.stream_name, self.chain_name) + } +} + +/// Chainable stream that transforms items of type `Result` to items of type `T`. +/// +/// If it encounters an item of type `Err`, it returns `Poll::Ready(None)` +/// and terminates the underlying stream. +struct Unwrap>, T, E> { + desc: StreamDescription, + stream: Option, +} + +impl>, T, E> Unwrap { + /// Create a new instance of `Unwrap`. + pub fn new(desc: StreamDescription, stream: S) -> Self { + Self { desc, stream: Some(stream) } + } +} + +impl> + Unpin, T: DeserializeOwned, E: Debug> Stream + for Unwrap +{ + type Item = T; + + fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Poll::Ready(match self.stream.as_mut() { + Some(subscription) => match futures::ready!(Pin::new(subscription).poll_next(cx)) { + Some(Ok(item)) => Some(item), + Some(Err(e)) => { + self.stream.take(); + log::debug!( + target: "bridge", + "{} has returned error: {:?}. It may need to be restarted", + self.desc.get(), + e, + ); + None + }, + None => { + self.stream.take(); + log::debug!( + target: "bridge", + "{} has returned `None`. It may need to be restarted", + self.desc.get() + ); + None + }, + }, + None => None, + }) + } +} + +/// Subscription factory that produces subscriptions, sharing the same background thread. +#[derive(Clone)] +pub struct SubscriptionBroadcaster { + desc: StreamDescription, + subscribers_sender: Sender>, +} + +impl SubscriptionBroadcaster { + /// Create new subscription factory. + pub fn new(subscription: Subscription) -> StdResult> { + // It doesn't make sense to further broadcast a broadcasted subscription. + if subscription.is_broadcasted { + return Err(subscription) + } + + let desc = subscription.desc().clone(); + let (subscribers_sender, subscribers_receiver) = bounded(CHANNEL_CAPACITY); + async_std::task::spawn(background_worker(subscription, subscribers_receiver)); + Ok(Self { desc, subscribers_sender }) + } + + /// Produce new subscription. + pub async fn subscribe(&self) -> ClientResult> { + let (items_sender, items_receiver) = bounded(CHANNEL_CAPACITY); + self.subscribers_sender.try_send(items_sender)?; + + Ok(Subscription::new_broadcasted(self.desc.clone(), items_receiver)) + } +} + +/// Subscription to some chain events. +pub struct Subscription { + desc: StreamDescription, + subscription: Box + Unpin + Send>, + is_broadcasted: bool, +} + +impl Subscription { + /// Create new forwarded subscription. + pub fn new_forwarded( + desc: StreamDescription, + subscription: impl Stream> + Unpin + Send + 'static, + ) -> Self { + Self { + desc: desc.clone(), + subscription: Box::new(Unwrap::new(desc, subscription)), + is_broadcasted: false, + } + } + + /// Create new broadcasted subscription. + pub fn new_broadcasted( + desc: StreamDescription, + subscription: impl Stream + Unpin + Send + 'static, + ) -> Self { + Self { desc, subscription: Box::new(subscription), is_broadcasted: true } + } + + /// Get the description of the underlying stream + pub fn desc(&self) -> &StreamDescription { + &self.desc + } +} + +impl Stream for Subscription { + type Item = T; + + fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { + Poll::Ready(futures::ready!(Pin::new(&mut self.subscription).poll_next(cx))) + } +} + +/// Background worker that is executed in tokio context as `jsonrpsee` requires. +/// +/// This task may exit under some circumstances. It'll send the correspondent +/// message (`Err` or `None`) to all known listeners. Also, when it stops, all +/// subsequent reads and new subscribers will get the connection error (`ChannelError`). +async fn background_worker( + mut subscription: Subscription, + mut subscribers_receiver: Receiver>, +) { + fn log_task_exit(desc: &StreamDescription, reason: &str) { + log::debug!( + target: "bridge", + "Background task of subscription broadcaster for {} has stopped: {}", + desc.get(), + reason, + ); + } + + // wait for first subscriber until actually starting subscription + let subscriber = match subscribers_receiver.next().await { + Some(subscriber) => subscriber, + None => { + // it means that the last subscriber/factory has been dropped, so we need to + // exit too + return log_task_exit(subscription.desc(), "client has stopped") + }, + }; + + // actually subscribe + let mut subscribers = vec![subscriber]; + + // start listening for new items and receivers + loop { + futures::select! { + subscriber = subscribers_receiver.next().fuse() => { + match subscriber { + Some(subscriber) => subscribers.push(subscriber), + None => { + // it means that the last subscriber/factory has been dropped, so we need to + // exit too + return log_task_exit(subscription.desc(), "client has stopped") + }, + } + }, + maybe_item = subscription.subscription.next().fuse() => { + match maybe_item { + Some(item) => { + // notify subscribers + subscribers.retain(|subscriber| { + let send_result = subscriber.try_send(item.clone()); + send_result.is_ok() + }); + } + None => { + // The underlying client has dropped, so we can't do anything here + // and need to stop the task. + return log_task_exit(subscription.desc(), "stream has finished"); + } + } + }, + } + } +} diff --git a/bridges/relays/client-substrate/src/client/traits.rs b/bridges/relays/client-substrate/src/client/traits.rs new file mode 100644 index 0000000000000000000000000000000000000000..6f4ef5aa951062ddd6586e0dadeb4ce7425eca5e --- /dev/null +++ b/bridges/relays/client-substrate/src/client/traits.rs @@ -0,0 +1,234 @@ +// Copyright 2019-2021 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 . + +use crate::{ + error::{Error, Result}, + AccountIdOf, AccountKeyPairOf, BlockNumberOf, Chain, ChainWithGrandpa, ChainWithTransactions, + HashOf, HeaderIdOf, HeaderOf, NonceOf, SignedBlockOf, SimpleRuntimeVersion, Subscription, + TransactionTracker, UnsignedTransaction, +}; + +use async_trait::async_trait; +use bp_runtime::{StorageDoubleMapKeyProvider, StorageMapKeyProvider}; +use codec::{Decode, Encode}; +use frame_support::weights::Weight; +use sp_core::{ + storage::{StorageData, StorageKey}, + Bytes, Pair, +}; +use sp_runtime::{traits::Header as _, transaction_validity::TransactionValidity}; +use sp_trie::StorageProof; +use sp_version::RuntimeVersion; +use std::fmt::Debug; + +/// Relay uses the `Client` to communicate with the node, connected to Substrate +/// chain `C`. +#[async_trait] +pub trait Client: 'static + Send + Sync + Clone + Debug { + /// Returns error if client has no connected peers or it believes it is far + /// behind the chain tip. + async fn ensure_synced(&self) -> Result<()>; + /// Reconnects the client. + async fn reconnect(&self) -> Result<()>; + + /// Return hash of the genesis block. + fn genesis_hash(&self) -> HashOf; + /// Get header hash by number. + async fn header_hash_by_number(&self, number: BlockNumberOf) -> Result>; + /// Get header by hash. + async fn header_by_hash(&self, hash: HashOf) -> Result>; + /// Get header by number. + async fn header_by_number(&self, number: BlockNumberOf) -> Result> { + self.header_by_hash(self.header_hash_by_number(number).await?).await + } + /// Get block by hash. + async fn block_by_hash(&self, hash: HashOf) -> Result>; + + /// Get best finalized header hash. + async fn best_finalized_header_hash(&self) -> Result>; + /// Get best finalized header number. + async fn best_finalized_header_number(&self) -> Result> { + Ok(*self.best_finalized_header().await?.number()) + } + /// Get best finalized header. + async fn best_finalized_header(&self) -> Result> { + self.header_by_hash(self.best_finalized_header_hash().await?).await + } + + /// Get best header. + async fn best_header(&self) -> Result>; + /// Get best header hash. + async fn best_header_hash(&self) -> Result> { + Ok(self.best_header().await?.hash()) + } + + /// Subscribe to new best headers. + async fn subscribe_best_headers(&self) -> Result>>; + /// Subscribe to new finalized headers. + async fn subscribe_finalized_headers(&self) -> Result>>; + + /// Subscribe to GRANDPA finality justifications. + async fn subscribe_grandpa_finality_justifications(&self) -> Result> + where + C: ChainWithGrandpa; + /// Generates a proof of key ownership for the given authority in the given set. + async fn generate_grandpa_key_ownership_proof( + &self, + at: HashOf, + set_id: sp_consensus_grandpa::SetId, + authority_id: sp_consensus_grandpa::AuthorityId, + ) -> Result>; + + /// Subscribe to BEEFY finality justifications. + async fn subscribe_beefy_finality_justifications(&self) -> Result>; + + /// Return `tokenDecimals` property from the set of chain properties. + async fn token_decimals(&self) -> Result>; + /// Get runtime version of the connected chain. + async fn runtime_version(&self) -> Result; + /// Get partial runtime version, to use when signing transactions. + async fn simple_runtime_version(&self) -> Result; + /// Returns `true` if version guard can be started. + /// + /// There's no reason to run version guard when version mode is set to `Auto`. It can + /// lead to relay shutdown when chain is upgraded, even though we have explicitly + /// said that we don't want to shutdown. + fn can_start_version_guard(&self) -> bool; + + /// Read raw value from runtime storage. + async fn raw_storage_value( + &self, + at: HashOf, + storage_key: StorageKey, + ) -> Result>; + /// Read and decode value from runtime storage. + async fn storage_value( + &self, + at: HashOf, + storage_key: StorageKey, + ) -> Result> { + self.raw_storage_value(at, storage_key.clone()) + .await? + .map(|encoded_value| { + T::decode(&mut &encoded_value.0[..]).map_err(|e| { + Error::failed_to_read_storage_value::(at, storage_key, e.into()) + }) + }) + .transpose() + } + /// Read and decode value from runtime storage map. + /// + /// `pallet_prefix` is the name of the pallet (used in `construct_runtime`), which + /// "contains" the storage map. + async fn storage_map_value( + &self, + at: HashOf, + pallet_prefix: &str, + storage_key: &T::Key, + ) -> Result> { + self.storage_value(at, T::final_key(pallet_prefix, storage_key)).await + } + /// Read and decode value from runtime storage double map. + /// + /// `pallet_prefix` is the name of the pallet (used in `construct_runtime`), which + /// "contains" the storage double map. + async fn storage_double_map_value( + &self, + at: HashOf, + pallet_prefix: &str, + key1: &T::Key1, + key2: &T::Key2, + ) -> Result> { + self.storage_value(at, T::final_key(pallet_prefix, key1, key2)).await + } + + /// Returns pending extrinsics from transaction pool. + async fn pending_extrinsics(&self) -> Result>; + /// Submit unsigned extrinsic for inclusion in a block. + /// + /// Note: The given transaction needs to be SCALE encoded beforehand. + async fn submit_unsigned_extrinsic(&self, transaction: Bytes) -> Result>; + /// Submit an extrinsic signed by given account. + /// + /// All calls of this method are synchronized, so there can't be more than one active + /// `submit_signed_extrinsic()` call. This guarantees that no nonces collision may happen + /// if all client instances are clones of the same initial `Client`. + /// + /// Note: The given transaction needs to be SCALE encoded beforehand. + async fn submit_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>; + /// Does exactly the same as `submit_signed_extrinsic`, but keeps watching for extrinsic status + /// after submission. + async fn submit_and_watch_signed_extrinsic( + &self, + signer: &AccountKeyPairOf, + prepare_extrinsic: impl FnOnce(HeaderIdOf, NonceOf) -> Result> + + Send + + 'static, + ) -> Result> + where + C: ChainWithTransactions, + AccountIdOf: From< as Pair>::Public>; + /// Validate transaction at given block. + async fn validate_transaction( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result; + /// Returns weight of the given transaction. + async fn estimate_extrinsic_weight( + &self, + at: HashOf, + transaction: SignedTransaction, + ) -> Result; + + /// Execute runtime call at given block. + async fn raw_state_call( + &self, + at: HashOf, + method: String, + arguments: Args, + ) -> Result; + /// Execute runtime call at given block, provided the input and output types. + /// It also performs the input encode and output decode. + async fn state_call( + &self, + at: HashOf, + method: String, + arguments: Args, + ) -> Result { + let encoded_arguments = arguments.encode(); + let encoded_output = self.raw_state_call(at, method.clone(), arguments).await?; + Ret::decode(&mut &encoded_output.0[..]).map_err(|e| { + Error::failed_state_call::(at, method, Bytes(encoded_arguments), e.into()) + }) + } + + /// Returns storage proof of given storage keys and state root. + async fn prove_storage( + &self, + at: HashOf, + keys: Vec, + ) -> Result<(StorageProof, HashOf)>; +} diff --git a/bridges/relays/client-substrate/src/error.rs b/bridges/relays/client-substrate/src/error.rs index 0b446681818879d662ba9a71679a799519cf491b..ee3c73f806e65362a10185d5dd9090f5bbc4c300 100644 --- a/bridges/relays/client-substrate/src/error.rs +++ b/bridges/relays/client-substrate/src/error.rs @@ -16,12 +16,13 @@ //! Substrate node RPC errors. -use crate::SimpleRuntimeVersion; +use crate::{BlockNumberOf, Chain, HashOf, SimpleRuntimeVersion}; +use bp_header_chain::SubmitFinalityProofCallExtras; use bp_polkadot_core::parachains::ParaId; use jsonrpsee::core::ClientError as RpcError; use relay_utils::MaybeConnectionError; use sc_rpc_api::system::Health; -use sp_core::storage::StorageKey; +use sp_core::{storage::StorageKey, Bytes}; use sp_runtime::transaction_validity::TransactionValidityError; use thiserror::Error; @@ -42,12 +43,10 @@ pub enum Error { /// The response from the server could not be SCALE decoded. #[error("Response parse failed: {0}")] ResponseParseFailed(#[from] codec::Error), - /// Account does not exist on the chain. - #[error("Account does not exist on the chain.")] - AccountDoesNotExist, - /// Runtime storage is missing some mandatory value. - #[error("Mandatory storage value is missing from the runtime storage.")] - MissingMandatoryStorageValue, + /// Internal channel error - communication channel is either closed, or full. + /// It can be solved with reconnect. + #[error("Internal communication channel error: {0:?}.")] + ChannelError(String), /// Required parachain head is not present at the relay chain. #[error("Parachain {0:?} head {1} is missing from the relay chain storage.")] MissingRequiredParachainHead(ParaId, u64), @@ -57,6 +56,14 @@ pub enum Error { /// The client we're connected to is not synced, so we can't rely on its state. #[error("Substrate client is not synced {0}.")] ClientNotSynced(Health), + /// Failed to get system health. + #[error("Failed to get system health of {chain} node: {error:?}.")] + FailedToGetSystemHealth { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, /// Failed to read best finalized header hash from given chain. #[error("Failed to read best finalized header hash of {chain}: {error:?}.")] FailedToReadBestFinalizedHeaderHash { @@ -73,6 +80,16 @@ pub enum Error { /// Underlying error. error: Box, }, + /// Failed to read header hash by number from given chain. + #[error("Failed to read header hash by number {number} of {chain}: {error:?}.")] + FailedToReadHeaderHashByNumber { + /// Name of the chain where the error has happened. + chain: String, + /// Number of the header we've tried to read. + number: String, + /// Underlying error. + error: Box, + }, /// Failed to read header by hash from given chain. #[error("Failed to read header {hash} of {chain}: {error:?}.")] FailedToReadHeaderByHash { @@ -83,38 +100,119 @@ pub enum Error { /// Underlying error. error: Box, }, - /// Failed to execute runtime call at given chain. - #[error("Failed to execute runtime call {method} at {chain}: {error:?}.")] - ErrorExecutingRuntimeCall { + /// Failed to read block by hash from given chain. + #[error("Failed to read block {hash} of {chain}: {error:?}.")] + FailedToReadBlockByHash { /// Name of the chain where the error has happened. chain: String, - /// Runtime method name. - method: String, + /// Hash of the header we've tried to read. + hash: String, /// Underlying error. error: Box, }, /// Failed to read sotrage value at given chain. #[error("Failed to read storage value {key:?} at {chain}: {error:?}.")] - FailedToReadRuntimeStorageValue { + FailedToReadStorageValue { /// Name of the chain where the error has happened. chain: String, + /// Hash of the block we've tried to read value from. + hash: String, /// Runtime storage key key: StorageKey, /// Underlying error. error: Box, }, + /// Failed to read runtime version of given chain. + #[error("Failed to read runtime version of {chain}: {error:?}.")] + FailedToReadRuntimeVersion { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Failed to get pending extrinsics. + #[error("Failed to get pending extrinsics of {chain}: {error:?}.")] + FailedToGetPendingExtrinsics { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Failed to submit transaction. + #[error("Failed to submit {chain} transaction: {error:?}.")] + FailedToSubmitTransaction { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Runtime call has failed. + #[error("Runtime call {method} with arguments {arguments:?} of chain {chain} at {hash} has failed: {error:?}.")] + FailedStateCall { + /// Name of the chain where the error has happened. + chain: String, + /// Hash of the block we've tried to call at. + hash: String, + /// Runtime API method. + method: String, + /// Encoded method arguments. + arguments: Bytes, + /// Underlying error. + error: Box, + }, + /// Failed to prove storage keys. + #[error("Failed to prove storage keys {storage_keys:?} of {chain} at {hash}: {error:?}.")] + FailedToProveStorage { + /// Name of the chain where the error has happened. + chain: String, + /// Hash of the block we've tried to prove keys at. + hash: String, + /// Storage keys we have tried to prove. + storage_keys: Vec, + /// Underlying error. + error: Box, + }, + /// Failed to subscribe to GRANDPA justifications stream. + #[error("Failed to subscribe to {chain} best headers: {error:?}.")] + FailedToSubscribeBestHeaders { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Failed to subscribe to GRANDPA justifications stream. + #[error("Failed to subscribe to {chain} finalized headers: {error:?}.")] + FailedToSubscribeFinalizedHeaders { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Failed to subscribe to GRANDPA justifications stream. + #[error("Failed to subscribe to {chain} justifications: {error:?}.")] + FailedToSubscribeJustifications { + /// Name of the chain where the error has happened. + chain: String, + /// Underlying error. + error: Box, + }, + /// Headers of the chain are finalized out of order. Maybe chain has been + /// restarted? + #[error("Finalized headers of {chain} are unordered: previously finalized {prev_number} vs new {next_number}")] + UnorderedFinalizedHeaders { + /// Name of the chain where the error has happened. + chain: String, + /// Previously finalized header number. + prev_number: String, + /// New finalized header number. + next_number: String, + }, /// The bridge pallet is halted and all transactions will be rejected. #[error("Bridge pallet is halted.")] BridgePalletIsHalted, /// The bridge pallet is not yet initialized and all transactions will be rejected. #[error("Bridge pallet is not initialized.")] BridgePalletIsNotInitialized, - /// There's no best head of the parachain at the `pallet-bridge-parachains` at the target side. - #[error("No head of the ParaId({0}) at the bridge parachains pallet at {1}.")] - NoParachainHeadAtTarget(u32, String), - /// An error has happened when we have tried to parse storage proof. - #[error("Error when parsing storage proof: {0:?}.")] - StorageProofError(bp_runtime::StorageProofError), /// The Substrate transaction is invalid. #[error("Substrate transaction is invalid: {0:?}")] TransactionInvalid(#[from] TransactionValidityError), @@ -129,6 +227,12 @@ pub enum Error { /// Actual runtime version. actual: SimpleRuntimeVersion, }, + /// Finality proof submission exceeds size and/or weight limits. + #[error("Finality proof submission exceeds limits: {extras:?}")] + FinalityProofWeightLimitExceeded { + /// Finality proof submission extras. + extras: SubmitFinalityProofCallExtras, + }, /// Custom logic error. #[error("{0}")] Custom(String), @@ -136,7 +240,19 @@ pub enum Error { impl From for Error { fn from(error: tokio::task::JoinError) -> Self { - Error::Custom(format!("Failed to wait tokio task: {error}")) + Error::ChannelError(format!("failed to wait tokio task: {error}")) + } +} + +impl From> for Error { + fn from(error: async_std::channel::TrySendError) -> Self { + Error::ChannelError(format!("`try_send` has failed: {error:?}")) + } +} + +impl From for Error { + fn from(error: async_std::channel::RecvError) -> Self { + Error::ChannelError(format!("`recv` has failed: {error:?}")) } } @@ -145,21 +261,170 @@ impl Error { pub fn boxed(self) -> Box { Box::new(self) } + + /// Returns nested error reference. + pub fn nested(&self) -> Option<&Self> { + match *self { + Self::FailedToReadBestFinalizedHeaderHash { ref error, .. } => Some(&**error), + Self::FailedToReadBestHeader { ref error, .. } => Some(&**error), + Self::FailedToReadHeaderHashByNumber { ref error, .. } => Some(&**error), + Self::FailedToReadHeaderByHash { ref error, .. } => Some(&**error), + Self::FailedToReadBlockByHash { ref error, .. } => Some(&**error), + Self::FailedToReadStorageValue { ref error, .. } => Some(&**error), + Self::FailedToReadRuntimeVersion { ref error, .. } => Some(&**error), + Self::FailedToGetPendingExtrinsics { ref error, .. } => Some(&**error), + Self::FailedToSubmitTransaction { ref error, .. } => Some(&**error), + Self::FailedStateCall { ref error, .. } => Some(&**error), + Self::FailedToProveStorage { ref error, .. } => Some(&**error), + Self::FailedToGetSystemHealth { ref error, .. } => Some(&**error), + Self::FailedToSubscribeBestHeaders { ref error, .. } => Some(&**error), + Self::FailedToSubscribeFinalizedHeaders { ref error, .. } => Some(&**error), + Self::FailedToSubscribeJustifications { ref error, .. } => Some(&**error), + _ => None, + } + } + + /// Constructs `FailedToReadHeaderHashByNumber` variant. + pub fn failed_to_read_header_hash_by_number( + number: BlockNumberOf, + e: Error, + ) -> Self { + Error::FailedToReadHeaderHashByNumber { + chain: C::NAME.into(), + number: format!("{number}"), + error: e.boxed(), + } + } + + /// Constructs `FailedToReadHeaderByHash` variant. + pub fn failed_to_read_header_by_hash(hash: HashOf, e: Error) -> Self { + Error::FailedToReadHeaderByHash { + chain: C::NAME.into(), + hash: format!("{hash}"), + error: e.boxed(), + } + } + + /// Constructs `FailedToReadBlockByHash` variant. + pub fn failed_to_read_block_by_hash(hash: HashOf, e: Error) -> Self { + Error::FailedToReadHeaderByHash { + chain: C::NAME.into(), + hash: format!("{hash}"), + error: e.boxed(), + } + } + + /// Constructs `FailedToReadBestFinalizedHeaderHash` variant. + pub fn failed_to_read_best_finalized_header_hash(e: Error) -> Self { + Error::FailedToReadBestFinalizedHeaderHash { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToReadBestHeader` variant. + pub fn failed_to_read_best_header(e: Error) -> Self { + Error::FailedToReadBestHeader { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToReadRuntimeVersion` variant. + pub fn failed_to_read_runtime_version(e: Error) -> Self { + Error::FailedToReadRuntimeVersion { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToReadStorageValue` variant. + pub fn failed_to_read_storage_value( + at: HashOf, + key: StorageKey, + e: Error, + ) -> Self { + Error::FailedToReadStorageValue { + chain: C::NAME.into(), + hash: format!("{at}"), + key, + error: e.boxed(), + } + } + + /// Constructs `FailedToGetPendingExtrinsics` variant. + pub fn failed_to_get_pending_extrinsics(e: Error) -> Self { + Error::FailedToGetPendingExtrinsics { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToSubmitTransaction` variant. + pub fn failed_to_submit_transaction(e: Error) -> Self { + Error::FailedToSubmitTransaction { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedStateCall` variant. + pub fn failed_state_call( + at: HashOf, + method: String, + arguments: Bytes, + e: Error, + ) -> Self { + Error::FailedStateCall { + chain: C::NAME.into(), + hash: format!("{at}"), + method, + arguments, + error: e.boxed(), + } + } + + /// Constructs `FailedToProveStorage` variant. + pub fn failed_to_prove_storage( + at: HashOf, + storage_keys: Vec, + e: Error, + ) -> Self { + Error::FailedToProveStorage { + chain: C::NAME.into(), + hash: format!("{at}"), + storage_keys, + error: e.boxed(), + } + } + + /// Constructs `FailedToGetSystemHealth` variant. + pub fn failed_to_get_system_health(e: Error) -> Self { + Error::FailedToGetSystemHealth { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToSubscribeBestHeaders` variant. + pub fn failed_to_subscribe_best_headers(e: Error) -> Self { + Error::FailedToSubscribeBestHeaders { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToSubscribeFinalizedHeaders` variant. + pub fn failed_to_subscribe_finalized_headers(e: Error) -> Self { + Error::FailedToSubscribeFinalizedHeaders { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `FailedToSubscribeJustifications` variant. + pub fn failed_to_subscribe_justification(e: Error) -> Self { + Error::FailedToSubscribeJustifications { chain: C::NAME.into(), error: e.boxed() } + } + + /// Constructs `Un` + pub fn unordered_finalized_headers( + prev_number: BlockNumberOf, + next_number: BlockNumberOf, + ) -> Self { + Error::UnorderedFinalizedHeaders { + chain: C::NAME.into(), + prev_number: format!("{}", prev_number), + next_number: format!("{}", next_number), + } + } } impl MaybeConnectionError for Error { fn is_connection_error(&self) -> bool { match *self { - Error::RpcError(RpcError::Transport(_)) | - Error::RpcError(RpcError::RestartNeeded(_)) | + Error::ChannelError(_) => true, + Error::RpcError(ref e) => + matches!(*e, RpcError::Transport(_) | RpcError::RestartNeeded(_),), Error::ClientNotSynced(_) => true, - Error::FailedToReadBestFinalizedHeaderHash { ref error, .. } => - error.is_connection_error(), - Error::FailedToReadBestHeader { ref error, .. } => error.is_connection_error(), - Error::FailedToReadHeaderByHash { ref error, .. } => error.is_connection_error(), - Error::ErrorExecutingRuntimeCall { ref error, .. } => error.is_connection_error(), - Error::FailedToReadRuntimeStorageValue { ref error, .. } => error.is_connection_error(), - _ => false, + Error::UnorderedFinalizedHeaders { .. } => true, + _ => self.nested().map(|e| e.is_connection_error()).unwrap_or(false), } } } diff --git a/bridges/relays/client-substrate/src/guard.rs b/bridges/relays/client-substrate/src/guard.rs index 47454892cd039f40e92a8f25db435698360bde9b..3dbf95bff8e10de452992a0f3d42befbe058dd74 100644 --- a/bridges/relays/client-substrate/src/guard.rs +++ b/bridges/relays/client-substrate/src/guard.rs @@ -98,7 +98,7 @@ fn conditions_check_delay() -> Duration { } #[async_trait] -impl Environment for Client { +impl> Environment for Clnt { type Error = Error; async fn runtime_version(&mut self) -> Result { diff --git a/bridges/relays/client-substrate/src/lib.rs b/bridges/relays/client-substrate/src/lib.rs index d5b8d4dcced2d8b2e1883b6779905c536eec49f1..12a1c48c09c7ad59d05c0e40a578bc71f7575b35 100644 --- a/bridges/relays/client-substrate/src/lib.rs +++ b/bridges/relays/client-substrate/src/lib.rs @@ -21,7 +21,6 @@ mod chain; mod client; mod error; -mod rpc; mod sync_header; mod transaction_tracker; @@ -37,14 +36,15 @@ pub use crate::{ AccountKeyPairOf, BlockWithJustification, CallOf, Chain, ChainWithBalances, ChainWithGrandpa, ChainWithMessages, ChainWithRuntimeVersion, ChainWithTransactions, ChainWithUtilityPallet, FullRuntimeUtilityPallet, MockedRuntimeUtilityPallet, Parachain, - RelayChain, SignParam, TransactionStatusOf, UnsignedTransaction, UtilityPallet, + RelayChain, SignParam, SignedBlockOf, TransactionStatusOf, UnsignedTransaction, + UtilityPallet, }, client::{ - is_ancient_block, ChainRuntimeVersion, Client, OpaqueGrandpaAuthoritiesSet, - SimpleRuntimeVersion, Subscription, ANCIENT_BLOCK_THRESHOLD, + is_ancient_block, rpc_with_caching as new, ChainRuntimeVersion, Client, + OpaqueGrandpaAuthoritiesSet, RpcWithCachingClient, SimpleRuntimeVersion, StreamDescription, + Subscription, ANCIENT_BLOCK_THRESHOLD, }, error::{Error, Result}, - rpc::{SubstrateBeefyFinalityClient, SubstrateFinalityClient, SubstrateGrandpaFinalityClient}, sync_header::SyncHeader, transaction_tracker::TransactionTracker, }; diff --git a/bridges/relays/client-substrate/src/metrics/float_storage_value.rs b/bridges/relays/client-substrate/src/metrics/float_storage_value.rs index 7bb92693b38d27f42b623d323ba3e7ced8ebbda2..27c9d8cd7a8b68d4ad04ff4ab00f89f408f96a28 100644 --- a/bridges/relays/client-substrate/src/metrics/float_storage_value.rs +++ b/bridges/relays/client-substrate/src/metrics/float_storage_value.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Parity Bridges Common. If not, see . -use crate::{chain::Chain, client::Client, Error as SubstrateError}; +use crate::{Chain, Client, Error as SubstrateError}; use async_std::sync::{Arc, RwLock}; use async_trait::async_trait; @@ -66,20 +66,20 @@ impl FloatStorageValue for FixedU128OrOne { /// Metric that represents fixed-point runtime storage value as float gauge. #[derive(Clone, Debug)] -pub struct FloatStorageValueMetric { +pub struct FloatStorageValueMetric { value_converter: V, - client: Client, + client: Clnt, storage_key: StorageKey, metric: Gauge, shared_value_ref: F64SharedRef, - _phantom: PhantomData, + _phantom: PhantomData<(C, V)>, } -impl FloatStorageValueMetric { +impl FloatStorageValueMetric { /// Create new metric. pub fn new( value_converter: V, - client: Client, + client: Clnt, storage_key: StorageKey, name: String, help: String, @@ -101,32 +101,39 @@ impl FloatStorageValueMetric { } } -impl Metric for FloatStorageValueMetric { +impl, V: FloatStorageValue> Metric + for FloatStorageValueMetric +{ fn register(&self, registry: &Registry) -> Result<(), PrometheusError> { register(self.metric.clone(), registry).map(drop) } } #[async_trait] -impl StandaloneMetric for FloatStorageValueMetric { +impl, V: FloatStorageValue> StandaloneMetric + for FloatStorageValueMetric +{ fn update_interval(&self) -> Duration { C::AVERAGE_BLOCK_INTERVAL * UPDATE_INTERVAL_IN_BLOCKS } async fn update(&self) { - let value = self - .client - .raw_storage_value(self.storage_key.clone(), None) - .await - .and_then(|maybe_storage_value| { - self.value_converter.decode(maybe_storage_value).map(|maybe_fixed_point_value| { - maybe_fixed_point_value.map(|fixed_point_value| { - fixed_point_value.into_inner().unique_saturated_into() as f64 / - V::Value::DIV.unique_saturated_into() as f64 - }) + let value = async move { + let best_header_hash = self.client.best_header_hash().await?; + let maybe_storage_value = self + .client + .raw_storage_value(best_header_hash, self.storage_key.clone()) + .await?; + self.value_converter.decode(maybe_storage_value).map(|maybe_fixed_point_value| { + maybe_fixed_point_value.map(|fixed_point_value| { + fixed_point_value.into_inner().unique_saturated_into() as f64 / + V::Value::DIV.unique_saturated_into() as f64 }) }) - .map_err(|e| e.to_string()); + } + .await + .map_err(|e| e.to_string()); + relay_utils::metrics::set_gauge_value(&self.metric, value.clone()); *self.shared_value_ref.write().await = value.ok().and_then(|x| x); } diff --git a/bridges/relays/client-substrate/src/test_chain.rs b/bridges/relays/client-substrate/src/test_chain.rs index cfd241c022a269da799e8e03c4398566d98a14a0..991202e9874c790e404b42b74102248cb5f6723f 100644 --- a/bridges/relays/client-substrate/src/test_chain.rs +++ b/bridges/relays/client-substrate/src/test_chain.rs @@ -24,7 +24,7 @@ use crate::{Chain, ChainWithBalances, ChainWithMessages}; use bp_messages::{ChainWithMessages as ChainWithMessagesBase, MessageNonce}; use bp_runtime::ChainId; -use frame_support::weights::Weight; +use frame_support::{sp_runtime::StateVersion, weights::Weight}; use std::time::Duration; /// Chain that may be used in tests. @@ -44,6 +44,8 @@ impl bp_runtime::Chain for TestChain { type Nonce = u32; type Signature = sp_runtime::testing::TestSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { 100000 } @@ -100,6 +102,8 @@ impl bp_runtime::Chain for TestParachainBase { type Nonce = u32; type Signature = sp_runtime::testing::TestSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { unreachable!() } diff --git a/bridges/relays/client-substrate/src/transaction_tracker.rs b/bridges/relays/client-substrate/src/transaction_tracker.rs index 00375768c45c27c23dfccb7730668108a6fab788..b4801c89f51e1b1d9fd31373cdafb5b4770037cc 100644 --- a/bridges/relays/client-substrate/src/transaction_tracker.rs +++ b/bridges/relays/client-substrate/src/transaction_tracker.rs @@ -16,7 +16,7 @@ //! Helper for tracking transaction invalidation events. -use crate::{Chain, Client, Error, HashOf, HeaderIdOf, Subscription, TransactionStatusOf}; +use crate::{Chain, Error, HashOf, HeaderIdOf, Subscription, TransactionStatusOf}; use async_trait::async_trait; use futures::{future::Either, Future, FutureExt, Stream, StreamExt}; @@ -31,8 +31,10 @@ pub trait Environment: Send + Sync { async fn header_id_by_hash(&self, hash: HashOf) -> Result, Error>; } +// TODO (https://github.com/paritytech/parity-bridges-common/issues/2133): remove `Environment` trait +// after test client is implemented #[async_trait] -impl Environment for Client { +impl> Environment for T { async fn header_id_by_hash(&self, hash: HashOf) -> Result, Error> { self.header_by_hash(hash).await.map(|h| HeaderId(*h.number(), hash)) } @@ -76,6 +78,21 @@ impl> TransactionTracker { Self { environment, stall_timeout, transaction_hash, subscription } } + // TODO (https://github.com/paritytech/parity-bridges-common/issues/2133): remove me after + // test client is implemented + /// Converts self into tracker with different environment. + pub fn switch_environment>( + self, + environment: NewE, + ) -> TransactionTracker { + TransactionTracker { + environment, + stall_timeout: self.stall_timeout, + transaction_hash: self.transaction_hash, + subscription: self.subscription, + } + } + /// Wait for final transaction status and return it along with last known internal invalidation /// status. async fn do_wait( @@ -88,7 +105,7 @@ impl> TransactionTracker { let wait_for_invalidation = watch_transaction_status::<_, C, _>( self.environment, self.transaction_hash, - self.subscription.into_stream(), + self.subscription, ); futures::pin_mut!(wait_for_stall_timeout, wait_for_invalidation); @@ -284,7 +301,7 @@ async fn watch_transaction_status< #[cfg(test)] mod tests { use super::*; - use crate::test_chain::TestChain; + use crate::{test_chain::TestChain, StreamDescription}; use futures::{FutureExt, SinkExt}; use sc_transaction_pool_api::TransactionStatus; @@ -311,16 +328,22 @@ mod tests { TestEnvironment(Ok(HeaderId(0, Default::default()))), Duration::from_secs(0), Default::default(), - Subscription(async_std::sync::Mutex::new(receiver)), + Subscription::new_forwarded( + StreamDescription::new("test".into(), "test".into()), + receiver, + ), ); - let wait_for_stall_timeout = futures::future::pending(); + // we can't do `.now_or_never()` on `do_wait()` call, because `Subscription` has its own + // background thread, which may cause additional async task switches => let's leave some + // relatively small timeout here + let wait_for_stall_timeout = async_std::task::sleep(std::time::Duration::from_millis(100)); let wait_for_stall_timeout_rest = futures::future::ready(()); - sender.send(Some(status)).await.unwrap(); - tx_tracker - .do_wait(wait_for_stall_timeout, wait_for_stall_timeout_rest) - .now_or_never() - .map(|(ts, is)| (ts, is.unwrap())) + sender.send(Ok(status)).await.unwrap(); + + let (ts, is) = + tx_tracker.do_wait(wait_for_stall_timeout, wait_for_stall_timeout_rest).await; + is.map(|is| (ts, is)) } #[async_std::test] @@ -433,7 +456,10 @@ mod tests { TestEnvironment(Ok(HeaderId(0, Default::default()))), Duration::from_secs(0), Default::default(), - Subscription(async_std::sync::Mutex::new(receiver)), + Subscription::new_forwarded( + StreamDescription::new("test".into(), "test".into()), + receiver, + ), ); let wait_for_stall_timeout = futures::future::ready(()).shared(); diff --git a/bridges/relays/equivocation/Cargo.toml b/bridges/relays/equivocation/Cargo.toml index 5a067b62e0774ffb93e8b935ed287696e1fefd7c..09bdda23f2c25edabc5c4adbf6fa6739b99ddeef 100644 --- a/bridges/relays/equivocation/Cargo.toml +++ b/bridges/relays/equivocation/Cargo.toml @@ -12,12 +12,12 @@ publish = false workspace = true [dependencies] -async-std = { version = "1.9.0", features = ["attributes"] } -async-trait = "0.1.79" -bp-header-chain = { path = "../../primitives/header-chain" } -finality-relay = { path = "../finality" } -frame-support = { path = "../../../substrate/frame/support" } -futures = "0.3.30" +async-std = { features = ["attributes"], workspace = true } +async-trait = { workspace = true } +bp-header-chain = { workspace = true, default-features = true } +finality-relay = { workspace = true } +frame-support = { workspace = true, default-features = true } +futures = { workspace = true } log = { workspace = true } -num-traits = "0.2" -relay-utils = { path = "../utils" } +num-traits = { workspace = true, default-features = true } +relay-utils = { workspace = true } diff --git a/bridges/relays/finality/Cargo.toml b/bridges/relays/finality/Cargo.toml index 5ee4b10fa638f5ec226df14beca1e0c79d0055df..06c4a5dcc43e0d54410424a85e2ff72dbbf24729 100644 --- a/bridges/relays/finality/Cargo.toml +++ b/bridges/relays/finality/Cargo.toml @@ -12,14 +12,14 @@ publish = false workspace = true [dependencies] -async-std = "1.9.0" -async-trait = "0.1.79" -backoff = "0.4" -bp-header-chain = { path = "../../primitives/header-chain" } -futures = "0.3.30" +async-std = { workspace = true } +async-trait = { workspace = true } +backoff = { workspace = true } +bp-header-chain = { workspace = true, default-features = true } +futures = { workspace = true } log = { workspace = true } -num-traits = "0.2" -relay-utils = { path = "../utils" } +num-traits = { workspace = true, default-features = true } +relay-utils = { workspace = true } [dev-dependencies] -parking_lot = "0.12.1" +parking_lot = { workspace = true, default-features = true } diff --git a/bridges/relays/finality/src/base.rs b/bridges/relays/finality/src/base.rs index 4253468eaace1ef2a2adc47790f7e16c38160200..8704bff95494a88274f0e78f5df53aa15708cccf 100644 --- a/bridges/relays/finality/src/base.rs +++ b/bridges/relays/finality/src/base.rs @@ -45,7 +45,3 @@ pub trait SourceClientBase: RelayClient { /// Subscribe to new finality proofs. async fn finality_proofs(&self) -> Result; } - -/// Target client used in finality related loops. -#[async_trait] -pub trait TargetClientBase: RelayClient {} diff --git a/bridges/relays/lib-substrate-relay/Cargo.toml b/bridges/relays/lib-substrate-relay/Cargo.toml index 3f657645b591c51ab74c5b6b64bfdd8ca04e7b18..b0f93e5b5485f24b230b9b2868c6301b6ed64181 100644 --- a/bridges/relays/lib-substrate-relay/Cargo.toml +++ b/bridges/relays/lib-substrate-relay/Cargo.toml @@ -11,52 +11,50 @@ publish = false workspace = true [dependencies] -anyhow = "1.0" -async-std = "1.9.0" -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" -hex = "0.4" +anyhow = { workspace = true } +async-std = { workspace = true } +async-trait = { workspace = true } +codec = { workspace = true, default-features = true } +futures = { workspace = true } +hex = { workspace = true, default-features = true } log = { workspace = true } -num-traits = "0.2" -rbtag = "0.3" -structopt = "0.3" -strum = { version = "0.26.2", features = ["derive"] } +num-traits = { workspace = true, default-features = true } +rbtag = { workspace = true } +structopt = { workspace = true } +strum = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } # Bridge dependencies +bp-header-chain = { workspace = true, default-features = true } +bp-parachains = { workspace = true, default-features = true } +bp-polkadot-core = { workspace = true, default-features = true } +bp-relayers = { workspace = true, default-features = true } -bp-header-chain = { path = "../../primitives/header-chain" } -bp-parachains = { path = "../../primitives/parachains" } -bp-polkadot-core = { path = "../../primitives/polkadot-core" } -bp-relayers = { path = "../../primitives/relayers" } -bridge-runtime-common = { path = "../../bin/runtime-common" } +equivocation-detector = { workspace = true } +finality-relay = { workspace = true } +parachains-relay = { workspace = true } +relay-utils = { workspace = true } +messages-relay = { workspace = true } +relay-substrate-client = { workspace = true } -equivocation-detector = { path = "../equivocation" } -finality-grandpa = { version = "0.16.2" } -finality-relay = { path = "../finality" } -parachains-relay = { path = "../parachains" } -relay-utils = { path = "../utils" } -messages-relay = { path = "../messages" } -relay-substrate-client = { path = "../client-substrate" } +pallet-bridge-grandpa = { workspace = true, default-features = true } +pallet-bridge-messages = { workspace = true, default-features = true } +pallet-bridge-parachains = { workspace = true, default-features = true } -pallet-bridge-grandpa = { path = "../../modules/grandpa" } -pallet-bridge-messages = { path = "../../modules/messages" } -pallet-bridge-parachains = { path = "../../modules/parachains" } - -bp-runtime = { path = "../../primitives/runtime" } -bp-messages = { path = "../../primitives/messages" } +bp-runtime = { workspace = true, default-features = true } +bp-messages = { workspace = true, default-features = true } # Substrate Dependencies - -frame-support = { path = "../../../substrate/frame/support" } -frame-system = { path = "../../../substrate/frame/system" } -pallet-balances = { path = "../../../substrate/frame/balances" } -pallet-grandpa = { path = "../../../substrate/frame/grandpa" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } +frame-support = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-grandpa = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-trie = { workspace = true } [dev-dependencies] -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment" } -relay-substrate-client = { path = "../client-substrate", features = ["test-helpers"] } +scale-info = { features = ["derive"], workspace = true } +pallet-transaction-payment = { workspace = true, default-features = true } +relay-substrate-client = { features = ["test-helpers"], workspace = true } diff --git a/bridges/relays/lib-substrate-relay/src/cli/bridge.rs b/bridges/relays/lib-substrate-relay/src/cli/bridge.rs index 316f59a2b0c86e1bc78c1446bb69a90b0b0bf0f7..5631285b3c544de0e3caf85a6b74b7ee31601c56 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/bridge.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/bridge.rs @@ -19,7 +19,7 @@ use crate::{ equivocation::SubstrateEquivocationDetectionPipeline, finality::SubstrateFinalitySyncPipeline, - messages_lane::{MessagesRelayLimits, SubstrateMessageLane}, + messages::{MessagesRelayLimits, SubstrateMessageLane}, parachains::SubstrateParachainsPipeline, }; use pallet_bridge_parachains::{RelayBlockHash, RelayBlockHasher, RelayBlockNumber}; diff --git a/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs b/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs index 6246bdbf015152fe0e82ac0a8287692df6a1ace9..d985d35c9e802e694e74264ed3f611f14e8bc0d2 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/chain_schema.rs @@ -123,11 +123,11 @@ macro_rules! declare_chain_connection_params_cli_schema { #[allow(dead_code)] pub async fn into_client( self, - ) -> anyhow::Result> { + ) -> anyhow::Result<$crate::cli::DefaultClient> { let chain_runtime_version = self .[<$chain_prefix _runtime_version>] .into_runtime_version(Chain::RUNTIME_VERSION)?; - Ok(relay_substrate_client::Client::new(relay_substrate_client::ConnectionParams { + Ok(relay_substrate_client::new(relay_substrate_client::ConnectionParams { uri: self.[<$chain_prefix _uri>], host: self.[<$chain_prefix _host>], port: self.[<$chain_prefix _port>], diff --git a/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs b/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs index b98e41b2a43e4f88670ac8ed1d7129a0187fecfe..3921685d9e8ad70a9173a87ef19fb567c9263a63 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/detect_equivocations.rs @@ -23,7 +23,7 @@ use crate::{ }; use async_trait::async_trait; -use relay_substrate_client::ChainWithTransactions; +use relay_substrate_client::{ChainWithTransactions, Client}; use structopt::StructOpt; /// Start equivocation detection loop. diff --git a/bridges/relays/lib-substrate-relay/src/cli/mod.rs b/bridges/relays/lib-substrate-relay/src/cli/mod.rs index 0dd0d5474b3a517b7eb67b641a5d3b427cad2b84..ddb3e416dc32628b5a85f27f322d0568cbee1c10 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/mod.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/mod.rs @@ -35,6 +35,11 @@ pub mod relay_parachains; /// The target that will be used when publishing logs related to this pallet. pub const LOG_TARGET: &str = "bridge"; +/// Default Substrate client type that we are using. We'll use it all over the glue CLI code +/// to avoid multiple level generic arguments and constraints. We still allow usage of other +/// clients in the **core logic code**. +pub type DefaultClient = relay_substrate_client::RpcWithCachingClient; + /// Lane id. #[derive(Debug, Clone, PartialEq, Eq)] pub struct HexLaneId(pub [u8; 4]); @@ -125,14 +130,13 @@ impl PrometheusParams { None }; - let relay_version = option_env!("CARGO_PKG_VERSION").unwrap_or("unknown"); + let relay_version = relay_utils::initialize::RELAYER_VERSION + .lock() + .clone() + .unwrap_or_else(|| "unknown".to_string()); let relay_commit = SubstrateRelayBuildInfo::get_git_commit(); - relay_utils::metrics::MetricsParams::new( - metrics_address, - relay_version.into(), - relay_commit, - ) - .map_err(|e| anyhow::format_err!("{:?}", e)) + relay_utils::metrics::MetricsParams::new(metrics_address, relay_version, relay_commit) + .map_err(|e| anyhow::format_err!("{:?}", e)) } } diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs index 093f98ef21ed24b40a0c2d8f217d84b841137a69..ea92a0c9acce15a7f5000d0dd7e0253bbafc7844 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers.rs @@ -29,6 +29,7 @@ use crate::{ finality::SubstrateFinalitySyncPipeline, HeadersToRelay, }; +use relay_substrate_client::Client; /// Chain headers relaying params. #[derive(StructOpt)] diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs index a796df6721b8c8afd7f401f92e2fca6afcb41b02..338dda3c63309acbefd2616d052ae5dc4bf1d1e0 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/mod.rs @@ -37,8 +37,8 @@ use structopt::StructOpt; use futures::{FutureExt, TryFutureExt}; use crate::{ - cli::{bridge::MessagesCliBridge, HexLaneId, PrometheusParams}, - messages_lane::{MessagesRelayLimits, MessagesRelayParams}, + cli::{bridge::MessagesCliBridge, DefaultClient, HexLaneId, PrometheusParams}, + messages::{MessagesRelayLimits, MessagesRelayParams}, on_demand::OnDemandRelay, HeadersToRelay, TaggedAccount, TransactionParams, }; @@ -46,7 +46,7 @@ use bp_messages::LaneId; use bp_runtime::BalanceOf; use relay_substrate_client::{ AccountIdOf, AccountKeyPairOf, Chain, ChainWithBalances, ChainWithMessages, - ChainWithRuntimeVersion, ChainWithTransactions, Client, + ChainWithRuntimeVersion, ChainWithTransactions, }; use relay_utils::metrics::MetricsParams; use sp_core::Pair; @@ -118,7 +118,7 @@ impl< /// Parameters that are associated with one side of the bridge. pub struct BridgeEndCommonParams { /// Chain client. - pub client: Client, + pub client: DefaultClient, /// Params used for sending transactions to the chain. pub tx_params: TransactionParams>, /// Accounts, which balances are exposed as metrics by the relay process. @@ -165,7 +165,7 @@ where target_to_source_headers_relay: Arc>, lane_id: LaneId, maybe_limits: Option, - ) -> MessagesRelayParams { + ) -> MessagesRelayParams, DefaultClient> { MessagesRelayParams { source_client: self.source.client.clone(), source_transaction_params: self.source.tx_params.clone(), @@ -298,14 +298,14 @@ where .collect::>(); { let common = self.mut_base().mut_common(); - crate::messages_metrics::add_relay_balances_metrics::<_, Self::Right>( + crate::messages::metrics::add_relay_balances_metrics::<_, Self::Right>( common.left.client.clone(), &common.metrics_params, &common.left.accounts, &lanes, ) .await?; - crate::messages_metrics::add_relay_balances_metrics::<_, Self::Left>( + crate::messages::metrics::add_relay_balances_metrics::<_, Self::Left>( common.right.client.clone(), &common.metrics_params, &common.right.accounts, @@ -317,28 +317,30 @@ where // Need 2x capacity since we consider both directions for each lane let mut message_relays = Vec::with_capacity(lanes.len() * 2); for lane in lanes { - let left_to_right_messages = crate::messages_lane::run::< - ::MessagesLane, - >(self.left_to_right().messages_relay_params( - left_to_right_on_demand_headers.clone(), - right_to_left_on_demand_headers.clone(), - lane, - Self::L2R::maybe_messages_limits(), - )) - .map_err(|e| anyhow::format_err!("{}", e)) - .boxed(); + let left_to_right_messages = + crate::messages::run::<::MessagesLane, _, _>( + self.left_to_right().messages_relay_params( + left_to_right_on_demand_headers.clone(), + right_to_left_on_demand_headers.clone(), + lane, + Self::L2R::maybe_messages_limits(), + ), + ) + .map_err(|e| anyhow::format_err!("{}", e)) + .boxed(); message_relays.push(left_to_right_messages); - let right_to_left_messages = crate::messages_lane::run::< - ::MessagesLane, - >(self.right_to_left().messages_relay_params( - right_to_left_on_demand_headers.clone(), - left_to_right_on_demand_headers.clone(), - lane, - Self::R2L::maybe_messages_limits(), - )) - .map_err(|e| anyhow::format_err!("{}", e)) - .boxed(); + let right_to_left_messages = + crate::messages::run::<::MessagesLane, _, _>( + self.right_to_left().messages_relay_params( + right_to_left_on_demand_headers.clone(), + left_to_right_on_demand_headers.clone(), + lane, + Self::R2L::maybe_messages_limits(), + ), + ) + .map_err(|e| anyhow::format_err!("{}", e)) + .boxed(); message_relays.push(right_to_left_messages); } diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs index 7f6f40777823679c97577f1244eb9a860948d267..8104be7af807a67bbc001e70e24565c81b6beb17 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/parachain_to_parachain.rs @@ -23,6 +23,7 @@ use crate::{ cli::{ bridge::{CliBridgeBase, MessagesCliBridge, ParachainToRelayHeadersCliBridge}, relay_headers_and_messages::{Full2WayBridgeBase, Full2WayBridgeCommonParams}, + DefaultClient, }, finality::SubstrateFinalitySyncPipeline, on_demand::{ @@ -52,9 +53,9 @@ pub struct ParachainToParachainBridge< pub common: Full2WayBridgeCommonParams<::Target, ::Target>, /// Client of the left relay chain. - pub left_relay: Client<::SourceRelay>, + pub left_relay: DefaultClient<::SourceRelay>, /// Client of the right relay chain. - pub right_relay: Client<::SourceRelay>, + pub right_relay: DefaultClient<::SourceRelay>, } /// Create set of configuration objects specific to parachain-to-parachain relayer. @@ -175,25 +176,33 @@ where ) .await?; - let left_relay_to_right_on_demand_headers = - OnDemandHeadersRelay::<::RelayFinality>::new( - self.left_relay.clone(), - self.common.right.client.clone(), - self.common.right.tx_params.clone(), - self.common.shared.headers_to_relay(), - Some(self.common.metrics_params.clone()), - ); - let right_relay_to_left_on_demand_headers = - OnDemandHeadersRelay::<::RelayFinality>::new( - self.right_relay.clone(), - self.common.left.client.clone(), - self.common.left.tx_params.clone(), - self.common.shared.headers_to_relay(), - Some(self.common.metrics_params.clone()), - ); + let left_relay_to_right_on_demand_headers = OnDemandHeadersRelay::< + ::RelayFinality, + _, + _, + >::new( + self.left_relay.clone(), + self.common.right.client.clone(), + self.common.right.tx_params.clone(), + self.common.shared.headers_to_relay(), + Some(self.common.metrics_params.clone()), + ); + let right_relay_to_left_on_demand_headers = OnDemandHeadersRelay::< + ::RelayFinality, + _, + _, + >::new( + self.right_relay.clone(), + self.common.left.client.clone(), + self.common.left.tx_params.clone(), + self.common.shared.headers_to_relay(), + Some(self.common.metrics_params.clone()), + ); let left_to_right_on_demand_parachains = OnDemandParachainsRelay::< ::ParachainFinality, + _, + _, >::new( self.left_relay.clone(), self.common.right.client.clone(), @@ -202,6 +211,8 @@ where ); let right_to_left_on_demand_parachains = OnDemandParachainsRelay::< ::ParachainFinality, + _, + _, >::new( self.right_relay.clone(), self.common.left.client.clone(), diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs index 5911fe49df4adfc955cbab4d142998fbc7ed4d22..6c078973fedc08a724e51808f2cb47f3a64ca1a1 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_parachain.rs @@ -26,6 +26,7 @@ use crate::{ RelayToRelayHeadersCliBridge, }, relay_headers_and_messages::{Full2WayBridgeBase, Full2WayBridgeCommonParams}, + DefaultClient, }, finality::SubstrateFinalitySyncPipeline, on_demand::{ @@ -54,7 +55,7 @@ pub struct RelayToParachainBridge< pub common: Full2WayBridgeCommonParams<::Target, ::Target>, /// Client of the right relay chain. - pub right_relay: Client<::SourceRelay>, + pub right_relay: DefaultClient<::SourceRelay>, } /// Create set of configuration objects specific to relay-to-parachain relayer. @@ -167,23 +168,28 @@ where .await?; let left_to_right_on_demand_headers = - OnDemandHeadersRelay::<::Finality>::new( + OnDemandHeadersRelay::<::Finality, _, _>::new( self.common.left.client.clone(), self.common.right.client.clone(), self.common.right.tx_params.clone(), self.common.shared.headers_to_relay(), None, ); - let right_relay_to_left_on_demand_headers = - OnDemandHeadersRelay::<::RelayFinality>::new( - self.right_relay.clone(), - self.common.left.client.clone(), - self.common.left.tx_params.clone(), - self.common.shared.headers_to_relay(), - Some(self.common.metrics_params.clone()), - ); + let right_relay_to_left_on_demand_headers = OnDemandHeadersRelay::< + ::RelayFinality, + _, + _, + >::new( + self.right_relay.clone(), + self.common.left.client.clone(), + self.common.left.tx_params.clone(), + self.common.shared.headers_to_relay(), + Some(self.common.metrics_params.clone()), + ); let right_to_left_on_demand_parachains = OnDemandParachainsRelay::< ::ParachainFinality, + _, + _, >::new( self.right_relay.clone(), self.common.left.client.clone(), diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs index 832df4ae4003ced1715d7b9d495989d9163417d5..3f8c8bb40c99c7218cdc69a2524ec5dd113e621f 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_headers_and_messages/relay_to_relay.rs @@ -32,7 +32,7 @@ use crate::{ on_demand::{headers::OnDemandHeadersRelay, OnDemandRelay}, }; use relay_substrate_client::{ - AccountIdOf, AccountKeyPairOf, ChainWithRuntimeVersion, ChainWithTransactions, + AccountIdOf, AccountKeyPairOf, ChainWithRuntimeVersion, ChainWithTransactions, Client, }; use sp_core::Pair; @@ -148,7 +148,7 @@ where .await?; let left_to_right_on_demand_headers = - OnDemandHeadersRelay::<::Finality>::new( + OnDemandHeadersRelay::<::Finality, _, _>::new( self.common.left.client.clone(), self.common.right.client.clone(), self.common.right.tx_params.clone(), @@ -156,7 +156,7 @@ where None, ); let right_to_left_on_demand_headers = - OnDemandHeadersRelay::<::Finality>::new( + OnDemandHeadersRelay::<::Finality, _, _>::new( self.common.right.client.clone(), self.common.left.client.clone(), self.common.left.tx_params.clone(), diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs index b672bd4f9b86812c87532012debb89e0a601451f..68bbe71ae599c901bdf7a9b6e55cf93c020adbb6 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_messages.rs @@ -18,7 +18,7 @@ use crate::{ cli::{bridge::*, chain_schema::*, HexLaneId, PrometheusParams}, - messages_lane::MessagesRelayParams, + messages::MessagesRelayParams, TransactionParams, }; @@ -26,9 +26,13 @@ use async_trait::async_trait; use sp_core::Pair; use structopt::StructOpt; +use bp_messages::MessageNonce; +use bp_runtime::HeaderIdProvider; use relay_substrate_client::{ - AccountIdOf, AccountKeyPairOf, BalanceOf, ChainWithRuntimeVersion, ChainWithTransactions, + AccountIdOf, AccountKeyPairOf, BalanceOf, Chain, ChainWithRuntimeVersion, + ChainWithTransactions, Client, }; +use relay_utils::UniqueSaturatedInto; /// Messages relaying params. #[derive(StructOpt)] @@ -48,6 +52,53 @@ pub struct RelayMessagesParams { prometheus_params: PrometheusParams, } +/// Messages range relaying params. +#[derive(StructOpt)] +pub struct RelayMessagesRangeParams { + /// Number of the source chain header that we will use to prepare a messages proof. + /// This header must be previously proved to the target chain. + #[structopt(long)] + at_source_block: u128, + /// Hex-encoded lane id that should be served by the relay. Defaults to `00000000`. + #[structopt(long, default_value = "00000000")] + lane: HexLaneId, + /// Nonce (inclusive) of the first message to relay. + #[structopt(long)] + messages_start: MessageNonce, + /// Nonce (inclusive) of the last message to relay. + #[structopt(long)] + messages_end: MessageNonce, + /// Whether the outbound lane state proof should be included into transaction. + #[structopt(long)] + outbound_state_proof_required: bool, + #[structopt(flatten)] + source: SourceConnectionParams, + #[structopt(flatten)] + source_sign: SourceSigningParams, + #[structopt(flatten)] + target: TargetConnectionParams, + #[structopt(flatten)] + target_sign: TargetSigningParams, +} + +/// Messages delivery confirmation relaying params. +#[derive(StructOpt)] +pub struct RelayMessagesDeliveryConfirmationParams { + /// Number of the target chain header that we will use to prepare a messages + /// delivery proof. This header must be previously proved to the source chain. + #[structopt(long)] + at_target_block: u128, + /// Hex-encoded lane id that should be served by the relay. Defaults to `00000000`. + #[structopt(long, default_value = "00000000")] + lane: HexLaneId, + #[structopt(flatten)] + source: SourceConnectionParams, + #[structopt(flatten)] + source_sign: SourceSigningParams, + #[structopt(flatten)] + target: TargetConnectionParams, +} + /// Trait used for relaying messages between 2 chains. #[async_trait] pub trait MessagesRelayer: MessagesCliBridge @@ -66,7 +117,7 @@ where let target_sign = data.target_sign.to_keypair::()?; let target_transactions_mortality = data.target_sign.transactions_mortality()?; - crate::messages_lane::run::(MessagesRelayParams { + crate::messages::run::(MessagesRelayParams { source_client, source_transaction_params: TransactionParams { signer: source_sign, @@ -86,4 +137,73 @@ where .await .map_err(|e| anyhow::format_err!("{}", e)) } + + /// Relay a consequitive range of messages. + async fn relay_messages_range(data: RelayMessagesRangeParams) -> anyhow::Result<()> { + let source_client = data.source.into_client::().await?; + let target_client = data.target.into_client::().await?; + let source_sign = data.source_sign.to_keypair::()?; + let source_transactions_mortality = data.source_sign.transactions_mortality()?; + let target_sign = data.target_sign.to_keypair::()?; + let target_transactions_mortality = data.target_sign.transactions_mortality()?; + + let at_source_block = source_client + .header_by_number(data.at_source_block.unique_saturated_into()) + .await + .map_err(|e| { + log::trace!( + target: "bridge", + "Failed to read {} header with number {}: {e:?}", + Self::Source::NAME, + data.at_source_block, + ); + anyhow::format_err!("The command has failed") + })? + .id(); + + crate::messages::relay_messages_range::( + source_client, + target_client, + TransactionParams { signer: source_sign, mortality: source_transactions_mortality }, + TransactionParams { signer: target_sign, mortality: target_transactions_mortality }, + at_source_block, + data.lane.into(), + data.messages_start..=data.messages_end, + data.outbound_state_proof_required, + ) + .await + } + + /// Relay a messages delivery confirmation. + async fn relay_messages_delivery_confirmation( + data: RelayMessagesDeliveryConfirmationParams, + ) -> anyhow::Result<()> { + let source_client = data.source.into_client::().await?; + let target_client = data.target.into_client::().await?; + let source_sign = data.source_sign.to_keypair::()?; + let source_transactions_mortality = data.source_sign.transactions_mortality()?; + + let at_target_block = target_client + .header_by_number(data.at_target_block.unique_saturated_into()) + .await + .map_err(|e| { + log::trace!( + target: "bridge", + "Failed to read {} header with number {}: {e:?}", + Self::Target::NAME, + data.at_target_block, + ); + anyhow::format_err!("The command has failed") + })? + .id(); + + crate::messages::relay_messages_delivery_confirmation::( + source_client, + target_client, + TransactionParams { signer: source_sign, mortality: source_transactions_mortality }, + at_target_block, + data.lane.into(), + ) + .await + } } diff --git a/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs b/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs index 00f8cf79ef1fb54577954cf198e7296819591a43..77cd395ff7225e9a0d088cc35cf0f86ab78caf46 100644 --- a/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs +++ b/bridges/relays/lib-substrate-relay/src/cli/relay_parachains.rs @@ -21,7 +21,7 @@ use async_trait::async_trait; use bp_polkadot_core::BlockNumber as RelayBlockNumber; use bp_runtime::HeaderIdProvider; use parachains_relay::parachains_loop::{AvailableHeader, SourceClient, TargetClient}; -use relay_substrate_client::Parachain; +use relay_substrate_client::{Client, Parachain}; use relay_utils::metrics::{GlobalMetrics, StandaloneMetric}; use std::sync::Arc; use structopt::StructOpt; @@ -30,7 +30,7 @@ use crate::{ cli::{ bridge::{CliBridgeBase, ParachainToRelayHeadersCliBridge}, chain_schema::*, - PrometheusParams, + DefaultClient, PrometheusParams, }, parachains::{source::ParachainsSource, target::ParachainsTarget, ParachainsPipelineAdapter}, TransactionParams, @@ -72,16 +72,19 @@ pub struct RelayParachainHeadParams { #[async_trait] pub trait ParachainsRelayer: ParachainToRelayHeadersCliBridge where - ParachainsSource: + ParachainsSource>: SourceClient>, - ParachainsTarget: - TargetClient>, + ParachainsTarget< + Self::ParachainFinality, + DefaultClient, + DefaultClient, + >: TargetClient>, ::Source: Parachain, { /// Start relaying parachains finality. async fn relay_parachains(data: RelayParachainsParams) -> anyhow::Result<()> { let source_chain_client = data.source.into_client::().await?; - let source_client = ParachainsSource::::new( + let source_client = ParachainsSource::::new( source_chain_client.clone(), Arc::new(Mutex::new(AvailableHeader::Missing)), ); @@ -91,7 +94,7 @@ where mortality: data.target_sign.target_transactions_mortality, }; let target_chain_client = data.target.into_client::().await?; - let target_client = ParachainsTarget::::new( + let target_client = ParachainsTarget::::new( source_chain_client, target_chain_client, target_transaction_params, @@ -121,7 +124,7 @@ where .map_err(|e| anyhow::format_err!("{}", e))? .id(); - let source_client = ParachainsSource::::new( + let source_client = ParachainsSource::::new( source_chain_client.clone(), Arc::new(Mutex::new(AvailableHeader::Missing)), ); @@ -131,7 +134,7 @@ where mortality: data.target_sign.target_transactions_mortality, }; let target_chain_client = data.target.into_client::().await?; - let target_client = ParachainsTarget::::new( + let target_client = ParachainsTarget::::new( source_chain_client, target_chain_client, target_transaction_params, diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs b/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs index f6d58cbaa4ab4c4d7f489de5a80ab226b3b475b4..f8077923b82023cc640ddcf131f248ef141853a0 100644 --- a/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs +++ b/bridges/relays/lib-substrate-relay/src/equivocation/mod.rs @@ -69,7 +69,7 @@ pub trait SubstrateEquivocationDetectionPipeline: /// Add relay guards if required. async fn start_relay_guards( - source_client: &Client, + source_client: &impl Client, enable_version_guard: bool, ) -> relay_substrate_client::Result<()> { if enable_version_guard { @@ -199,8 +199,8 @@ macro_rules! generate_report_equivocation_call_builder { /// Run Substrate-to-Substrate equivocations detection loop. pub async fn run( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, source_transaction_params: TransactionParams>, metrics_params: MetricsParams, ) -> anyhow::Result<()> { @@ -212,8 +212,8 @@ pub async fn run( ); equivocation_detector::run( - SubstrateEquivocationSource::

::new(source_client, source_transaction_params), - SubstrateEquivocationTarget::

::new(target_client), + SubstrateEquivocationSource::::new(source_client, source_transaction_params), + SubstrateEquivocationTarget::::new(target_client), P::TargetChain::AVERAGE_BLOCK_INTERVAL, metrics_params, futures::future::pending(), diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/source.rs b/bridges/relays/lib-substrate-relay/src/equivocation/source.rs index a0c7dcf5cbc32c7e5a39de5acd53d92def24a22f..66d651600a1ec72943cb4d13c3e094c5be0a33e3 100644 --- a/bridges/relays/lib-substrate-relay/src/equivocation/source.rs +++ b/bridges/relays/lib-substrate-relay/src/equivocation/source.rs @@ -35,29 +35,35 @@ use relay_substrate_client::{ use relay_utils::relay_loop::Client as RelayClient; /// Substrate node as equivocation source. -pub struct SubstrateEquivocationSource { - client: Client, +pub struct SubstrateEquivocationSource { + client: SourceClnt, transaction_params: TransactionParams>, } -impl SubstrateEquivocationSource

{ +impl> + SubstrateEquivocationSource +{ /// Create new instance of `SubstrateEquivocationSource`. pub fn new( - client: Client, + client: SourceClnt, transaction_params: TransactionParams>, ) -> Self { Self { client, transaction_params } } } -impl Clone for SubstrateEquivocationSource

{ +impl> Clone + for SubstrateEquivocationSource +{ fn clone(&self) -> Self { Self { client: self.client.clone(), transaction_params: self.transaction_params.clone() } } } #[async_trait] -impl RelayClient for SubstrateEquivocationSource

{ +impl> RelayClient + for SubstrateEquivocationSource +{ type Error = Error; async fn reconnect(&mut self) -> Result<(), Error> { @@ -66,8 +72,9 @@ impl RelayClient for SubstrateEquivoc } #[async_trait] -impl - SourceClientBase> for SubstrateEquivocationSource

+impl> + SourceClientBase> + for SubstrateEquivocationSource { type FinalityProofsStream = SubstrateFinalityProofsStream

; @@ -77,10 +84,11 @@ impl } #[async_trait] -impl - SourceClient> for SubstrateEquivocationSource

+impl> + SourceClient> + for SubstrateEquivocationSource { - type TransactionTracker = TransactionTracker>; + type TransactionTracker = TransactionTracker; async fn report_equivocation( &self, diff --git a/bridges/relays/lib-substrate-relay/src/equivocation/target.rs b/bridges/relays/lib-substrate-relay/src/equivocation/target.rs index 6eee2ab91d45b033a77e30b7d05ae28b246b9735..7d054e843d0db6c09b5baec551c46bb9fbe0fc34 100644 --- a/bridges/relays/lib-substrate-relay/src/equivocation/target.rs +++ b/bridges/relays/lib-substrate-relay/src/equivocation/target.rs @@ -34,27 +34,33 @@ use sp_runtime::traits::Header; use std::marker::PhantomData; /// Substrate node as equivocation source. -pub struct SubstrateEquivocationTarget { - client: Client, +pub struct SubstrateEquivocationTarget { + client: TargetClnt, _phantom: PhantomData

, } -impl SubstrateEquivocationTarget

{ +impl> + SubstrateEquivocationTarget +{ /// Create new instance of `SubstrateEquivocationTarget`. - pub fn new(client: Client) -> Self { + pub fn new(client: TargetClnt) -> Self { Self { client, _phantom: Default::default() } } } -impl Clone for SubstrateEquivocationTarget

{ +impl> Clone + for SubstrateEquivocationTarget +{ fn clone(&self) -> Self { Self { client: self.client.clone(), _phantom: Default::default() } } } #[async_trait] -impl RelayClient for SubstrateEquivocationTarget

{ +impl> RelayClient + for SubstrateEquivocationTarget +{ type Error = Error; async fn reconnect(&mut self) -> Result<(), Error> { @@ -63,8 +69,9 @@ impl RelayClient for SubstrateEquivoc } #[async_trait] -impl - TargetClient> for SubstrateEquivocationTarget

+impl> + TargetClient> + for SubstrateEquivocationTarget { async fn best_finalized_header_number( &self, diff --git a/bridges/relays/lib-substrate-relay/src/finality/initialize.rs b/bridges/relays/lib-substrate-relay/src/finality/initialize.rs index 5dde46c39dd674e7c01eebba4b014bc999611eb5..a972f743e117ce280fb2dd5a950581713766a3b6 100644 --- a/bridges/relays/lib-substrate-relay/src/finality/initialize.rs +++ b/bridges/relays/lib-substrate-relay/src/finality/initialize.rs @@ -39,8 +39,8 @@ pub async fn initialize< TargetChain: ChainWithTransactions, F, >( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, target_signer: AccountKeyPairOf, prepare_initialize_transaction: F, dry_run: bool, @@ -101,8 +101,8 @@ async fn do_initialize< TargetChain: ChainWithTransactions, F, >( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, target_signer: AccountKeyPairOf, prepare_initialize_transaction: F, dry_run: bool, diff --git a/bridges/relays/lib-substrate-relay/src/finality/mod.rs b/bridges/relays/lib-substrate-relay/src/finality/mod.rs index 0293e1da224a6323fed59f7f727b5d5263391bb8..a2379eb4812e2ab7d904eff0ce9b082ac474d36e 100644 --- a/bridges/relays/lib-substrate-relay/src/finality/mod.rs +++ b/bridges/relays/lib-substrate-relay/src/finality/mod.rs @@ -77,7 +77,7 @@ pub trait SubstrateFinalitySyncPipeline: BaseSubstrateFinalitySyncPipeline { /// Add relay guards if required. async fn start_relay_guards( - target_client: &Client, + target_client: &impl Client, enable_version_guard: bool, ) -> relay_substrate_client::Result<()> { if enable_version_guard { @@ -240,8 +240,8 @@ macro_rules! generate_submit_finality_proof_ex_call_builder { /// Run Substrate-to-Substrate finality sync loop. pub async fn run( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, headers_to_relay: HeadersToRelay, transaction_params: TransactionParams>, metrics_params: MetricsParams, @@ -255,8 +255,8 @@ pub async fn run( ); finality_relay::run( - SubstrateFinalitySource::

::new(source_client, None), - SubstrateFinalityTarget::

::new(target_client, transaction_params.clone()), + SubstrateFinalitySource::::new(source_client, None), + SubstrateFinalityTarget::::new(target_client, transaction_params.clone()), finality_relay::FinalitySyncParams { tick: std::cmp::max( P::SourceChain::AVERAGE_BLOCK_INTERVAL, @@ -279,12 +279,12 @@ pub async fn run( /// Relay single header. No checks are made to ensure that transaction will succeed. pub async fn relay_single_header( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, transaction_params: TransactionParams>, header_number: BlockNumberOf, ) -> anyhow::Result<()> { - let finality_source = SubstrateFinalitySource::

::new(source_client, None); + let finality_source = SubstrateFinalitySource::::new(source_client, None); let (header, proof) = finality_source.header_and_finality_proof(header_number).await?; let Some(proof) = proof else { return Err(anyhow::format_err!( @@ -295,7 +295,7 @@ pub async fn relay_single_header( )); }; - let finality_target = SubstrateFinalityTarget::

::new(target_client, transaction_params); + let finality_target = SubstrateFinalityTarget::::new(target_client, transaction_params); let tx_tracker = finality_target.submit_finality_proof(header, proof, false).await?; match tx_tracker.wait().await { TrackedTransactionStatus::Finalized(_) => Ok(()), diff --git a/bridges/relays/lib-substrate-relay/src/finality/source.rs b/bridges/relays/lib-substrate-relay/src/finality/source.rs index c94af6108957a0d2d4b0b4079220be9c11a5a470..f6fa5c24add5066ab0c062a6966844b48be17ce8 100644 --- a/bridges/relays/lib-substrate-relay/src/finality/source.rs +++ b/bridges/relays/lib-substrate-relay/src/finality/source.rs @@ -40,22 +40,24 @@ use relay_utils::{relay_loop::Client as RelayClient, UniqueSaturatedInto}; pub type RequiredHeaderNumberRef = Arc::BlockNumber>>; /// Substrate node as finality source. -pub struct SubstrateFinalitySource { - client: Client, +pub struct SubstrateFinalitySource { + client: SourceClnt, maximal_header_number: Option>, } -impl SubstrateFinalitySource

{ +impl> + SubstrateFinalitySource +{ /// Create new headers source using given client. pub fn new( - client: Client, + client: SourceClnt, maximal_header_number: Option>, ) -> Self { SubstrateFinalitySource { client, maximal_header_number } } /// Returns reference to the underlying RPC client. - pub fn client(&self) -> &Client { + pub fn client(&self) -> &SourceClnt { &self.client } @@ -174,7 +176,9 @@ impl SubstrateFinalitySource

{ } } -impl Clone for SubstrateFinalitySource

{ +impl Clone + for SubstrateFinalitySource +{ fn clone(&self) -> Self { SubstrateFinalitySource { client: self.client.clone(), @@ -184,7 +188,9 @@ impl Clone for SubstrateFinalitySource

{ } #[async_trait] -impl RelayClient for SubstrateFinalitySource

{ +impl> RelayClient + for SubstrateFinalitySource +{ type Error = Error; async fn reconnect(&mut self) -> Result<(), Error> { @@ -193,8 +199,8 @@ impl RelayClient for SubstrateFinalitySource

SourceClientBase> - for SubstrateFinalitySource

+impl> + SourceClientBase> for SubstrateFinalitySource { type FinalityProofsStream = SubstrateFinalityProofsStream

; @@ -204,8 +210,8 @@ impl SourceClientBase SourceClient> - for SubstrateFinalitySource

+impl> + SourceClient> for SubstrateFinalitySource { async fn best_finalized_block_number(&self) -> Result, Error> { let mut finalized_header_number = self.on_chain_best_finalized_block_number().await?; @@ -235,7 +241,7 @@ impl SourceClient( - client: &Client, + client: &impl Client, number: BlockNumberOf, ) -> Result< ( @@ -244,8 +250,8 @@ async fn header_and_finality_proof( ), Error, > { - let header_hash = client.block_hash_by_number(number).await?; - let signed_block = client.get_block(Some(header_hash)).await?; + let header_hash = client.header_hash_by_number(number).await?; + let signed_block = client.block_by_hash(header_hash).await?; let justification = signed_block .justification(P::FinalityEngine::ID) diff --git a/bridges/relays/lib-substrate-relay/src/finality/target.rs b/bridges/relays/lib-substrate-relay/src/finality/target.rs index 0874fa53549c59f413a2f3f0c4f3dbc582fe0090..18b696685dd4e7122a7ff6a9f7d7cb2afd333f5f 100644 --- a/bridges/relays/lib-substrate-relay/src/finality/target.rs +++ b/bridges/relays/lib-substrate-relay/src/finality/target.rs @@ -28,22 +28,25 @@ use async_trait::async_trait; use bp_runtime::BlockNumberOf; use finality_relay::TargetClient; use relay_substrate_client::{ - AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SyncHeader, TransactionEra, - TransactionTracker, UnsignedTransaction, + AccountIdOf, AccountKeyPairOf, Chain, Client, Error, HeaderIdOf, HeaderOf, SyncHeader, + TransactionEra, TransactionTracker, UnsignedTransaction, }; use relay_utils::relay_loop::Client as RelayClient; +use sp_core::Pair; use sp_runtime::traits::Header; /// Substrate client as Substrate finality target. -pub struct SubstrateFinalityTarget { - client: Client, +pub struct SubstrateFinalityTarget { + client: TargetClnt, transaction_params: TransactionParams>, } -impl SubstrateFinalityTarget

{ +impl> + SubstrateFinalityTarget +{ /// Create new Substrate headers target. pub fn new( - client: Client, + client: TargetClnt, transaction_params: TransactionParams>, ) -> Self { SubstrateFinalityTarget { client, transaction_params } @@ -65,7 +68,9 @@ impl SubstrateFinalityTarget

{ } } -impl Clone for SubstrateFinalityTarget

{ +impl Clone + for SubstrateFinalityTarget +{ fn clone(&self) -> Self { SubstrateFinalityTarget { client: self.client.clone(), @@ -75,7 +80,9 @@ impl Clone for SubstrateFinalityTarget

{ } #[async_trait] -impl RelayClient for SubstrateFinalityTarget

{ +impl> RelayClient + for SubstrateFinalityTarget +{ type Error = Error; async fn reconnect(&mut self) -> Result<(), Error> { @@ -84,10 +91,12 @@ impl RelayClient for SubstrateFinalityTarget

TargetClient> - for SubstrateFinalityTarget

+impl> + TargetClient> for SubstrateFinalityTarget +where + AccountIdOf: From< as Pair>::Public>, { - type TransactionTracker = TransactionTracker>; + type TransactionTracker = TransactionTracker; async fn best_finalized_source_block_id(&self) -> Result, Error> { // we can't continue to relay finality if target node is out of sync, because @@ -109,10 +118,10 @@ impl TargetClient Result>, Self::Error> { Ok(self .client - .typed_state_call( + .state_call( + self.client.best_header().await?.hash(), P::SourceChain::FREE_HEADERS_INTERVAL_METHOD.into(), (), - Some(self.client.best_header().await?.hash()), ) .await .unwrap_or_else(|e| { @@ -137,6 +146,16 @@ impl TargetClient: Send { @@ -59,8 +46,6 @@ pub trait Engine: Send { const ID: ConsensusEngineId; /// A reader that can extract the consensus log from the header digest and interpret it. type ConsensusLogReader: ConsensusLogReader; - /// Type of Finality RPC client used by this engine. - type FinalityClient: SubstrateFinalityClient; /// Type of finality proofs, used by consensus engine. type FinalityProof: FinalityProof, BlockNumberOf> + Decode + Encode; /// The context needed for verifying finality proofs. @@ -88,10 +73,10 @@ pub trait Engine: Send { /// Returns `Ok(true)` if finality pallet at the bridged chain has already been initialized. async fn is_initialized( - target_client: &Client, + target_client: &impl Client, ) -> Result { Ok(target_client - .raw_storage_value(Self::is_initialized_key(), None) + .raw_storage_value(target_client.best_header_hash().await?, Self::is_initialized_key()) .await? .is_some()) } @@ -102,10 +87,13 @@ pub trait Engine: Send { /// Returns `Ok(true)` if finality pallet at the bridged chain is halted. async fn is_halted( - target_client: &Client, + target_client: &impl Client, ) -> Result { Ok(target_client - .storage_value::(Self::pallet_operating_mode_key(), None) + .storage_value::( + target_client.best_header_hash().await?, + Self::pallet_operating_mode_key(), + ) .await? .map(|operating_mode| operating_mode.is_halted()) .unwrap_or(false)) @@ -113,44 +101,41 @@ pub trait Engine: Send { /// A method to subscribe to encoded finality proofs, given source client. async fn source_finality_proofs( - source_client: &Client, - ) -> Result, SubstrateError> { - source_client.subscribe_finality_justifications::().await - } + source_client: &impl Client, + ) -> Result, SubstrateError>; /// Verify and optimize finality proof before sending it to the target node. /// /// Apart from optimization, we expect this method to perform all required checks /// that the `header` and `proof` are valid at the current state of the target chain. async fn verify_and_optimize_proof( - target_client: &Client, + target_client: &impl Client, header: &C::Header, proof: &mut Self::FinalityProof, ) -> Result; /// Checks whether the given `header` and its finality `proof` fit the maximal expected - /// call size limit. If result is `MaxExpectedCallSizeCheck::Exceeds { .. }`, this - /// submission won't be fully refunded and relayer will spend its own funds on that. - fn check_max_expected_call_size( + /// call limits (size and weight). + fn check_max_expected_call_limits( header: &C::Header, proof: &Self::FinalityProof, - ) -> MaxExpectedCallSizeCheck; + ) -> SubmitFinalityProofCallExtras; /// Prepare initialization data for the finality bridge pallet. async fn prepare_initialization_data( - client: Client, + client: impl Client, ) -> Result, BlockNumberOf>>; /// Get the context needed for validating a finality proof. async fn finality_verification_context( - target_client: &Client, + target_client: &impl Client, at: HashOf, ) -> Result; /// Returns the finality info associated to the source headers synced with the target /// at the provided block. async fn synced_headers_finality_info( - target_client: &Client, + target_client: &impl Client, at: TargetChain::Hash, ) -> Result< Vec>, @@ -159,7 +144,7 @@ pub trait Engine: Send { /// Generate key ownership proof for the provided equivocation. async fn generate_source_key_ownership_proof( - source_client: &Client, + source_client: &impl Client, at: C::Hash, equivocation: &Self::EquivocationProof, ) -> Result; @@ -171,7 +156,7 @@ pub struct Grandpa(PhantomData); impl Grandpa { /// Read header by hash from the source client. async fn source_header( - source_client: &Client, + source_client: &impl Client, header_hash: C::Hash, ) -> Result, BlockNumberOf>> { source_client @@ -182,15 +167,15 @@ impl Grandpa { /// Read GRANDPA authorities set at given header. async fn source_authorities_set( - source_client: &Client, + source_client: &impl Client, header_hash: C::Hash, ) -> Result, BlockNumberOf>> { - let raw_authorities_set = source_client - .grandpa_authorities_set(header_hash) + const SUB_API_GRANDPA_AUTHORITIES: &str = "GrandpaApi_grandpa_authorities"; + + source_client + .state_call(header_hash, SUB_API_GRANDPA_AUTHORITIES.to_string(), ()) .await - .map_err(|err| Error::RetrieveAuthorities(C::NAME, header_hash, err))?; - GrandpaAuthoritiesSet::decode(&mut &raw_authorities_set[..]) - .map_err(|err| Error::DecodeAuthorities(C::NAME, header_hash, err)) + .map_err(|err| Error::RetrieveAuthorities(C::NAME, header_hash, err)) } } @@ -198,7 +183,6 @@ impl Grandpa { impl Engine for Grandpa { const ID: ConsensusEngineId = GRANDPA_ENGINE_ID; type ConsensusLogReader = GrandpaConsensusLogReader<::Number>; - type FinalityClient = SubstrateGrandpaFinalityClient; type FinalityProof = GrandpaJustification>; type FinalityVerificationContext = JustificationVerificationContext; type EquivocationProof = sp_consensus_grandpa::EquivocationProof, BlockNumberOf>; @@ -215,8 +199,14 @@ impl Engine for Grandpa { bp_header_chain::storage_keys::pallet_operating_mode_key(C::WITH_CHAIN_GRANDPA_PALLET_NAME) } + async fn source_finality_proofs( + client: &impl Client, + ) -> Result, SubstrateError> { + client.subscribe_grandpa_finality_justifications().await + } + async fn verify_and_optimize_proof( - target_client: &Client, + target_client: &impl Client, header: &C::Header, proof: &mut Self::FinalityProof, ) -> Result { @@ -245,27 +235,16 @@ impl Engine for Grandpa { }) } - fn check_max_expected_call_size( + fn check_max_expected_call_limits( header: &C::Header, proof: &Self::FinalityProof, - ) -> MaxExpectedCallSizeCheck { - let is_mandatory = Self::ConsensusLogReader::schedules_authorities_change(header.digest()); - let call_size: u32 = - header.encoded_size().saturating_add(proof.encoded_size()).saturated_into(); - let max_call_size = max_expected_submit_finality_proof_arguments_size::( - is_mandatory, - proof.commit.precommits.len().saturated_into(), - ); - if call_size > max_call_size { - MaxExpectedCallSizeCheck::Exceeds { call_size, max_call_size } - } else { - MaxExpectedCallSizeCheck::Ok - } + ) -> SubmitFinalityProofCallExtras { + bp_header_chain::submit_finality_proof_limits_extras::(header, proof) } /// Prepare initialization data for the GRANDPA verifier pallet. async fn prepare_initialization_data( - source_client: Client, + source_client: impl Client, ) -> Result, BlockNumberOf>> { // In ideal world we just need to get best finalized header and then to read GRANDPA // authorities set (`pallet_grandpa::CurrentSetId` + `GrandpaApi::grandpa_authorities()`) at @@ -274,17 +253,14 @@ impl Engine for Grandpa { // But now there are problems with this approach - `CurrentSetId` may return invalid value. // So here we're waiting for the next justification, read the authorities set and then try // to figure out the set id with bruteforce. - let justifications = Self::source_finality_proofs(&source_client) + let mut justifications = Self::source_finality_proofs(&source_client) .await .map_err(|err| Error::Subscribe(C::NAME, err))?; // Read next justification - the header that it finalizes will be used as initial header. let justification = justifications .next() .await - .map_err(|e| Error::ReadJustification(C::NAME, e)) - .and_then(|justification| { - justification.ok_or(Error::ReadJustificationStreamEnded(C::NAME)) - })?; + .ok_or(Error::ReadJustificationStreamEnded(C::NAME))?; // Read initial header. let justification: GrandpaJustification = @@ -385,14 +361,14 @@ impl Engine for Grandpa { } async fn finality_verification_context( - target_client: &Client, + target_client: &impl Client, at: HashOf, ) -> Result { let current_authority_set_key = bp_header_chain::storage_keys::current_authority_set_key( C::WITH_CHAIN_GRANDPA_PALLET_NAME, ); let authority_set: AuthoritySet = target_client - .storage_value(current_authority_set_key, Some(at)) + .storage_value(at, current_authority_set_key) .await? .map(Ok) .unwrap_or(Err(SubstrateError::Custom(format!( @@ -411,11 +387,11 @@ impl Engine for Grandpa { } async fn synced_headers_finality_info( - target_client: &Client, + target_client: &impl Client, at: TargetChain::Hash, ) -> Result>>, SubstrateError> { let stored_headers_grandpa_info: Vec>> = target_client - .typed_state_call(C::SYNCED_HEADERS_GRANDPA_INFO_METHOD.to_string(), (), Some(at)) + .state_call(at, C::SYNCED_HEADERS_GRANDPA_INFO_METHOD.to_string(), ()) .await?; let mut headers_grandpa_info = vec![]; @@ -433,7 +409,7 @@ impl Engine for Grandpa { } async fn generate_source_key_ownership_proof( - source_client: &Client, + source_client: &impl Client, at: C::Hash, equivocation: &Self::EquivocationProof, ) -> Result { diff --git a/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs b/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs index 825960b1b3ef2cc4f73b7565d6a2c8fe3e30fdd9..71d15ca3868e04da680f83387ac792b3a02a5f24 100644 --- a/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs +++ b/bridges/relays/lib-substrate-relay/src/finality_base/mod.rs @@ -50,11 +50,11 @@ pub type SubstrateFinalityProofsStream

= /// Subscribe to new finality proofs. pub async fn finality_proofs( - client: &Client, + client: &impl Client, ) -> Result, Error> { Ok(unfold( P::FinalityEngine::source_finality_proofs(client).await?, - move |subscription| async move { + move |mut subscription| async move { loop { let log_error = |err| { log::error!( @@ -65,8 +65,7 @@ pub async fn finality_proofs( ); }; - let next_justification = - subscription.next().await.map_err(|err| log_error(err.to_string())).ok()??; + let next_justification = subscription.next().await?; let decoded_justification = >::FinalityProof::decode( @@ -93,7 +92,7 @@ pub async fn finality_proofs( /// /// The runtime API method should be `FinalityApi::best_finalized()`. pub async fn best_synced_header_id( - target_client: &Client, + target_client: &impl Client, at: HashOf, ) -> Result>, Error> where @@ -102,6 +101,6 @@ where { // now let's read id of best finalized peer header at our best finalized block target_client - .typed_state_call(SourceChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), (), Some(at)) + .state_call(at, SourceChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), ()) .await } diff --git a/bridges/relays/lib-substrate-relay/src/lib.rs b/bridges/relays/lib-substrate-relay/src/lib.rs index b3e8e7ed9a2059bb07134640aa4e0bc98494a6a1..c004540a9f4951f3aeeb43a91c74da68a3ff1064 100644 --- a/bridges/relays/lib-substrate-relay/src/lib.rs +++ b/bridges/relays/lib-substrate-relay/src/lib.rs @@ -30,10 +30,7 @@ pub mod equivocation; pub mod error; pub mod finality; pub mod finality_base; -pub mod messages_lane; -pub mod messages_metrics; -pub mod messages_source; -pub mod messages_target; +pub mod messages; pub mod on_demand; pub mod parachains; @@ -130,3 +127,17 @@ impl BatchCallBuilder for () { unreachable!("never called, because ()::new_builder() returns None; qed") } } + +/// Module for handling storage proofs compatibility. +pub mod proofs { + use bp_runtime::{HashOf, RawStorageProof}; + use relay_substrate_client::Chain; + use sp_trie::StorageProof; + + /// Converts proof to `RawStorageProof` type. + pub fn to_raw_storage_proof( + proof: (StorageProof, HashOf), + ) -> RawStorageProof { + proof.0.into_iter_nodes().collect() + } +} diff --git a/bridges/relays/lib-substrate-relay/src/messages_metrics.rs b/bridges/relays/lib-substrate-relay/src/messages/metrics.rs similarity index 99% rename from bridges/relays/lib-substrate-relay/src/messages_metrics.rs rename to bridges/relays/lib-substrate-relay/src/messages/metrics.rs index b30e75bd8bacbbd25c056eb7d499cc18d040f991..8845f43dcb62aa778b50354141381290fc0b897d 100644 --- a/bridges/relays/lib-substrate-relay/src/messages_metrics.rs +++ b/bridges/relays/lib-substrate-relay/src/messages/metrics.rs @@ -36,7 +36,7 @@ use std::{fmt::Debug, marker::PhantomData}; /// Add relay accounts balance metrics. pub async fn add_relay_balances_metrics( - client: Client, + client: impl Client, metrics: &MetricsParams, relay_accounts: &Vec>>, lanes: &[LaneId], diff --git a/bridges/relays/lib-substrate-relay/src/messages_lane.rs b/bridges/relays/lib-substrate-relay/src/messages/mod.rs similarity index 52% rename from bridges/relays/lib-substrate-relay/src/messages_lane.rs rename to bridges/relays/lib-substrate-relay/src/messages/mod.rs index 58e9ded312dfea4813d1a5ddf843e76752bfc0cb..e52b7020666941c9a8d9937655496acf451c5379 100644 --- a/bridges/relays/lib-substrate-relay/src/messages_lane.rs +++ b/bridges/relays/lib-substrate-relay/src/messages/mod.rs @@ -17,20 +17,21 @@ //! Tools for supporting message lanes between two Substrate-based chains. use crate::{ - messages_source::{SubstrateMessagesProof, SubstrateMessagesSource}, - messages_target::{SubstrateMessagesDeliveryProof, SubstrateMessagesTarget}, + messages::{ + source::{SubstrateMessagesProof, SubstrateMessagesSource}, + target::{SubstrateMessagesDeliveryProof, SubstrateMessagesTarget}, + }, on_demand::OnDemandRelay, BatchCallBuilder, BatchCallBuilderConstructor, TransactionParams, }; use async_std::sync::Arc; -use bp_messages::{ChainWithMessages as _, LaneId, MessageNonce}; +use bp_messages::{ + target_chain::FromBridgedChainMessagesProof, ChainWithMessages as _, LaneId, MessageNonce, +}; use bp_runtime::{ AccountIdOf, Chain as _, EncodedOrDecodedCall, HeaderIdOf, TransactionEra, WeightExtraOps, }; -use bridge_runtime_common::messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, -}; use codec::Encode; use frame_support::{dispatch::GetDispatchInfo, weights::Weight}; use messages_relay::{message_lane::MessageLane, message_lane_loop::BatchTransaction}; @@ -46,7 +47,11 @@ use relay_utils::{ }; use sp_core::Pair; use sp_runtime::traits::Zero; -use std::{fmt::Debug, marker::PhantomData}; +use std::{fmt::Debug, marker::PhantomData, ops::RangeInclusive}; + +pub mod metrics; +pub mod source; +pub mod target; /// Substrate -> Substrate messages synchronization pipeline. pub trait SubstrateMessageLane: 'static + Clone + Debug + Send + Sync { @@ -88,13 +93,13 @@ impl MessageLane for MessageLaneAdapter

{ } /// Substrate <-> Substrate messages relay parameters. -pub struct MessagesRelayParams { +pub struct MessagesRelayParams { /// Messages source client. - pub source_client: Client, + pub source_client: SourceClnt, /// Source transaction params. pub source_transaction_params: TransactionParams>, /// Messages target client. - pub target_client: Client, + pub target_client: TargetClnt, /// Target transaction params. pub target_transaction_params: TransactionParams>, /// Optional on-demand source to target headers relay. @@ -179,8 +184,13 @@ impl>> } /// Run Substrate-to-Substrate messages sync loop. -pub async fn run(params: MessagesRelayParams

) -> anyhow::Result<()> +pub async fn run( + params: MessagesRelayParams, +) -> anyhow::Result<()> where + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, AccountIdOf: From< as Pair>::Public>, AccountIdOf: From< as Pair>::Public>, BalanceOf: TryFrom>, @@ -190,7 +200,7 @@ where let limits = match params.limits { Some(limits) => limits, None => - select_delivery_transaction_limits_rpc::

( + select_delivery_transaction_limits_rpc( ¶ms, P::TargetChain::max_extrinsic_weight(), P::SourceChain::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX, @@ -250,19 +260,19 @@ where max_messages_size_in_single_batch, }, }, - SubstrateMessagesSource::

::new( + SubstrateMessagesSource::::new( source_client.clone(), target_client.clone(), params.lane_id, params.source_transaction_params, params.target_to_source_headers_relay, ), - SubstrateMessagesTarget::

::new( + SubstrateMessagesTarget::::new( target_client, source_client, params.lane_id, relayer_id_at_source, - params.target_transaction_params, + Some(params.target_transaction_params), params.source_to_target_headers_relay, ), { @@ -275,6 +285,87 @@ where .map_err(Into::into) } +/// Deliver range of Substrate-to-Substrate messages. No checks are made to ensure that transaction +/// will succeed. +pub async fn relay_messages_range( + source_client: impl Client, + target_client: impl Client, + source_transaction_params: TransactionParams>, + target_transaction_params: TransactionParams>, + at_source_block: HeaderIdOf, + lane_id: LaneId, + range: RangeInclusive, + outbound_state_proof_required: bool, +) -> anyhow::Result<()> +where + AccountIdOf: From< as Pair>::Public>, + AccountIdOf: From< as Pair>::Public>, + BalanceOf: TryFrom>, +{ + let relayer_id_at_source: AccountIdOf = + source_transaction_params.signer.public().into(); + messages_relay::relay_messages_range( + SubstrateMessagesSource::::new( + source_client.clone(), + target_client.clone(), + lane_id, + source_transaction_params, + None, + ), + SubstrateMessagesTarget::::new( + target_client, + source_client, + lane_id, + relayer_id_at_source, + Some(target_transaction_params), + None, + ), + at_source_block, + range, + outbound_state_proof_required, + ) + .await + .map_err(|_| anyhow::format_err!("The command has failed")) +} + +/// Relay messages delivery confirmation of Substrate-to-Substrate messages. +/// No checks are made to ensure that transaction will succeed. +pub async fn relay_messages_delivery_confirmation( + source_client: impl Client, + target_client: impl Client, + source_transaction_params: TransactionParams>, + at_target_block: HeaderIdOf, + lane_id: LaneId, +) -> anyhow::Result<()> +where + AccountIdOf: From< as Pair>::Public>, + AccountIdOf: From< as Pair>::Public>, + BalanceOf: TryFrom>, +{ + let relayer_id_at_source: AccountIdOf = + source_transaction_params.signer.public().into(); + messages_relay::relay_messages_delivery_confirmation( + SubstrateMessagesSource::::new( + source_client.clone(), + target_client.clone(), + lane_id, + source_transaction_params, + None, + ), + SubstrateMessagesTarget::::new( + target_client, + source_client, + lane_id, + relayer_id_at_source, + None, + None, + ), + at_target_block, + ) + .await + .map_err(|_| anyhow::format_err!("The command has failed")) +} + /// Different ways of building `receive_messages_proof` calls. pub trait ReceiveMessagesProofCallBuilder { /// Given messages proof, build call of `receive_messages_proof` function of bridge @@ -297,11 +388,10 @@ pub struct DirectReceiveMessagesProofCallBuilder { impl ReceiveMessagesProofCallBuilder

for DirectReceiveMessagesProofCallBuilder where P: SubstrateMessageLane, - R: BridgeMessagesConfig>, + R: BridgeMessagesConfig, I: 'static, - R::SourceHeaderChain: bp_messages::target_chain::SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof>, - >, + R::BridgedChain: + bp_runtime::Chain, Hash = HashOf>, CallOf: From> + GetDispatchInfo, { fn build_receive_messages_proof_call( @@ -313,7 +403,7 @@ where ) -> CallOf { let call: CallOf = BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain: relayer_id_at_source, - proof: proof.1, + proof: proof.1.into(), messages_count, dispatch_weight, } @@ -346,26 +436,26 @@ macro_rules! generate_receive_message_proof_call_builder { ($pipeline:ident, $mocked_builder:ident, $bridge_messages:path, $receive_messages_proof:path) => { pub struct $mocked_builder; - impl $crate::messages_lane::ReceiveMessagesProofCallBuilder<$pipeline> + impl $crate::messages::ReceiveMessagesProofCallBuilder<$pipeline> for $mocked_builder { fn build_receive_messages_proof_call( relayer_id_at_source: relay_substrate_client::AccountIdOf< - <$pipeline as $crate::messages_lane::SubstrateMessageLane>::SourceChain + <$pipeline as $crate::messages::SubstrateMessageLane>::SourceChain >, - proof: $crate::messages_source::SubstrateMessagesProof< - <$pipeline as $crate::messages_lane::SubstrateMessageLane>::SourceChain + proof: $crate::messages::source::SubstrateMessagesProof< + <$pipeline as $crate::messages::SubstrateMessageLane>::SourceChain >, messages_count: u32, dispatch_weight: bp_messages::Weight, _trace_call: bool, ) -> relay_substrate_client::CallOf< - <$pipeline as $crate::messages_lane::SubstrateMessageLane>::TargetChain + <$pipeline as $crate::messages::SubstrateMessageLane>::TargetChain > { bp_runtime::paste::item! { $bridge_messages($receive_messages_proof { relayer_id_at_bridged_chain: relayer_id_at_source, - proof: proof.1, + proof: proof.1.into(), messages_count: messages_count, dispatch_weight: dispatch_weight, }) @@ -397,11 +487,7 @@ where P: SubstrateMessageLane, R: BridgeMessagesConfig, I: 'static, - R::TargetHeaderChain: bp_messages::source_chain::TargetHeaderChain< - R::OutboundPayload, - R::AccountId, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof>, - >, + R::BridgedChain: bp_runtime::Chain>, CallOf: From> + GetDispatchInfo, { fn build_receive_messages_delivery_proof_call( @@ -410,7 +496,7 @@ where ) -> CallOf { let call: CallOf = BridgeMessagesCall::::receive_messages_delivery_proof { - proof: proof.1, + proof: proof.1.into(), relayers_state: proof.0, } .into(); @@ -442,16 +528,16 @@ macro_rules! generate_receive_message_delivery_proof_call_builder { ($pipeline:ident, $mocked_builder:ident, $bridge_messages:path, $receive_messages_delivery_proof:path) => { pub struct $mocked_builder; - impl $crate::messages_lane::ReceiveMessagesDeliveryProofCallBuilder<$pipeline> + impl $crate::messages::ReceiveMessagesDeliveryProofCallBuilder<$pipeline> for $mocked_builder { fn build_receive_messages_delivery_proof_call( - proof: $crate::messages_target::SubstrateMessagesDeliveryProof< - <$pipeline as $crate::messages_lane::SubstrateMessageLane>::TargetChain + proof: $crate::messages::target::SubstrateMessagesDeliveryProof< + <$pipeline as $crate::messages::SubstrateMessageLane>::TargetChain >, _trace_call: bool, ) -> relay_substrate_client::CallOf< - <$pipeline as $crate::messages_lane::SubstrateMessageLane>::SourceChain + <$pipeline as $crate::messages::SubstrateMessageLane>::SourceChain > { bp_runtime::paste::item! { $bridge_messages($receive_messages_delivery_proof { @@ -465,12 +551,15 @@ macro_rules! generate_receive_message_delivery_proof_call_builder { } /// Returns maximal number of messages and their maximal cumulative dispatch weight. -async fn select_delivery_transaction_limits_rpc( - params: &MessagesRelayParams

, +async fn select_delivery_transaction_limits_rpc( + params: &MessagesRelayParams, max_extrinsic_weight: Weight, max_unconfirmed_messages_at_inbound_lane: MessageNonce, ) -> anyhow::Result where + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, AccountIdOf: From< as Pair>::Public>, { // We may try to guess accurate value, based on maximal number of messages and per-message @@ -486,20 +575,21 @@ where let weight_for_messages_dispatch = max_extrinsic_weight - weight_for_delivery_tx; // weight of empty message delivery with outbound lane state - let delivery_tx_with_zero_messages = dummy_messages_delivery_transaction::

(params, 0)?; + let best_target_block_hash = params.target_client.best_header_hash().await?; + let delivery_tx_with_zero_messages = dummy_messages_delivery_transaction::(params, 0)?; let delivery_tx_with_zero_messages_weight = params .target_client - .extimate_extrinsic_weight(delivery_tx_with_zero_messages) + .estimate_extrinsic_weight(best_target_block_hash, delivery_tx_with_zero_messages) .await .map_err(|e| { anyhow::format_err!("Failed to estimate delivery extrinsic weight: {:?}", e) })?; // weight of single message delivery with outbound lane state - let delivery_tx_with_one_message = dummy_messages_delivery_transaction::

(params, 1)?; + let delivery_tx_with_one_message = dummy_messages_delivery_transaction::(params, 1)?; let delivery_tx_with_one_message_weight = params .target_client - .extimate_extrinsic_weight(delivery_tx_with_one_message) + .estimate_extrinsic_weight(best_target_block_hash, delivery_tx_with_one_message) .await .map_err(|e| { anyhow::format_err!("Failed to estimate delivery extrinsic weight: {:?}", e) @@ -534,8 +624,8 @@ where } /// Returns dummy message delivery transaction with zero messages and `1kb` proof. -fn dummy_messages_delivery_transaction( - params: &MessagesRelayParams

, +fn dummy_messages_delivery_transaction( + params: &MessagesRelayParams, messages: u32, ) -> anyhow::Result<::SignedTransaction> where @@ -553,13 +643,7 @@ where Weight::zero(), FromBridgedChainMessagesProof { bridged_header_hash: Default::default(), - // we may use per-chain `EXTRA_STORAGE_PROOF_SIZE`, but since we don't need - // exact values, this global estimation is fine - storage_proof: vec![vec![ - 42u8; - pallet_bridge_messages::EXTRA_STORAGE_PROOF_SIZE - as usize - ]], + storage_proof: Default::default(), lane: Default::default(), nonces_start: 1, nonces_end: messages as u64, @@ -585,3 +669,362 @@ where ) .map_err(Into::into) } + +#[cfg(test)] +mod tests { + use super::*; + use bp_messages::{ + source_chain::FromBridgedChainMessagesDeliveryProof, UnrewardedRelayersState, + }; + use relay_substrate_client::calls::{UtilityCall as MockUtilityCall, UtilityCall}; + + #[derive(codec::Decode, codec::Encode, Clone, Debug, PartialEq)] + pub enum RuntimeCall { + #[codec(index = 53)] + BridgeMessages(CodegenBridgeMessagesCall), + #[codec(index = 123)] + Utility(UtilityCall), + } + pub type CodegenBridgeMessagesCall = bp_messages::BridgeMessagesCall< + u64, + Box>, + FromBridgedChainMessagesDeliveryProof, + >; + + impl From> for RuntimeCall { + fn from(value: MockUtilityCall) -> RuntimeCall { + match value { + MockUtilityCall::batch_all(calls) => + RuntimeCall::Utility(UtilityCall::::batch_all(calls)), + } + } + } + + #[test] + fn ensure_macro_compatibility_for_generate_receive_message_proof_call_builder() { + // data + let receive_messages_proof = FromBridgedChainMessagesProof { + bridged_header_hash: Default::default(), + storage_proof: Default::default(), + lane: LaneId([0, 0, 0, 0]), + nonces_start: 0, + nonces_end: 0, + }; + let account = 1234; + let messages_count = 0; + let dispatch_weight = Default::default(); + + // construct pallet Call directly + let pallet_receive_messages_proof = + pallet_bridge_messages::Call::::receive_messages_proof { + relayer_id_at_bridged_chain: account, + proof: receive_messages_proof.clone().into(), + messages_count, + dispatch_weight, + }; + + // construct mock enum Call + let mock_enum_receive_messages_proof = CodegenBridgeMessagesCall::receive_messages_proof { + relayer_id_at_bridged_chain: account, + proof: receive_messages_proof.clone().into(), + messages_count, + dispatch_weight, + }; + + // now we should be able to use macro `generate_receive_message_proof_call_builder` + let relayer_call_builder_receive_messages_proof = relayer::ThisChainToBridgedChainMessageLaneReceiveMessagesProofCallBuilder::build_receive_messages_proof_call( + account, + (Default::default(), receive_messages_proof), + messages_count, + dispatch_weight, + false, + ); + + // ensure they are all equal + assert_eq!( + pallet_receive_messages_proof.encode(), + mock_enum_receive_messages_proof.encode() + ); + match relayer_call_builder_receive_messages_proof { + RuntimeCall::BridgeMessages(call) => match call { + call @ CodegenBridgeMessagesCall::receive_messages_proof { .. } => + assert_eq!(pallet_receive_messages_proof.encode(), call.encode()), + _ => panic!("Unexpected CodegenBridgeMessagesCall type"), + }, + _ => panic!("Unexpected RuntimeCall type"), + }; + } + + #[test] + fn ensure_macro_compatibility_for_generate_receive_message_delivery_proof_call_builder() { + // data + let receive_messages_delivery_proof = FromBridgedChainMessagesDeliveryProof { + bridged_header_hash: Default::default(), + storage_proof: Default::default(), + lane: LaneId([0, 0, 0, 0]), + }; + let relayers_state = UnrewardedRelayersState { + unrewarded_relayer_entries: 0, + messages_in_oldest_entry: 0, + total_messages: 0, + last_delivered_nonce: 0, + }; + + // construct pallet Call directly + let pallet_receive_messages_delivery_proof = + pallet_bridge_messages::Call::::receive_messages_delivery_proof { + proof: receive_messages_delivery_proof.clone(), + relayers_state: relayers_state.clone(), + }; + + // construct mock enum Call + let mock_enum_receive_messages_delivery_proof = + CodegenBridgeMessagesCall::receive_messages_delivery_proof { + proof: receive_messages_delivery_proof.clone(), + relayers_state: relayers_state.clone(), + }; + + // now we should be able to use macro `generate_receive_message_proof_call_builder` + let relayer_call_builder_receive_messages_delivery_proof = relayer::ThisChainToBridgedChainMessageLaneReceiveMessagesDeliveryProofCallBuilder::build_receive_messages_delivery_proof_call( + (relayers_state, receive_messages_delivery_proof), + false, + ); + + // ensure they are all equal + assert_eq!( + pallet_receive_messages_delivery_proof.encode(), + mock_enum_receive_messages_delivery_proof.encode() + ); + match relayer_call_builder_receive_messages_delivery_proof { + RuntimeCall::BridgeMessages(call) => match call { + call @ CodegenBridgeMessagesCall::receive_messages_delivery_proof { .. } => + assert_eq!(pallet_receive_messages_delivery_proof.encode(), call.encode()), + _ => panic!("Unexpected CodegenBridgeMessagesCall type"), + }, + _ => panic!("Unexpected RuntimeCall type"), + }; + } + + // mock runtime with `pallet_bridge_messages` + mod mock { + use super::super::*; + use bp_messages::target_chain::ForbidInboundMessages; + use bp_runtime::ChainId; + use frame_support::derive_impl; + use sp_core::H256; + use sp_runtime::{ + generic, testing::Header as SubstrateHeader, traits::BlakeTwo256, StateVersion, + }; + + type Block = frame_system::mocking::MockBlock; + pub type SignedBlock = generic::SignedBlock; + + frame_support::construct_runtime! { + pub enum TestRuntime + { + System: frame_system, + Messages: pallet_bridge_messages, + } + } + + #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] + impl frame_system::Config for TestRuntime { + type Block = Block; + } + + impl pallet_bridge_messages::Config for TestRuntime { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = (); + type ThisChain = ThisUnderlyingChain; + type BridgedChain = BridgedUnderlyingChain; + type BridgedHeaderChain = BridgedHeaderChain; + type ActiveOutboundLanes = (); + type OutboundPayload = Vec; + type InboundPayload = Vec; + type DeliveryPayments = (); + type DeliveryConfirmationPayments = (); + type OnMessagesDelivered = (); + type MessageDispatch = ForbidInboundMessages>; + } + + pub struct ThisUnderlyingChain; + + impl bp_runtime::Chain for ThisUnderlyingChain { + const ID: ChainId = *b"tuch"; + type BlockNumber = u64; + type Hash = H256; + type Hasher = BlakeTwo256; + type Header = SubstrateHeader; + type AccountId = u64; + type Balance = u64; + type Nonce = u64; + type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { + u32::MAX + } + fn max_extrinsic_weight() -> Weight { + Weight::MAX + } + } + + impl bp_messages::ChainWithMessages for ThisUnderlyingChain { + 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; + } + + pub struct BridgedUnderlyingChain; + + pub type BridgedHeaderHash = H256; + pub type BridgedChainHeader = SubstrateHeader; + + impl bp_runtime::Chain for BridgedUnderlyingChain { + const ID: ChainId = *b"bgdc"; + type BlockNumber = u64; + type Hash = BridgedHeaderHash; + type Hasher = BlakeTwo256; + type Header = BridgedChainHeader; + type AccountId = u64; + type Balance = u64; + type Nonce = u64; + type Signature = sp_runtime::MultiSignature; + const STATE_VERSION: StateVersion = StateVersion::V1; + fn max_extrinsic_size() -> u32 { + 4096 + } + fn max_extrinsic_weight() -> Weight { + Weight::MAX + } + } + + impl bp_messages::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; + } + + pub struct BridgedHeaderChain; + + impl bp_header_chain::HeaderChain for BridgedHeaderChain { + fn finalized_header_state_root( + _hash: HashOf, + ) -> Option> { + unreachable!() + } + } + } + + // relayer configuration + mod relayer { + use super::*; + use crate::{ + messages::{ + tests::{mock, RuntimeCall}, + SubstrateMessageLane, + }, + UtilityPalletBatchCallBuilder, + }; + use bp_runtime::UnderlyingChainProvider; + use relay_substrate_client::{MockedRuntimeUtilityPallet, SignParam, UnsignedTransaction}; + use std::time::Duration; + + #[derive(Clone)] + pub struct ThisChain; + impl UnderlyingChainProvider for ThisChain { + type Chain = mock::ThisUnderlyingChain; + } + impl relay_substrate_client::Chain for ThisChain { + const NAME: &'static str = ""; + const BEST_FINALIZED_HEADER_ID_METHOD: &'static str = ""; + const FREE_HEADERS_INTERVAL_METHOD: &'static str = ""; + const AVERAGE_BLOCK_INTERVAL: Duration = Duration::from_millis(0); + type SignedBlock = mock::SignedBlock; + type Call = RuntimeCall; + } + impl relay_substrate_client::ChainWithTransactions for ThisChain { + type AccountKeyPair = sp_core::sr25519::Pair; + type SignedTransaction = (); + + fn sign_transaction( + _: SignParam, + _: UnsignedTransaction, + ) -> Result + where + Self: Sized, + { + todo!() + } + } + impl relay_substrate_client::ChainWithMessages for ThisChain { + const WITH_CHAIN_RELAYERS_PALLET_NAME: Option<&'static str> = None; + const TO_CHAIN_MESSAGE_DETAILS_METHOD: &'static str = ""; + const FROM_CHAIN_MESSAGE_DETAILS_METHOD: &'static str = ""; + } + impl relay_substrate_client::ChainWithUtilityPallet for ThisChain { + type UtilityPallet = MockedRuntimeUtilityPallet; + } + + #[derive(Clone)] + pub struct BridgedChain; + impl UnderlyingChainProvider for BridgedChain { + type Chain = mock::BridgedUnderlyingChain; + } + impl relay_substrate_client::Chain for BridgedChain { + const NAME: &'static str = ""; + const BEST_FINALIZED_HEADER_ID_METHOD: &'static str = ""; + const FREE_HEADERS_INTERVAL_METHOD: &'static str = ""; + const AVERAGE_BLOCK_INTERVAL: Duration = Duration::from_millis(0); + type SignedBlock = mock::SignedBlock; + type Call = RuntimeCall; + } + impl relay_substrate_client::ChainWithTransactions for BridgedChain { + type AccountKeyPair = sp_core::sr25519::Pair; + type SignedTransaction = (); + + fn sign_transaction( + _: SignParam, + _: UnsignedTransaction, + ) -> Result + where + Self: Sized, + { + todo!() + } + } + impl relay_substrate_client::ChainWithMessages for BridgedChain { + const WITH_CHAIN_RELAYERS_PALLET_NAME: Option<&'static str> = None; + const TO_CHAIN_MESSAGE_DETAILS_METHOD: &'static str = ""; + const FROM_CHAIN_MESSAGE_DETAILS_METHOD: &'static str = ""; + } + impl relay_substrate_client::ChainWithUtilityPallet for BridgedChain { + type UtilityPallet = MockedRuntimeUtilityPallet; + } + + #[derive(Clone, Debug)] + pub struct ThisChainToBridgedChainMessageLane; + impl SubstrateMessageLane for ThisChainToBridgedChainMessageLane { + type SourceChain = ThisChain; + type TargetChain = BridgedChain; + type ReceiveMessagesProofCallBuilder = + ThisChainToBridgedChainMessageLaneReceiveMessagesProofCallBuilder; + type ReceiveMessagesDeliveryProofCallBuilder = + ThisChainToBridgedChainMessageLaneReceiveMessagesDeliveryProofCallBuilder; + type SourceBatchCallBuilder = UtilityPalletBatchCallBuilder; + type TargetBatchCallBuilder = UtilityPalletBatchCallBuilder; + } + + generate_receive_message_proof_call_builder!( + ThisChainToBridgedChainMessageLane, + ThisChainToBridgedChainMessageLaneReceiveMessagesProofCallBuilder, + RuntimeCall::BridgeMessages, + CodegenBridgeMessagesCall::receive_messages_proof + ); + generate_receive_message_delivery_proof_call_builder!( + ThisChainToBridgedChainMessageLane, + ThisChainToBridgedChainMessageLaneReceiveMessagesDeliveryProofCallBuilder, + RuntimeCall::BridgeMessages, + CodegenBridgeMessagesCall::receive_messages_delivery_proof + ); + } +} diff --git a/bridges/relays/lib-substrate-relay/src/messages_source.rs b/bridges/relays/lib-substrate-relay/src/messages/source.rs similarity index 86% rename from bridges/relays/lib-substrate-relay/src/messages_source.rs rename to bridges/relays/lib-substrate-relay/src/messages/source.rs index 49deff046f9ca0914846d19b18653f85b8cd8554..b75fc86d5eee20d247de3cbc26f324ed46e9ad2d 100644 --- a/bridges/relays/lib-substrate-relay/src/messages_source.rs +++ b/bridges/relays/lib-substrate-relay/src/messages/source.rs @@ -20,11 +20,12 @@ use crate::{ finality_base::best_synced_header_id, - messages_lane::{ + messages::{ BatchProofTransaction, MessageLaneAdapter, ReceiveMessagesDeliveryProofCallBuilder, SubstrateMessageLane, }, on_demand::OnDemandRelay, + proofs::to_raw_storage_proof, TransactionParams, }; @@ -32,11 +33,11 @@ use async_std::sync::Arc; use async_trait::async_trait; use bp_messages::{ storage_keys::{operating_mode_key, outbound_lane_data_key}, + target_chain::FromBridgedChainMessagesProof, ChainWithMessages as _, InboundMessageDetails, LaneId, MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData, OutboundMessageDetails, }; -use bp_runtime::{BasicOperatingMode, HeaderIdProvider}; -use bridge_runtime_common::messages::target::FromBridgedChainMessagesProof; +use bp_runtime::{BasicOperatingMode, HeaderIdProvider, RangeInclusiveExt}; use codec::Encode; use frame_support::weights::Weight; use messages_relay::{ @@ -63,19 +64,21 @@ pub type SubstrateMessagesProof = (Weight, FromBridgedChainMessagesProof = Vec<(MessagePayload, &'a mut OutboundMessageDetails)>; /// Substrate client as Substrate messages source. -pub struct SubstrateMessagesSource { - source_client: Client, - target_client: Client, +pub struct SubstrateMessagesSource { + source_client: SourceClnt, + target_client: TargetClnt, lane_id: LaneId, transaction_params: TransactionParams>, target_to_source_headers_relay: Option>>, } -impl SubstrateMessagesSource

{ +impl, TargetClnt> + SubstrateMessagesSource +{ /// Create new Substrate headers source. pub fn new( - source_client: Client, - target_client: Client, + source_client: SourceClnt, + target_client: TargetClnt, lane_id: LaneId, transaction_params: TransactionParams>, target_to_source_headers_relay: Option< @@ -98,22 +101,25 @@ impl SubstrateMessagesSource

{ ) -> Result, SubstrateError> { self.source_client .storage_value( + id.hash(), outbound_lane_data_key( P::TargetChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &self.lane_id, ), - Some(id.1), ) .await } /// Ensure that the messages pallet at source chain is active. async fn ensure_pallet_active(&self) -> Result<(), SubstrateError> { - ensure_messages_pallet_active::(&self.source_client).await + ensure_messages_pallet_active::(&self.source_client) + .await } } -impl Clone for SubstrateMessagesSource

{ +impl Clone + for SubstrateMessagesSource +{ fn clone(&self) -> Self { Self { source_client: self.source_client.clone(), @@ -126,7 +132,12 @@ impl Clone for SubstrateMessagesSource

{ } #[async_trait] -impl RelayClient for SubstrateMessagesSource

{ +impl< + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, + > RelayClient for SubstrateMessagesSource +{ type Error = SubstrateError; async fn reconnect(&mut self) -> Result<(), SubstrateError> { @@ -150,13 +161,17 @@ impl RelayClient for SubstrateMessagesSource

{ } #[async_trait] -impl SourceClient> for SubstrateMessagesSource

+impl< + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, + > SourceClient> for SubstrateMessagesSource where AccountIdOf: From< as Pair>::Public>, { type BatchTransaction = BatchProofTransaction; - type TransactionTracker = TransactionTracker>; + type TransactionTracker = TransactionTracker; async fn state(&self) -> Result>, SubstrateError> { // we can't continue to deliver confirmations if source node is out of sync, because @@ -169,7 +184,7 @@ where // we can't relay confirmations if messages pallet at source chain is halted self.ensure_pallet_active().await?; - read_client_state(&self.source_client, Some(&self.target_client)).await + read_client_state_from_both_chains(&self.source_client, &self.target_client).await } async fn latest_generated_nonce( @@ -203,12 +218,12 @@ where id: SourceHeaderIdOf>, nonces: RangeInclusive, ) -> Result>, SubstrateError> { - let mut out_msgs_details = self + let mut out_msgs_details: Vec<_> = self .source_client - .typed_state_call::<_, Vec<_>>( + .state_call::<_, Vec<_>>( + id.hash(), P::TargetChain::TO_CHAIN_MESSAGE_DETAILS_METHOD.into(), (self.lane_id, *nonces.start(), *nonces.end()), - Some(id.1), ) .await?; validate_out_msgs_details::(&out_msgs_details, nonces)?; @@ -226,7 +241,7 @@ where out_msg_details.nonce, ); let msg_payload: MessagePayload = - self.source_client.storage_value(msg_key, Some(id.1)).await?.ok_or_else(|| { + self.source_client.storage_value(id.hash(), msg_key).await?.ok_or_else(|| { SubstrateError::Custom(format!( "Message to {} {:?}/{} is missing from runtime the storage of {} at {:?}", P::TargetChain::NAME, @@ -240,15 +255,16 @@ where msgs_to_refine.push((msg_payload, out_msg_details)); } + let best_target_header_hash = self.target_client.best_header_hash().await?; for mut msgs_to_refine_batch in split_msgs_to_refine::(self.lane_id, msgs_to_refine)? { let in_msgs_details = self .target_client - .typed_state_call::<_, Vec>( + .state_call::<_, Vec>( + best_target_header_hash, P::SourceChain::FROM_CHAIN_MESSAGE_DETAILS_METHOD.into(), (self.lane_id, &msgs_to_refine_batch), - None, ) .await?; if in_msgs_details.len() != msgs_to_refine_batch.len() { @@ -305,34 +321,27 @@ where ), SubstrateError, > { - let mut storage_keys = - Vec::with_capacity(nonces.end().saturating_sub(*nonces.start()) as usize + 1); - let mut message_nonce = *nonces.start(); - while message_nonce <= *nonces.end() { + let mut storage_keys = Vec::with_capacity(nonces.saturating_len() as usize); + for message_nonce in nonces.clone() { let message_key = bp_messages::storage_keys::message_key( P::TargetChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &self.lane_id, message_nonce, ); storage_keys.push(message_key); - message_nonce += 1; } if proof_parameters.outbound_state_proof_required { - storage_keys.push(bp_messages::storage_keys::outbound_lane_data_key( + storage_keys.push(outbound_lane_data_key( P::TargetChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &self.lane_id, )); } - let proof = self - .source_client - .prove_storage(storage_keys, id.1) - .await? - .into_iter_nodes() - .collect(); + let storage_proof = + self.source_client.prove_storage(id.hash(), storage_keys.clone()).await?; let proof = FromBridgedChainMessagesProof { bridged_header_hash: id.1, - storage_proof: proof, + storage_proof: to_raw_storage_proof::(storage_proof), lane: self.lane_id, nonces_start: *nonces.start(), nonces_end: *nonces.end(), @@ -387,15 +396,19 @@ where } /// Ensure that the messages pallet at source chain is active. -pub(crate) async fn ensure_messages_pallet_active( - client: &Client, +pub(crate) async fn ensure_messages_pallet_active( + client: &AtChainClient, ) -> Result<(), SubstrateError> where AtChain: ChainWithMessages, WithChain: ChainWithMessages, + AtChainClient: Client, { let operating_mode = client - .storage_value(operating_mode_key(WithChain::WITH_CHAIN_MESSAGES_PALLET_NAME), None) + .storage_value( + client.best_header_hash().await?, + operating_mode_key(WithChain::WITH_CHAIN_MESSAGES_PALLET_NAME), + ) .await?; let is_halted = operating_mode == Some(MessagesOperatingMode::Basic(BasicOperatingMode::Halted)); @@ -412,11 +425,10 @@ where /// bridge GRANDPA pallet deployed and it provides `best_finalized_header_id_method_name` /// runtime API to read the best finalized Bridged chain header. /// -/// If `peer_client` is `None`, the value of `actual_best_finalized_peer_at_best_self` will -/// always match the `best_finalized_peer_at_best_self`. +/// The value of `actual_best_finalized_peer_at_best_self` will always match +/// the `best_finalized_peer_at_best_self`. pub async fn read_client_state( - self_client: &Client, - peer_client: Option<&Client>, + self_client: &impl Client, ) -> Result, HeaderIdOf>, SubstrateError> where SelfChain: Chain, @@ -431,30 +443,42 @@ where let peer_on_self_best_finalized_id = best_synced_header_id::(self_client, self_best_id.hash()).await?; - // read actual header, matching the `peer_on_self_best_finalized_id` from the peer chain - let actual_peer_on_self_best_finalized_id = - match (peer_client, peer_on_self_best_finalized_id.as_ref()) { - (Some(peer_client), Some(peer_on_self_best_finalized_id)) => { - let actual_peer_on_self_best_finalized = - peer_client.header_by_number(peer_on_self_best_finalized_id.number()).await?; - Some(actual_peer_on_self_best_finalized.id()) - }, - _ => peer_on_self_best_finalized_id, - }; - Ok(ClientState { best_self: self_best_id, best_finalized_self: self_best_finalized_id, best_finalized_peer_at_best_self: peer_on_self_best_finalized_id, - actual_best_finalized_peer_at_best_self: actual_peer_on_self_best_finalized_id, + actual_best_finalized_peer_at_best_self: peer_on_self_best_finalized_id, }) } +/// Does the same stuff as `read_client_state`, but properly fills the +/// `actual_best_finalized_peer_at_best_self` field of the result. +pub async fn read_client_state_from_both_chains( + self_client: &impl Client, + peer_client: &impl Client, +) -> Result, HeaderIdOf>, SubstrateError> +where + SelfChain: Chain, + PeerChain: Chain, +{ + let mut client_state = read_client_state::(self_client).await?; + client_state.actual_best_finalized_peer_at_best_self = + match client_state.best_finalized_peer_at_best_self.as_ref() { + Some(peer_on_self_best_finalized_id) => { + let actual_peer_on_self_best_finalized = + peer_client.header_by_number(peer_on_self_best_finalized_id.number()).await?; + Some(actual_peer_on_self_best_finalized.id()) + }, + _ => client_state.best_finalized_peer_at_best_self, + }; + Ok(client_state) +} + /// Reads best `PeerChain` header known to the `SelfChain` using provided runtime API method. /// /// Method is supposed to be the `FinalityApi::best_finalized()` method. pub async fn best_finalized_peer_header_at_self( - self_client: &Client, + self_client: &impl Client, at_self_hash: HashOf, ) -> Result>, SubstrateError> where @@ -463,10 +487,10 @@ where { // now let's read id of best finalized peer header at our best finalized block self_client - .typed_state_call::<_, Option<_>>( + .state_call::<_, Option<_>>( + at_self_hash, PeerChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), (), - Some(at_self_hash), ) .await } diff --git a/bridges/relays/lib-substrate-relay/src/messages_target.rs b/bridges/relays/lib-substrate-relay/src/messages/target.rs similarity index 79% rename from bridges/relays/lib-substrate-relay/src/messages_target.rs rename to bridges/relays/lib-substrate-relay/src/messages/target.rs index 633b11f0b8028636fdb8c9c6b4f1ec5fa42ccf33..a6bf169cffb67ae149d9d4c8c5a2348dc18f5b39 100644 --- a/bridges/relays/lib-substrate-relay/src/messages_target.rs +++ b/bridges/relays/lib-substrate-relay/src/messages/target.rs @@ -19,56 +19,63 @@ //! `` chain. use crate::{ - messages_lane::{ + messages::{ + source::{ + ensure_messages_pallet_active, read_client_state_from_both_chains, + SubstrateMessagesProof, + }, BatchProofTransaction, MessageLaneAdapter, ReceiveMessagesProofCallBuilder, SubstrateMessageLane, }, - messages_source::{ensure_messages_pallet_active, read_client_state, SubstrateMessagesProof}, on_demand::OnDemandRelay, + proofs::to_raw_storage_proof, TransactionParams, }; use async_std::sync::Arc; use async_trait::async_trait; use bp_messages::{ - storage_keys::inbound_lane_data_key, ChainWithMessages as _, InboundLaneData, LaneId, - MessageNonce, UnrewardedRelayersState, + source_chain::FromBridgedChainMessagesDeliveryProof, storage_keys::inbound_lane_data_key, + ChainWithMessages as _, InboundLaneData, LaneId, MessageNonce, UnrewardedRelayersState, }; -use bridge_runtime_common::messages::source::FromBridgedChainMessagesDeliveryProof; use messages_relay::{ message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf}, message_lane_loop::{NoncesSubmitArtifacts, TargetClient, TargetClientState}, }; use relay_substrate_client::{ - AccountIdOf, AccountKeyPairOf, BalanceOf, CallOf, Client, Error as SubstrateError, HashOf, - TransactionEra, TransactionTracker, UnsignedTransaction, + AccountIdOf, AccountKeyPairOf, BalanceOf, CallOf, Chain, Client, Error as SubstrateError, + HashOf, TransactionEra, TransactionTracker, UnsignedTransaction, }; use relay_utils::relay_loop::Client as RelayClient; use sp_core::Pair; -use std::ops::RangeInclusive; +use std::{convert::TryFrom, ops::RangeInclusive}; /// Message receiving proof returned by the target Substrate node. pub type SubstrateMessagesDeliveryProof = (UnrewardedRelayersState, FromBridgedChainMessagesDeliveryProof>); /// Substrate client as Substrate messages target. -pub struct SubstrateMessagesTarget { - target_client: Client, - source_client: Client, +pub struct SubstrateMessagesTarget { + target_client: TargetClnt, + source_client: SourceClnt, lane_id: LaneId, relayer_id_at_source: AccountIdOf, - transaction_params: TransactionParams>, + transaction_params: Option>>, source_to_target_headers_relay: Option>>, } -impl SubstrateMessagesTarget

{ +impl SubstrateMessagesTarget +where + P: SubstrateMessageLane, + TargetClnt: Client, +{ /// Create new Substrate headers target. pub fn new( - target_client: Client, - source_client: Client, + target_client: TargetClnt, + source_client: SourceClnt, lane_id: LaneId, relayer_id_at_source: AccountIdOf, - transaction_params: TransactionParams>, + transaction_params: Option>>, source_to_target_headers_relay: Option< Arc>, >, @@ -90,22 +97,25 @@ impl SubstrateMessagesTarget

{ ) -> Result>>, SubstrateError> { self.target_client .storage_value( + id.hash(), inbound_lane_data_key( P::SourceChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &self.lane_id, ), - Some(id.1), ) .await } /// Ensure that the messages pallet at target chain is active. async fn ensure_pallet_active(&self) -> Result<(), SubstrateError> { - ensure_messages_pallet_active::(&self.target_client).await + ensure_messages_pallet_active::(&self.target_client) + .await } } -impl Clone for SubstrateMessagesTarget

{ +impl Clone + for SubstrateMessagesTarget +{ fn clone(&self) -> Self { Self { target_client: self.target_client.clone(), @@ -119,7 +129,12 @@ impl Clone for SubstrateMessagesTarget

{ } #[async_trait] -impl RelayClient for SubstrateMessagesTarget

{ +impl< + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, + > RelayClient for SubstrateMessagesTarget +{ type Error = SubstrateError; async fn reconnect(&mut self) -> Result<(), SubstrateError> { @@ -143,14 +158,18 @@ impl RelayClient for SubstrateMessagesTarget

{ } #[async_trait] -impl TargetClient> for SubstrateMessagesTarget

+impl< + P: SubstrateMessageLane, + SourceClnt: Client, + TargetClnt: Client, + > TargetClient> for SubstrateMessagesTarget where AccountIdOf: From< as Pair>::Public>, BalanceOf: TryFrom>, { type BatchTransaction = BatchProofTransaction; - type TransactionTracker = TransactionTracker>; + type TransactionTracker = TransactionTracker; async fn state(&self) -> Result>, SubstrateError> { // we can't continue to deliver confirmations if source node is out of sync, because @@ -163,7 +182,7 @@ where // we can't relay messages if messages pallet at target chain is halted self.ensure_pallet_active().await?; - read_client_state(&self.target_client, Some(&self.source_client)).await + read_client_state_from_both_chains(&self.target_client, &self.source_client).await } async fn latest_received_nonce( @@ -213,19 +232,16 @@ where SubstrateError, > { let (id, relayers_state) = self.unrewarded_relayers_state(id).await?; - let inbound_data_key = bp_messages::storage_keys::inbound_lane_data_key( + let storage_keys = vec![inbound_lane_data_key( P::SourceChain::WITH_CHAIN_MESSAGES_PALLET_NAME, &self.lane_id, - ); - let proof = self - .target_client - .prove_storage(vec![inbound_data_key], id.1) - .await? - .into_iter_nodes() - .collect(); + )]; + + let storage_proof = + self.target_client.prove_storage(id.hash(), storage_keys.clone()).await?; let proof = FromBridgedChainMessagesDeliveryProof { bridged_header_hash: id.1, - storage_proof: proof, + storage_proof: to_raw_storage_proof::(storage_proof), lane: self.lane_id, }; Ok((id, (relayers_state, proof))) @@ -249,11 +265,18 @@ where None => messages_proof_call, }; - let transaction_params = self.transaction_params.clone(); + let transaction_params = self.transaction_params.clone().map(Ok).unwrap_or_else(|| { + // this error shall never happen in practice, so it not deserves + // a separate error variant + Err(SubstrateError::Custom(format!( + "Cannot sign transaction of {} chain", + P::TargetChain::NAME, + ))) + })?; let tx_tracker = self .target_client .submit_and_watch_signed_extrinsic( - &self.transaction_params.signer, + &transaction_params.signer, move |best_block_id, transaction_nonce| { Ok(UnsignedTransaction::new(final_call.into(), transaction_nonce) .era(TransactionEra::new(best_block_id, transaction_params.mortality))) diff --git a/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs b/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs index 74f3a70c5e81bbc1d27162a74fb8dadab46a6d09..d18c582dfac4340a72f1bebd2eea3cabd0563dbe 100644 --- a/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs +++ b/bridges/relays/lib-substrate-relay/src/on_demand/headers.rs @@ -16,9 +16,7 @@ //! On-demand Substrate -> Substrate header finality relay. -use crate::{ - finality::SubmitFinalityProofCallBuilder, finality_base::engine::MaxExpectedCallSizeCheck, -}; +use crate::finality::SubmitFinalityProofCallBuilder; use async_std::sync::{Arc, Mutex}; use async_trait::async_trait; @@ -55,25 +53,30 @@ use crate::{ /// relay) needs it to continue its regular work. When enough headers are relayed, on-demand stops /// syncing headers. #[derive(Clone)] -pub struct OnDemandHeadersRelay { +pub struct OnDemandHeadersRelay { /// Relay task name. relay_task_name: String, /// Shared reference to maximal required finalized header number. required_header_number: RequiredHeaderNumberRef, /// Client of the source chain. - source_client: Client, + source_client: SourceClnt, /// Client of the target chain. - target_client: Client, + target_client: TargetClnt, } -impl OnDemandHeadersRelay

{ +impl< + P: SubstrateFinalitySyncPipeline, + SourceClnt: Client, + TargetClnt: Client, + > OnDemandHeadersRelay +{ /// Create new on-demand headers relay. /// /// If `metrics_params` is `Some(_)`, the metrics of the finality relay are registered. /// Otherwise, all required metrics must be exposed outside of this method. pub fn new( - source_client: Client, - target_client: Client, + source_client: SourceClnt, + target_client: TargetClnt, target_transaction_params: TransactionParams>, headers_to_relay: HeadersToRelay, metrics_params: Option, @@ -106,8 +109,12 @@ impl OnDemandHeadersRelay

{ } #[async_trait] -impl OnDemandRelay - for OnDemandHeadersRelay

+impl< + P: SubstrateFinalitySyncPipeline, + SourceClnt: Client, + TargetClnt: Client, + > OnDemandRelay + for OnDemandHeadersRelay { async fn reconnect(&self) -> Result<(), SubstrateError> { // using clone is fine here (to avoid mut requirement), because clone on Client clones @@ -141,7 +148,7 @@ impl OnDemandRelay::new(self.source_client.clone(), None); + SubstrateFinalitySource::::new(self.source_client.clone(), None); let (header, mut proof) = finality_source.prove_block_finality(current_required_header).await?; let header_id = header.id(); @@ -156,22 +163,21 @@ impl OnDemandRelay OnDemandRelay( - source_client: Client, - target_client: Client, + source_client: impl Client, + target_client: impl Client, target_transaction_params: TransactionParams>, headers_to_relay: HeadersToRelay, required_header_number: RequiredHeaderNumberRef, @@ -212,7 +218,7 @@ async fn background_task( { let relay_task_name = on_demand_headers_relay_name::(); let target_transactions_mortality = target_transaction_params.mortality; - let mut finality_source = SubstrateFinalitySource::

::new( + let mut finality_source = SubstrateFinalitySource::::new( source_client.clone(), Some(required_header_number.clone()), ); @@ -249,7 +255,8 @@ async fn background_task( // read best finalized source header number from target let best_finalized_source_header_at_target = - best_finalized_source_header_at_target::

(&finality_target, &relay_task_name).await; + best_finalized_source_header_at_target::(&finality_target, &relay_task_name) + .await; if matches!(best_finalized_source_header_at_target, Err(ref e) if e.is_connection_error()) { relay_utils::relay_loop::reconnect_failed_client( FailedClient::Target, @@ -413,13 +420,17 @@ async fn mandatory_headers_scan_range( /// it. /// /// Returns `true` if header was found and (asked to be) relayed and `false` otherwise. -async fn relay_mandatory_header_from_range( - finality_source: &SubstrateFinalitySource

, +async fn relay_mandatory_header_from_range( + finality_source: &SubstrateFinalitySource, required_header_number: &RequiredHeaderNumberRef, best_finalized_source_header_at_target: String, range: (BlockNumberOf, BlockNumberOf), relay_task_name: &str, -) -> Result { +) -> Result +where + P: SubstrateFinalitySyncPipeline, + SourceClnt: Client, +{ // search for mandatory header first let mandatory_source_header_number = find_mandatory_header_in_range(finality_source, range).await?; @@ -454,10 +465,14 @@ async fn relay_mandatory_header_from_range( /// Read best finalized source block number from source client. /// /// Returns `None` if we have failed to read the number. -async fn best_finalized_source_header_at_source( - finality_source: &SubstrateFinalitySource

, +async fn best_finalized_source_header_at_source( + finality_source: &SubstrateFinalitySource, relay_task_name: &str, -) -> Result, relay_substrate_client::Error> { +) -> Result, relay_substrate_client::Error> +where + P: SubstrateFinalitySyncPipeline, + SourceClnt: Client, +{ finality_source.on_chain_best_finalized_block_number().await.map_err(|error| { log::error!( target: "bridge", @@ -473,11 +488,16 @@ async fn best_finalized_source_header_at_source( - finality_target: &SubstrateFinalityTarget

, +async fn best_finalized_source_header_at_target( + finality_target: &SubstrateFinalityTarget, relay_task_name: &str, -) -> Result, as RelayClient>::Error> +) -> Result< + BlockNumberOf, + as RelayClient>::Error, +> where + P: SubstrateFinalitySyncPipeline, + TargetClnt: Client, AccountIdOf: From< as sp_core::Pair>::Public>, { finality_target @@ -499,10 +519,14 @@ where /// Read first mandatory header in given inclusive range. /// /// Returns `Ok(None)` if there were no mandatory headers in the range. -async fn find_mandatory_header_in_range( - finality_source: &SubstrateFinalitySource

, +async fn find_mandatory_header_in_range( + finality_source: &SubstrateFinalitySource, range: (BlockNumberOf, BlockNumberOf), -) -> Result>, relay_substrate_client::Error> { +) -> Result>, relay_substrate_client::Error> +where + P: SubstrateFinalitySyncPipeline, + SourceClnt: Client, +{ let mut current = range.0; while current <= range.1 { let header = finality_source.client().header_by_number(current).await?; diff --git a/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs b/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs index 966bdc3107203a61cf405adba2cf09124330954e..4579222a2c681c49e076f67d2eacaeb1dc8b9fca 100644 --- a/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs +++ b/bridges/relays/lib-substrate-relay/src/on_demand/parachains.rs @@ -17,7 +17,7 @@ //! On-demand Substrate -> Substrate parachain finality relay. use crate::{ - messages_source::best_finalized_peer_header_at_self, + messages::source::best_finalized_peer_header_at_self, on_demand::OnDemandRelay, parachains::{ source::ParachainsSource, target::ParachainsTarget, ParachainsPipelineAdapter, @@ -53,29 +53,34 @@ use std::fmt::Debug; /// (e.g. messages relay) needs it to continue its regular work. When enough parachain headers /// are relayed, on-demand stops syncing headers. #[derive(Clone)] -pub struct OnDemandParachainsRelay { +pub struct OnDemandParachainsRelay { /// Relay task name. relay_task_name: String, /// Channel used to communicate with background task and ask for relay of parachain heads. required_header_number_sender: Sender>, /// Source relay chain client. - source_relay_client: Client, + source_relay_client: SourceRelayClnt, /// Target chain client. - target_client: Client, + target_client: TargetClnt, /// On-demand relay chain relay. on_demand_source_relay_to_target_headers: Arc>, } -impl OnDemandParachainsRelay

{ +impl< + P: SubstrateParachainsPipeline, + SourceRelayClnt: Client, + TargetClnt: Client, + > OnDemandParachainsRelay +{ /// Create new on-demand parachains relay. /// /// Note that the argument is the source relay chain client, not the parachain client. /// That's because parachain finality is determined by the relay chain and we don't /// need to connect to the parachain itself here. pub fn new( - source_relay_client: Client, - target_client: Client, + source_relay_client: SourceRelayClnt, + target_client: TargetClnt, target_transaction_params: TransactionParams>, on_demand_source_relay_to_target_headers: Arc< dyn OnDemandRelay, @@ -114,10 +119,13 @@ impl OnDemandParachainsRelay

{ } #[async_trait] -impl OnDemandRelay - for OnDemandParachainsRelay

+impl + OnDemandRelay + for OnDemandParachainsRelay where P::SourceParachain: Chain, + SourceRelayClnt: Client, + TargetClnt: Client, { async fn reconnect(&self) -> Result<(), SubstrateError> { // using clone is fine here (to avoid mut requirement), because clone on Client clones @@ -147,7 +155,7 @@ where required_parachain_header: BlockNumberOf, ) -> Result<(HeaderIdOf, Vec>), SubstrateError> { // select headers to prove - let parachains_source = ParachainsSource::

::new( + let parachains_source = ParachainsSource::::new( self.source_relay_client.clone(), Arc::new(Mutex::new(AvailableHeader::Missing)), ); @@ -231,8 +239,8 @@ where /// Background task that is responsible for starting parachain headers relay. async fn background_task( - source_relay_client: Client, - target_client: Client, + source_relay_client: impl Client, + target_client: impl Client, target_transaction_params: TransactionParams>, on_demand_source_relay_to_target_headers: Arc< dyn OnDemandRelay, @@ -255,9 +263,11 @@ async fn background_task( let parachains_relay_task = futures::future::Fuse::terminated(); futures::pin_mut!(parachains_relay_task); - let mut parachains_source = - ParachainsSource::

::new(source_relay_client.clone(), required_para_header_ref.clone()); - let mut parachains_target = ParachainsTarget::

::new( + let mut parachains_source = ParachainsSource::::new( + source_relay_client.clone(), + required_para_header_ref.clone(), + ); + let mut parachains_target = ParachainsTarget::::new( source_relay_client.clone(), target_client.clone(), target_transaction_params.clone(), @@ -446,9 +456,9 @@ struct RelayData { } /// Read required data from source and target clients. -async fn read_relay_data( - source: &ParachainsSource

, - target: &ParachainsTarget

, +async fn read_relay_data( + source: &ParachainsSource, + target: &ParachainsTarget, required_header_number: BlockNumberOf, ) -> Result< RelayData< @@ -459,7 +469,9 @@ async fn read_relay_data( FailedClient, > where - ParachainsTarget

: + SourceRelayClnt: Client, + TargetClnt: Client, + ParachainsTarget: TargetClient> + RelayClient, { let map_target_err = |e| { @@ -642,13 +654,19 @@ trait SelectHeadersToProveEnvironment { } #[async_trait] -impl<'a, P: SubstrateParachainsPipeline> +impl<'a, P: SubstrateParachainsPipeline, SourceRelayClnt, TargetClnt> SelectHeadersToProveEnvironment< BlockNumberOf, HashOf, BlockNumberOf, HashOf, - > for (&'a OnDemandParachainsRelay

, &'a ParachainsSource

) + > + for ( + &'a OnDemandParachainsRelay, + &'a ParachainsSource, + ) where + SourceRelayClnt: Client, + TargetClnt: Client, { fn parachain_id(&self) -> ParaId { ParaId(P::SourceParachain::PARACHAIN_ID) @@ -663,9 +681,8 @@ impl<'a, P: SubstrateParachainsPipeline> async fn best_finalized_relay_block_at_target( &self, ) -> Result, SubstrateError> { - Ok(crate::messages_source::read_client_state::( + Ok(crate::messages::source::read_client_state::( &self.0.target_client, - None, ) .await? .best_finalized_peer_at_best_self diff --git a/bridges/relays/lib-substrate-relay/src/parachains/source.rs b/bridges/relays/lib-substrate-relay/src/parachains/source.rs index 4cc512b9d9b45c7334ffb121c1a8613b7f118550..1aa12d1c913d11e13e95908db44c6302942fa94a 100644 --- a/bridges/relays/lib-substrate-relay/src/parachains/source.rs +++ b/bridges/relays/lib-substrate-relay/src/parachains/source.rs @@ -16,8 +16,10 @@ //! Parachain heads source. -use crate::parachains::{ParachainsPipelineAdapter, SubstrateParachainsPipeline}; - +use crate::{ + parachains::{ParachainsPipelineAdapter, SubstrateParachainsPipeline}, + proofs::to_raw_storage_proof, +}; use async_std::sync::{Arc, Mutex}; use async_trait::async_trait; use bp_parachains::parachain_head_storage_key_at_source; @@ -37,22 +39,24 @@ pub type RequiredHeaderIdRef = Arc>>>; /// Substrate client as parachain heads source. #[derive(Clone)] -pub struct ParachainsSource { - client: Client, +pub struct ParachainsSource { + client: SourceRelayClnt, max_head_id: RequiredHeaderIdRef, } -impl ParachainsSource

{ +impl> + ParachainsSource +{ /// Creates new parachains source client. pub fn new( - client: Client, + client: SourceRelayClnt, max_head_id: RequiredHeaderIdRef, ) -> Self { ParachainsSource { client, max_head_id } } /// Returns reference to the underlying RPC client. - pub fn client(&self) -> &Client { + pub fn client(&self) -> &SourceRelayClnt { &self.client } @@ -64,8 +68,8 @@ impl ParachainsSource

{ let para_id = ParaId(P::SourceParachain::PARACHAIN_ID); let storage_key = parachain_head_storage_key_at_source(P::SourceRelayChain::PARAS_PALLET_NAME, para_id); - let para_head = self.client.raw_storage_value(storage_key, Some(at_block.1)).await?; - let para_head = para_head.map(|h| ParaHead::decode(&mut &h.0[..])).transpose()?; + let para_head: Option = + self.client.storage_value(at_block.hash(), storage_key).await?; let para_head = match para_head { Some(para_head) => para_head, None => return Ok(None), @@ -76,7 +80,9 @@ impl ParachainsSource

{ } #[async_trait] -impl RelayClient for ParachainsSource

{ +impl> RelayClient + for ParachainsSource +{ type Error = SubstrateError; async fn reconnect(&mut self) -> Result<(), SubstrateError> { @@ -85,8 +91,8 @@ impl RelayClient for ParachainsSource

{ } #[async_trait] -impl SourceClient> - for ParachainsSource

+impl> + SourceClient> for ParachainsSource where P::SourceParachain: Chain, { @@ -149,12 +155,9 @@ where let parachain = ParaId(P::SourceParachain::PARACHAIN_ID); let storage_key = parachain_head_storage_key_at_source(P::SourceRelayChain::PARAS_PALLET_NAME, parachain); - let parachain_heads_proof = self - .client - .prove_storage(vec![storage_key.clone()], at_block.1) - .await? - .into_iter_nodes() - .collect(); + + let storage_proof = + self.client.prove_storage(at_block.hash(), vec![storage_key.clone()]).await?; // why we're reading parachain head here once again (it has already been read at the // `parachain_head`)? that's because `parachain_head` sometimes returns obsolete parachain @@ -165,10 +168,8 @@ where // rereading actual value here let parachain_head = self .client - .raw_storage_value(storage_key, Some(at_block.1)) + .storage_value::(at_block.hash(), storage_key) .await? - .map(|h| ParaHead::decode(&mut &h.0[..])) - .transpose()? .ok_or_else(|| { SubstrateError::Custom(format!( "Failed to read expected parachain {parachain:?} head at {at_block:?}" @@ -176,6 +177,11 @@ where })?; let parachain_head_hash = parachain_head.hash(); - Ok((ParaHeadsProof { storage_proof: parachain_heads_proof }, parachain_head_hash)) + Ok(( + ParaHeadsProof { + storage_proof: to_raw_storage_proof::(storage_proof), + }, + parachain_head_hash, + )) } } diff --git a/bridges/relays/lib-substrate-relay/src/parachains/target.rs b/bridges/relays/lib-substrate-relay/src/parachains/target.rs index 531d55b53223609c523d521f43a38336353c597f..f66b193340c1a5e243b3bca17a111ed20f422c37 100644 --- a/bridges/relays/lib-substrate-relay/src/parachains/target.rs +++ b/bridges/relays/lib-substrate-relay/src/parachains/target.rs @@ -42,31 +42,42 @@ use relay_substrate_client::{ }; use relay_utils::relay_loop::Client as RelayClient; use sp_core::Pair; +use sp_runtime::traits::Header; /// Substrate client as parachain heads source. -pub struct ParachainsTarget { - source_client: Client, - target_client: Client, +pub struct ParachainsTarget { + source_client: SourceClnt, + target_client: TargetClnt, transaction_params: TransactionParams>, } -impl ParachainsTarget

{ +impl< + P: SubstrateParachainsPipeline, + SourceClnt: Client, + TargetClnt: Client, + > ParachainsTarget +{ /// Creates new parachains target client. pub fn new( - source_client: Client, - target_client: Client, + source_client: SourceClnt, + target_client: TargetClnt, transaction_params: TransactionParams>, ) -> Self { ParachainsTarget { source_client, target_client, transaction_params } } /// Returns reference to the underlying RPC client. - pub fn target_client(&self) -> &Client { + pub fn target_client(&self) -> &TargetClnt { &self.target_client } } -impl Clone for ParachainsTarget

{ +impl< + P: SubstrateParachainsPipeline, + SourceClnt: Client, + TargetClnt: Clone, + > Clone for ParachainsTarget +{ fn clone(&self) -> Self { ParachainsTarget { source_client: self.source_client.clone(), @@ -77,7 +88,12 @@ impl Clone for ParachainsTarget

{ } #[async_trait] -impl RelayClient for ParachainsTarget

{ +impl< + P: SubstrateParachainsPipeline, + SourceClnt: Client, + TargetClnt: Client, + > RelayClient for ParachainsTarget +{ type Error = SubstrateError; async fn reconnect(&mut self) -> Result<(), SubstrateError> { @@ -88,14 +104,17 @@ impl RelayClient for ParachainsTarget

{ } #[async_trait] -impl

TargetClient> for ParachainsTarget

+impl TargetClient> + for ParachainsTarget where P: SubstrateParachainsPipeline, + SourceClnt: Client, + TargetClnt: Client, AccountIdOf: From< as Pair>::Public>, P::SourceParachain: ChainBase, P::SourceRelayChain: ChainBase, { - type TransactionTracker = TransactionTracker>; + type TransactionTracker = TransactionTracker; async fn best_block(&self) -> Result, Self::Error> { let best_header = self.target_client.best_header().await?; @@ -109,10 +128,10 @@ where at_block: &HeaderIdOf, ) -> Result, Self::Error> { self.target_client - .typed_state_call::<_, Option>>( + .state_call::<_, Option>>( + at_block.hash(), P::SourceRelayChain::BEST_FINALIZED_HEADER_ID_METHOD.into(), (), - Some(at_block.1), ) .await? .map(Ok) @@ -124,7 +143,11 @@ where ) -> Result>, Self::Error> { Ok(self .target_client - .typed_state_call(P::SourceRelayChain::FREE_HEADERS_INTERVAL_METHOD.into(), (), None) + .state_call( + self.target_client.best_header().await?.hash(), + P::SourceRelayChain::FREE_HEADERS_INTERVAL_METHOD.into(), + (), + ) .await .unwrap_or_else(|e| { log::info!( @@ -151,7 +174,7 @@ where &P::SourceParachain::PARACHAIN_ID.into(), ); let storage_value: Option = - self.target_client.storage_value(storage_key, Some(at_block.hash())).await?; + self.target_client.storage_value(at_block.hash(), storage_key).await?; let para_info = match storage_value { Some(para_info) => para_info, None => return Ok(None), @@ -172,7 +195,7 @@ where ¶_info.best_head_hash.head_hash, ); let storage_value: Option = - self.target_client.storage_value(storage_key, Some(at_block.hash())).await?; + self.target_client.storage_value(at_block.hash(), storage_key).await?; let para_head_number = match storage_value { Some(para_head_data) => para_head_data.decode_parachain_head_data::()?.number, diff --git a/bridges/relays/messages/Cargo.toml b/bridges/relays/messages/Cargo.toml index 570e11c0da6feeaa7bbbbd76a845df51444a10cb..c7a132bb3bae7ebc34728de8c94c41fb39c89751 100644 --- a/bridges/relays/messages/Cargo.toml +++ b/bridges/relays/messages/Cargo.toml @@ -11,19 +11,18 @@ publish = false workspace = true [dependencies] -async-std = { version = "1.9.0", features = ["attributes"] } -async-trait = "0.1.79" -env_logger = "0.11" -futures = "0.3.30" -hex = "0.4" +async-std = { features = ["attributes"], workspace = true } +async-trait = { workspace = true } +futures = { workspace = true } +hex = { workspace = true, default-features = true } log = { workspace = true } -num-traits = "0.2" -parking_lot = "0.12.1" +num-traits = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } # Bridge Dependencies -bp-messages = { path = "../../primitives/messages" } -finality-relay = { path = "../finality" } -relay-utils = { path = "../utils" } +bp-messages = { workspace = true, default-features = true } +finality-relay = { workspace = true } +relay-utils = { workspace = true } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic" } +sp-arithmetic = { workspace = true, default-features = true } diff --git a/bridges/relays/messages/src/lib.rs b/bridges/relays/messages/src/lib.rs index 9c62cee5ee3db1e0b8825d2893d53422bf44a33c..78a3237ba4fe03851412b86e08867fcba07e8451 100644 --- a/bridges/relays/messages/src/lib.rs +++ b/bridges/relays/messages/src/lib.rs @@ -35,3 +35,6 @@ mod message_race_limits; mod message_race_loop; mod message_race_receiving; mod message_race_strategy; + +pub use message_race_delivery::relay_messages_range; +pub use message_race_receiving::relay_messages_delivery_confirmation; diff --git a/bridges/relays/messages/src/message_race_delivery.rs b/bridges/relays/messages/src/message_race_delivery.rs index f18c43cc7f0e084100d8096432dccafbd61301be..cbb89baabcc5ab38f164189066e225ad1e8f9240 100644 --- a/bridges/relays/messages/src/message_race_delivery.rs +++ b/bridges/relays/messages/src/message_race_delivery.rs @@ -19,7 +19,7 @@ use async_trait::async_trait; use futures::stream::FusedStream; use bp_messages::{MessageNonce, UnrewardedRelayersState, Weight}; -use relay_utils::FailedClient; +use relay_utils::{FailedClient, TrackedTransactionStatus, TransactionTracker}; use crate::{ message_lane::{MessageLane, SourceHeaderIdOf, TargetHeaderIdOf}, @@ -77,6 +77,69 @@ pub async fn run( .await } +/// Relay range of messages. +pub async fn relay_messages_range( + source_client: impl MessageLaneSourceClient

, + target_client: impl MessageLaneTargetClient

, + at: SourceHeaderIdOf

, + range: RangeInclusive, + outbound_state_proof_required: bool, +) -> Result<(), ()> { + // compute cumulative dispatch weight of all messages in given range + let dispatch_weight = source_client + .generated_message_details(at.clone(), range.clone()) + .await + .map_err(|e| { + log::error!( + target: "bridge", + "Failed to get generated message details at {:?} for messages {:?}: {:?}", + at, + range, + e, + ); + })? + .values() + .fold(Weight::zero(), |total, details| total.saturating_add(details.dispatch_weight)); + // prepare messages proof + let (at, range, proof) = source_client + .prove_messages( + at.clone(), + range.clone(), + MessageProofParameters { outbound_state_proof_required, dispatch_weight }, + ) + .await + .map_err(|e| { + log::error!( + target: "bridge", + "Failed to generate messages proof at {:?} for messages {:?}: {:?}", + at, + range, + e, + ); + })?; + // submit messages proof to the target node + let tx_tracker = target_client + .submit_messages_proof(None, at, range.clone(), proof) + .await + .map_err(|e| { + log::error!( + target: "bridge", + "Failed to submit messages proof for messages {:?}: {:?}", + range, + e, + ); + })? + .tx_tracker; + + match tx_tracker.wait().await { + TrackedTransactionStatus::Finalized(_) => Ok(()), + TrackedTransactionStatus::Lost => { + log::error!("Transaction with messages {:?} is considered lost", range,); + Err(()) + }, + } +} + /// Message delivery race. struct MessageDeliveryRace

(std::marker::PhantomData

); diff --git a/bridges/relays/messages/src/message_race_receiving.rs b/bridges/relays/messages/src/message_race_receiving.rs index e6497a1b79eb70999f16cd0c1926ae9cf0ad5411..ac4149b22d7b124f9cf661e8a99de7dedc4a15fe 100644 --- a/bridges/relays/messages/src/message_race_receiving.rs +++ b/bridges/relays/messages/src/message_race_receiving.rs @@ -30,7 +30,7 @@ use crate::{ use async_trait::async_trait; use bp_messages::MessageNonce; use futures::stream::FusedStream; -use relay_utils::FailedClient; +use relay_utils::{FailedClient, TrackedTransactionStatus, TransactionTracker}; use std::{marker::PhantomData, ops::RangeInclusive}; /// Message receiving confirmations delivery strategy. @@ -69,6 +69,43 @@ pub async fn run( .await } +/// Relay messages delivery confirmation. +pub async fn relay_messages_delivery_confirmation( + source_client: impl MessageLaneSourceClient

, + target_client: impl MessageLaneTargetClient

, + at: TargetHeaderIdOf

, +) -> Result<(), ()> { + // prepare messages delivery proof + let (at, proof) = target_client.prove_messages_receiving(at.clone()).await.map_err(|e| { + log::error!( + target: "bridge", + "Failed to generate messages delivery proof at {:?}: {:?}", + at, + e, + ); + })?; + // submit messages delivery proof to the source node + let tx_tracker = + source_client + .submit_messages_receiving_proof(None, at, proof) + .await + .map_err(|e| { + log::error!( + target: "bridge", + "Failed to submit messages delivery proof: {:?}", + e, + ); + })?; + + match tx_tracker.wait().await { + TrackedTransactionStatus::Finalized(_) => Ok(()), + TrackedTransactionStatus::Lost => { + log::error!("Transaction with messages delivery proof is considered lost"); + Err(()) + }, + } +} + /// Messages receiving confirmations race. struct ReceivingConfirmationsRace

(std::marker::PhantomData

); diff --git a/bridges/relays/parachains/Cargo.toml b/bridges/relays/parachains/Cargo.toml index a73a2f5b31c1aca5d93bf0b871b79b5e279da6ff..ed03bdbb0f65e6f5e3b15c63f6ccd680c89e6626 100644 --- a/bridges/relays/parachains/Cargo.toml +++ b/bridges/relays/parachains/Cargo.toml @@ -11,18 +11,18 @@ publish = false workspace = true [dependencies] -async-std = "1.9.0" -async-trait = "0.1.79" -futures = "0.3.30" +async-std = { workspace = true } +async-trait = { workspace = true } +futures = { workspace = true } log = { workspace = true } -relay-utils = { path = "../utils" } +relay-utils = { workspace = true } # Bridge dependencies -bp-polkadot-core = { path = "../../primitives/polkadot-core" } -relay-substrate-client = { path = "../client-substrate" } +bp-polkadot-core = { workspace = true, default-features = true } +relay-substrate-client = { workspace = true } [dev-dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -relay-substrate-client = { path = "../client-substrate", features = ["test-helpers"] } -sp-core = { path = "../../../substrate/primitives/core" } +codec = { workspace = true, default-features = true } +relay-substrate-client = { features = ["test-helpers"], workspace = true } +sp-core = { workspace = true, default-features = true } diff --git a/bridges/relays/parachains/src/parachains_loop.rs b/bridges/relays/parachains/src/parachains_loop.rs index fd73ca2d46c00f8e05bb05a14a7fa4104ef898c4..0fd1d72c7075bc29632280615f203e0c0028359b 100644 --- a/bridges/relays/parachains/src/parachains_loop.rs +++ b/bridges/relays/parachains/src/parachains_loop.rs @@ -680,7 +680,6 @@ impl SubmittedHeadsTracker

{ mod tests { use super::*; use async_std::sync::{Arc, Mutex}; - use codec::Encode; use futures::{SinkExt, StreamExt}; use relay_substrate_client::test_chain::{TestChain, TestParachain}; use relay_utils::{HeaderId, MaybeConnectionError}; @@ -821,8 +820,7 @@ mod tests { let head_result = SourceClient::::parachain_head(self, at_block).await?; let head = head_result.as_available().unwrap(); - let storage_proof = vec![head.hash().encode()]; - let proof = (ParaHeadsProof { storage_proof }, head.hash()); + let proof = (ParaHeadsProof { storage_proof: Default::default() }, head.hash()); self.data.lock().await.source_proof.clone().map(|_| proof) } } diff --git a/bridges/relays/utils/Cargo.toml b/bridges/relays/utils/Cargo.toml index ee56ebf9a956c6f4fdd06b554da279b56ed534dc..4c25566607dcdb574dce7f36183867fee0d29742 100644 --- a/bridges/relays/utils/Cargo.toml +++ b/bridges/relays/utils/Cargo.toml @@ -11,28 +11,29 @@ publish = false workspace = true [dependencies] -ansi_term = "0.12" -anyhow = "1.0" -async-std = "1.9.0" -async-trait = "0.1.79" -backoff = "0.4" -isahc = "1.2" -env_logger = "0.11.3" -futures = "0.3.30" -jsonpath_lib = "0.3" +anyhow = { workspace = true, default-features = true } +async-std = { workspace = true } +async-trait = { workspace = true } +backoff = { workspace = true } +console = { workspace = true } +isahc = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +futures = { workspace = true } +jsonpath_lib = { workspace = true } log = { workspace = true } -num-traits = "0.2" +num-traits = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -sysinfo = "0.30" -time = { version = "0.3", features = ["formatting", "local-offset", "std"] } -tokio = { version = "1.37", features = ["rt"] } +sysinfo = { workspace = true } +time = { features = ["formatting", "local-offset", "std"], workspace = true } +tokio = { features = ["rt"], workspace = true, default-features = true } thiserror = { workspace = true } # Bridge dependencies -bp-runtime = { path = "../../primitives/runtime" } +bp-runtime = { workspace = true, default-features = true } # Substrate dependencies -sp-runtime = { path = "../../../substrate/primitives/runtime" } -substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" } +sp-runtime = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } diff --git a/bridges/relays/utils/src/error.rs b/bridges/relays/utils/src/error.rs index 26f1d0cacefd8eef5687e0102588f999859012a5..48c02bb9bd7a4510e46f4353f4bad448addbf1f4 100644 --- a/bridges/relays/utils/src/error.rs +++ b/bridges/relays/utils/src/error.rs @@ -42,5 +42,5 @@ pub enum Error { ExposingMetricsInvalidHost(String, AddrParseError), /// Prometheus error. #[error("{0}")] - Prometheus(#[from] substrate_prometheus_endpoint::prometheus::Error), + Prometheus(#[from] prometheus_endpoint::prometheus::Error), } diff --git a/bridges/relays/utils/src/initialize.rs b/bridges/relays/utils/src/initialize.rs index 8224c1803ad2f74ec694cd68c18a556dddc6d76f..564ed1f0e5cc831e27df6dbb973583752ad4374f 100644 --- a/bridges/relays/utils/src/initialize.rs +++ b/bridges/relays/utils/src/initialize.rs @@ -16,7 +16,19 @@ //! Relayer initialization functions. -use std::{cell::RefCell, fmt::Display, io::Write}; +use parking_lot::Mutex; +use sp_tracing::{ + tracing::Level, + tracing_subscriber::{ + fmt::{time::OffsetTime, SubscriberBuilder}, + EnvFilter, + }, +}; +use std::cell::RefCell; + +/// Relayer version that is provided as metric. Must be set by a binary +/// (get it with `option_env!("CARGO_PKG_VERSION")` from a binary package code). +pub static RELAYER_VERSION: Mutex> = Mutex::new(None); async_std::task_local! { pub(crate) static LOOP_NAME: RefCell = RefCell::new(String::default()); @@ -35,102 +47,25 @@ pub fn initialize_logger(with_timestamp: bool) { ) .expect("static format string is valid"); - let mut builder = env_logger::Builder::new(); - builder.filter_level(log::LevelFilter::Warn); - builder.filter_module("bridge", log::LevelFilter::Info); - builder.parse_default_env(); - if with_timestamp { - builder.format(move |buf, record| { - let timestamp = time::OffsetDateTime::now_local() - .unwrap_or_else(|_| time::OffsetDateTime::now_utc()); - let timestamp = timestamp.format(&format).unwrap_or_else(|_| timestamp.to_string()); + let local_time = OffsetTime::new( + time::UtcOffset::current_local_offset().unwrap_or(time::UtcOffset::UTC), + format, + ); - let log_level = color_level(record.level()); - let log_target = color_target(record.target()); - let timestamp = if cfg!(windows) { - Either::Left(timestamp) - } else { - Either::Right(ansi_term::Colour::Fixed(8).bold().paint(timestamp)) - }; + let env_filter = EnvFilter::from_default_env() + .add_directive(Level::WARN.into()) + .add_directive("bridge=info".parse().expect("static filter string is valid")); - writeln!( - buf, - "{}{} {} {} {}", - loop_name_prefix(), - timestamp, - log_level, - log_target, - record.args(), - ) - }); - } else { - builder.format(move |buf, record| { - let log_level = color_level(record.level()); - let log_target = color_target(record.target()); + let builder = SubscriberBuilder::default().with_env_filter(env_filter); - writeln!(buf, "{}{log_level} {log_target} {}", loop_name_prefix(), record.args(),) - }); + if with_timestamp { + builder.with_timer(local_time).init(); + } else { + builder.without_time().init(); } - - builder.init(); } /// Initialize relay loop. Must only be called once per every loop task. pub(crate) fn initialize_loop(loop_name: String) { LOOP_NAME.with(|g_loop_name| *g_loop_name.borrow_mut() = loop_name); } - -/// Returns loop name prefix to use in logs. The prefix is initialized with the `initialize_loop` -/// call. -fn loop_name_prefix() -> String { - // try_with to avoid panic outside of async-std task context - LOOP_NAME - .try_with(|loop_name| { - // using borrow is ok here, because loop is only initialized once (=> borrow_mut will - // only be called once) - let loop_name = loop_name.borrow(); - if loop_name.is_empty() { - String::new() - } else { - format!("[{loop_name}] ") - } - }) - .unwrap_or_else(|_| String::new()) -} - -enum Either { - Left(A), - Right(B), -} -impl Display for Either { - fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result { - match self { - Self::Left(a) => write!(fmt, "{a}"), - Self::Right(b) => write!(fmt, "{b}"), - } - } -} - -fn color_target(target: &str) -> impl Display + '_ { - if cfg!(windows) { - Either::Left(target) - } else { - Either::Right(ansi_term::Colour::Fixed(8).paint(target)) - } -} - -fn color_level(level: log::Level) -> impl Display { - if cfg!(windows) { - Either::Left(level) - } else { - let s = level.to_string(); - use ansi_term::Colour as Color; - Either::Right(match level { - log::Level::Error => Color::Fixed(9).bold().paint(s), - log::Level::Warn => Color::Fixed(11).bold().paint(s), - log::Level::Info => Color::Fixed(10).paint(s), - log::Level::Debug => Color::Fixed(14).paint(s), - log::Level::Trace => Color::Fixed(12).paint(s), - }) - } -} diff --git a/bridges/relays/utils/src/metrics.rs b/bridges/relays/utils/src/metrics.rs index 2e6c8236da454dd620ccdb5f1f03cdbf9eed9471..4c946651b058cc87eca3d2d88431cfc500a1126a 100644 --- a/bridges/relays/utils/src/metrics.rs +++ b/bridges/relays/utils/src/metrics.rs @@ -16,7 +16,7 @@ pub use float_json_value::FloatJsonValueMetric; pub use global::GlobalMetrics; -pub use substrate_prometheus_endpoint::{ +pub use prometheus_endpoint::{ prometheus::core::{Atomic, Collector}, register, Counter, CounterVec, Gauge, GaugeVec, Opts, PrometheusError, Registry, F64, I64, U64, }; diff --git a/bridges/relays/utils/src/relay_loop.rs b/bridges/relays/utils/src/relay_loop.rs index 7105190a45831f57ecb728ac0d354157b020db8a..7f84fdc98f3cfbdfd61b4d413c7296d583ad6789 100644 --- a/bridges/relays/utils/src/relay_loop.rs +++ b/bridges/relays/utils/src/relay_loop.rs @@ -21,8 +21,8 @@ use crate::{ }; use async_trait::async_trait; +use prometheus_endpoint::{init_prometheus, Registry}; use std::{fmt::Debug, future::Future, net::SocketAddr, time::Duration}; -use substrate_prometheus_endpoint::{init_prometheus, Registry}; /// Default pause between reconnect attempts. pub const RECONNECT_DELAY: Duration = Duration::from_secs(10); diff --git a/bridges/snowbridge/pallets/ethereum-client/Cargo.toml b/bridges/snowbridge/pallets/ethereum-client/Cargo.toml index 0e15304ff11234d6c1871511fc8c3237830fe9a4..666ac3fbc8a2ab32b485c088c37b536e751cdd46 100644 --- a/bridges/snowbridge/pallets/ethereum-client/Cargo.toml +++ b/bridges/snowbridge/pallets/ethereum-client/Cargo.toml @@ -17,34 +17,34 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] serde = { optional = true, workspace = true, default-features = true } serde_json = { optional = true, workspace = true, default-features = true } -codec = { version = "3.6.1", package = "parity-scale-codec", default-features = false, features = ["derive"] } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1", optional = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } +hex-literal = { optional = true, workspace = true, default-features = true } log = { workspace = true } -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-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false, optional = true } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +sp-runtime = { workspace = true } +sp-io = { optional = true, workspace = true } -snowbridge-core = { path = "../../primitives/core", default-features = false } -snowbridge-ethereum = { path = "../../primitives/ethereum", default-features = false } -snowbridge-pallet-ethereum-client-fixtures = { path = "fixtures", default-features = false, optional = true } -primitives = { package = "snowbridge-beacon-primitives", path = "../../primitives/beacon", default-features = false } -static_assertions = { version = "1.1.0", default-features = false } -pallet-timestamp = { path = "../../../../substrate/frame/timestamp", default-features = false, optional = true } +snowbridge-core = { workspace = true } +snowbridge-ethereum = { workspace = true } +snowbridge-pallet-ethereum-client-fixtures = { optional = true, workspace = true } +snowbridge-beacon-primitives = { workspace = true } +static_assertions = { workspace = true } +pallet-timestamp = { optional = true, workspace = true } [dev-dependencies] -rand = "0.8.5" -sp-keyring = { path = "../../../../substrate/primitives/keyring" } +rand = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -hex-literal = "0.4.1" -pallet-timestamp = { path = "../../../../substrate/frame/timestamp" } -snowbridge-pallet-ethereum-client-fixtures = { path = "fixtures" } -sp-io = { path = "../../../../substrate/primitives/io" } +hex-literal = { workspace = true, default-features = true } +pallet-timestamp = { workspace = true, default-features = true } +snowbridge-pallet-ethereum-client-fixtures = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } serde = { workspace = true, default-features = true } [features] @@ -62,9 +62,9 @@ std = [ "frame-system/std", "log/std", "pallet-timestamp/std", - "primitives/std", "scale-info/std", "serde", + "snowbridge-beacon-primitives/std", "snowbridge-core/std", "snowbridge-ethereum/std", "snowbridge-pallet-ethereum-client-fixtures/std", diff --git a/bridges/snowbridge/pallets/ethereum-client/fixtures/Cargo.toml b/bridges/snowbridge/pallets/ethereum-client/fixtures/Cargo.toml index 858e2513a961288dd24c47e7d57ada1506b212d2..bd4176875733f64f61026e165a2a03b221193bad 100644 --- a/bridges/snowbridge/pallets/ethereum-client/fixtures/Cargo.toml +++ b/bridges/snowbridge/pallets/ethereum-client/fixtures/Cargo.toml @@ -15,11 +15,11 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -hex-literal = { version = "0.4.1" } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -snowbridge-core = { path = "../../../primitives/core", default-features = false } -snowbridge-beacon-primitives = { path = "../../../primitives/beacon", default-features = false } +hex-literal = { workspace = true, default-features = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +snowbridge-core = { workspace = true } +snowbridge-beacon-primitives = { workspace = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs index 4b8796b628d793951fec9ba905db1cd17f544eee..12aa3f4ca1fad4a0ac3c2adf8a0f54eaaf30b457 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/mod.rs @@ -9,7 +9,7 @@ use frame_system::RawOrigin; use snowbridge_pallet_ethereum_client_fixtures::*; -use primitives::{ +use snowbridge_beacon_primitives::{ fast_aggregate_verify, prepare_aggregate_pubkey, prepare_aggregate_signature, verify_merkle_branch, }; diff --git a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs index 7e5ded6e1f0d26cad99b5ee84f97eeb277605954..95e16d9fd434226db614cc29b9a8d995eb7ee930 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/benchmarking/util.rs @@ -4,7 +4,7 @@ use crate::{ decompress_sync_committee_bits, Config, CurrentSyncCommittee, Pallet as EthereumBeaconClient, Update, ValidatorsRoot, Vec, }; -use primitives::PublicKeyPrepared; +use snowbridge_beacon_primitives::PublicKeyPrepared; use sp_core::H256; pub fn participant_pubkeys( diff --git a/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs b/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs index ba3ea47b94f9acf3dade1aec2bf39bd4d18b51ee..1ab1f67d6397f49d1f793d4250a3552c715db28d 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/config/mod.rs @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 Snowfork -use primitives::merkle_proof::{generalized_index_length, subtree_index}; +use snowbridge_beacon_primitives::merkle_proof::{generalized_index_length, subtree_index}; use static_assertions::const_assert; /// Generalized Indices diff --git a/bridges/snowbridge/pallets/ethereum-client/src/functions.rs b/bridges/snowbridge/pallets/ethereum-client/src/functions.rs index 751e63c7f86afb6ae4161e9ec4b9ebe750d67436..781ae6c67638a60e5114b996fc73502795337c4d 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/functions.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/functions.rs @@ -10,9 +10,10 @@ use crate::config::{ pub fn decompress_sync_committee_bits( input: [u8; SYNC_COMMITTEE_BITS_SIZE], ) -> [u8; SYNC_COMMITTEE_SIZE] { - primitives::decompress_sync_committee_bits::( - input, - ) + snowbridge_beacon_primitives::decompress_sync_committee_bits::< + SYNC_COMMITTEE_SIZE, + SYNC_COMMITTEE_BITS_SIZE, + >(input) } /// Compute the sync committee period in which a slot is contained. diff --git a/bridges/snowbridge/pallets/ethereum-client/src/impls.rs b/bridges/snowbridge/pallets/ethereum-client/src/impls.rs index f600b1f67e29e7875bfccd6fab6926edda6498cc..2def6f58ba3034d2639a1bf8d25fddb1bbd1af31 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/impls.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/impls.rs @@ -2,7 +2,7 @@ // SPDX-FileCopyrightText: 2023 Snowfork use super::*; use frame_support::ensure; -use primitives::ExecutionProof; +use snowbridge_beacon_primitives::ExecutionProof; use snowbridge_core::inbound::{ VerificationError::{self, *}, diff --git a/bridges/snowbridge/pallets/ethereum-client/src/lib.rs b/bridges/snowbridge/pallets/ethereum-client/src/lib.rs index c1b9e19729bc47588ad179db0c9c280a05834bc1..6894977c21f4a2a78b1c7f67eb0b36a791936b92 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/lib.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/lib.rs @@ -36,7 +36,7 @@ use frame_support::{ dispatch::DispatchResult, pallet_prelude::OptionQuery, traits::Get, transactional, }; use frame_system::ensure_signed; -use primitives::{ +use snowbridge_beacon_primitives::{ fast_aggregate_verify, verify_merkle_branch, verify_receipt_proof, BeaconHeader, BlsError, CompactBeaconState, ForkData, ForkVersion, ForkVersions, PublicKeyPrepared, SigningData, }; @@ -104,6 +104,7 @@ pub mod pallet { #[pallet::error] pub enum Error { SkippedSyncCommitteePeriod, + SyncCommitteeUpdateRequired, /// Attested header is older than latest finalized header. IrrelevantUpdate, NotBootstrapped, @@ -138,41 +139,39 @@ pub mod pallet { /// Latest imported checkpoint root #[pallet::storage] #[pallet::getter(fn initial_checkpoint_root)] - pub(super) type InitialCheckpointRoot = StorageValue<_, H256, ValueQuery>; + pub type InitialCheckpointRoot = StorageValue<_, H256, ValueQuery>; /// Latest imported finalized block root #[pallet::storage] #[pallet::getter(fn latest_finalized_block_root)] - pub(super) type LatestFinalizedBlockRoot = StorageValue<_, H256, ValueQuery>; + pub type LatestFinalizedBlockRoot = StorageValue<_, H256, ValueQuery>; /// Beacon state by finalized block root #[pallet::storage] #[pallet::getter(fn finalized_beacon_state)] - pub(super) type FinalizedBeaconState = + pub type FinalizedBeaconState = StorageMap<_, Identity, H256, CompactBeaconState, OptionQuery>; /// Finalized Headers: Current position in ring buffer #[pallet::storage] - pub(crate) type FinalizedBeaconStateIndex = StorageValue<_, u32, ValueQuery>; + pub type FinalizedBeaconStateIndex = StorageValue<_, u32, ValueQuery>; /// Finalized Headers: Mapping of ring buffer index to a pruning candidate #[pallet::storage] - pub(crate) type FinalizedBeaconStateMapping = + pub type FinalizedBeaconStateMapping = StorageMap<_, Identity, u32, H256, ValueQuery>; #[pallet::storage] #[pallet::getter(fn validators_root)] - pub(super) type ValidatorsRoot = StorageValue<_, H256, ValueQuery>; + pub type ValidatorsRoot = StorageValue<_, H256, ValueQuery>; /// Sync committee for current period #[pallet::storage] - pub(super) type CurrentSyncCommittee = - StorageValue<_, SyncCommitteePrepared, ValueQuery>; + pub type CurrentSyncCommittee = StorageValue<_, SyncCommitteePrepared, ValueQuery>; /// Sync committee for next period #[pallet::storage] - pub(super) type NextSyncCommittee = - StorageValue<_, SyncCommitteePrepared, ValueQuery>; + pub type NextSyncCommittee = StorageValue<_, SyncCommitteePrepared, ValueQuery>; /// The current operating mode of the pallet. #[pallet::storage] @@ -320,6 +319,7 @@ pub mod pallet { // Verify update is relevant. let update_attested_period = compute_period(update.attested_header.slot); + let update_finalized_period = compute_period(update.finalized_header.slot); let update_has_next_sync_committee = !>::exists() && (update.next_sync_committee_update.is_some() && update_attested_period == store_period); @@ -395,6 +395,11 @@ pub mod pallet { ), Error::::InvalidSyncCommitteeMerkleProof ); + } else { + ensure!( + update_finalized_period == store_period, + Error::::SyncCommitteeUpdateRequired + ); } // Verify sync committee aggregate signature. diff --git a/bridges/snowbridge/pallets/ethereum-client/src/mock.rs b/bridges/snowbridge/pallets/ethereum-client/src/mock.rs index bd6144ebd8f9335ff02a82ad756d1b6dd06125e5..96298d4fa8962641d6ec8bab0ef67b751ab749cc 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/mock.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/mock.rs @@ -4,7 +4,7 @@ use crate as ethereum_beacon_client; use crate::config; use frame_support::{derive_impl, dispatch::DispatchResult, parameter_types}; use pallet_timestamp; -use primitives::{Fork, ForkVersions}; +use snowbridge_beacon_primitives::{Fork, ForkVersions}; use snowbridge_core::inbound::{Log, Proof}; use sp_std::default::Default; use std::{fs::File, path::PathBuf}; @@ -21,32 +21,40 @@ where serde_json::from_reader(File::open(filepath).unwrap()) } -pub fn load_execution_proof_fixture() -> primitives::ExecutionProof { +pub fn load_execution_proof_fixture() -> snowbridge_beacon_primitives::ExecutionProof { load_fixture("execution-proof.json".to_string()).unwrap() } pub fn load_checkpoint_update_fixture( -) -> primitives::CheckpointUpdate<{ config::SYNC_COMMITTEE_SIZE }> { +) -> snowbridge_beacon_primitives::CheckpointUpdate<{ config::SYNC_COMMITTEE_SIZE }> { load_fixture("initial-checkpoint.json".to_string()).unwrap() } -pub fn load_sync_committee_update_fixture( -) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> { +pub fn load_sync_committee_update_fixture() -> snowbridge_beacon_primitives::Update< + { config::SYNC_COMMITTEE_SIZE }, + { config::SYNC_COMMITTEE_BITS_SIZE }, +> { load_fixture("sync-committee-update.json".to_string()).unwrap() } -pub fn load_finalized_header_update_fixture( -) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> { +pub fn load_finalized_header_update_fixture() -> snowbridge_beacon_primitives::Update< + { config::SYNC_COMMITTEE_SIZE }, + { config::SYNC_COMMITTEE_BITS_SIZE }, +> { load_fixture("finalized-header-update.json".to_string()).unwrap() } -pub fn load_next_sync_committee_update_fixture( -) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> { +pub fn load_next_sync_committee_update_fixture() -> snowbridge_beacon_primitives::Update< + { config::SYNC_COMMITTEE_SIZE }, + { config::SYNC_COMMITTEE_BITS_SIZE }, +> { load_fixture("next-sync-committee-update.json".to_string()).unwrap() } -pub fn load_next_finalized_header_update_fixture( -) -> primitives::Update<{ config::SYNC_COMMITTEE_SIZE }, { config::SYNC_COMMITTEE_BITS_SIZE }> { +pub fn load_next_finalized_header_update_fixture() -> snowbridge_beacon_primitives::Update< + { config::SYNC_COMMITTEE_SIZE }, + { config::SYNC_COMMITTEE_BITS_SIZE }, +> { load_fixture("next-finalized-header-update.json".to_string()).unwrap() } diff --git a/bridges/snowbridge/pallets/ethereum-client/src/tests.rs b/bridges/snowbridge/pallets/ethereum-client/src/tests.rs index 765958c128212ee279bf547eb864335c7921e2eb..c16743b75ea40b793947240773d159da908dab01 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/tests.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/tests.rs @@ -17,7 +17,7 @@ pub use crate::mock::*; use crate::config::{EPOCHS_PER_SYNC_COMMITTEE_PERIOD, SLOTS_PER_EPOCH, SLOTS_PER_HISTORICAL_ROOT}; use frame_support::{assert_err, assert_noop, assert_ok}; use hex_literal::hex; -use primitives::{ +use snowbridge_beacon_primitives::{ types::deneb, Fork, ForkVersions, NextSyncCommitteeUpdate, VersionedExecutionPayloadHeader, }; use snowbridge_core::inbound::{VerificationError, Verifier}; @@ -171,7 +171,8 @@ pub fn sync_committee_participation_is_supermajority() { let bits = hex!("bffffffff7f1ffdfcfeffeffbfdffffbfffffdffffefefffdffff7f7ffff77fffdf7bff77ffdf7fffafffffff77fefffeff7effffffff5f7fedfffdfb6ddff7b" ); - let participation = primitives::decompress_sync_committee_bits::<512, 64>(bits); + let participation = + snowbridge_beacon_primitives::decompress_sync_committee_bits::<512, 64>(bits); assert_ok!(EthereumBeaconClient::sync_committee_participation_is_supermajority(&participation)); } @@ -362,13 +363,14 @@ fn submit_update_with_sync_committee_in_current_period() { } #[test] -fn submit_update_in_next_period() { +fn reject_submit_update_in_next_period() { let checkpoint = Box::new(load_checkpoint_update_fixture()); let sync_committee_update = Box::new(load_sync_committee_update_fixture()); let update = Box::new(load_next_finalized_header_update_fixture()); let sync_committee_period = compute_period(sync_committee_update.finalized_header.slot); let next_sync_committee_period = compute_period(update.finalized_header.slot); assert_eq!(sync_committee_period + 1, next_sync_committee_period); + let next_sync_committee_update = Box::new(load_next_sync_committee_update_fixture()); new_tester().execute_with(|| { assert_ok!(EthereumBeaconClient::process_checkpoint_update(&checkpoint)); @@ -376,6 +378,17 @@ fn submit_update_in_next_period() { RuntimeOrigin::signed(1), sync_committee_update.clone() )); + // check an update in the next period is rejected + assert_err!( + EthereumBeaconClient::submit(RuntimeOrigin::signed(1), update.clone()), + Error::::SyncCommitteeUpdateRequired + ); + // submit update with next sync committee + assert_ok!(EthereumBeaconClient::submit( + RuntimeOrigin::signed(1), + next_sync_committee_update + )); + // check same header in the next period can now be submitted successfully assert_ok!(EthereumBeaconClient::submit(RuntimeOrigin::signed(1), update.clone())); let block_root: H256 = update.finalized_header.clone().hash_tree_root().unwrap(); assert!(>::contains_key(block_root)); diff --git a/bridges/snowbridge/pallets/ethereum-client/src/types.rs b/bridges/snowbridge/pallets/ethereum-client/src/types.rs index 8808f989754b240d207101cbeff6fe25fe74279a..a670e691612ec132f8b11f1584b7de9dea504405 100644 --- a/bridges/snowbridge/pallets/ethereum-client/src/types.rs +++ b/bridges/snowbridge/pallets/ethereum-client/src/types.rs @@ -8,17 +8,17 @@ use frame_support::storage::types::OptionQuery; use snowbridge_core::RingBufferMapImpl; // Specialize types based on configured sync committee size -pub type SyncCommittee = primitives::SyncCommittee; -pub type SyncCommitteePrepared = primitives::SyncCommitteePrepared; -pub type SyncAggregate = primitives::SyncAggregate; -pub type CheckpointUpdate = primitives::CheckpointUpdate; -pub type Update = primitives::Update; -pub type NextSyncCommitteeUpdate = primitives::NextSyncCommitteeUpdate; +pub type SyncCommittee = snowbridge_beacon_primitives::SyncCommittee; +pub type SyncCommitteePrepared = snowbridge_beacon_primitives::SyncCommitteePrepared; +pub type SyncAggregate = snowbridge_beacon_primitives::SyncAggregate; +pub type CheckpointUpdate = snowbridge_beacon_primitives::CheckpointUpdate; +pub type Update = snowbridge_beacon_primitives::Update; +pub type NextSyncCommitteeUpdate = snowbridge_beacon_primitives::NextSyncCommitteeUpdate; -pub use primitives::{AncestryProof, ExecutionProof}; +pub use snowbridge_beacon_primitives::{AncestryProof, ExecutionProof}; /// FinalizedState ring buffer implementation -pub(crate) type FinalizedBeaconStateBuffer = RingBufferMapImpl< +pub type FinalizedBeaconStateBuffer = RingBufferMapImpl< u32, crate::MaxFinalizedHeadersToKeep, crate::FinalizedBeaconStateIndex, diff --git a/bridges/snowbridge/pallets/inbound-queue/Cargo.toml b/bridges/snowbridge/pallets/inbound-queue/Cargo.toml index 71d49e684e0b9379778f45743f6427a41796fd8a..1b08bb39b4346a76e58c0a695b4c71126bd40510 100644 --- a/bridges/snowbridge/pallets/inbound-queue/Cargo.toml +++ b/bridges/snowbridge/pallets/inbound-queue/Cargo.toml @@ -16,35 +16,35 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] serde = { optional = true, workspace = true, default-features = true } -codec = { version = "3.6.1", package = "parity-scale-codec", default-features = false, features = ["derive"] } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1", optional = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } +hex-literal = { optional = true, workspace = true, default-features = true } log = { workspace = true } -alloy-primitives = { version = "0.4.2", default-features = false, features = ["rlp"] } -alloy-sol-types = { version = "0.4.2", default-features = false } +alloy-primitives = { features = ["rlp"], workspace = true } +alloy-sol-types = { workspace = true } -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 } -pallet-balances = { path = "../../../../substrate/frame/balances", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-balances = { workspace = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } -snowbridge-core = { path = "../../primitives/core", default-features = false } -snowbridge-router-primitives = { path = "../../primitives/router", default-features = false } -snowbridge-beacon-primitives = { path = "../../primitives/beacon", default-features = false } -snowbridge-pallet-inbound-queue-fixtures = { path = "fixtures", default-features = false, optional = true } +snowbridge-core = { workspace = true } +snowbridge-router-primitives = { workspace = true } +snowbridge-beacon-primitives = { workspace = true } +snowbridge-pallet-inbound-queue-fixtures = { optional = true, workspace = true } [dev-dependencies] -frame-benchmarking = { path = "../../../../substrate/frame/benchmarking" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -snowbridge-pallet-ethereum-client = { path = "../ethereum-client" } -hex-literal = { version = "0.4.1" } +frame-benchmarking = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +snowbridge-pallet-ethereum-client = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/inbound-queue/fixtures/Cargo.toml b/bridges/snowbridge/pallets/inbound-queue/fixtures/Cargo.toml index e84246fb5a551b2512c4e00cb4ca00171e8c3f75..b66b57c3620ad5488d58b90a8f337ecd88f07e5d 100644 --- a/bridges/snowbridge/pallets/inbound-queue/fixtures/Cargo.toml +++ b/bridges/snowbridge/pallets/inbound-queue/fixtures/Cargo.toml @@ -15,11 +15,11 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -hex-literal = { version = "0.4.1" } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -snowbridge-core = { path = "../../../primitives/core", default-features = false } -snowbridge-beacon-primitives = { path = "../../../primitives/beacon", default-features = false } +hex-literal = { workspace = true, default-features = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +snowbridge-core = { workspace = true } +snowbridge-beacon-primitives = { workspace = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/inbound-queue/src/mock.rs b/bridges/snowbridge/pallets/inbound-queue/src/mock.rs index c96c868bc26ef71984e70bc40863db73cf18b9c5..a031676c6076ad417a9d0fd1f060e9387bb99eea 100644 --- a/bridges/snowbridge/pallets/inbound-queue/src/mock.rs +++ b/bridges/snowbridge/pallets/inbound-queue/src/mock.rs @@ -2,11 +2,7 @@ // SPDX-FileCopyrightText: 2023 Snowfork use super::*; -use frame_support::{ - derive_impl, parameter_types, - traits::{ConstU32, Everything}, - weights::IdentityFee, -}; +use frame_support::{derive_impl, parameter_types, traits::ConstU32, weights::IdentityFee}; use hex_literal::hex; use snowbridge_beacon_primitives::{ types::deneb, BeaconHeader, ExecutionProof, Fork, ForkVersions, VersionedExecutionPayloadHeader, @@ -19,7 +15,7 @@ use snowbridge_core::{ use snowbridge_router_primitives::inbound::MessageToXcm; use sp_core::{H160, H256}; use sp_runtime::{ - traits::{BlakeTwo256, IdentifyAccount, IdentityLookup, Verify}, + traits::{IdentifyAccount, IdentityLookup, Verify}, BuildStorage, FixedU128, MultiSignature, }; use sp_std::{convert::From, default::Default}; @@ -43,27 +39,13 @@ frame_support::construct_runtime!( pub type Signature = MultiSignature; pub type AccountId = <::Signer as IdentifyAccount>::AccountId; -parameter_types! { - pub const BlockHashCount: u64 = 250; -} - type Balance = u128; #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { - type BaseCallFilter = Everything; - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type RuntimeTask = RuntimeTask; - type Hash = H256; - type Hashing = BlakeTwo256; type AccountId = AccountId; type Lookup = IdentityLookup; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; - type Nonce = u64; type Block = Block; } @@ -71,20 +53,11 @@ parameter_types! { pub const ExistentialDeposit: u128 = 1; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type FreezeIdentifier = (); - type MaxFreezes = (); - type RuntimeHoldReason = (); - type RuntimeFreezeReason = (); } parameter_types! { diff --git a/bridges/snowbridge/pallets/outbound-queue/Cargo.toml b/bridges/snowbridge/pallets/outbound-queue/Cargo.toml index 387491abae0f652d63c55d50279d4145dc03b18d..78546e258daa30e966ddef1ed48c35cebcc17d65 100644 --- a/bridges/snowbridge/pallets/outbound-queue/Cargo.toml +++ b/bridges/snowbridge/pallets/outbound-queue/Cargo.toml @@ -16,27 +16,27 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] serde = { features = ["alloc", "derive"], workspace = true } -codec = { version = "3.6.1", package = "parity-scale-codec", default-features = false, features = ["derive"] } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } -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-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-arithmetic = { path = "../../../../substrate/primitives/arithmetic", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +sp-runtime = { workspace = true } +sp-io = { workspace = true } +sp-arithmetic = { workspace = true } -bridge-hub-common = { path = "../../../../cumulus/parachains/runtimes/bridge-hubs/common", default-features = false } +bridge-hub-common = { workspace = true } -snowbridge-core = { path = "../../primitives/core", default-features = false, features = ["serde"] } -snowbridge-outbound-queue-merkle-tree = { path = "merkle-tree", default-features = false } -ethabi = { package = "ethabi-decode", version = "1.0.0", default-features = false } +snowbridge-core = { features = ["serde"], workspace = true } +snowbridge-outbound-queue-merkle-tree = { workspace = true } +ethabi = { workspace = true } [dev-dependencies] -pallet-message-queue = { path = "../../../../substrate/frame/message-queue", default-features = false } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } +pallet-message-queue = { workspace = true } +sp-keyring = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/outbound-queue/merkle-tree/Cargo.toml b/bridges/snowbridge/pallets/outbound-queue/merkle-tree/Cargo.toml index 2d58517c18b0c55ff96e612948c7151c5dfc6ba8..9d4cffc98d789532ef13ed2a59f9f8d28d330ebb 100644 --- a/bridges/snowbridge/pallets/outbound-queue/merkle-tree/Cargo.toml +++ b/bridges/snowbridge/pallets/outbound-queue/merkle-tree/Cargo.toml @@ -15,18 +15,18 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { version = "3.1.5", package = "parity-scale-codec", default-features = false, features = ["derive"] } -scale-info = { version = "2.7.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } +sp-core = { workspace = true } +sp-runtime = { workspace = true } [dev-dependencies] -hex-literal = { version = "0.4.1" } -env_logger = "0.11" -hex = "0.4" -array-bytes = "6.2.2" -sp-crypto-hashing = { path = "../../../../../substrate/primitives/crypto/hashing" } +hex-literal = { workspace = true, default-features = true } +hex = { workspace = true, default-features = true } +array-bytes = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/outbound-queue/merkle-tree/src/lib.rs b/bridges/snowbridge/pallets/outbound-queue/merkle-tree/src/lib.rs index 8c91ccd04d9a6b001db3cf561b95ff0723d700aa..d5c89b9c0987f22573aed765ce87ca0ec54c5bf1 100644 --- a/bridges/snowbridge/pallets/outbound-queue/merkle-tree/src/lib.rs +++ b/bridges/snowbridge/pallets/outbound-queue/merkle-tree/src/lib.rs @@ -335,7 +335,7 @@ mod tests { #[test] fn should_generate_empty_root() { // given - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); let data = vec![]; // when @@ -351,7 +351,7 @@ mod tests { #[test] fn should_generate_single_root() { // given - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); let data = make_leaves(1); // when @@ -367,7 +367,7 @@ mod tests { #[test] fn should_generate_root_pow_2() { // given - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); let data = make_leaves(2); // when @@ -382,7 +382,7 @@ mod tests { #[test] fn should_generate_root_complex() { - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); let test = |root, data: Vec| { assert_eq!( array_bytes::bytes2hex("", merkle_root::(data.into_iter()).as_ref()), @@ -401,7 +401,7 @@ mod tests { #[ignore] fn should_generate_and_verify_proof() { // given - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); let data: Vec = make_leaves(3); // when @@ -458,7 +458,7 @@ mod tests { #[test] #[should_panic] fn should_panic_on_invalid_leaf_index() { - let _ = env_logger::try_init(); + sp_tracing::init_for_tests(); merkle_proof::(make_leaves(1).into_iter(), 5); } } diff --git a/bridges/snowbridge/pallets/outbound-queue/runtime-api/Cargo.toml b/bridges/snowbridge/pallets/outbound-queue/runtime-api/Cargo.toml index fa49cc0f29a0a161838ab62a1210e33a79f32c59..d35bdde5a81e7a80a228efff19c3c1de0eceefef 100644 --- a/bridges/snowbridge/pallets/outbound-queue/runtime-api/Cargo.toml +++ b/bridges/snowbridge/pallets/outbound-queue/runtime-api/Cargo.toml @@ -15,12 +15,12 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { version = "3.1.5", package = "parity-scale-codec", features = ["derive"], default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -snowbridge-outbound-queue-merkle-tree = { path = "../merkle-tree", default-features = false } -snowbridge-core = { path = "../../../primitives/core", default-features = false } +codec = { features = ["derive"], workspace = true } +sp-std = { workspace = true } +sp-api = { workspace = true } +frame-support = { workspace = true } +snowbridge-outbound-queue-merkle-tree = { workspace = true } +snowbridge-core = { workspace = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/outbound-queue/src/mock.rs b/bridges/snowbridge/pallets/outbound-queue/src/mock.rs index 5eeeeead140018e81a8aaaf302d678e3a4321e08..d65a96e2702dfbc69e52a913964de230bcdeadd0 100644 --- a/bridges/snowbridge/pallets/outbound-queue/src/mock.rs +++ b/bridges/snowbridge/pallets/outbound-queue/src/mock.rs @@ -33,10 +33,6 @@ frame_support::construct_runtime!( } ); -parameter_types! { - pub const BlockHashCount: u64 = 250; -} - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type BaseCallFilter = Everything; @@ -48,7 +44,6 @@ impl frame_system::Config for Test { type AccountId = AccountId; type Lookup = IdentityLookup; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type PalletInfo = PalletInfo; type Nonce = u64; type Block = Block; diff --git a/bridges/snowbridge/pallets/system/Cargo.toml b/bridges/snowbridge/pallets/system/Cargo.toml index c1ee44214c84a81dd9c4727bf81be93d5375c50c..f1e749afb9977c440ba7bbfa55c8a8acbc8c0cda 100644 --- a/bridges/snowbridge/pallets/system/Cargo.toml +++ b/bridges/snowbridge/pallets/system/Cargo.toml @@ -15,33 +15,33 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ +codec = { features = [ "derive", -] } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -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 } +], workspace = true } +scale-info = { features = ["derive"], workspace = true } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } log = { workspace = true } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +sp-core = { workspace = true } +sp-std = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } -snowbridge-core = { path = "../../primitives/core", default-features = false } +snowbridge-core = { workspace = true } [dev-dependencies] -hex = "0.4.1" -hex-literal = { version = "0.4.1" } -pallet-balances = { path = "../../../../substrate/frame/balances" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -polkadot-primitives = { path = "../../../../polkadot/primitives" } -pallet-message-queue = { path = "../../../../substrate/frame/message-queue" } -snowbridge-pallet-outbound-queue = { path = "../outbound-queue" } +hex = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +pallet-message-queue = { workspace = true, default-features = true } +snowbridge-pallet-outbound-queue = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/system/runtime-api/Cargo.toml b/bridges/snowbridge/pallets/system/runtime-api/Cargo.toml index 4073dc0f71c2096edce47a0857cd70cf969affed..7c524dd2edadb6132be50616f7e6855ad463c8b4 100644 --- a/bridges/snowbridge/pallets/system/runtime-api/Cargo.toml +++ b/bridges/snowbridge/pallets/system/runtime-api/Cargo.toml @@ -15,13 +15,13 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ +codec = { features = [ "derive", -] } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false } -snowbridge-core = { path = "../../../primitives/core", default-features = false } +], workspace = true } +sp-std = { workspace = true } +sp-api = { workspace = true } +xcm = { workspace = true } +snowbridge-core = { workspace = true } [features] default = ["std"] diff --git a/bridges/snowbridge/pallets/system/src/mock.rs b/bridges/snowbridge/pallets/system/src/mock.rs index 687072a49e2e5ca9e27d7f1be94ea89564c2275f..98bd3da9ab27c974a1a85abbb208064e41f89991 100644 --- a/bridges/snowbridge/pallets/system/src/mock.rs +++ b/bridges/snowbridge/pallets/system/src/mock.rs @@ -3,7 +3,7 @@ use crate as snowbridge_system; use frame_support::{ derive_impl, parameter_types, - traits::{tokens::fungible::Mutate, ConstU128, ConstU64, ConstU8}, + traits::{tokens::fungible::Mutate, ConstU128, ConstU8}, weights::IdentityFee, PalletId, }; @@ -106,27 +106,17 @@ impl frame_system::Config for Test { type AccountId = AccountId; type Lookup = IdentityLookup; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = ConstU64<250>; type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; type Nonce = u64; type Block = Block; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ConstU128<1>; type AccountStore = System; - type WeightInfo = (); - type FreezeIdentifier = (); - type MaxFreezes = (); - type RuntimeHoldReason = (); - type RuntimeFreezeReason = (); } impl pallet_xcm_origin::Config for Test { diff --git a/bridges/snowbridge/primitives/beacon/Cargo.toml b/bridges/snowbridge/primitives/beacon/Cargo.toml index 7d901bcdb04493ea3103150c7dfeff0a32814269..9ced99fbf3fdddd8f64877606f957da14c70f608 100644 --- a/bridges/snowbridge/primitives/beacon/Cargo.toml +++ b/bridges/snowbridge/primitives/beacon/Cargo.toml @@ -13,26 +13,26 @@ workspace = true [dependencies] serde = { optional = true, features = ["derive"], workspace = true, default-features = true } -hex = { version = "0.4", default-features = false } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -rlp = { version = "0.5", default-features = false } +hex = { workspace = true } +codec = { workspace = true } +scale-info = { features = ["derive"], workspace = true } +rlp = { workspace = true } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } +frame-support = { workspace = true } +sp-runtime = { workspace = true } +sp-core = { workspace = true } +sp-std = { workspace = true } +sp-io = { workspace = true } -ssz_rs = { version = "0.9.0", default-features = false } -ssz_rs_derive = { version = "0.9.0", default-features = false } -byte-slice-cast = { version = "1.2.1", default-features = false } +ssz_rs = { workspace = true } +ssz_rs_derive = { workspace = true } +byte-slice-cast = { workspace = true } -snowbridge-ethereum = { path = "../ethereum", default-features = false } -milagro-bls = { package = "snowbridge-milagro-bls", version = "1.5.4", default-features = false } +snowbridge-ethereum = { workspace = true } +milagro-bls = { workspace = true } [dev-dependencies] -hex-literal = { version = "0.4.1" } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/primitives/core/Cargo.toml b/bridges/snowbridge/primitives/core/Cargo.toml index 9a299ad0ae92326a6d0bb0391baf81e6e5bad663..f9bee1ff4959ae56f73b50d4c91c2ea2e63bb0a6 100644 --- a/bridges/snowbridge/primitives/core/Cargo.toml +++ b/bridges/snowbridge/primitives/core/Cargo.toml @@ -13,28 +13,28 @@ workspace = true [dependencies] serde = { optional = true, features = ["alloc", "derive"], workspace = true } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1" } +codec = { workspace = true } +scale-info = { features = ["derive"], workspace = true } +hex-literal = { workspace = true, default-features = true } -polkadot-parachain-primitives = { path = "../../../../polkadot/parachain", default-features = false } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../../polkadot/xcm/xcm-builder", default-features = false } +polkadot-parachain-primitives = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = 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 } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-arithmetic = { path = "../../../../substrate/primitives/arithmetic", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } +sp-io = { workspace = true } +sp-core = { workspace = true } +sp-arithmetic = { workspace = true } -snowbridge-beacon-primitives = { path = "../beacon", default-features = false } +snowbridge-beacon-primitives = { workspace = true } -ethabi = { package = "ethabi-decode", version = "1.0.0", default-features = false } +ethabi = { workspace = true } [dev-dependencies] -hex = { version = "0.4.3" } +hex = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/bridges/snowbridge/primitives/ethereum/Cargo.toml b/bridges/snowbridge/primitives/ethereum/Cargo.toml index d72cd2661733b516a6a9b8102782b4d8d5c40e36..764ce90b8139d936d16e38a2f337c05004427675 100644 --- a/bridges/snowbridge/primitives/ethereum/Cargo.toml +++ b/bridges/snowbridge/primitives/ethereum/Cargo.toml @@ -14,23 +14,23 @@ workspace = true [dependencies] serde = { optional = true, features = ["derive"], workspace = true, default-features = true } serde-big-array = { optional = true, features = ["const-generics"], workspace = true } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } -ethbloom = { version = "0.13.0", default-features = false } -ethereum-types = { version = "0.14.1", default-features = false, features = ["codec", "rlp", "serialize"] } -hex-literal = { version = "0.4.1", default-features = false } -parity-bytes = { version = "0.1.2", default-features = false } -rlp = { version = "0.5.2", default-features = false } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } +ethbloom = { workspace = true } +ethereum-types = { features = ["codec", "rlp", "serialize"], workspace = true } +hex-literal = { workspace = true } +parity-bytes = { workspace = true } +rlp = { workspace = true } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +sp-io = { workspace = true } +sp-std = { workspace = true } +sp-runtime = { workspace = true } -ethabi = { package = "ethabi-decode", version = "1.0.0", default-features = false } +ethabi = { workspace = true } [dev-dependencies] -wasm-bindgen-test = "0.3.19" -rand = "0.8.5" +wasm-bindgen-test = { workspace = true } +rand = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } [features] diff --git a/bridges/snowbridge/primitives/router/Cargo.toml b/bridges/snowbridge/primitives/router/Cargo.toml index 361b539af3e350a29871e82a76265de072bbf779..ee8d481cec12ae07d107c0463b778345fcfcecee 100644 --- a/bridges/snowbridge/primitives/router/Cargo.toml +++ b/bridges/snowbridge/primitives/router/Cargo.toml @@ -12,25 +12,24 @@ categories = ["cryptography::cryptocurrencies"] workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +codec = { workspace = true } +scale-info = { features = ["derive"], workspace = true } log = { workspace = true } -frame-support = { path = "../../../../substrate/frame/support", 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 } +frame-support = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +sp-std = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } -snowbridge-core = { path = "../core", default-features = false } +snowbridge-core = { workspace = true } -hex-literal = { version = "0.4.1" } +hex-literal = { workspace = true, default-features = true } [dev-dependencies] -hex = { package = "rustc-hex", version = "2.1.0" } [features] default = ["std"] diff --git a/bridges/snowbridge/runtime/runtime-common/Cargo.toml b/bridges/snowbridge/runtime/runtime-common/Cargo.toml index 995475349e4cb62045c613596acaf659eabd7076..d47cb3cb7101fb54d7bdde854ff73e628555e86b 100644 --- a/bridges/snowbridge/runtime/runtime-common/Cargo.toml +++ b/bridges/snowbridge/runtime/runtime-common/Cargo.toml @@ -13,15 +13,15 @@ workspace = true [dependencies] log = { workspace = true } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-arithmetic = { path = "../../../../substrate/primitives/arithmetic", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } +codec = { workspace = true } +frame-support = { workspace = true } +sp-std = { workspace = true } +sp-arithmetic = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } -snowbridge-core = { path = "../../primitives/core", default-features = false } +snowbridge-core = { workspace = true } [dev-dependencies] diff --git a/bridges/snowbridge/runtime/test-common/Cargo.toml b/bridges/snowbridge/runtime/test-common/Cargo.toml index 7cbb38574034c0b4c7f8b0bf82866c0392c82a10..6f8e586bf5ff12e7d870df95ffc6a0f02461357b 100644 --- a/bridges/snowbridge/runtime/test-common/Cargo.toml +++ b/bridges/snowbridge/runtime/test-common/Cargo.toml @@ -11,38 +11,38 @@ categories = ["cryptography::cryptocurrencies"] workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } # Substrate -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../substrate/frame/system", default-features = false } -pallet-balances = { path = "../../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../../substrate/frame/session", default-features = false } -pallet-message-queue = { path = "../../../../substrate/frame/message-queue", default-features = false } -pallet-timestamp = { path = "../../../../substrate/frame/timestamp", default-features = false } -pallet-utility = { path = "../../../../substrate/frame/utility", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-utility = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../polkadot/xcm/pallet-xcm", default-features = false } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../../../../cumulus/pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -pallet-collator-selection = { path = "../../../../cumulus/pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../../cumulus/parachains/pallets/parachain-info", default-features = false } -parachains-runtimes-test-utils = { path = "../../../../cumulus/parachains/runtimes/test-utils", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-runtimes-test-utils = { workspace = true } # Ethereum Bridge (Snowbridge) -snowbridge-core = { path = "../../primitives/core", default-features = false } -snowbridge-pallet-ethereum-client = { path = "../../pallets/ethereum-client", default-features = false } -snowbridge-pallet-ethereum-client-fixtures = { path = "../../pallets/ethereum-client/fixtures", default-features = false } -snowbridge-pallet-outbound-queue = { path = "../../pallets/outbound-queue", default-features = false } -snowbridge-pallet-system = { path = "../../pallets/system", default-features = false } +snowbridge-core = { workspace = true } +snowbridge-pallet-ethereum-client = { workspace = true } +snowbridge-pallet-ethereum-client-fixtures = { workspace = true } +snowbridge-pallet-outbound-queue = { workspace = true } +snowbridge-pallet-system = { workspace = true } [features] default = ["std"] diff --git a/bridges/testing/README.md b/bridges/testing/README.md index bd467a410d013c363913a8e4b2be8ca7b184e2dc..158dfd73b1ad8d6b67891b661bc215c290017cd0 100644 --- a/bridges/testing/README.md +++ b/bridges/testing/README.md @@ -1,31 +1,29 @@ # Bridges Tests for Local Rococo <> Westend Bridge This folder contains [zombienet](https://github.com/paritytech/zombienet/) based integration tests for both -onchain and offchain bridges code. Due to some -[technical difficulties](https://github.com/paritytech/parity-bridges-common/pull/2649#issue-1965339051), we -are using native zombienet provider, which means that you need to build some binaries locally. +onchain and offchain bridges code. -To start those tests, you need to: +Prerequisites for running the tests locally: - download latest [zombienet release](https://github.com/paritytech/zombienet/releases); - build Polkadot binary by running `cargo build -p polkadot --release --features fast-runtime` command in the -[`polkadot-sdk`](https://github.com/paritytech/polkadot-sdk) repository clone; + [`polkadot-sdk`](https://github.com/paritytech/polkadot-sdk) repository clone; - build Polkadot Parachain binary by running `cargo build -p polkadot-parachain-bin --release` command in the -[`polkadot-sdk`](https://github.com/paritytech/polkadot-sdk) repository clone; + [`polkadot-sdk`](https://github.com/paritytech/polkadot-sdk) repository clone; - ensure that you have [`node`](https://nodejs.org/en) installed. Additionally, we'll need globally installed -`polkadot/api-cli` package (use `npm install -g @polkadot/api-cli@beta` to install it); + `polkadot/api-cli` package (use `npm install -g @polkadot/api-cli@beta` to install it); - build Substrate relay by running `cargo build -p substrate-relay --release` command in the -[`parity-bridges-common`](https://github.com/paritytech/parity-bridges-common) repository clone. + [`parity-bridges-common`](https://github.com/paritytech/parity-bridges-common) repository clone; -- copy fresh `substrate-relay` binary, built in previous point, to the `~/local_bridge_testing/bin/substrate-relay`; +- copy the `substrate-relay` binary, built in the previous step, to `~/local_bridge_testing/bin/substrate-relay`; -- change the `POLKADOT_SDK_PATH` and `ZOMBIENET_BINARY_PATH` (and ensure that the nearby variables -have correct values) in the `./run-tests.sh`. +After that, any test can be run using the `run-test.sh` command. +Example: `./run-new-test.sh 0001-asset-transfer` -After that, you could run tests with the `./run-tests.sh` command. Hopefully, it'll show the +Hopefully, it'll show the "All tests have completed successfully" message in the end. Otherwise, it'll print paths to zombienet process logs, which, in turn, may be used to track locations of all spinned relay and parachain nodes. diff --git a/bridges/testing/environments/rococo-westend/bridges_rococo_westend.sh b/bridges/testing/environments/rococo-westend/bridges_rococo_westend.sh index 57a3e08502f2da8efb13c45e6982bba7353cf2ac..54633449134b4ce85ff124d034cd6f58061409a1 100755 --- a/bridges/testing/environments/rococo-westend/bridges_rococo_westend.sh +++ b/bridges/testing/environments/rococo-westend/bridges_rococo_westend.sh @@ -175,11 +175,9 @@ function run_finality_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-headers rococo-to-bridge-hub-westend \ --only-free-headers \ - --source-host localhost \ - --source-port 9942 \ + --source-uri ws://localhost:9942 \ --source-version-mode Auto \ - --target-host localhost \ - --target-port 8945 \ + --target-uri ws://localhost:8945 \ --target-version-mode Auto \ --target-signer //Charlie \ --target-transactions-mortality 4& @@ -187,11 +185,9 @@ function run_finality_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-headers westend-to-bridge-hub-rococo \ --only-free-headers \ - --source-host localhost \ - --source-port 9945 \ + --source-uri ws://localhost:9945 \ --source-version-mode Auto \ - --target-host localhost \ - --target-port 8943 \ + --target-uri ws://localhost:8943 \ --target-version-mode Auto \ --target-signer //Charlie \ --target-transactions-mortality 4 @@ -203,11 +199,9 @@ function run_parachains_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-parachains rococo-to-bridge-hub-westend \ --only-free-headers \ - --source-host localhost \ - --source-port 9942 \ + --source-uri ws://localhost:9942 \ --source-version-mode Auto \ - --target-host localhost \ - --target-port 8945 \ + --target-uri ws://localhost:8945 \ --target-version-mode Auto \ --target-signer //Dave \ --target-transactions-mortality 4& @@ -215,11 +209,9 @@ function run_parachains_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-parachains westend-to-bridge-hub-rococo \ --only-free-headers \ - --source-host localhost \ - --source-port 9945 \ + --source-uri ws://localhost:9945 \ --source-version-mode Auto \ - --target-host localhost \ - --target-port 8943 \ + --target-uri ws://localhost:8943 \ --target-version-mode Auto \ --target-signer //Dave \ --target-transactions-mortality 4 @@ -230,13 +222,11 @@ function run_messages_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-messages bridge-hub-rococo-to-bridge-hub-westend \ - --source-host localhost \ - --source-port 8943 \ + --source-uri ws://localhost:8943 \ --source-version-mode Auto \ --source-signer //Eve \ --source-transactions-mortality 4 \ - --target-host localhost \ - --target-port 8945 \ + --target-uri ws://localhost:8945 \ --target-version-mode Auto \ --target-signer //Eve \ --target-transactions-mortality 4 \ @@ -244,13 +234,11 @@ function run_messages_relay() { RUST_LOG=runtime=trace,rpc=trace,bridge=trace \ $relayer_path relay-messages bridge-hub-westend-to-bridge-hub-rococo \ - --source-host localhost \ - --source-port 8945 \ + --source-uri ws://localhost:8945 \ --source-version-mode Auto \ --source-signer //Ferdie \ --source-transactions-mortality 4 \ - --target-host localhost \ - --target-port 8943 \ + --target-uri ws://localhost:8943 \ --target-version-mode Auto \ --target-signer //Ferdie \ --target-transactions-mortality 4 \ @@ -282,7 +270,7 @@ case "$1" in "//Alice" \ 1000 \ "ws://127.0.0.1:9910" \ - "$(jq --null-input '{ "parents": 2, "interior": { "X1": { "GlobalConsensus": "Westend" } } }')" \ + "$(jq --null-input '{ "parents": 2, "interior": { "X1": [{ "GlobalConsensus": "Westend" }] } }')" \ "$GLOBAL_CONSENSUS_WESTEND_SOVEREIGN_ACCOUNT" \ 10000000000 \ true @@ -341,7 +329,7 @@ case "$1" in "//Alice" \ 1000 \ "ws://127.0.0.1:9010" \ - "$(jq --null-input '{ "parents": 2, "interior": { "X1": { "GlobalConsensus": "Rococo" } } }')" \ + "$(jq --null-input '{ "parents": 2, "interior": { "X1": [{ "GlobalConsensus": "Rococo" }] } }')" \ "$GLOBAL_CONSENSUS_ROCOCO_SOVEREIGN_ACCOUNT" \ 10000000000 \ true diff --git a/bridges/testing/framework/js-helpers/only-required-headers-synced-when-idle.js b/bridges/testing/framework/js-helpers/only-required-headers-synced-when-active.js similarity index 94% rename from bridges/testing/framework/js-helpers/only-required-headers-synced-when-idle.js rename to bridges/testing/framework/js-helpers/only-required-headers-synced-when-active.js index 8c3130e4fd960601d377dde5101520c95531cdf6..61738a21e38e726efff98ca19249dd33f91626e6 100644 --- a/bridges/testing/framework/js-helpers/only-required-headers-synced-when-idle.js +++ b/bridges/testing/framework/js-helpers/only-required-headers-synced-when-active.js @@ -65,8 +65,12 @@ async function run(nodeName, networkInfo, args) { // wait until we have received + delivered messages OR until timeout await utils.pollUntil( exitAfterSeconds, - () => { return atLeastOneMessageReceived && atLeastOneMessageDelivered; }, - () => { unsubscribe(); }, + () => { + return atLeastOneMessageReceived && atLeastOneMessageDelivered; + }, + () => { + unsubscribe(); + }, () => { if (!atLeastOneMessageReceived) { throw new Error("No messages received from bridged chain"); @@ -78,4 +82,4 @@ async function run(nodeName, networkInfo, args) { ); } -module.exports = { run } +module.exports = {run} diff --git a/bridges/testing/framework/js-helpers/wrapped-assets-balance.js b/bridges/testing/framework/js-helpers/wrapped-assets-balance.js index 27287118547f702b3e94eb635f9e3855d1cab535..7b343ed97a88f36f19ab7fe34e6d515d521f2b35 100644 --- a/bridges/testing/framework/js-helpers/wrapped-assets-balance.js +++ b/bridges/testing/framework/js-helpers/wrapped-assets-balance.js @@ -8,7 +8,7 @@ async function run(nodeName, networkInfo, args) { const bridgedNetworkName = args[2]; while (true) { const foreignAssetAccount = await api.query.foreignAssets.account( - { parents: 2, interior: { X1: { GlobalConsensus: bridgedNetworkName } } }, + { parents: 2, interior: { X1: [{ GlobalConsensus: bridgedNetworkName }] } }, accountAddress ); if (foreignAssetAccount.isSome) { diff --git a/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json b/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json index b2dddaa19ed1561b98422b3a28f6777308b3ba47..ca3abcc528cfaabc19cebf47426ef62f4ea5a8a6 100644 --- a/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json +++ b/bridges/testing/framework/utils/generate_hex_encoded_call/package-lock.json @@ -736,9 +736,9 @@ } }, "node_modules/ws": { - "version": "8.16.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.16.0.tgz", - "integrity": "sha512-HS0c//TP7Ina87TfiPUz1rQzMhHrl/SG2guqRcTOIUYD2q8uhUdNHZYJUaQ8aTGPzCh+c6oawMKW35nFl1dxyQ==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz", + "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==", "engines": { "node": ">=10.0.0" }, diff --git a/bridges/testing/run-new-test.sh b/bridges/testing/run-test.sh similarity index 100% rename from bridges/testing/run-new-test.sh rename to bridges/testing/run-test.sh diff --git a/bridges/testing/run-tests.sh b/bridges/testing/run-tests.sh deleted file mode 100755 index fd12b57f53349a0a449af7103c05341d3c94ceb9..0000000000000000000000000000000000000000 --- a/bridges/testing/run-tests.sh +++ /dev/null @@ -1,138 +0,0 @@ -#!/bin/bash -set -x -shopt -s nullglob - -trap "trap - SIGINT SIGTERM EXIT && killall -q -9 substrate-relay && kill -- -$$" SIGINT SIGTERM EXIT - -# run tests in range [TESTS_BEGIN; TESTS_END) -TESTS_BEGIN=1 -TESTS_END=1000 -# whether to use paths for zombienet+bridges tests container or for local testing -ZOMBIENET_DOCKER_PATHS=0 -while [ $# -ne 0 ] -do - arg="$1" - case "$arg" in - --docker) - ZOMBIENET_DOCKER_PATHS=1 - ;; - --test) - shift - TESTS_BEGIN="$1" - TESTS_END="$1" - ;; - esac - shift -done - -# assuming that we'll be using native provide && all processes will be executing locally -# (we need absolute paths here, because they're used when scripts are called by zombienet from tmp folders) -export POLKADOT_SDK_PATH=`realpath $(dirname "$0")/../..` -export BRIDGE_TESTS_FOLDER=$POLKADOT_SDK_PATH/bridges/testing/tests - -# set path to binaries -if [ "$ZOMBIENET_DOCKER_PATHS" -eq 1 ]; then - export POLKADOT_BINARY=/usr/local/bin/polkadot - export POLKADOT_PARACHAIN_BINARY=/usr/local/bin/polkadot-parachain - - export SUBSTRATE_RELAY_BINARY=/usr/local/bin/substrate-relay - export ZOMBIENET_BINARY_PATH=/usr/local/bin/zombie -else - export POLKADOT_BINARY=$POLKADOT_SDK_PATH/target/release/polkadot - export POLKADOT_PARACHAIN_BINARY=$POLKADOT_SDK_PATH/target/release/polkadot-parachain - - export SUBSTRATE_RELAY_BINARY=~/local_bridge_testing/bin/substrate-relay - export ZOMBIENET_BINARY_PATH=~/local_bridge_testing/bin/zombienet-linux -fi - -# check if `wait` supports -p flag -if [ `printf "$BASH_VERSION\n5.1" | sort -V | head -n 1` = "5.1" ]; then IS_BASH_5_1=1; else IS_BASH_5_1=0; fi - -# bridge configuration -export LANE_ID="00000002" - -# tests configuration -ALL_TESTS_FOLDER=`mktemp -d /tmp/bridges-zombienet-tests.XXXXX` - -function start_coproc() { - local command=$1 - local name=$2 - local logname=`basename $name` - local coproc_log=`mktemp -p $TEST_FOLDER $logname.XXXXX` - coproc COPROC { - # otherwise zombienet uses some hardcoded paths - unset RUN_IN_CONTAINER - unset ZOMBIENET_IMAGE - - $command >$coproc_log 2>&1 - } - TEST_COPROCS[$COPROC_PID, 0]=$name - TEST_COPROCS[$COPROC_PID, 1]=$coproc_log - echo "Spawned $name coprocess. StdOut + StdErr: $coproc_log" - - return $COPROC_PID -} - -# execute every test from tests folder -TEST_INDEX=$TESTS_BEGIN -while true -do - declare -A TEST_COPROCS - TEST_COPROCS_COUNT=0 - TEST_PREFIX=$(printf "%04d" $TEST_INDEX) - - # it'll be used by the `sync-exit.sh` script - export TEST_FOLDER=`mktemp -d -p $ALL_TESTS_FOLDER test-$TEST_PREFIX.XXXXX` - - # check if there are no more tests - zndsl_files=($BRIDGE_TESTS_FOLDER/$TEST_PREFIX-*.zndsl) - if [ ${#zndsl_files[@]} -eq 0 ]; then - break - fi - - # start tests - for zndsl_file in "${zndsl_files[@]}"; do - start_coproc "$ZOMBIENET_BINARY_PATH --provider native test $zndsl_file" "$zndsl_file" - echo -n "1">>$TEST_FOLDER/exit-sync - ((TEST_COPROCS_COUNT++)) - done - # wait until all tests are completed - for n in `seq 1 $TEST_COPROCS_COUNT`; do - if [ "$IS_BASH_5_1" -eq 1 ]; then - wait -n -p COPROC_PID - exit_code=$? - coproc_name=${TEST_COPROCS[$COPROC_PID, 0]} - coproc_log=${TEST_COPROCS[$COPROC_PID, 1]} - coproc_stdout=$(cat $coproc_log) - else - wait -n - exit_code=$? - coproc_name="" - coproc_stdout="" - fi - echo "Process $coproc_name has finished with exit code: $exit_code" - - # if exit code is not zero, exit - if [ $exit_code -ne 0 ]; then - echo "=====================================================================" - echo "=== Shutting down. Log of failed process below ===" - echo "=====================================================================" - echo "$coproc_stdout" - - exit 1 - fi - done - - # proceed to next index - ((TEST_INDEX++)) - if [ "$TEST_INDEX" -ge "$TESTS_END" ]; then - break - fi - - # kill relay here - it is started manually by tests - killall substrate-relay -done - -echo "=====================================================================" -echo "=== All tests have completed successfully ===" -echo "=====================================================================" diff --git a/bridges/testing/tests/0003-required-headers-synced-while-active-rococo-to-westend.zndsl b/bridges/testing/tests/0003-required-headers-synced-while-active-rococo-to-westend.zndsl deleted file mode 100644 index 07b91481dc7cf995b913a9bf84edd3728982eaae..0000000000000000000000000000000000000000 --- a/bridges/testing/tests/0003-required-headers-synced-while-active-rococo-to-westend.zndsl +++ /dev/null @@ -1,26 +0,0 @@ -Description: While relayer is active, we only sync mandatory and required Rococo (and Rococo BH) headers to Westend BH. -Network: ../environments/rococo-westend/bridge_hub_westend_local_network.toml -Creds: config - -# step 1: initialize Westend AH -asset-hub-westend-collator1: run ../scripts/invoke-script.sh with "init-asset-hub-westend-local" within 60 seconds - -# step 2: initialize Westend bridge hub -bridge-hub-westend-collator1: run ../scripts/invoke-script.sh with "init-bridge-hub-westend-local" within 60 seconds - -# step 3: ensure that initialization has completed -asset-hub-westend-collator1: js-script ../js-helpers/wait-hrmp-channel-opened.js with "1002" within 600 seconds - -# step 4: send message from Westend to Rococo -asset-hub-westend-collator1: run ../scripts/invoke-script.sh with "reserve-transfer-assets-from-asset-hub-westend-local" within 60 seconds - -# step 5: start relayer -# (we are starting it after sending the message to be sure that relayer won't relay messages before our js script -# will be started at step 6) -# (it is started by sibling 0003-required-headers-synced-while-active-westend-to-rococo.zndsl) - -# step 6: ensure that relayer won't sync any extra headers while delivering messages and confirmations -bridge-hub-westend-collator1: js-script ../js-helpers/only-required-headers-synced-when-active.js with "500,rococo-at-westend" within 600 seconds - -# wait until other network test has completed OR exit with an error too -asset-hub-westend-collator1: run ../scripts/sync-exit.sh within 600 seconds diff --git a/bridges/testing/tests/0003-required-headers-synced-while-active-westend-to-rococo.zndsl b/bridges/testing/tests/0003-required-headers-synced-while-active-westend-to-rococo.zndsl deleted file mode 100644 index a6b11fc24052aadf562bc34704aeda9ee115eccf..0000000000000000000000000000000000000000 --- a/bridges/testing/tests/0003-required-headers-synced-while-active-westend-to-rococo.zndsl +++ /dev/null @@ -1,26 +0,0 @@ -Description: While relayer is active, we only sync mandatory and required Westend (and Westend BH) headers to Rococo BH. -Network: ../environments/rococo-westend/bridge_hub_rococo_local_network.toml -Creds: config - -# step 1: initialize Rococo AH -asset-hub-rococo-collator1: run ../scripts/invoke-script.sh with "init-asset-hub-rococo-local" within 60 seconds - -# step 2: initialize Rococo bridge hub -bridge-hub-rococo-collator1: run ../scripts/invoke-script.sh with "init-bridge-hub-rococo-local" within 60 seconds - -# step 3: ensure that initialization has completed -asset-hub-rococo-collator1: js-script ../js-helpers/wait-hrmp-channel-opened.js with "1013" within 600 seconds - -# step 4: send message from Rococo to Westend -asset-hub-rococo-collator1: run ../scripts/invoke-script.sh with "reserve-transfer-assets-from-asset-hub-rococo-local" within 60 seconds - -# step 5: start relayer -# (we are starting it after sending the message to be sure that relayer won't relay messages before our js script -# will be started at step 6) -bridge-hub-rococo-collator1: run ../scripts/start-relayer.sh within 60 seconds - -# step 6: ensure that relayer won't sync any extra headers while delivering messages and confirmations -bridge-hub-rococo-collator1: js-script ../js-helpers/only-required-headers-synced-when-active.js with "500,westend-at-rococo" within 600 seconds - -# wait until other network test has completed OR exit with an error too -asset-hub-rococo-collator1: run ../scripts/sync-exit.sh within 600 seconds diff --git a/bridges/testing/tests/0003-required-headers-synced-while-active/rococo-to-westend.zndsl b/bridges/testing/tests/0003-required-headers-synced-while-active/rococo-to-westend.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..897b79eeff23b19a3a32efd8cab68209c8bb254f --- /dev/null +++ b/bridges/testing/tests/0003-required-headers-synced-while-active/rococo-to-westend.zndsl @@ -0,0 +1,7 @@ +Description: While relayer is active, we only sync mandatory and required Rococo (and Rococo BH) headers to Westend BH. +Network: {{ENV_PATH}}/bridge_hub_westend_local_network.toml +Creds: config + +# ensure that relayer won't sync any extra headers while delivering messages and confirmations +bridge-hub-westend-collator1: js-script {{FRAMEWORK_PATH}}/js-helpers/only-required-headers-synced-when-active.js with "500,rococo-at-westend" within 600 seconds + diff --git a/bridges/testing/tests/0003-required-headers-synced-while-active/run.sh b/bridges/testing/tests/0003-required-headers-synced-while-active/run.sh new file mode 100755 index 0000000000000000000000000000000000000000..8fad38f220520629f27d1c1bfca53d2dbe8187bc --- /dev/null +++ b/bridges/testing/tests/0003-required-headers-synced-while-active/run.sh @@ -0,0 +1,44 @@ +#!/bin/bash + +set -e + +# TODO: This test doesn't work. It was added at a time when we couldn't run it because we didn't have the scafolding. +# It needs to be fixed. For the moment we keep it in the repo as it is since the idea has value. +# But we don't run it in the CI. + +source "${BASH_SOURCE%/*}/../../framework/utils/common.sh" +source "${BASH_SOURCE%/*}/../../framework/utils/zombienet.sh" + +export ENV_PATH=`realpath ${BASH_SOURCE%/*}/../../environments/rococo-westend` + +logs_dir=$TEST_DIR/logs + +$ENV_PATH/spawn.sh --init & +env_pid=$! + +ensure_process_file $env_pid $TEST_DIR/rococo.env 600 +rococo_dir=`cat $TEST_DIR/rococo.env` +echo + +ensure_process_file $env_pid $TEST_DIR/westend.env 300 +westend_dir=`cat $TEST_DIR/westend.env` +echo + +echo "Sending message from Rococo to Westend" +$ENV_PATH/helper.sh auto-log reserve-transfer-assets-from-asset-hub-rococo-local 5000000000000 +echo + +echo "Sending message from Westend to Rococo" +$ENV_PATH/helper.sh auto-log reserve-transfer-assets-from-asset-hub-westend-local 5000000000000 +echo + + +# Start the relayer with a 30s delay +# We want to be sure that the messages won't be relayed before starting the js script in `rococo-to-westend.zndsl` +start_relayer_log=$logs_dir/start_relayer.log +echo -e "The rococo-westend relayer will be started in 30s. Logs will be available at: $start_relayer_log\n" +(sleep 30 && $ENV_PATH/start_relayer.sh \ + $rococo_dir $westend_dir finality_relayer_pid parachains_relayer_pid messages_relayer_pid > $start_relayer_log)& + +run_zndsl ${BASH_SOURCE%/*}/rococo-to-westend.zndsl $westend_dir + diff --git a/cumulus/bin/pov-validator/Cargo.toml b/cumulus/bin/pov-validator/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..9be92960ad772217635c796f0f7962384aaebfe8 --- /dev/null +++ b/cumulus/bin/pov-validator/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "cumulus-pov-validator" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +repository.workspace = true +license.workspace = true +homepage.workspace = true +description = "A tool for validating PoVs locally" + +[dependencies] +codec.workspace = true +clap = { workspace = true, features = ["derive"] } +sc-executor.workspace = true +sp-io.workspace = true +sp-core.workspace = true +sp-maybe-compressed-blob.workspace = true +polkadot-node-primitives.workspace = true +polkadot-parachain-primitives.workspace = true +polkadot-primitives.workspace = true +anyhow.workspace = true +tracing.workspace = true +tracing-subscriber.workspace = true + +[lints] +workspace = true diff --git a/cumulus/bin/pov-validator/src/main.rs b/cumulus/bin/pov-validator/src/main.rs new file mode 100644 index 0000000000000000000000000000000000000000..1c08f218f6b8ae38d86764b6e5ed148944addcd9 --- /dev/null +++ b/cumulus/bin/pov-validator/src/main.rs @@ -0,0 +1,154 @@ +// This file is part of Cumulus. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program 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. + +// This program 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 this program. If not, see . + +use clap::Parser; +use codec::{Decode, Encode}; +use polkadot_node_primitives::{BlockData, PoV, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT}; +use polkadot_parachain_primitives::primitives::ValidationParams; +use polkadot_primitives::{BlockNumber as RBlockNumber, Hash as RHash, HeadData}; +use sc_executor::WasmExecutor; +use sp_core::traits::{CallContext, CodeExecutor, RuntimeCode, WrappedRuntimeCode}; +use std::{fs, path::PathBuf, time::Instant}; +use tracing::level_filters::LevelFilter; + +/// Tool for validating a `PoV` locally. +#[derive(Parser)] +struct Cli { + /// The path to the validation code that should be used to validate the `PoV`. + /// + /// The validation code can either be downloaded from the relay chain that the parachain is + /// connected to or by building the runtime manually to obtain the WASM binary. + #[arg(long)] + validation_code: PathBuf, + + /// The path to the `PoV` to validate. + /// + /// The `PoV`'s can be obtained by running `polkadot-parachains --collator --chain YOUR_CHAIN + /// --export-pov-to-path PATH_TO_EXPORT` and then choose one of the exported `PoV`'s. + #[arg(long)] + pov: PathBuf, +} + +fn main() -> anyhow::Result<()> { + let _ = tracing_subscriber::fmt() + .with_env_filter( + tracing_subscriber::EnvFilter::from_default_env() + .add_directive(LevelFilter::INFO.into()), + ) + .with_writer(std::io::stderr) + .try_init(); + + let cli = Cli::parse(); + + let validation_code = fs::read(&cli.validation_code).map_err(|error| { + tracing::error!(%error, path = %cli.validation_code.display(), "Failed to read validation code"); + anyhow::anyhow!("Failed to read validation code") + })?; + + let validation_code = + sp_maybe_compressed_blob::decompress(&validation_code, VALIDATION_CODE_BOMB_LIMIT) + .map_err(|error| { + tracing::error!(%error, "Failed to decompress validation code"); + anyhow::anyhow!("Failed to decompress validation code") + })?; + + let pov_file = fs::read(&cli.pov).map_err(|error| { + tracing::error!(%error, path = %cli.pov.display(), "Failed to read PoV"); + anyhow::anyhow!("Failed to read PoV") + })?; + + let executor = WasmExecutor::::builder() + .with_allow_missing_host_functions(true) + .build(); + + let runtime_code = RuntimeCode { + code_fetcher: &WrappedRuntimeCode(validation_code.into()), + heap_pages: None, + // The hash is used for caching, which we need here, but we only use one wasm file. So, the + // actual hash is not that important. + hash: vec![1, 2, 3], + }; + + // We are calling `Core_version` to get the wasm file compiled. We don't care about the result. + let _ = executor + .call( + &mut sp_io::TestExternalities::default().ext(), + &runtime_code, + "Core_version", + &[], + CallContext::Offchain, + ) + .0; + + let pov_file_ptr = &mut &pov_file[..]; + let pov = PoV::decode(pov_file_ptr).map_err(|error| { + tracing::error!(%error, "Failed to decode `PoV`"); + anyhow::anyhow!("Failed to decode `PoV`") + })?; + let head_data = HeadData::decode(pov_file_ptr).map_err(|error| { + tracing::error!(%error, "Failed to `HeadData`"); + anyhow::anyhow!("Failed to decode `HeadData`") + })?; + let relay_parent_storage_root = RHash::decode(pov_file_ptr).map_err(|error| { + tracing::error!(%error, "Failed to relay storage root"); + anyhow::anyhow!("Failed to decode relay storage root") + })?; + let relay_parent_number = RBlockNumber::decode(pov_file_ptr).map_err(|error| { + tracing::error!(%error, "Failed to relay block number"); + anyhow::anyhow!("Failed to decode relay block number") + })?; + + let pov = sp_maybe_compressed_blob::decompress(&pov.block_data.0, POV_BOMB_LIMIT).map_err( + |error| { + tracing::error!(%error, "Failed to decompress `PoV`"); + anyhow::anyhow!("Failed to decompress `PoV`") + }, + )?; + + let validation_params = ValidationParams { + relay_parent_number, + relay_parent_storage_root, + parent_head: head_data, + block_data: BlockData(pov.into()), + }; + + tracing::info!("Starting validation"); + + let start = Instant::now(); + + let res = executor + .call( + &mut sp_io::TestExternalities::default().ext(), + &runtime_code, + "validate_block", + &validation_params.encode(), + CallContext::Offchain, + ) + .0; + + let duration = start.elapsed(); + + match res { + Ok(_) => tracing::info!("Validation was successful"), + Err(error) => tracing::error!(%error, "Validation failed"), + } + + tracing::info!("Validation took {}ms", duration.as_millis()); + + Ok(()) +} diff --git a/cumulus/client/cli/Cargo.toml b/cumulus/client/cli/Cargo.toml index 0b2edb593c405bef266fa7e389a996fe3a2fcec1..9b6f6b73960b416c481b43f053477c70e55b8495 100644 --- a/cumulus/client/cli/Cargo.toml +++ b/cumulus/client/cli/Cargo.toml @@ -10,15 +10,15 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -clap = { version = "4.5.3", features = ["derive"] } -codec = { package = "parity-scale-codec", version = "3.0.0" } -url = "2.4.0" +clap = { features = ["derive"], workspace = true } +codec = { workspace = true, default-features = true } +url = { workspace = true } # Substrate -sc-cli = { path = "../../../substrate/client/cli" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-chain-spec = { path = "../../../substrate/client/chain-spec" } -sc-service = { path = "../../../substrate/client/service" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } diff --git a/cumulus/client/cli/src/lib.rs b/cumulus/client/cli/src/lib.rs index a7b2eb19de88a5c585ec3f6dfe5ad46ef0399b88..564d7b58c94dc8d093031753ab69251f9b905ec5 100644 --- a/cumulus/client/cli/src/lib.rs +++ b/cumulus/client/cli/src/lib.rs @@ -21,13 +21,13 @@ use std::{ fs, io::{self, Write}, - net::SocketAddr, path::PathBuf, sync::Arc, }; use codec::Encode; use sc_chain_spec::ChainSpec; +use sc_cli::RpcEndpoint; use sc_client_api::HeaderBackend; use sc_service::{ config::{PrometheusConfig, RpcBatchRequestConfig, TelemetryEndpoints}, @@ -423,7 +423,7 @@ impl sc_cli::CliConfiguration for NormalizedRunCmd { self.base.rpc_cors(is_dev) } - fn rpc_addr(&self, default_listen_port: u16) -> sc_cli::Result> { + fn rpc_addr(&self, default_listen_port: u16) -> sc_cli::Result>> { self.base.rpc_addr(default_listen_port) } diff --git a/cumulus/client/collator/Cargo.toml b/cumulus/client/collator/Cargo.toml index 42f7342d1a5381a6174c15909b815485eb7c8a7e..6ebde0c2c653b8279ead203bdabeafd3ab8292e1 100644 --- a/cumulus/client/collator/Cargo.toml +++ b/cumulus/client/collator/Cargo.toml @@ -10,41 +10,41 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -parking_lot = "0.12.1" -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -futures = "0.3.30" -tracing = "0.1.25" +parking_lot = { workspace = true, default-features = true } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +tracing = { workspace = true, default-features = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } +sc-client-api = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } # Polkadot -polkadot-node-primitives = { path = "../../../polkadot/node/primitives" } -polkadot-node-subsystem = { path = "../../../polkadot/node/subsystem" } -polkadot-overseer = { path = "../../../polkadot/node/overseer" } -polkadot-primitives = { path = "../../../polkadot/primitives" } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } # Cumulus -cumulus-client-consensus-common = { path = "../consensus/common" } -cumulus-client-network = { path = "../network" } -cumulus-primitives-core = { path = "../../primitives/core" } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-client-network = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } [dev-dependencies] -async-trait = "0.1.79" +async-trait = { workspace = true } # Substrate -sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } # Polkadot -polkadot-node-subsystem-test-helpers = { path = "../../../polkadot/node/subsystem-test-helpers" } +polkadot-node-subsystem-test-helpers = { workspace = true } # Cumulus -cumulus-test-client = { path = "../../test/client" } -cumulus-test-runtime = { path = "../../test/runtime" } -cumulus-test-relay-sproof-builder = { path = "../../test/relay-sproof-builder" } +cumulus-test-client = { workspace = true } +cumulus-test-runtime = { workspace = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } diff --git a/cumulus/client/consensus/aura/Cargo.toml b/cumulus/client/consensus/aura/Cargo.toml index 70dd67cb9a00b2e7b0baf04dbfdaaff0386104e5..47e2d8572c3f8e589997ca9066e63c6896e721f9 100644 --- a/cumulus/client/consensus/aura/Cargo.toml +++ b/cumulus/client/consensus/aura/Cargo.toml @@ -10,44 +10,51 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -futures = "0.3.28" -tracing = "0.1.37" -schnellru = "0.2.1" +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +parking_lot = { workspace = true } +tracing = { workspace = true, default-features = true } +schnellru = { workspace = true } +tokio = { workspace = true, features = ["macros"] } # Substrate -sc-client-api = { path = "../../../../substrate/client/api" } -sc-consensus = { path = "../../../../substrate/client/consensus/common" } -sc-consensus-aura = { path = "../../../../substrate/client/consensus/aura" } -sc-consensus-babe = { path = "../../../../substrate/client/consensus/babe" } -sc-consensus-slots = { path = "../../../../substrate/client/consensus/slots" } -sc-telemetry = { path = "../../../../substrate/client/telemetry" } -sp-api = { path = "../../../../substrate/primitives/api" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-block-builder = { path = "../../../../substrate/primitives/block-builder" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-consensus-aura = { path = "../../../../substrate/primitives/consensus/aura" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-inherents = { path = "../../../../substrate/primitives/inherents" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-timestamp = { path = "../../../../substrate/primitives/timestamp" } -sp-state-machine = { path = "../../../../substrate/primitives/state-machine" } -substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-aura = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-slots = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } # Cumulus -cumulus-client-consensus-common = { path = "../common" } -cumulus-relay-chain-interface = { path = "../../relay-chain-interface" } -cumulus-client-consensus-proposer = { path = "../proposer" } -cumulus-client-parachain-inherent = { path = "../../parachain-inherent" } -cumulus-primitives-aura = { path = "../../../primitives/aura" } -cumulus-primitives-core = { path = "../../../primitives/core" } -cumulus-client-collator = { path = "../../collator" } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-client-consensus-proposer = { workspace = true, default-features = true } +cumulus-client-parachain-inherent = { workspace = true, default-features = true } +cumulus-primitives-aura = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-client-collator = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../../polkadot/primitives" } -polkadot-node-primitives = { path = "../../../../polkadot/node/primitives" } -polkadot-node-subsystem = { path = "../../../../polkadot/node/subsystem" } -polkadot-overseer = { path = "../../../../polkadot/node/overseer" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } + +[features] +# Allows collator to use full PoV size for block building +full-pov-size = [] diff --git a/cumulus/client/consensus/aura/src/collator.rs b/cumulus/client/consensus/aura/src/collator.rs index 776052215d9397c529699ed07040819f666e16b5..dc830e463a4f5bca1f39ec82a11d5364b148c675 100644 --- a/cumulus/client/consensus/aura/src/collator.rs +++ b/cumulus/client/consensus/aura/src/collator.rs @@ -156,15 +156,8 @@ where Ok((paras_inherent_data, other_inherent_data)) } - /// Propose, seal, and import a block, packaging it into a collation. - /// - /// Provide the slot to build at as well as any other necessary pre-digest logs, - /// the inherent data, and the proposal duration and PoV size limits. - /// - /// The Aura pre-digest should not be explicitly provided and is set internally. - /// - /// This does not announce the collation to the parachain network or the relay chain. - pub async fn collate( + /// Build and import a parachain block on the given parent header, using the given slot claim. + pub async fn build_block_and_import( &mut self, parent_header: &Block::Header, slot_claim: &SlotClaim, @@ -172,10 +165,7 @@ where inherent_data: (ParachainInherentData, InherentData), proposal_duration: Duration, max_pov_size: usize, - ) -> Result< - Option<(Collation, ParachainBlockData, Block::Hash)>, - Box, - > { + ) -> Result>, Box> { let mut digest = additional_pre_digest.into().unwrap_or_default(); digest.push(slot_claim.pre_digest.clone()); @@ -205,7 +195,6 @@ where ) .map_err(|e| e as Box)?; - let post_hash = sealed_importable.post_hash(); let block = Block::new( sealed_importable.post_header(), sealed_importable @@ -220,11 +209,46 @@ where .map_err(|e| Box::new(e) as Box) .await?; - if let Some((collation, block_data)) = self.collator_service.build_collation( - parent_header, - post_hash, - ParachainCandidate { block, proof: proposal.proof }, - ) { + Ok(Some(ParachainCandidate { block, proof: proposal.proof })) + } + + /// Propose, seal, import a block and packaging it into a collation. + /// + /// Provide the slot to build at as well as any other necessary pre-digest logs, + /// the inherent data, and the proposal duration and PoV size limits. + /// + /// The Aura pre-digest should not be explicitly provided and is set internally. + /// + /// This does not announce the collation to the parachain network or the relay chain. + pub async fn collate( + &mut self, + parent_header: &Block::Header, + slot_claim: &SlotClaim, + additional_pre_digest: impl Into>>, + inherent_data: (ParachainInherentData, InherentData), + proposal_duration: Duration, + max_pov_size: usize, + ) -> Result< + Option<(Collation, ParachainBlockData, Block::Hash)>, + Box, + > { + let maybe_candidate = self + .build_block_and_import( + parent_header, + slot_claim, + additional_pre_digest, + inherent_data, + proposal_duration, + max_pov_size, + ) + .await?; + + let Some(candidate) = maybe_candidate else { return Ok(None) }; + + let hash = candidate.block.header().hash(); + if let Some((collation, block_data)) = + self.collator_service.build_collation(parent_header, hash, candidate) + { tracing::info!( target: crate::LOG_TARGET, "PoV size {{ header: {}kb, extrinsics: {}kb, storage_proof: {}kb }}", @@ -241,7 +265,7 @@ where ); } - Ok(Some((collation, block_data, post_hash))) + Ok(Some((collation, block_data, hash))) } else { Err(Box::::from("Unable to produce collation") as Box) diff --git a/cumulus/client/consensus/aura/src/collators/basic.rs b/cumulus/client/consensus/aura/src/collators/basic.rs index 1047c6219ad132403014cacaf3d071d8009b9dbc..d843483b79fa0fd7d3ad577e191b4836c6a5dceb 100644 --- a/cumulus/client/consensus/aura/src/collators/basic.rs +++ b/cumulus/client/consensus/aura/src/collators/basic.rs @@ -41,7 +41,6 @@ use sc_consensus::BlockImport; use sp_api::{CallApiAt, ProvideRuntimeApi}; use sp_application_crypto::AppPublic; use sp_blockchain::HeaderBackend; -use sp_consensus::SyncOracle; use sp_consensus_aura::AuraApi; use sp_core::crypto::Pair; use sp_inherents::CreateInherentDataProviders; @@ -53,7 +52,7 @@ use std::{sync::Arc, time::Duration}; use crate::collator as collator_util; /// Parameters for [`run`]. -pub struct Params { +pub struct Params { /// Inherent data providers. Only non-consensus inherent data should be provided, i.e. /// the timestamp, slot, and paras inherents should be omitted, as they are set by this /// collator. @@ -64,8 +63,6 @@ pub struct Params { pub para_client: Arc, /// A handle to the relay-chain client. pub relay_client: RClient, - /// A chain synchronization oracle. - pub sync_oracle: SO, /// The underlying keystore, which should contain Aura consensus keys. pub keystore: KeystorePtr, /// The collator key used to sign collations before submitting to validators. @@ -89,8 +86,8 @@ pub struct Params { } /// Run bare Aura consensus as a relay-chain-driven collator. -pub fn run( - params: Params, +pub fn run( + params: Params, ) -> impl Future + Send + 'static where Block: BlockT + Send, @@ -108,7 +105,6 @@ where CIDP: CreateInherentDataProviders + Send + 'static, CIDP::InherentDataProviders: Send, BI: BlockImport + ParachainBlockImportMarker + Send + Sync + 'static, - SO: SyncOracle + Send + Sync + Clone + 'static, Proposer: ProposerInterface + Send + Sync + 'static, CS: CollatorServiceInterface + Send + Sync + 'static, P: Pair, @@ -142,6 +138,7 @@ where }; let mut last_processed_slot = 0; + let mut last_relay_chain_block = Default::default(); while let Some(request) = collation_requests.next().await { macro_rules! reject_with_error { @@ -219,11 +216,13 @@ where // // Most parachains currently run with 12 seconds slots and thus, they would try to // produce multiple blocks per slot which very likely would fail on chain. Thus, we have - // this "hack" to only produce on block per slot. + // this "hack" to only produce one block per slot per relay chain fork. // // With https://github.com/paritytech/polkadot-sdk/issues/3168 this implementation will be // obsolete and also the underlying issue will be fixed. - if last_processed_slot >= *claim.slot() { + if last_processed_slot >= *claim.slot() && + last_relay_chain_block < *relay_parent_header.number() + { continue } @@ -238,6 +237,16 @@ where .await ); + let allowed_pov_size = if cfg!(feature = "full-pov-size") { + validation_data.max_pov_size + } else { + // Set the block limit to 50% of the maximum PoV size. + // + // TODO: If we got benchmarking that includes the proof size, + // we should be able to use the maximum pov size. + validation_data.max_pov_size / 2 + } as usize; + let maybe_collation = try_request!( collator .collate( @@ -246,11 +255,7 @@ where None, (parachain_inherent_data, other_inherent_data), params.authoring_duration, - // Set the block limit to 50% of the maximum PoV size. - // - // TODO: If we got benchmarking that includes the proof size, - // we should be able to use the maximum pov size. - (validation_data.max_pov_size / 2) as usize, + allowed_pov_size, ) .await ); @@ -265,6 +270,7 @@ where } last_processed_slot = *claim.slot(); + last_relay_chain_block = *relay_parent_header.number(); } } } diff --git a/cumulus/client/consensus/aura/src/collators/lookahead.rs b/cumulus/client/consensus/aura/src/collators/lookahead.rs index 09416233ea9b39dfd4bd4126149d51f922d7b6e4..0be1e0a23ca5bbd70c00c86443a5ebf4ab90c833 100644 --- a/cumulus/client/consensus/aura/src/collators/lookahead.rs +++ b/cumulus/client/consensus/aura/src/collators/lookahead.rs @@ -33,46 +33,76 @@ use codec::{Codec, Encode}; use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface; -use cumulus_client_consensus_common::{ - self as consensus_common, load_abridged_host_configuration, ParachainBlockImportMarker, - ParentSearchParams, -}; +use cumulus_client_consensus_common::{self as consensus_common, ParachainBlockImportMarker}; use cumulus_client_consensus_proposer::ProposerInterface; use cumulus_primitives_aura::AuraUnincludedSegmentApi; -use cumulus_primitives_core::{ - relay_chain::Hash as PHash, CollectCollationInfo, PersistedValidationData, -}; +use cumulus_primitives_core::{CollectCollationInfo, PersistedValidationData}; use cumulus_relay_chain_interface::RelayChainInterface; -use polkadot_node_primitives::SubmitCollationParams; -use polkadot_node_subsystem::messages::{ - CollationGenerationMessage, RuntimeApiMessage, RuntimeApiRequest, -}; +use polkadot_node_primitives::{PoV, SubmitCollationParams}; +use polkadot_node_subsystem::messages::CollationGenerationMessage; use polkadot_overseer::Handle as OverseerHandle; use polkadot_primitives::{ - AsyncBackingParams, CollatorPair, CoreIndex, CoreState, Id as ParaId, OccupiedCoreAssumption, + BlockNumber as RBlockNumber, CollatorPair, Hash as RHash, HeadData, Id as ParaId, + OccupiedCoreAssumption, }; -use futures::{channel::oneshot, prelude::*}; +use futures::prelude::*; use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf}; use sc_consensus::BlockImport; -use sc_consensus_aura::standalone as aura_internal; use sp_api::ProvideRuntimeApi; use sp_application_crypto::AppPublic; use sp_blockchain::HeaderBackend; -use sp_consensus::SyncOracle; use sp_consensus_aura::{AuraApi, Slot}; use sp_core::crypto::Pair; use sp_inherents::CreateInherentDataProviders; use sp_keystore::KeystorePtr; -use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member}; -use sp_timestamp::Timestamp; -use std::{sync::Arc, time::Duration}; +use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member, NumberFor}; +use std::{ + fs::{self, File}, + path::PathBuf, + sync::Arc, + time::Duration, +}; -use crate::collator::{self as collator_util, SlotClaim}; +use crate::{collator as collator_util, LOG_TARGET}; + +/// Export the given `pov` to the file system at `path`. +/// +/// The file will be named `block_hash_block_number.pov`. +/// +/// The `parent_header`, `relay_parent_storage_root` and `relay_parent_number` will also be +/// stored in the file alongside the `pov`. This enables stateless validation of the `pov`. +fn export_pov_to_path( + path: PathBuf, + pov: PoV, + block_hash: Block::Hash, + block_number: NumberFor, + parent_header: Block::Header, + relay_parent_storage_root: RHash, + relay_parent_number: RBlockNumber, +) { + if let Err(error) = fs::create_dir_all(&path) { + tracing::error!(target: LOG_TARGET, %error, path = %path.display(), "Failed to create PoV export directory"); + return + } + + let mut file = match File::create(path.join(format!("{block_hash:?}_{block_number}.pov"))) { + Ok(f) => f, + Err(error) => { + tracing::error!(target: LOG_TARGET, %error, "Failed to export PoV."); + return + }, + }; + + pov.encode_to(&mut file); + HeadData(parent_header.encode()).encode_to(&mut file); + relay_parent_storage_root.encode_to(&mut file); + relay_parent_number.encode_to(&mut file); +} /// Parameters for [`run`]. -pub struct Params { +pub struct Params { /// Inherent data providers. Only non-consensus inherent data should be provided, i.e. /// the timestamp, slot, and paras inherents should be omitted, as they are set by this /// collator. @@ -87,8 +117,6 @@ pub struct Params { pub relay_client: RClient, /// A validation code hash provider, used to get the current validation code hash. pub code_hash_provider: CHP, - /// A chain synchronization oracle. - pub sync_oracle: SO, /// The underlying keystore, which should contain Aura consensus keys. pub keystore: KeystorePtr, /// The collator key used to sign collations before submitting to validators. @@ -110,8 +138,8 @@ pub struct Params { } /// Run async-backing-friendly Aura. -pub fn run( - mut params: Params, +pub fn run( + params: Params, ) -> impl Future + Send + 'static where Block: BlockT, @@ -130,7 +158,6 @@ where CIDP: CreateInherentDataProviders + 'static, CIDP::InherentDataProviders: Send, BI: BlockImport + ParachainBlockImportMarker + Send + Sync + 'static, - SO: SyncOracle + Send + Sync + Clone + 'static, Proposer: ProposerInterface + Send + Sync + 'static, CS: CollatorServiceInterface + Send + Sync + 'static, CHP: consensus_common::ValidationCodeHashProvider + Send + 'static, @@ -138,14 +165,57 @@ where P::Public: AppPublic + Member + Codec, P::Signature: TryFrom> + Member + Codec, { - // This is an arbitrary value which is likely guaranteed to exceed any reasonable - // limit, as it would correspond to 10 non-included blocks. - // - // Since we only search for parent blocks which have already been imported, - // we can guarantee that all imported blocks respect the unincluded segment - // rules specified by the parachain's runtime and thus will never be too deep. - const PARENT_SEARCH_DEPTH: usize = 10; + run_with_export::<_, P, _, _, _, _, _, _, _, _>(ParamsWithExport { params, export_pov: None }) +} +/// Parameters for [`run_with_export`]. +pub struct ParamsWithExport { + /// The parameters. + pub params: Params, + /// When set, the collator will export every produced `POV` to this folder. + pub export_pov: Option, +} + +/// Run async-backing-friendly Aura. +/// +/// This is exactly the same as [`run`], but it supports the optional export of each produced `POV` +/// to the file system. +pub fn run_with_export( + ParamsWithExport { mut params, export_pov }: ParamsWithExport< + BI, + CIDP, + Client, + Backend, + RClient, + CHP, + Proposer, + CS, + >, +) -> impl Future + Send + 'static +where + Block: BlockT, + Client: ProvideRuntimeApi + + BlockOf + + AuxStore + + HeaderBackend + + BlockBackend + + Send + + Sync + + 'static, + Client::Api: + AuraApi + CollectCollationInfo + AuraUnincludedSegmentApi, + Backend: sc_client_api::Backend + 'static, + RClient: RelayChainInterface + Clone + 'static, + CIDP: CreateInherentDataProviders + 'static, + CIDP::InherentDataProviders: Send, + BI: BlockImport + ParachainBlockImportMarker + Send + Sync + 'static, + Proposer: ProposerInterface + Send + Sync + 'static, + CS: CollatorServiceInterface + Send + Sync + 'static, + CHP: consensus_common::ValidationCodeHashProvider + Send + 'static, + P: Pair, + P::Public: AppPublic + Member + Codec, + P::Signature: TryFrom> + Member + Codec, +{ async move { cumulus_client_collator::initialize_collator_subsystems( &mut params.overseer_handle, @@ -186,12 +256,9 @@ where while let Some(relay_parent_header) = import_notifications.next().await { let relay_parent = relay_parent_header.hash(); - // TODO: Currently we use just the first core here, but for elastic scaling - // we iterate and build on all of the cores returned. - let core_index = if let Some(core_index) = cores_scheduled_for_para( + let core_index = if let Some(core_index) = super::cores_scheduled_for_para( relay_parent, params.para_id, - &mut params.overseer_handle, &mut params.relay_client, ) .await @@ -226,42 +293,16 @@ where }, }; - let parent_search_params = ParentSearchParams { + let (included_block, initial_parent) = match crate::collators::find_parent( relay_parent, - para_id: params.para_id, - ancestry_lookback: async_backing_params(relay_parent, ¶ms.relay_client) - .await - .map(|c| c.allowed_ancestry_len as usize) - .unwrap_or(0), - max_depth: PARENT_SEARCH_DEPTH, - ignore_alternative_branches: true, - }; - - let potential_parents = - cumulus_client_consensus_common::find_potential_parents::( - parent_search_params, - &*params.para_backend, - ¶ms.relay_client, - ) - .await; - - let mut potential_parents = match potential_parents { - Err(e) => { - tracing::error!( - target: crate::LOG_TARGET, - ?relay_parent, - err = ?e, - "Could not fetch potential parents to build upon" - ); - - continue - }, - Ok(x) => x, - }; - - let included_block = match potential_parents.iter().find(|x| x.depth == 0) { - None => continue, // also serves as an `is_empty` check. - Some(b) => b.hash, + params.para_id, + &*params.para_backend, + ¶ms.relay_client, + ) + .await + { + Some(value) => value, + None => continue, }; let para_client = &*params.para_client; @@ -292,7 +333,7 @@ where relay_chain_slot_duration = ?params.relay_chain_slot_duration, "Adjusted relay-chain slot to parachain slot" ); - Some(can_build_upon::<_, _, P>( + Some(super::can_build_upon::<_, _, P>( slot_now, timestamp, block_hash, @@ -302,13 +343,6 @@ where )) }; - // Sort by depth, ascending, to choose the longest chain. - // - // If the longest chain has space, build upon that. Otherwise, don't - // build at all. - potential_parents.sort_by_key(|a| a.depth); - let Some(initial_parent) = potential_parents.pop() else { continue }; - // Build in a loop until not allowed. Note that the authorities can change // at any block, so we need to re-claim our slot every time. let mut parent_hash = initial_parent.hash; @@ -363,13 +397,11 @@ where Ok(x) => x, }; - let validation_code_hash = match params.code_hash_provider.code_hash_at(parent_hash) - { - None => { - tracing::error!(target: crate::LOG_TARGET, ?parent_hash, "Could not fetch validation code hash"); - break - }, - Some(v) => v, + let Some(validation_code_hash) = + params.code_hash_provider.code_hash_at(parent_hash) + else { + tracing::error!(target: crate::LOG_TARGET, ?parent_hash, "Could not fetch validation code hash"); + break }; super::check_validation_code_or_log( @@ -380,6 +412,16 @@ where ) .await; + let allowed_pov_size = if cfg!(feature = "full-pov-size") { + validation_data.max_pov_size + } else { + // Set the block limit to 50% of the maximum PoV size. + // + // TODO: If we got benchmarking that includes the proof size, + // we should be able to use the maximum pov size. + validation_data.max_pov_size / 2 + } as usize; + match collator .collate( &parent_header, @@ -387,11 +429,7 @@ where None, (parachain_inherent_data, other_inherent_data), params.authoring_duration, - // Set the block limit to 50% of the maximum PoV size. - // - // TODO: If we got benchmarking that includes the proof size, - // we should be able to use the maximum pov size. - (validation_data.max_pov_size / 2) as usize, + allowed_pov_size, ) .await { @@ -400,6 +438,18 @@ where // and provides sybil-resistance, as it should. collator.collator_service().announce_block(new_block_hash, None); + if let Some(ref export_pov) = export_pov { + export_pov_to_path::( + export_pov.clone(), + collation.proof_of_validity.clone().into_compressed(), + new_block_hash, + *block_data.header().number(), + parent_header.clone(), + *relay_parent_header.state_root(), + *relay_parent_header.number(), + ); + } + // Send a submit-collation message to the collation generation subsystem, // which then distributes this to validators. // @@ -437,124 +487,3 @@ where } } } - -// Checks if we own the slot at the given block and whether there -// is space in the unincluded segment. -async fn can_build_upon( - slot: Slot, - timestamp: Timestamp, - parent_hash: Block::Hash, - included_block: Block::Hash, - client: &Client, - keystore: &KeystorePtr, -) -> Option> -where - Client: ProvideRuntimeApi, - Client::Api: AuraApi + AuraUnincludedSegmentApi, - P: Pair, - P::Public: Codec, - P::Signature: Codec, -{ - let runtime_api = client.runtime_api(); - let authorities = runtime_api.authorities(parent_hash).ok()?; - let author_pub = aura_internal::claim_slot::

(slot, &authorities, keystore).await?; - - // Here we lean on the property that building on an empty unincluded segment must always - // be legal. Skipping the runtime API query here allows us to seamlessly run this - // collator against chains which have not yet upgraded their runtime. - if parent_hash != included_block { - if !runtime_api.can_build_upon(parent_hash, included_block, slot).ok()? { - return None - } - } - - Some(SlotClaim::unchecked::

(author_pub, slot, timestamp)) -} - -/// Reads async backing parameters from the relay chain storage at the given relay parent. -async fn async_backing_params( - relay_parent: PHash, - relay_client: &impl RelayChainInterface, -) -> Option { - match load_abridged_host_configuration(relay_parent, relay_client).await { - Ok(Some(config)) => Some(config.async_backing_params), - Ok(None) => { - tracing::error!( - target: crate::LOG_TARGET, - "Active config is missing in relay chain storage", - ); - None - }, - Err(err) => { - tracing::error!( - target: crate::LOG_TARGET, - ?err, - ?relay_parent, - "Failed to read active config from relay chain client", - ); - None - }, - } -} - -// Return all the cores assigned to the para at the provided relay parent. -async fn cores_scheduled_for_para( - relay_parent: PHash, - para_id: ParaId, - overseer_handle: &mut OverseerHandle, - relay_client: &impl RelayChainInterface, -) -> Vec { - // Get `AvailabilityCores` from runtime - let (tx, rx) = oneshot::channel(); - let request = RuntimeApiRequest::AvailabilityCores(tx); - overseer_handle - .send_msg(RuntimeApiMessage::Request(relay_parent, request), "LookaheadCollator") - .await; - - let cores = match rx.await { - Ok(Ok(cores)) => cores, - Ok(Err(error)) => { - tracing::error!( - target: crate::LOG_TARGET, - ?error, - ?relay_parent, - "Failed to query availability cores runtime API", - ); - return Vec::new() - }, - Err(oneshot::Canceled) => { - tracing::error!( - target: crate::LOG_TARGET, - ?relay_parent, - "Sender for availability cores runtime request dropped", - ); - return Vec::new() - }, - }; - - let max_candidate_depth = async_backing_params(relay_parent, relay_client) - .await - .map(|c| c.max_candidate_depth) - .unwrap_or(0); - - cores - .iter() - .enumerate() - .filter_map(|(index, core)| { - let core_para_id = match core { - CoreState::Scheduled(scheduled_core) => Some(scheduled_core.para_id), - CoreState::Occupied(occupied_core) if max_candidate_depth >= 1 => occupied_core - .next_up_on_available - .as_ref() - .map(|scheduled_core| scheduled_core.para_id), - CoreState::Free | CoreState::Occupied(_) => None, - }; - - if core_para_id == Some(para_id) { - Some(CoreIndex(index as u32)) - } else { - None - } - }) - .collect() -} diff --git a/cumulus/client/consensus/aura/src/collators/mod.rs b/cumulus/client/consensus/aura/src/collators/mod.rs index 6e0067d0cedb602face8943737f99f3cb1a201a3..7d430ecdc727ab2c44b84bec509938a22da4c3f8 100644 --- a/cumulus/client/consensus/aura/src/collators/mod.rs +++ b/cumulus/client/consensus/aura/src/collators/mod.rs @@ -20,13 +20,35 @@ //! included parachain block, as well as the [`lookahead`] collator, which prospectively //! builds on parachain blocks which have not yet been included in the relay chain. +use crate::collator::SlotClaim; +use codec::Codec; +use cumulus_client_consensus_common::{ + self as consensus_common, load_abridged_host_configuration, ParentSearchParams, +}; +use cumulus_primitives_aura::{AuraUnincludedSegmentApi, Slot}; +use cumulus_primitives_core::{relay_chain::Hash as ParaHash, BlockT}; use cumulus_relay_chain_interface::RelayChainInterface; use polkadot_primitives::{ - Hash as RHash, Id as ParaId, OccupiedCoreAssumption, ValidationCodeHash, + AsyncBackingParams, CoreIndex, CoreState, Hash as RelayHash, Id as ParaId, + OccupiedCoreAssumption, ValidationCodeHash, }; +use sc_consensus_aura::{standalone as aura_internal, AuraApi}; +use sp_api::ProvideRuntimeApi; +use sp_core::Pair; +use sp_keystore::KeystorePtr; +use sp_timestamp::Timestamp; pub mod basic; pub mod lookahead; +pub mod slot_based; + +// This is an arbitrary value which is likely guaranteed to exceed any reasonable +// limit, as it would correspond to 10 non-included blocks. +// +// Since we only search for parent blocks which have already been imported, +// we can guarantee that all imported blocks respect the unincluded segment +// rules specified by the parachain's runtime and thus will never be too deep. +const PARENT_SEARCH_DEPTH: usize = 10; /// Check the `local_validation_code_hash` against the validation code hash in the relay chain /// state. @@ -36,7 +58,7 @@ async fn check_validation_code_or_log( local_validation_code_hash: &ValidationCodeHash, para_id: ParaId, relay_client: &impl RelayChainInterface, - relay_parent: RHash, + relay_parent: RelayHash, ) { let state_validation_code_hash = match relay_client .validation_code_hash(relay_parent, para_id, OccupiedCoreAssumption::Included) @@ -64,7 +86,7 @@ async fn check_validation_code_or_log( ?relay_parent, ?local_validation_code_hash, relay_validation_code_hash = ?state, - "Parachain code doesn't match validation code stored in the relay chain state", + "Parachain code doesn't match validation code stored in the relay chain state.", ); }, None => { @@ -77,3 +99,159 @@ async fn check_validation_code_or_log( }, } } + +/// Reads async backing parameters from the relay chain storage at the given relay parent. +async fn async_backing_params( + relay_parent: RelayHash, + relay_client: &impl RelayChainInterface, +) -> Option { + match load_abridged_host_configuration(relay_parent, relay_client).await { + Ok(Some(config)) => Some(config.async_backing_params), + Ok(None) => { + tracing::error!( + target: crate::LOG_TARGET, + "Active config is missing in relay chain storage", + ); + None + }, + Err(err) => { + tracing::error!( + target: crate::LOG_TARGET, + ?err, + ?relay_parent, + "Failed to read active config from relay chain client", + ); + None + }, + } +} + +// Return all the cores assigned to the para at the provided relay parent. +async fn cores_scheduled_for_para( + relay_parent: RelayHash, + para_id: ParaId, + relay_client: &impl RelayChainInterface, +) -> Vec { + // Get `AvailabilityCores` from runtime + let cores = match relay_client.availability_cores(relay_parent).await { + Ok(cores) => cores, + Err(error) => { + tracing::error!( + target: crate::LOG_TARGET, + ?error, + ?relay_parent, + "Failed to query availability cores runtime API", + ); + return Vec::new() + }, + }; + + let max_candidate_depth = async_backing_params(relay_parent, relay_client) + .await + .map(|c| c.max_candidate_depth) + .unwrap_or(0); + + cores + .iter() + .enumerate() + .filter_map(|(index, core)| { + let core_para_id = match core { + CoreState::Scheduled(scheduled_core) => Some(scheduled_core.para_id), + CoreState::Occupied(occupied_core) if max_candidate_depth > 0 => occupied_core + .next_up_on_available + .as_ref() + .map(|scheduled_core| scheduled_core.para_id), + CoreState::Free | CoreState::Occupied(_) => None, + }; + + if core_para_id == Some(para_id) { + Some(CoreIndex(index as u32)) + } else { + None + } + }) + .collect() +} + +// Checks if we own the slot at the given block and whether there +// is space in the unincluded segment. +async fn can_build_upon( + slot: Slot, + timestamp: Timestamp, + parent_hash: Block::Hash, + included_block: Block::Hash, + client: &Client, + keystore: &KeystorePtr, +) -> Option> +where + Client: ProvideRuntimeApi, + Client::Api: AuraApi + AuraUnincludedSegmentApi, + P: Pair, + P::Public: Codec, + P::Signature: Codec, +{ + let runtime_api = client.runtime_api(); + let authorities = runtime_api.authorities(parent_hash).ok()?; + let author_pub = aura_internal::claim_slot::

(slot, &authorities, keystore).await?; + + // Here we lean on the property that building on an empty unincluded segment must always + // be legal. Skipping the runtime API query here allows us to seamlessly run this + // collator against chains which have not yet upgraded their runtime. + if parent_hash != included_block && + !runtime_api.can_build_upon(parent_hash, included_block, slot).ok()? + { + return None + } + + Some(SlotClaim::unchecked::

(author_pub, slot, timestamp)) +} + +/// Use [`cumulus_client_consensus_common::find_potential_parents`] to find parachain blocks that +/// we can build on. Once a list of potential parents is retrieved, return the last one of the +/// longest chain. +async fn find_parent( + relay_parent: ParaHash, + para_id: ParaId, + para_backend: &impl sc_client_api::Backend, + relay_client: &impl RelayChainInterface, +) -> Option<(::Hash, consensus_common::PotentialParent)> +where + Block: BlockT, +{ + let parent_search_params = ParentSearchParams { + relay_parent, + para_id, + ancestry_lookback: crate::collators::async_backing_params(relay_parent, relay_client) + .await + .map_or(0, |params| params.allowed_ancestry_len as usize), + max_depth: PARENT_SEARCH_DEPTH, + ignore_alternative_branches: true, + }; + + let potential_parents = cumulus_client_consensus_common::find_potential_parents::( + parent_search_params, + para_backend, + relay_client, + ) + .await; + + let potential_parents = match potential_parents { + Err(e) => { + tracing::error!( + target: crate::LOG_TARGET, + ?relay_parent, + err = ?e, + "Could not fetch potential parents to build upon" + ); + + return None + }, + Ok(x) => x, + }; + + let included_block = potential_parents.iter().find(|x| x.depth == 0)?.hash; + potential_parents + .into_iter() + .max_by_key(|a| a.depth) + .map(|parent| (included_block, parent)) +} diff --git a/cumulus/client/consensus/aura/src/collators/slot_based/block_builder_task.rs b/cumulus/client/consensus/aura/src/collators/slot_based/block_builder_task.rs new file mode 100644 index 0000000000000000000000000000000000000000..b70cfe3841b78e439c2a936a37222da89ea9c5de --- /dev/null +++ b/cumulus/client/consensus/aura/src/collators/slot_based/block_builder_task.rs @@ -0,0 +1,497 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use codec::{Codec, Encode}; + +use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface; +use cumulus_client_consensus_common::{self as consensus_common, ParachainBlockImportMarker}; +use cumulus_client_consensus_proposer::ProposerInterface; +use cumulus_primitives_aura::AuraUnincludedSegmentApi; +use cumulus_primitives_core::{CollectCollationInfo, PersistedValidationData}; +use cumulus_relay_chain_interface::RelayChainInterface; + +use polkadot_primitives::{ + BlockId, CoreIndex, Hash as RelayHash, Header as RelayHeader, Id as ParaId, + OccupiedCoreAssumption, +}; + +use futures::prelude::*; +use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf, UsageProvider}; +use sc_consensus::BlockImport; +use sp_api::ProvideRuntimeApi; +use sp_application_crypto::AppPublic; +use sp_blockchain::HeaderBackend; +use sp_consensus_aura::{AuraApi, Slot, SlotDuration}; +use sp_core::crypto::Pair; +use sp_inherents::CreateInherentDataProviders; +use sp_keystore::KeystorePtr; +use sp_runtime::traits::{Block as BlockT, Header as HeaderT, Member}; +use sp_timestamp::Timestamp; +use std::{sync::Arc, time::Duration}; + +use super::CollatorMessage; +use crate::{ + collator::{self as collator_util}, + collators::{check_validation_code_or_log, cores_scheduled_for_para}, + LOG_TARGET, +}; + +/// Parameters for [`run_block_builder`]. +pub struct BuilderTaskParams< + Block: BlockT, + BI, + CIDP, + Client, + Backend, + RelayClient, + CHP, + Proposer, + CS, +> { + /// Inherent data providers. Only non-consensus inherent data should be provided, i.e. + /// the timestamp, slot, and paras inherents should be omitted, as they are set by this + /// collator. + pub create_inherent_data_providers: CIDP, + /// Used to actually import blocks. + pub block_import: BI, + /// The underlying para client. + pub para_client: Arc, + /// The para client's backend, used to access the database. + pub para_backend: Arc, + /// A handle to the relay-chain client. + pub relay_client: RelayClient, + /// A validation code hash provider, used to get the current validation code hash. + pub code_hash_provider: CHP, + /// The underlying keystore, which should contain Aura consensus keys. + pub keystore: KeystorePtr, + /// The para's ID. + pub para_id: ParaId, + /// The underlying block proposer this should call into. + pub proposer: Proposer, + /// The generic collator service used to plug into this consensus engine. + pub collator_service: CS, + /// The amount of time to spend authoring each block. + pub authoring_duration: Duration, + /// Channel to send built blocks to the collation task. + pub collator_sender: sc_utils::mpsc::TracingUnboundedSender>, + /// Slot duration of the relay chain + pub relay_chain_slot_duration: Duration, + /// Drift every slot by this duration. + /// This is a time quantity that is subtracted from the actual timestamp when computing + /// the time left to enter a new slot. In practice, this *left-shifts* the clock time with the + /// intent to keep our "clock" slightly behind the relay chain one and thus reducing the + /// likelihood of encountering unfavorable notification arrival timings (i.e. we don't want to + /// wait for relay chain notifications because we woke up too early). + pub slot_drift: Duration, +} + +#[derive(Debug)] +struct SlotInfo { + pub timestamp: Timestamp, + pub slot: Slot, + pub slot_duration: SlotDuration, +} + +#[derive(Debug)] +struct SlotTimer { + client: Arc, + drift: Duration, + _marker: std::marker::PhantomData<(Block, Box)>, +} + +/// Returns current duration since Unix epoch. +fn duration_now() -> Duration { + use std::time::SystemTime; + let now = SystemTime::now(); + now.duration_since(SystemTime::UNIX_EPOCH).unwrap_or_else(|e| { + panic!("Current time {:?} is before Unix epoch. Something is wrong: {:?}", now, e) + }) +} + +/// Returns the duration until the next slot from now. +fn time_until_next_slot(slot_duration: Duration, drift: Duration) -> Duration { + let now = duration_now().as_millis() - drift.as_millis(); + + let next_slot = (now + slot_duration.as_millis()) / slot_duration.as_millis(); + let remaining_millis = next_slot * slot_duration.as_millis() - now; + Duration::from_millis(remaining_millis as u64) +} + +impl SlotTimer +where + Block: BlockT, + Client: ProvideRuntimeApi + Send + Sync + 'static + UsageProvider, + Client::Api: AuraApi, + P: Pair, + P::Public: AppPublic + Member + Codec, + P::Signature: TryFrom> + Member + Codec, +{ + pub fn new_with_drift(client: Arc, drift: Duration) -> Self { + Self { client, drift, _marker: Default::default() } + } + + /// Returns a future that resolves when the next slot arrives. + pub async fn wait_until_next_slot(&self) -> Result { + let Ok(slot_duration) = crate::slot_duration(&*self.client) else { + tracing::error!(target: crate::LOG_TARGET, "Failed to fetch slot duration from runtime."); + return Err(()) + }; + + let time_until_next_slot = time_until_next_slot(slot_duration.as_duration(), self.drift); + tokio::time::sleep(time_until_next_slot).await; + let timestamp = sp_timestamp::Timestamp::current(); + Ok(SlotInfo { + slot: Slot::from_timestamp(timestamp, slot_duration), + timestamp, + slot_duration, + }) + } +} + +/// Run block-builder. +pub fn run_block_builder( + params: BuilderTaskParams, +) -> impl Future + Send + 'static +where + Block: BlockT, + Client: ProvideRuntimeApi + + UsageProvider + + BlockOf + + AuxStore + + HeaderBackend + + BlockBackend + + Send + + Sync + + 'static, + Client::Api: + AuraApi + CollectCollationInfo + AuraUnincludedSegmentApi, + Backend: sc_client_api::Backend + 'static, + RelayClient: RelayChainInterface + Clone + 'static, + CIDP: CreateInherentDataProviders + 'static, + CIDP::InherentDataProviders: Send, + BI: BlockImport + ParachainBlockImportMarker + Send + Sync + 'static, + Proposer: ProposerInterface + Send + Sync + 'static, + CS: CollatorServiceInterface + Send + Sync + 'static, + CHP: consensus_common::ValidationCodeHashProvider + Send + 'static, + P: Pair, + P::Public: AppPublic + Member + Codec, + P::Signature: TryFrom> + Member + Codec, +{ + async move { + tracing::info!(target: LOG_TARGET, "Starting slot-based block-builder task."); + let BuilderTaskParams { + relay_client, + create_inherent_data_providers, + para_client, + keystore, + block_import, + para_id, + proposer, + collator_service, + collator_sender, + code_hash_provider, + authoring_duration, + para_backend, + relay_chain_slot_duration, + slot_drift, + } = params; + + let slot_timer = SlotTimer::<_, _, P>::new_with_drift(para_client.clone(), slot_drift); + + let mut collator = { + let params = collator_util::Params { + create_inherent_data_providers, + block_import, + relay_client: relay_client.clone(), + keystore: keystore.clone(), + para_id, + proposer, + collator_service, + }; + + collator_util::Collator::::new(params) + }; + + let mut relay_chain_fetcher = RelayChainCachingFetcher::new(relay_client.clone(), para_id); + + loop { + // We wait here until the next slot arrives. + let Ok(para_slot) = slot_timer.wait_until_next_slot().await else { + return; + }; + + let Some(expected_cores) = + expected_core_count(relay_chain_slot_duration, para_slot.slot_duration) + else { + return + }; + + let Ok(RelayChainData { + relay_parent_header, + max_pov_size, + relay_parent_hash: relay_parent, + scheduled_cores, + }) = relay_chain_fetcher.get_relay_chain_data().await + else { + continue; + }; + + if scheduled_cores.is_empty() { + tracing::debug!(target: LOG_TARGET, "Parachain not scheduled, skipping slot."); + continue; + } + + let core_index_in_scheduled: u64 = *para_slot.slot % expected_cores; + let Some(core_index) = scheduled_cores.get(core_index_in_scheduled as usize) else { + tracing::debug!(target: LOG_TARGET, core_index_in_scheduled, core_len = scheduled_cores.len(), "Para is scheduled, but not enough cores available."); + continue; + }; + + let Some((included_block, parent)) = + crate::collators::find_parent(relay_parent, para_id, &*para_backend, &relay_client) + .await + else { + continue + }; + + let parent_header = parent.header; + let parent_hash = parent.hash; + + // We mainly call this to inform users at genesis if there is a mismatch with the + // on-chain data. + collator.collator_service().check_block_status(parent_hash, &parent_header); + + let slot_claim = match crate::collators::can_build_upon::<_, _, P>( + para_slot.slot, + para_slot.timestamp, + parent_hash, + included_block, + &*para_client, + &keystore, + ) + .await + { + Some(slot) => slot, + None => { + tracing::debug!( + target: crate::LOG_TARGET, + ?core_index, + slot_info = ?para_slot, + unincluded_segment_len = parent.depth, + relay_parent = %relay_parent, + included = %included_block, + parent = %parent_hash, + "Not building block." + ); + continue + }, + }; + + tracing::debug!( + target: crate::LOG_TARGET, + ?core_index, + slot_info = ?para_slot, + unincluded_segment_len = parent.depth, + relay_parent = %relay_parent, + included = %included_block, + parent = %parent_hash, + "Building block." + ); + + let validation_data = PersistedValidationData { + parent_head: parent_header.encode().into(), + relay_parent_number: *relay_parent_header.number(), + relay_parent_storage_root: *relay_parent_header.state_root(), + max_pov_size, + }; + + let (parachain_inherent_data, other_inherent_data) = match collator + .create_inherent_data( + relay_parent, + &validation_data, + parent_hash, + slot_claim.timestamp(), + ) + .await + { + Err(err) => { + tracing::error!(target: crate::LOG_TARGET, ?err); + break + }, + Ok(x) => x, + }; + + let validation_code_hash = match code_hash_provider.code_hash_at(parent_hash) { + None => { + tracing::error!(target: crate::LOG_TARGET, ?parent_hash, "Could not fetch validation code hash"); + break + }, + Some(v) => v, + }; + + check_validation_code_or_log( + &validation_code_hash, + para_id, + &relay_client, + relay_parent, + ) + .await; + + let allowed_pov_size = if cfg!(feature = "full-pov-size") { + validation_data.max_pov_size + } else { + // Set the block limit to 50% of the maximum PoV size. + // + // TODO: If we got benchmarking that includes the proof size, + // we should be able to use the maximum pov size. + validation_data.max_pov_size / 2 + } as usize; + + let Ok(Some(candidate)) = collator + .build_block_and_import( + &parent_header, + &slot_claim, + None, + (parachain_inherent_data, other_inherent_data), + authoring_duration, + allowed_pov_size, + ) + .await + else { + tracing::error!(target: crate::LOG_TARGET, "Unable to build block at slot."); + continue; + }; + + let new_block_hash = candidate.block.header().hash(); + + // Announce the newly built block to our peers. + collator.collator_service().announce_block(new_block_hash, None); + + if let Err(err) = collator_sender.unbounded_send(CollatorMessage { + relay_parent, + parent_header, + parachain_candidate: candidate, + validation_code_hash, + core_index: *core_index, + }) { + tracing::error!(target: crate::LOG_TARGET, ?err, "Unable to send block to collation task."); + return + } + } + } +} + +/// Calculate the expected core count based on the slot duration of the relay and parachain. +/// +/// If `slot_duration` is smaller than `relay_chain_slot_duration` that means that we produce more +/// than one parachain block per relay chain block. In order to get these backed, we need multiple +/// cores. This method calculates how many cores we should expect to have scheduled under the +/// assumption that we have a fixed number of cores assigned to our parachain. +fn expected_core_count( + relay_chain_slot_duration: Duration, + slot_duration: SlotDuration, +) -> Option { + let slot_duration_millis = slot_duration.as_millis(); + u64::try_from(relay_chain_slot_duration.as_millis()) + .map_err(|e| tracing::error!("Unable to calculate expected parachain core count: {e}")) + .map(|relay_slot_duration| (relay_slot_duration / slot_duration_millis).max(1)) + .ok() +} + +/// Contains relay chain data necessary for parachain block building. +#[derive(Clone)] +struct RelayChainData { + /// Current relay chain parent header. + pub relay_parent_header: RelayHeader, + /// The cores this para is scheduled on in the context of the relay parent. + pub scheduled_cores: Vec, + /// Maximum configured PoV size on the relay chain. + pub max_pov_size: u32, + /// Current relay chain parent header. + pub relay_parent_hash: RelayHash, +} + +/// Simple helper to fetch relay chain data and cache it based on the current relay chain best block +/// hash. +struct RelayChainCachingFetcher { + relay_client: RI, + para_id: ParaId, + last_data: Option<(RelayHash, RelayChainData)>, +} + +impl RelayChainCachingFetcher +where + RI: RelayChainInterface + Clone + 'static, +{ + pub fn new(relay_client: RI, para_id: ParaId) -> Self { + Self { relay_client, para_id, last_data: None } + } + + /// Fetch required [`RelayChainData`] from the relay chain. + /// If this data has been fetched in the past for the incoming hash, it will reuse + /// cached data. + pub async fn get_relay_chain_data(&mut self) -> Result { + let Ok(relay_parent) = self.relay_client.best_block_hash().await else { + tracing::warn!(target: crate::LOG_TARGET, "Unable to fetch latest relay chain block hash."); + return Err(()) + }; + + match &self.last_data { + Some((last_seen_hash, data)) if *last_seen_hash == relay_parent => { + tracing::trace!(target: crate::LOG_TARGET, %relay_parent, "Using cached data for relay parent."); + Ok(data.clone()) + }, + _ => { + tracing::trace!(target: crate::LOG_TARGET, %relay_parent, "Relay chain best block changed, fetching new data from relay chain."); + let data = self.update_for_relay_parent(relay_parent).await?; + self.last_data = Some((relay_parent, data.clone())); + Ok(data) + }, + } + } + + /// Fetch fresh data from the relay chain for the given relay parent hash. + async fn update_for_relay_parent(&self, relay_parent: RelayHash) -> Result { + let scheduled_cores = + cores_scheduled_for_para(relay_parent, self.para_id, &self.relay_client).await; + let Ok(Some(relay_parent_header)) = + self.relay_client.header(BlockId::Hash(relay_parent)).await + else { + tracing::warn!(target: crate::LOG_TARGET, "Unable to fetch latest relay chain block header."); + return Err(()) + }; + + let max_pov_size = match self + .relay_client + .persisted_validation_data(relay_parent, self.para_id, OccupiedCoreAssumption::Included) + .await + { + Ok(None) => return Err(()), + Ok(Some(pvd)) => pvd.max_pov_size, + Err(err) => { + tracing::error!(target: crate::LOG_TARGET, ?err, "Failed to gather information from relay-client"); + return Err(()) + }, + }; + + Ok(RelayChainData { + relay_parent_hash: relay_parent, + relay_parent_header, + scheduled_cores, + max_pov_size, + }) + } +} diff --git a/cumulus/client/consensus/aura/src/collators/slot_based/collation_task.rs b/cumulus/client/consensus/aura/src/collators/slot_based/collation_task.rs new file mode 100644 index 0000000000000000000000000000000000000000..5b8151f6302c411469a3258135de2618fc6f5d48 --- /dev/null +++ b/cumulus/client/consensus/aura/src/collators/slot_based/collation_task.rs @@ -0,0 +1,140 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use codec::Encode; + +use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface; +use cumulus_relay_chain_interface::RelayChainInterface; + +use polkadot_node_primitives::{MaybeCompressedPoV, SubmitCollationParams}; +use polkadot_node_subsystem::messages::CollationGenerationMessage; +use polkadot_overseer::Handle as OverseerHandle; +use polkadot_primitives::{CollatorPair, Id as ParaId}; + +use futures::prelude::*; + +use sc_utils::mpsc::TracingUnboundedReceiver; +use sp_runtime::traits::{Block as BlockT, Header}; + +use super::CollatorMessage; + +const LOG_TARGET: &str = "aura::cumulus::collation_task"; + +/// Parameters for the collation task. +pub struct Params { + /// A handle to the relay-chain client. + pub relay_client: RClient, + /// The collator key used to sign collations before submitting to validators. + pub collator_key: CollatorPair, + /// The para's ID. + pub para_id: ParaId, + /// Whether we should reinitialize the collator config (i.e. we are transitioning to aura). + pub reinitialize: bool, + /// Collator service interface + pub collator_service: CS, + /// Receiver channel for communication with the block builder task. + pub collator_receiver: TracingUnboundedReceiver>, +} + +/// Asynchronously executes the collation task for a parachain. +/// +/// This function initializes the collator subsystems necessary for producing and submitting +/// collations to the relay chain. It listens for new best relay chain block notifications and +/// handles collator messages. If our parachain is scheduled on a core and we have a candidate, +/// the task will build a collation and send it to the relay chain. +pub async fn run_collation_task(mut params: Params) +where + Block: BlockT, + CS: CollatorServiceInterface + Send + Sync + 'static, + RClient: RelayChainInterface + Clone + 'static, +{ + let Ok(mut overseer_handle) = params.relay_client.overseer_handle() else { + tracing::error!(target: LOG_TARGET, "Failed to get overseer handle."); + return + }; + + cumulus_client_collator::initialize_collator_subsystems( + &mut overseer_handle, + params.collator_key, + params.para_id, + params.reinitialize, + ) + .await; + + let collator_service = params.collator_service; + while let Some(collator_message) = params.collator_receiver.next().await { + handle_collation_message(collator_message, &collator_service, &mut overseer_handle).await; + } +} + +/// Handle an incoming collation message from the block builder task. +/// This builds the collation from the [`CollatorMessage`] and submits it to +/// the collation-generation subsystem of the relay chain. +async fn handle_collation_message( + message: CollatorMessage, + collator_service: &impl CollatorServiceInterface, + overseer_handle: &mut OverseerHandle, +) { + let CollatorMessage { + parent_header, + parachain_candidate, + validation_code_hash, + relay_parent, + core_index, + } = message; + + let hash = parachain_candidate.block.header().hash(); + let number = *parachain_candidate.block.header().number(); + let (collation, block_data) = + match collator_service.build_collation(&parent_header, hash, parachain_candidate) { + Some(collation) => collation, + None => { + tracing::warn!(target: LOG_TARGET, %hash, ?number, ?core_index, "Unable to build collation."); + return; + }, + }; + + tracing::info!( + target: LOG_TARGET, + "PoV size {{ header: {:.2}kB, extrinsics: {:.2}kB, storage_proof: {:.2}kB }}", + block_data.header().encoded_size() as f64 / 1024f64, + block_data.extrinsics().encoded_size() as f64 / 1024f64, + block_data.storage_proof().encoded_size() as f64 / 1024f64, + ); + + if let MaybeCompressedPoV::Compressed(ref pov) = collation.proof_of_validity { + tracing::info!( + target: LOG_TARGET, + "Compressed PoV size: {}kb", + pov.block_data.0.len() as f64 / 1024f64, + ); + } + + tracing::debug!(target: LOG_TARGET, ?core_index, %hash, %number, "Submitting collation for core."); + overseer_handle + .send_msg( + CollationGenerationMessage::SubmitCollation(SubmitCollationParams { + relay_parent, + collation, + parent_head: parent_header.encode().into(), + validation_code_hash, + core_index, + result_sender: None, + }), + "SubmitCollation", + ) + .await; +} diff --git a/cumulus/client/consensus/aura/src/collators/slot_based/mod.rs b/cumulus/client/consensus/aura/src/collators/slot_based/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0fe49d58d25be672d8541b486c0aa8f22d825c30 --- /dev/null +++ b/cumulus/client/consensus/aura/src/collators/slot_based/mod.rs @@ -0,0 +1,178 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! A collator for Aura that looks ahead of the most recently included parachain block +//! when determining what to build upon. +//! +//! The block building mechanism consists of two parts: +//! 1. A block-builder task that builds parachain blocks at each of our slots. +//! 2. A collator task that transforms the blocks into a collation and submits them to the relay +//! chain. +//! +//! Blocks are built on every parachain slot if there is a core scheduled on the relay chain. At the +//! beginning of each block building loop, we determine how many blocks we expect to build per relay +//! chain block. The collator implementation then expects that we have that many cores scheduled +//! during the relay chain block. After the block is built, the block builder task sends it to +//! the collation task which compresses it and submits it to the collation-generation subsystem. + +use codec::Codec; +use consensus_common::ParachainCandidate; +use cumulus_client_collator::service::ServiceInterface as CollatorServiceInterface; +use cumulus_client_consensus_common::{self as consensus_common, ParachainBlockImportMarker}; +use cumulus_client_consensus_proposer::ProposerInterface; +use cumulus_primitives_aura::AuraUnincludedSegmentApi; +use cumulus_primitives_core::CollectCollationInfo; +use cumulus_relay_chain_interface::RelayChainInterface; +use polkadot_primitives::{ + CollatorPair, CoreIndex, Hash as RelayHash, Id as ParaId, ValidationCodeHash, +}; + +use sc_client_api::{backend::AuxStore, BlockBackend, BlockOf, UsageProvider}; +use sc_consensus::BlockImport; +use sc_utils::mpsc::tracing_unbounded; + +use sp_api::ProvideRuntimeApi; +use sp_application_crypto::AppPublic; +use sp_blockchain::HeaderBackend; +use sp_consensus_aura::AuraApi; +use sp_core::crypto::Pair; +use sp_inherents::CreateInherentDataProviders; +use sp_keystore::KeystorePtr; +use sp_runtime::traits::{Block as BlockT, Member}; + +use std::{sync::Arc, time::Duration}; + +use self::{block_builder_task::run_block_builder, collation_task::run_collation_task}; + +mod block_builder_task; +mod collation_task; + +/// Parameters for [`run`]. +pub struct Params { + /// Inherent data providers. Only non-consensus inherent data should be provided, i.e. + /// the timestamp, slot, and paras inherents should be omitted, as they are set by this + /// collator. + pub create_inherent_data_providers: CIDP, + /// Used to actually import blocks. + pub block_import: BI, + /// The underlying para client. + pub para_client: Arc, + /// The para client's backend, used to access the database. + pub para_backend: Arc, + /// A handle to the relay-chain client. + pub relay_client: RClient, + /// A validation code hash provider, used to get the current validation code hash. + pub code_hash_provider: CHP, + /// The underlying keystore, which should contain Aura consensus keys. + pub keystore: KeystorePtr, + /// The collator key used to sign collations before submitting to validators. + pub collator_key: CollatorPair, + /// The para's ID. + pub para_id: ParaId, + /// The length of slots in the relay chain. + pub relay_chain_slot_duration: Duration, + /// The underlying block proposer this should call into. + pub proposer: Proposer, + /// The generic collator service used to plug into this consensus engine. + pub collator_service: CS, + /// The amount of time to spend authoring each block. + pub authoring_duration: Duration, + /// Whether we should reinitialize the collator config (i.e. we are transitioning to aura). + pub reinitialize: bool, + /// Drift slots by a fixed duration. This can be used to create more preferrable authoring + /// timings. + pub slot_drift: Duration, +} + +/// Run aura-based block building and collation task. +pub fn run( + params: Params, +) -> (impl futures::Future, impl futures::Future) +where + Block: BlockT, + Client: ProvideRuntimeApi + + BlockOf + + AuxStore + + HeaderBackend + + BlockBackend + + UsageProvider + + Send + + Sync + + 'static, + Client::Api: + AuraApi + CollectCollationInfo + AuraUnincludedSegmentApi, + Backend: sc_client_api::Backend + 'static, + RClient: RelayChainInterface + Clone + 'static, + CIDP: CreateInherentDataProviders + 'static, + CIDP::InherentDataProviders: Send, + BI: BlockImport + ParachainBlockImportMarker + Send + Sync + 'static, + Proposer: ProposerInterface + Send + Sync + 'static, + CS: CollatorServiceInterface + Send + Sync + Clone + 'static, + CHP: consensus_common::ValidationCodeHashProvider + Send + 'static, + P: Pair + 'static, + P::Public: AppPublic + Member + Codec, + P::Signature: TryFrom> + Member + Codec, +{ + let (tx, rx) = tracing_unbounded("mpsc_builder_to_collator", 100); + let collator_task_params = collation_task::Params { + relay_client: params.relay_client.clone(), + collator_key: params.collator_key, + para_id: params.para_id, + reinitialize: params.reinitialize, + collator_service: params.collator_service.clone(), + collator_receiver: rx, + }; + + let collation_task_fut = run_collation_task::(collator_task_params); + + let block_builder_params = block_builder_task::BuilderTaskParams { + create_inherent_data_providers: params.create_inherent_data_providers, + block_import: params.block_import, + para_client: params.para_client, + para_backend: params.para_backend, + relay_client: params.relay_client, + code_hash_provider: params.code_hash_provider, + keystore: params.keystore, + para_id: params.para_id, + proposer: params.proposer, + collator_service: params.collator_service, + authoring_duration: params.authoring_duration, + collator_sender: tx, + relay_chain_slot_duration: params.relay_chain_slot_duration, + slot_drift: params.slot_drift, + }; + + let block_builder_fut = + run_block_builder::(block_builder_params); + + (collation_task_fut, block_builder_fut) +} + +/// Message to be sent from the block builder to the collation task. +/// +/// Contains all data necessary to submit a collation to the relay chain. +struct CollatorMessage { + /// The hash of the relay chain block that provides the context for the parachain block. + pub relay_parent: RelayHash, + /// The header of the parent block. + pub parent_header: Block::Header, + /// The parachain block candidate. + pub parachain_candidate: ParachainCandidate, + /// The validation code hash at the parent block. + pub validation_code_hash: ValidationCodeHash, + /// Core index that this block should be submitted on + pub core_index: CoreIndex, +} diff --git a/cumulus/client/consensus/aura/src/equivocation_import_queue.rs b/cumulus/client/consensus/aura/src/equivocation_import_queue.rs index c3b601123b56996c597104567f7f39d29d64bf9c..68f2d37c8748863be879134d3fd0849adf5efb11 100644 --- a/cumulus/client/consensus/aura/src/equivocation_import_queue.rs +++ b/cumulus/client/consensus/aura/src/equivocation_import_queue.rs @@ -21,6 +21,7 @@ /// should be thrown out and which ones should be kept. use codec::Codec; use cumulus_client_consensus_common::ParachainBlockImportMarker; +use parking_lot::Mutex; use schnellru::{ByLength, LruMap}; use sc_consensus::{ @@ -70,7 +71,7 @@ impl NaiveEquivocationDefender { struct Verifier { client: Arc, create_inherent_data_providers: CIDP, - defender: NaiveEquivocationDefender, + defender: Mutex, telemetry: Option, _phantom: std::marker::PhantomData (Block, P)>, } @@ -88,7 +89,7 @@ where CIDP: CreateInherentDataProviders, { async fn verify( - &mut self, + &self, mut block_params: BlockImportParams, ) -> Result, String> { // Skip checks that include execution, if being told so, or when importing only state. @@ -137,7 +138,7 @@ where block_params.post_hash = Some(post_hash); // Check for and reject egregious amounts of equivocations. - if self.defender.insert_and_check(slot) { + if self.defender.lock().insert_and_check(slot) { return Err(format!( "Rejecting block {:?} due to excessive equivocations at slot", post_hash, @@ -224,7 +225,7 @@ pub fn fully_verifying_import_queue( block_import: I, create_inherent_data_providers: CIDP, spawner: &impl sp_core::traits::SpawnEssentialNamed, - registry: Option<&substrate_prometheus_endpoint::Registry>, + registry: Option<&prometheus_endpoint::Registry>, telemetry: Option, ) -> BasicQueue where @@ -243,7 +244,7 @@ where let verifier = Verifier:: { client, create_inherent_data_providers, - defender: NaiveEquivocationDefender::default(), + defender: Mutex::new(NaiveEquivocationDefender::default()), telemetry, _phantom: std::marker::PhantomData, }; diff --git a/cumulus/client/consensus/aura/src/import_queue.rs b/cumulus/client/consensus/aura/src/import_queue.rs index 2611eaf532f8ffadebc1c2932f429803e561924e..cbbfbe8d22230330e5306ed76d31b63eb4cf82e5 100644 --- a/cumulus/client/consensus/aura/src/import_queue.rs +++ b/cumulus/client/consensus/aura/src/import_queue.rs @@ -18,6 +18,7 @@ use codec::Codec; use cumulus_client_consensus_common::ParachainBlockImportMarker; +use prometheus_endpoint::Registry; use sc_client_api::{backend::AuxStore, BlockOf, UsageProvider}; use sc_consensus::{import_queue::DefaultImportQueue, BlockImport}; use sc_consensus_aura::{AuraVerifier, CompatibilityMode}; @@ -32,7 +33,6 @@ use sp_core::crypto::Pair; use sp_inherents::CreateInherentDataProviders; use sp_runtime::traits::Block as BlockT; use std::{fmt::Debug, sync::Arc}; -use substrate_prometheus_endpoint::Registry; /// Parameters for [`import_queue`]. pub struct ImportQueueParams<'a, I, C, CIDP, S> { diff --git a/cumulus/client/consensus/common/Cargo.toml b/cumulus/client/consensus/common/Cargo.toml index fb4a85ad122637470a81371eb12352a14ac7c61e..4bc2f1d1e600e5f82faaf7cfa84a3b831cf085b7 100644 --- a/cumulus/client/consensus/common/Cargo.toml +++ b/cumulus/client/consensus/common/Cargo.toml @@ -10,41 +10,42 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -dyn-clone = "1.0.16" -futures = "0.3.28" +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +dyn-clone = { workspace = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -tracing = "0.1.37" +tracing = { workspace = true, default-features = true } # Substrate -sc-client-api = { path = "../../../../substrate/client/api" } -sc-consensus = { path = "../../../../substrate/client/consensus/common" } -sc-consensus-babe = { path = "../../../../substrate/client/consensus/babe" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-consensus-slots = { path = "../../../../substrate/primitives/consensus/slots" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-timestamp = { path = "../../../../substrate/primitives/timestamp" } -sp-trie = { path = "../../../../substrate/primitives/trie" } -substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../../polkadot/primitives" } +polkadot-primitives = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-core = { path = "../../../primitives/core" } -cumulus-relay-chain-interface = { path = "../../relay-chain-interface" } -cumulus-client-pov-recovery = { path = "../../pov-recovery" } -schnellru = "0.2.1" +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-client-pov-recovery = { workspace = true, default-features = true } +schnellru = { workspace = true } [dev-dependencies] -futures-timer = "3.0.2" +futures-timer = { workspace = true } # Substrate -sp-tracing = { path = "../../../../substrate/primitives/tracing" } +sp-tracing = { workspace = true, default-features = true } # Cumulus -cumulus-test-client = { path = "../../../test/client" } -cumulus-test-relay-sproof-builder = { path = "../../../test/relay-sproof-builder" } +cumulus-test-client = { workspace = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } diff --git a/cumulus/client/consensus/common/src/import_queue.rs b/cumulus/client/consensus/common/src/import_queue.rs index 311a2b7ad8cfddf50abe0b18aeb5bf5f1f193c1d..488693604fefccbe2c9b37a22c8ee3c4809383f2 100644 --- a/cumulus/client/consensus/common/src/import_queue.rs +++ b/cumulus/client/consensus/common/src/import_queue.rs @@ -50,7 +50,7 @@ pub struct VerifyNothing; #[async_trait::async_trait] impl Verifier for VerifyNothing { async fn verify( - &mut self, + &self, params: BlockImportParams, ) -> Result, String> { Ok(params) @@ -63,7 +63,7 @@ impl Verifier for VerifyNothing { pub fn verify_nothing_import_queue( block_import: I, spawner: &impl sp_core::traits::SpawnEssentialNamed, - registry: Option<&substrate_prometheus_endpoint::Registry>, + registry: Option<&prometheus_endpoint::Registry>, ) -> BasicQueue where I: BlockImport diff --git a/cumulus/client/consensus/common/src/lib.rs b/cumulus/client/consensus/common/src/lib.rs index cebe34e7ea58828372a9261e3be94866e119546a..6766c2409c385f2cada12ea5da5a81c39fe20205 100644 --- a/cumulus/client/consensus/common/src/lib.rs +++ b/cumulus/client/consensus/common/src/lib.rs @@ -19,16 +19,13 @@ use polkadot_primitives::{ Block as PBlock, Hash as PHash, Header as PHeader, PersistedValidationData, ValidationCodeHash, }; -use cumulus_primitives_core::{ - relay_chain::{self, BlockId as RBlockId, OccupiedCoreAssumption}, - AbridgedHostConfiguration, ParaId, -}; +use cumulus_primitives_core::{relay_chain, AbridgedHostConfiguration}; use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface}; -use sc_client_api::{Backend, HeaderBackend}; +use sc_client_api::Backend; use sc_consensus::{shared_data::SharedData, BlockImport, ImportResult}; -use sp_blockchain::Backend as BlockchainBackend; use sp_consensus_slots::Slot; + use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; use sp_timestamp::Timestamp; @@ -36,9 +33,12 @@ use std::{sync::Arc, time::Duration}; mod level_monitor; mod parachain_consensus; +mod parent_search; #[cfg(test)] mod tests; +pub use parent_search::*; + pub use parachain_consensus::run_parachain_consensus; use level_monitor::LevelMonitor; @@ -172,20 +172,20 @@ impl Clone for ParachainBlockImport { impl BlockImport for ParachainBlockImport where Block: BlockT, - BI: BlockImport + Send, + BI: BlockImport + Send + Sync, BE: Backend, { type Error = BI::Error; async fn check_block( - &mut self, + &self, block: sc_consensus::BlockCheckParams, ) -> Result { self.inner.check_block(block).await } async fn import_block( - &mut self, + &self, mut params: sc_consensus::BlockImportParams, ) -> Result { // Blocks are stored within the backend by using POST hash. @@ -229,196 +229,6 @@ pub trait ParachainBlockImportMarker {} impl ParachainBlockImportMarker for ParachainBlockImport {} -/// Parameters when searching for suitable parents to build on top of. -#[derive(Debug)] -pub struct ParentSearchParams { - /// The relay-parent that is intended to be used. - pub relay_parent: PHash, - /// The ID of the parachain. - pub para_id: ParaId, - /// A limitation on the age of relay parents for parachain blocks that are being - /// considered. This is relative to the `relay_parent` number. - pub ancestry_lookback: usize, - /// How "deep" parents can be relative to the included parachain block at the relay-parent. - /// The included block has depth 0. - pub max_depth: usize, - /// Whether to only ignore "alternative" branches, i.e. branches of the chain - /// which do not contain the block pending availability. - pub ignore_alternative_branches: bool, -} - -/// A potential parent block returned from [`find_potential_parents`] -#[derive(Debug, PartialEq)] -pub struct PotentialParent { - /// The hash of the block. - pub hash: B::Hash, - /// The header of the block. - pub header: B::Header, - /// The depth of the block. - pub depth: usize, - /// Whether the block is the included block, is itself pending on-chain, or descends - /// from the block pending availability. - pub aligned_with_pending: bool, -} - -/// Perform a recursive search through blocks to find potential -/// parent blocks for a new block. -/// -/// This accepts a relay-chain block to be used as an anchor and a maximum search depth, -/// along with some arguments for filtering parachain blocks and performs a recursive search -/// for parachain blocks. The search begins at the last included parachain block and returns -/// a set of [`PotentialParent`]s which could be potential parents of a new block with this -/// relay-parent according to the search parameters. -/// -/// A parachain block is a potential parent if it is either the last included parachain block, the -/// pending parachain block (when `max_depth` >= 1), or all of the following hold: -/// * its parent is a potential parent -/// * its relay-parent is within `ancestry_lookback` of the targeted relay-parent. -/// * its relay-parent is within the same session as the targeted relay-parent. -/// * the block number is within `max_depth` blocks of the included block -pub async fn find_potential_parents( - params: ParentSearchParams, - client: &impl Backend, - relay_client: &impl RelayChainInterface, -) -> Result>, RelayChainError> { - // 1. Build up the ancestry record of the relay chain to compare against. - let rp_ancestry = { - let mut ancestry = Vec::with_capacity(params.ancestry_lookback + 1); - let mut current_rp = params.relay_parent; - let mut required_session = None; - - while ancestry.len() <= params.ancestry_lookback { - let header = match relay_client.header(RBlockId::hash(current_rp)).await? { - None => break, - Some(h) => h, - }; - - let session = relay_client.session_index_for_child(current_rp).await?; - if let Some(required_session) = required_session { - // Respect the relay-chain rule not to cross session boundaries. - if session != required_session { - break - } - } else { - required_session = Some(session); - } - - ancestry.push((current_rp, *header.state_root())); - current_rp = *header.parent_hash(); - - // don't iterate back into the genesis block. - if header.number == 1 { - break - } - } - - ancestry - }; - - let is_hash_in_ancestry = |hash| rp_ancestry.iter().any(|x| x.0 == hash); - let is_root_in_ancestry = |root| rp_ancestry.iter().any(|x| x.1 == root); - - // 2. Get the included and pending availability blocks. - let included_header = relay_client - .persisted_validation_data( - params.relay_parent, - params.para_id, - OccupiedCoreAssumption::TimedOut, - ) - .await?; - - let included_header = match included_header { - Some(pvd) => pvd.parent_head, - None => return Ok(Vec::new()), // this implies the para doesn't exist. - }; - - let pending_header = relay_client - .persisted_validation_data( - params.relay_parent, - params.para_id, - OccupiedCoreAssumption::Included, - ) - .await? - .and_then(|x| if x.parent_head != included_header { Some(x.parent_head) } else { None }); - - let included_header = match B::Header::decode(&mut &included_header.0[..]).ok() { - None => return Ok(Vec::new()), - Some(x) => x, - }; - // Silently swallow if pending block can't decode. - let pending_header = pending_header.and_then(|p| B::Header::decode(&mut &p.0[..]).ok()); - let included_hash = included_header.hash(); - let pending_hash = pending_header.as_ref().map(|hdr| hdr.hash()); - - let mut frontier = vec![PotentialParent:: { - hash: included_hash, - header: included_header, - depth: 0, - aligned_with_pending: true, - }]; - - // Recursive search through descendants of the included block which have acceptable - // relay parents. - let mut potential_parents = Vec::new(); - while let Some(entry) = frontier.pop() { - let is_pending = - entry.depth == 1 && pending_hash.as_ref().map_or(false, |h| &entry.hash == h); - let is_included = entry.depth == 0; - - // note: even if the pending block or included block have a relay parent - // outside of the expected part of the relay chain, they are always allowed - // because they have already been posted on chain. - let is_potential = is_pending || is_included || { - let digest = entry.header.digest(); - cumulus_primitives_core::extract_relay_parent(digest).map_or(false, is_hash_in_ancestry) || - cumulus_primitives_core::rpsr_digest::extract_relay_parent_storage_root(digest) - .map(|(r, _n)| r) - .map_or(false, is_root_in_ancestry) - }; - - let parent_aligned_with_pending = entry.aligned_with_pending; - let child_depth = entry.depth + 1; - let hash = entry.hash; - - if is_potential { - potential_parents.push(entry); - } - - if !is_potential || child_depth > params.max_depth { - continue - } - - // push children onto search frontier. - for child in client.blockchain().children(hash).ok().into_iter().flatten() { - let aligned_with_pending = parent_aligned_with_pending && - if child_depth == 1 { - pending_hash.as_ref().map_or(true, |h| &child == h) - } else { - true - }; - - if params.ignore_alternative_branches && !aligned_with_pending { - continue - } - - let header = match client.blockchain().header(child) { - Ok(Some(h)) => h, - Ok(None) => continue, - Err(_) => continue, - }; - - frontier.push(PotentialParent { - hash: child, - header, - depth: child_depth, - aligned_with_pending, - }); - } - } - - Ok(potential_parents) -} - /// Get the relay-parent slot and timestamp from a header. pub fn relay_slot_and_timestamp( relay_parent_header: &PHeader, diff --git a/cumulus/client/consensus/common/src/parachain_consensus.rs b/cumulus/client/consensus/common/src/parachain_consensus.rs index b4b315bb32be6ea18d7ae9399cafe4640096f2b4..861354ed63c30783dc04cb20dd9195caf94096b9 100644 --- a/cumulus/client/consensus/common/src/parachain_consensus.rs +++ b/cumulus/client/consensus/common/src/parachain_consensus.rs @@ -375,68 +375,66 @@ async fn handle_new_best_parachain_head( target: LOG_TARGET, block_hash = ?hash, "Skipping set new best block, because block is already the best.", - ) - } else { - // Make sure the block is already known or otherwise we skip setting new best. - match parachain.block_status(hash) { - Ok(BlockStatus::InChainWithState) => { - unset_best_header.take(); - tracing::debug!( - target: LOG_TARGET, - ?hash, - "Importing block as new best for parachain.", - ); - import_block_as_new_best(hash, parachain_head, parachain).await; - }, - Ok(BlockStatus::InChainPruned) => { - tracing::error!( - target: LOG_TARGET, - block_hash = ?hash, - "Trying to set pruned block as new best!", - ); - }, - Ok(BlockStatus::Unknown) => { - *unset_best_header = Some(parachain_head); + ); + return; + } - tracing::debug!( - target: LOG_TARGET, - block_hash = ?hash, - "Parachain block not yet imported, waiting for import to enact as best block.", - ); - - if let Some(ref mut recovery_chan_tx) = recovery_chan_tx { - // Best effort channel to actively encourage block recovery. - // An error here is not fatal; the relay chain continuously re-announces - // the best block, thus we will have other opportunities to retry. - let req = RecoveryRequest { hash, kind: RecoveryKind::Full }; - if let Err(err) = recovery_chan_tx.try_send(req) { - tracing::warn!( - target: LOG_TARGET, - block_hash = ?hash, - error = ?err, - "Unable to notify block recovery subsystem" - ) - } + // Make sure the block is already known or otherwise we skip setting new best. + match parachain.block_status(hash) { + Ok(BlockStatus::InChainWithState) => { + unset_best_header.take(); + tracing::debug!( + target: LOG_TARGET, + included = ?hash, + "Importing block as new best for parachain.", + ); + import_block_as_new_best(hash, parachain_head, parachain).await; + }, + Ok(BlockStatus::InChainPruned) => { + tracing::error!( + target: LOG_TARGET, + block_hash = ?hash, + "Trying to set pruned block as new best!", + ); + }, + Ok(BlockStatus::Unknown) => { + *unset_best_header = Some(parachain_head); + + tracing::debug!( + target: LOG_TARGET, + block_hash = ?hash, + "Parachain block not yet imported, waiting for import to enact as best block.", + ); + + if let Some(ref mut recovery_chan_tx) = recovery_chan_tx { + // Best effort channel to actively encourage block recovery. + // An error here is not fatal; the relay chain continuously re-announces + // the best block, thus we will have other opportunities to retry. + let req = RecoveryRequest { hash, kind: RecoveryKind::Full }; + if let Err(err) = recovery_chan_tx.try_send(req) { + tracing::warn!( + target: LOG_TARGET, + block_hash = ?hash, + error = ?err, + "Unable to notify block recovery subsystem" + ) } - }, - Err(e) => { - tracing::error!( - target: LOG_TARGET, - block_hash = ?hash, - error = ?e, - "Failed to get block status of block.", - ); - }, - _ => {}, - } + } + }, + Err(e) => { + tracing::error!( + target: LOG_TARGET, + block_hash = ?hash, + error = ?e, + "Failed to get block status of block.", + ); + }, + _ => {}, } } -async fn import_block_as_new_best( - hash: Block::Hash, - header: Block::Header, - mut parachain: &P, -) where +async fn import_block_as_new_best(hash: Block::Hash, header: Block::Header, parachain: &P) +where Block: BlockT, P: UsageProvider + Send + Sync + BlockBackend, for<'a> &'a P: BlockImport, diff --git a/cumulus/client/consensus/common/src/parent_search.rs b/cumulus/client/consensus/common/src/parent_search.rs new file mode 100644 index 0000000000000000000000000000000000000000..c371ec62f8455cacc7d6a2d7b1ba71e142661fff --- /dev/null +++ b/cumulus/client/consensus/common/src/parent_search.rs @@ -0,0 +1,418 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use codec::Decode; +use polkadot_primitives::Hash as RelayHash; + +use cumulus_primitives_core::{ + relay_chain::{BlockId as RBlockId, OccupiedCoreAssumption}, + ParaId, +}; +use cumulus_relay_chain_interface::{RelayChainError, RelayChainInterface}; + +use sc_client_api::{Backend, HeaderBackend}; + +use sp_blockchain::{Backend as BlockchainBackend, TreeRoute}; + +use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; + +const PARENT_SEARCH_LOG_TARGET: &str = "consensus::common::find_potential_parents"; + +/// Parameters when searching for suitable parents to build on top of. +#[derive(Debug)] +pub struct ParentSearchParams { + /// The relay-parent that is intended to be used. + pub relay_parent: RelayHash, + /// The ID of the parachain. + pub para_id: ParaId, + /// A limitation on the age of relay parents for parachain blocks that are being + /// considered. This is relative to the `relay_parent` number. + pub ancestry_lookback: usize, + /// How "deep" parents can be relative to the included parachain block at the relay-parent. + /// The included block has depth 0. + pub max_depth: usize, + /// Whether to only ignore "alternative" branches, i.e. branches of the chain + /// which do not contain the block pending availability. + pub ignore_alternative_branches: bool, +} + +/// A potential parent block returned from [`find_potential_parents`] +#[derive(PartialEq)] +pub struct PotentialParent { + /// The hash of the block. + pub hash: B::Hash, + /// The header of the block. + pub header: B::Header, + /// The depth of the block with respect to the included block. + pub depth: usize, + /// Whether the block is the included block, is itself pending on-chain, or descends + /// from the block pending availability. + pub aligned_with_pending: bool, +} + +impl std::fmt::Debug for PotentialParent { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("PotentialParent") + .field("hash", &self.hash) + .field("depth", &self.depth) + .field("aligned_with_pending", &self.aligned_with_pending) + .field("number", &self.header.number()) + .finish() + } +} + +/// Perform a recursive search through blocks to find potential +/// parent blocks for a new block. +/// +/// This accepts a relay-chain block to be used as an anchor and a maximum search depth, +/// along with some arguments for filtering parachain blocks and performs a recursive search +/// for parachain blocks. The search begins at the last included parachain block and returns +/// a set of [`PotentialParent`]s which could be potential parents of a new block with this +/// relay-parent according to the search parameters. +/// +/// A parachain block is a potential parent if it is either the last included parachain block, the +/// pending parachain block (when `max_depth` >= 1), or all of the following hold: +/// * its parent is a potential parent +/// * its relay-parent is within `ancestry_lookback` of the targeted relay-parent. +/// * its relay-parent is within the same session as the targeted relay-parent. +/// * the block number is within `max_depth` blocks of the included block +pub async fn find_potential_parents( + params: ParentSearchParams, + backend: &impl Backend, + relay_client: &impl RelayChainInterface, +) -> Result>, RelayChainError> { + tracing::trace!("Parent search parameters: {params:?}"); + // Get the included block. + let Some((included_header, included_hash)) = + fetch_included_from_relay_chain(relay_client, backend, params.para_id, params.relay_parent) + .await? + else { + return Ok(Default::default()) + }; + + let only_included = vec![PotentialParent { + hash: included_hash, + header: included_header.clone(), + depth: 0, + aligned_with_pending: true, + }]; + + if params.max_depth == 0 { + return Ok(only_included) + }; + + // Pending header and hash. + let maybe_pending = { + // Fetch the most recent pending header from the relay chain. We use + // `OccupiedCoreAssumption::Included` so the candidate pending availability gets enacted + // before being returned to us. + let pending_header = relay_client + .persisted_validation_data( + params.relay_parent, + params.para_id, + OccupiedCoreAssumption::Included, + ) + .await? + .and_then(|p| B::Header::decode(&mut &p.parent_head.0[..]).ok()) + .filter(|x| x.hash() != included_hash); + + // If the pending block is not locally known, we can't do anything. + if let Some(header) = pending_header { + let pending_hash = header.hash(); + match backend.blockchain().header(pending_hash) { + // We are supposed to ignore branches that don't contain the pending block, but we + // do not know the pending block locally. + Ok(None) | Err(_) if params.ignore_alternative_branches => { + tracing::warn!( + target: PARENT_SEARCH_LOG_TARGET, + %pending_hash, + "Failed to get header for pending block.", + ); + return Ok(Default::default()) + }, + Ok(Some(_)) => Some((header, pending_hash)), + _ => None, + } + } else { + None + } + }; + + let maybe_route_to_last_pending = maybe_pending + .as_ref() + .map(|(_, pending)| { + sp_blockchain::tree_route(backend.blockchain(), included_hash, *pending) + }) + .transpose()?; + + // If we want to ignore alternative branches there is no reason to start + // the parent search at the included block. We can add the included block and + // the path to the pending block to the potential parents directly (limited by max_depth). + let (frontier, potential_parents) = match ( + &maybe_pending, + params.ignore_alternative_branches, + &maybe_route_to_last_pending, + ) { + (Some((pending_header, pending_hash)), true, Some(ref route_to_pending)) => { + let mut potential_parents = only_included; + + // This is a defensive check, should never happen. + if !route_to_pending.retracted().is_empty() { + tracing::warn!(target: PARENT_SEARCH_LOG_TARGET, "Included block not an ancestor of pending block. This should not happen."); + return Ok(Default::default()) + } + + // Add all items on the path included -> pending - 1 to the potential parents, but + // not more than `max_depth`. + let num_parents_on_path = + route_to_pending.enacted().len().saturating_sub(1).min(params.max_depth); + for (num, block) in + route_to_pending.enacted().iter().take(num_parents_on_path).enumerate() + { + let Ok(Some(header)) = backend.blockchain().header(block.hash) else { continue }; + + potential_parents.push(PotentialParent { + hash: block.hash, + header, + depth: 1 + num, + aligned_with_pending: true, + }); + } + + // The search for additional potential parents should now start at the children of + // the pending block. + ( + vec![PotentialParent { + hash: *pending_hash, + header: pending_header.clone(), + depth: route_to_pending.enacted().len(), + aligned_with_pending: true, + }], + potential_parents, + ) + }, + _ => (only_included, Default::default()), + }; + + if potential_parents.len() > params.max_depth { + return Ok(potential_parents); + } + + // Build up the ancestry record of the relay chain to compare against. + let rp_ancestry = + build_relay_parent_ancestry(params.ancestry_lookback, params.relay_parent, relay_client) + .await?; + + Ok(search_child_branches_for_parents( + frontier, + maybe_route_to_last_pending, + included_header, + maybe_pending.map(|(_, hash)| hash), + backend, + params.max_depth, + params.ignore_alternative_branches, + rp_ancestry, + potential_parents, + )) +} + +/// Fetch the included block from the relay chain. +async fn fetch_included_from_relay_chain( + relay_client: &impl RelayChainInterface, + backend: &impl Backend, + para_id: ParaId, + relay_parent: RelayHash, +) -> Result, RelayChainError> { + // Fetch the pending header from the relay chain. We use `OccupiedCoreAssumption::TimedOut` + // so that even if there is a pending candidate, we assume it is timed out and we get the + // included head. + let included_header = relay_client + .persisted_validation_data(relay_parent, para_id, OccupiedCoreAssumption::TimedOut) + .await?; + let included_header = match included_header { + Some(pvd) => pvd.parent_head, + None => return Ok(None), // this implies the para doesn't exist. + }; + + let included_header = match B::Header::decode(&mut &included_header.0[..]).ok() { + None => return Ok(None), + Some(x) => x, + }; + + let included_hash = included_header.hash(); + // If the included block is not locally known, we can't do anything. + match backend.blockchain().header(included_hash) { + Ok(None) => { + tracing::warn!( + target: PARENT_SEARCH_LOG_TARGET, + %included_hash, + "Failed to get header for included block.", + ); + return Ok(None) + }, + Err(e) => { + tracing::warn!( + target: PARENT_SEARCH_LOG_TARGET, + %included_hash, + %e, + "Failed to get header for included block.", + ); + return Ok(None) + }, + _ => {}, + }; + + Ok(Some((included_header, included_hash))) +} + +/// Build an ancestry of relay parents that are acceptable. +/// +/// An acceptable relay parent is one that is no more than `ancestry_lookback` + 1 blocks below the +/// relay parent we want to build on. Parachain blocks anchored on relay parents older than that can +/// not be considered potential parents for block building. They have no chance of still getting +/// included, so our newly build parachain block would also not get included. +/// +/// On success, returns a vector of `(header_hash, state_root)` of the relevant relay chain +/// ancestry blocks. +async fn build_relay_parent_ancestry( + ancestry_lookback: usize, + relay_parent: RelayHash, + relay_client: &impl RelayChainInterface, +) -> Result, RelayChainError> { + let mut ancestry = Vec::with_capacity(ancestry_lookback + 1); + let mut current_rp = relay_parent; + let mut required_session = None; + while ancestry.len() <= ancestry_lookback { + let Some(header) = relay_client.header(RBlockId::hash(current_rp)).await? else { break }; + + let session = relay_client.session_index_for_child(current_rp).await?; + if required_session.get_or_insert(session) != &session { + // Respect the relay-chain rule not to cross session boundaries. + break; + } + + ancestry.push((current_rp, *header.state_root())); + current_rp = *header.parent_hash(); + + // don't iterate back into the genesis block. + if header.number == 1 { + break + } + } + Ok(ancestry) +} + +/// Start search for child blocks that can be used as parents. +pub fn search_child_branches_for_parents( + mut frontier: Vec>, + maybe_route_to_last_pending: Option>, + included_header: Block::Header, + pending_hash: Option, + backend: &impl Backend, + max_depth: usize, + ignore_alternative_branches: bool, + rp_ancestry: Vec<(RelayHash, RelayHash)>, + mut potential_parents: Vec>, +) -> Vec> { + let included_hash = included_header.hash(); + let is_hash_in_ancestry = |hash| rp_ancestry.iter().any(|x| x.0 == hash); + let is_root_in_ancestry = |root| rp_ancestry.iter().any(|x| x.1 == root); + + // The distance between pending and included block. Is later used to check if a child + // is aligned with pending when it is between pending and included block. + let pending_distance = maybe_route_to_last_pending.as_ref().map(|route| route.enacted().len()); + + // If a block is on the path included -> pending, we consider it `aligned_with_pending`. + let is_child_pending = |hash| { + maybe_route_to_last_pending + .as_ref() + .map_or(true, |route| route.enacted().iter().any(|x| x.hash == hash)) + }; + + tracing::trace!( + target: PARENT_SEARCH_LOG_TARGET, + ?included_hash, + included_num = ?included_header.number(), + ?pending_hash , + ?rp_ancestry, + "Searching relay chain ancestry." + ); + while let Some(entry) = frontier.pop() { + let is_pending = pending_hash.as_ref().map_or(false, |h| &entry.hash == h); + let is_included = included_hash == entry.hash; + + // note: even if the pending block or included block have a relay parent + // outside of the expected part of the relay chain, they are always allowed + // because they have already been posted on chain. + let is_potential = is_pending || is_included || { + let digest = entry.header.digest(); + let is_hash_in_ancestry_check = cumulus_primitives_core::extract_relay_parent(digest) + .map_or(false, is_hash_in_ancestry); + let is_root_in_ancestry_check = + cumulus_primitives_core::rpsr_digest::extract_relay_parent_storage_root(digest) + .map(|(r, _n)| r) + .map_or(false, is_root_in_ancestry); + + is_hash_in_ancestry_check || is_root_in_ancestry_check + }; + + let parent_aligned_with_pending = entry.aligned_with_pending; + let child_depth = entry.depth + 1; + let hash = entry.hash; + + tracing::trace!( + target: PARENT_SEARCH_LOG_TARGET, + ?hash, + is_potential, + is_pending, + is_included, + "Checking potential parent." + ); + + if is_potential { + potential_parents.push(entry); + } + + if !is_potential || child_depth > max_depth { + continue + } + + // push children onto search frontier. + for child in backend.blockchain().children(hash).ok().into_iter().flatten() { + tracing::trace!(target: PARENT_SEARCH_LOG_TARGET, ?child, child_depth, ?pending_distance, "Looking at child."); + + let aligned_with_pending = parent_aligned_with_pending && + (pending_distance.map_or(true, |dist| child_depth > dist) || + is_child_pending(child)); + + if ignore_alternative_branches && !aligned_with_pending { + tracing::trace!(target: PARENT_SEARCH_LOG_TARGET, ?child, "Child is not aligned with pending block."); + continue + } + + let Ok(Some(header)) = backend.blockchain().header(child) else { continue }; + + frontier.push(PotentialParent { + hash: child, + header, + depth: child_depth, + aligned_with_pending, + }); + } + } + + potential_parents +} diff --git a/cumulus/client/consensus/common/src/tests.rs b/cumulus/client/consensus/common/src/tests.rs index aca9226570723c3285b2817e6bcdca22b141968b..06f90330d4745525cb20f6c3950b7d011a71f486 100644 --- a/cumulus/client/consensus/common/src/tests.rs +++ b/cumulus/client/consensus/common/src/tests.rs @@ -20,7 +20,7 @@ use async_trait::async_trait; use codec::Encode; use cumulus_client_pov_recovery::RecoveryKind; use cumulus_primitives_core::{ - relay_chain::{self, BlockId}, + relay_chain::{BlockId, BlockNumber, CoreState}, CumulusDigestItem, InboundDownwardMessage, InboundHrmpMessage, }; use cumulus_relay_chain_interface::{ @@ -37,7 +37,9 @@ use futures_timer::Delay; use polkadot_primitives::HeadData; use sc_client_api::{Backend as _, UsageProvider}; use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy}; +use sp_blockchain::Backend as BlockchainBackend; use sp_consensus::{BlockOrigin, BlockStatus}; +use sp_version::RuntimeVersion; use std::{ collections::{BTreeMap, HashMap}, pin::Pin, @@ -45,11 +47,11 @@ use std::{ time::Duration, }; -fn relay_block_num_from_hash(hash: &PHash) -> relay_chain::BlockNumber { +fn relay_block_num_from_hash(hash: &PHash) -> BlockNumber { hash.to_low_u64_be() as u32 } -fn relay_hash_from_block_num(block_number: relay_chain::BlockNumber) -> PHash { +fn relay_hash_from_block_num(block_number: BlockNumber) -> PHash { PHash::from_low_u64_be(block_number as u64) } @@ -153,6 +155,14 @@ impl RelayChainInterface for Relaychain { unimplemented!("Not needed for test") } + async fn candidates_pending_availability( + &self, + _: PHash, + _: ParaId, + ) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + async fn session_index_for_child(&self, _: PHash) -> RelayChainResult { Ok(0) } @@ -247,6 +257,17 @@ impl RelayChainInterface for Relaychain { extrinsics_root: PHash::zero(), })) } + + async fn availability_cores( + &self, + _relay_parent: PHash, + ) -> RelayChainResult>> { + unimplemented!("Not needed for test"); + } + + async fn version(&self, _: PHash) -> RelayChainResult { + unimplemented!("Not needed for test") + } } fn sproof_with_best_parent(client: &Client) -> RelayStateSproofBuilder { @@ -300,7 +321,7 @@ fn build_block( } async fn import_block>( - importer: &mut I, + importer: &I, block: Block, origin: BlockOrigin, import_as_best: bool, @@ -547,7 +568,7 @@ fn follow_finalized_does_not_stop_on_unknown_block() { fn follow_new_best_sets_best_after_it_is_imported() { sp_tracing::try_init_simple(); - let mut client = Arc::new(TestClientBuilder::default().build()); + let client = Arc::new(TestClientBuilder::default().build()); let block = build_and_import_block(client.clone(), false); @@ -1125,6 +1146,357 @@ fn find_potential_parents_with_max_depth() { } } +#[test] +fn find_potential_parents_unknown_included() { + sp_tracing::try_init_simple(); + + const NON_INCLUDED_CHAIN_LEN: usize = 5; + + let backend = Arc::new(Backend::new_test(1000, 1)); + let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); + let relay_parent = relay_hash_from_block_num(10); + // Choose different relay parent for alternative chain to get new hashes. + let search_relay_parent = relay_hash_from_block_num(11); + + let sproof = sproof_with_best_parent(&client); + let included_but_unknown = build_block(&*client, sproof, None, None, Some(relay_parent)); + + let relay_chain = Relaychain::new(); + { + let relay_inner = &mut relay_chain.inner.lock().unwrap(); + relay_inner + .relay_chain_hash_to_header + .insert(search_relay_parent, included_but_unknown.header().clone()); + } + + // Ignore alternative branch: + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + max_depth: NON_INCLUDED_CHAIN_LEN, + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + assert_eq!(potential_parents.len(), 0); +} + +#[test] +fn find_potential_parents_unknown_pending() { + sp_tracing::try_init_simple(); + + const NON_INCLUDED_CHAIN_LEN: usize = 5; + + let backend = Arc::new(Backend::new_test(1000, 1)); + let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); + let mut para_import = + ParachainBlockImport::new_with_delayed_best_block(client.clone(), backend.clone()); + + let relay_parent = relay_hash_from_block_num(10); + // Choose different relay parent for alternative chain to get new hashes. + let search_relay_parent = relay_hash_from_block_num(11); + let included_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + None, + None, + Some(relay_parent), + ); + + let sproof = sproof_with_parent_by_hash(&client, included_block.header().hash()); + let pending_but_unknown = build_block( + &*client, + sproof, + Some(included_block.header().hash()), + None, + Some(relay_parent), + ); + + let relay_chain = Relaychain::new(); + { + let relay_inner = &mut relay_chain.inner.lock().unwrap(); + relay_inner + .relay_chain_hash_to_header + .insert(search_relay_parent, included_block.header().clone()); + relay_inner + .relay_chain_hash_to_header_pending + .insert(search_relay_parent, pending_but_unknown.header().clone()); + } + + // Ignore alternative branch: + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + max_depth: NON_INCLUDED_CHAIN_LEN, + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + assert!(potential_parents.is_empty()); +} + +#[test] +fn find_potential_parents_unknown_pending_include_alternative_branches() { + sp_tracing::try_init_simple(); + + const NON_INCLUDED_CHAIN_LEN: usize = 5; + + let backend = Arc::new(Backend::new_test(1000, 1)); + let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); + let mut para_import = + ParachainBlockImport::new_with_delayed_best_block(client.clone(), backend.clone()); + + let relay_parent = relay_hash_from_block_num(10); + + // Choose different relay parent for alternative chain to get new hashes. + let search_relay_parent = relay_hash_from_block_num(11); + + let included_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + None, + None, + Some(relay_parent), + ); + + let alt_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + Some(included_block.header().hash()), + None, + Some(search_relay_parent), + ); + + tracing::info!(hash = %alt_block.header().hash(), "Alt block."); + let sproof = sproof_with_parent_by_hash(&client, included_block.header().hash()); + let pending_but_unknown = build_block( + &*client, + sproof, + Some(included_block.header().hash()), + None, + Some(relay_parent), + ); + + let relay_chain = Relaychain::new(); + { + let relay_inner = &mut relay_chain.inner.lock().unwrap(); + relay_inner + .relay_chain_hash_to_header + .insert(search_relay_parent, included_block.header().clone()); + relay_inner + .relay_chain_hash_to_header_pending + .insert(search_relay_parent, pending_but_unknown.header().clone()); + } + + // Ignore alternative branch: + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + max_depth: NON_INCLUDED_CHAIN_LEN, + ignore_alternative_branches: false, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_parents: Vec<_> = vec![&included_block, &alt_block]; + assert_eq!(potential_parents.len(), 2); + assert_eq!(expected_parents[0].hash(), potential_parents[0].hash); + assert_eq!(expected_parents[1].hash(), potential_parents[1].hash); +} + +/// Test where there are multiple pending blocks. +#[test] +fn find_potential_parents_aligned_with_late_pending() { + sp_tracing::try_init_simple(); + + const NON_INCLUDED_CHAIN_LEN: usize = 5; + + let backend = Arc::new(Backend::new_test(1000, 1)); + let client = Arc::new(TestClientBuilder::with_backend(backend.clone()).build()); + let mut para_import = + ParachainBlockImport::new_with_delayed_best_block(client.clone(), backend.clone()); + + let relay_parent = relay_hash_from_block_num(10); + // Choose different relay parent for alternative chain to get new hashes. + let search_relay_parent = relay_hash_from_block_num(11); + let included_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + None, + None, + Some(relay_parent), + ); + + let in_between_block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + Some(included_block.header().hash()), + None, + Some(relay_parent), + ); + + let pending_block = build_and_import_block_ext( + &client, + BlockOrigin::Own, + true, + &mut para_import, + Some(in_between_block.header().hash()), + None, + Some(relay_parent), + ); + + let relay_chain = Relaychain::new(); + { + let relay_inner = &mut relay_chain.inner.lock().unwrap(); + relay_inner + .relay_chain_hash_to_header + .insert(search_relay_parent, included_block.header().clone()); + relay_inner + .relay_chain_hash_to_header_pending + .insert(search_relay_parent, in_between_block.header().clone()); + relay_inner + .relay_chain_hash_to_header_pending + .insert(search_relay_parent, pending_block.header().clone()); + } + + // Build some blocks on the pending block and on the included block. + // We end up with two sibling chains, one is aligned with the pending block, + // the other is not. + let mut aligned_blocks = Vec::new(); + let mut parent = pending_block.header().hash(); + for _ in 2..NON_INCLUDED_CHAIN_LEN { + let block = build_and_import_block_ext( + &client, + BlockOrigin::Own, + true, + &mut para_import, + Some(parent), + None, + Some(relay_parent), + ); + parent = block.header().hash(); + aligned_blocks.push(block); + } + + let mut alt_blocks = Vec::new(); + let mut parent = included_block.header().hash(); + for _ in 0..NON_INCLUDED_CHAIN_LEN { + let block = build_and_import_block_ext( + &client, + BlockOrigin::NetworkInitialSync, + true, + &mut para_import, + Some(parent), + None, + Some(search_relay_parent), + ); + parent = block.header().hash(); + alt_blocks.push(block); + } + + // Ignore alternative branch: + for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + max_depth, + ignore_alternative_branches: true, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + assert_eq!(potential_parents.len(), max_depth + 1); + let expected_parents: Vec<_> = [&included_block, &in_between_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .take(max_depth + 1) + .collect(); + + for i in 0..(max_depth + 1) { + let parent = &potential_parents[i]; + let expected = &expected_parents[i]; + + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + assert_eq!(parent.depth, i); + assert!(parent.aligned_with_pending); + } + } + + // Do not ignore: + for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { + let potential_parents = block_on(find_potential_parents( + ParentSearchParams { + relay_parent: search_relay_parent, + para_id: ParaId::from(100), + ancestry_lookback: 1, // aligned chain is in ancestry. + max_depth, + ignore_alternative_branches: false, + }, + &*backend, + &relay_chain, + )) + .unwrap(); + + let expected_len = 2 * max_depth + 1; + assert_eq!(potential_parents.len(), expected_len); + let expected_aligned: Vec<_> = [&included_block, &in_between_block, &pending_block] + .into_iter() + .chain(aligned_blocks.iter()) + .take(max_depth + 1) + .collect(); + let expected_alt = alt_blocks.iter().take(max_depth); + + let expected_parents: Vec<_> = + expected_aligned.clone().into_iter().chain(expected_alt).collect(); + // Check correctness. + assert_eq!(expected_parents.len(), expected_len); + + for i in 0..expected_len { + let parent = &potential_parents[i]; + let expected = expected_parents + .iter() + .find(|block| block.header().hash() == parent.hash) + .expect("missing parent"); + + let is_aligned = expected_aligned.contains(&expected); + + assert_eq!(parent.hash, expected.hash()); + assert_eq!(&parent.header, expected.header()); + + assert_eq!(parent.aligned_with_pending, is_aligned); + } + } +} + #[test] fn find_potential_parents_aligned_with_pending() { sp_tracing::try_init_simple(); @@ -1236,6 +1608,7 @@ fn find_potential_parents_aligned_with_pending() { // Do not ignore: for max_depth in 0..=NON_INCLUDED_CHAIN_LEN { + log::info!("Ran with max_depth = {max_depth}"); let potential_parents = block_on(find_potential_parents( ParentSearchParams { relay_parent: search_relay_parent, @@ -1263,6 +1636,7 @@ fn find_potential_parents_aligned_with_pending() { // Check correctness. assert_eq!(expected_parents.len(), expected_len); + potential_parents.iter().for_each(|p| log::info!("result: {:?}", p)); for i in 0..expected_len { let parent = &potential_parents[i]; let expected = expected_parents @@ -1275,6 +1649,12 @@ fn find_potential_parents_aligned_with_pending() { assert_eq!(parent.hash, expected.hash()); assert_eq!(&parent.header, expected.header()); + log::info!( + "Check hash: {:?} expected: {} is: {}", + parent.hash, + is_aligned, + parent.aligned_with_pending, + ); assert_eq!(parent.aligned_with_pending, is_aligned); } } diff --git a/cumulus/client/consensus/proposer/Cargo.toml b/cumulus/client/consensus/proposer/Cargo.toml index 42ca4e06f8f45e410006304cf1290e811e153b4c..bb760ae03f4df0dfae60fce06ed49e223763a8e6 100644 --- a/cumulus/client/consensus/proposer/Cargo.toml +++ b/cumulus/client/consensus/proposer/Cargo.toml @@ -10,15 +10,15 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -anyhow = "1.0" -async-trait = "0.1.79" +anyhow = { workspace = true, default-features = true } +async-trait = { workspace = true } thiserror = { workspace = true } # Substrate -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-inherents = { path = "../../../../substrate/primitives/inherents" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-state-machine = { path = "../../../../substrate/primitives/state-machine" } +sp-consensus = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-parachain-inherent = { path = "../../../primitives/parachain-inherent" } +cumulus-primitives-parachain-inherent = { workspace = true, default-features = true } diff --git a/cumulus/client/consensus/relay-chain/Cargo.toml b/cumulus/client/consensus/relay-chain/Cargo.toml index cb32b98045760de5621792c6ef45f76faf2e7e08..f3ee6fc2f7d257ff2be86c3d9a0096ea78d30be8 100644 --- a/cumulus/client/consensus/relay-chain/Cargo.toml +++ b/cumulus/client/consensus/relay-chain/Cargo.toml @@ -10,23 +10,23 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -async-trait = "0.1.79" -futures = "0.3.28" -parking_lot = "0.12.1" -tracing = "0.1.37" +async-trait = { workspace = true } +futures = { workspace = true } +parking_lot = { workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } # Substrate -sc-consensus = { path = "../../../../substrate/client/consensus/common" } -sp-api = { path = "../../../../substrate/primitives/api" } -sp-block-builder = { path = "../../../../substrate/primitives/block-builder" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-inherents = { path = "../../../../substrate/primitives/inherents" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -substrate-prometheus-endpoint = { path = "../../../../substrate/utils/prometheus" } +sc-consensus = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } # Cumulus -cumulus-client-consensus-common = { path = "../common" } -cumulus-primitives-core = { path = "../../../primitives/core" } -cumulus-relay-chain-interface = { path = "../../relay-chain-interface" } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } diff --git a/cumulus/client/consensus/relay-chain/src/import_queue.rs b/cumulus/client/consensus/relay-chain/src/import_queue.rs index f44f440932437ff0cf658f7644bbf2e23670f8cd..1d6f039da4c123fc79c1132b7b96e93a96c69411 100644 --- a/cumulus/client/consensus/relay-chain/src/import_queue.rs +++ b/cumulus/client/consensus/relay-chain/src/import_queue.rs @@ -52,7 +52,7 @@ where CIDP: CreateInherentDataProviders, { async fn verify( - &mut self, + &self, mut block_params: BlockImportParams, ) -> Result, String> { block_params.fork_choice = Some(sc_consensus::ForkChoiceStrategy::Custom( @@ -114,7 +114,7 @@ pub fn import_queue( block_import: I, create_inherent_data_providers: CIDP, spawner: &impl sp_core::traits::SpawnEssentialNamed, - registry: Option<&substrate_prometheus_endpoint::Registry>, + registry: Option<&prometheus_endpoint::Registry>, ) -> ClientResult> where I: BlockImport diff --git a/cumulus/client/network/Cargo.toml b/cumulus/client/network/Cargo.toml index 1210975ef690c4d110a7f96b2e88e4d151edfa87..bc67678eedeb199d57aad6f35f5be386231b841e 100644 --- a/cumulus/client/network/Cargo.toml +++ b/cumulus/client/network/Cargo.toml @@ -10,47 +10,51 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -futures = "0.3.28" -futures-timer = "3.0.2" -parking_lot = "0.12.1" -tracing = "0.1.37" +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } +parking_lot = { workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } +sc-client-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } # Polkadot -polkadot-node-primitives = { path = "../../../polkadot/node/primitives" } -polkadot-parachain-primitives = { path = "../../../polkadot/parachain" } -polkadot-primitives = { path = "../../../polkadot/primitives" } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } # Cumulus -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } +cumulus-relay-chain-interface = { workspace = true, default-features = true } [dev-dependencies] -portpicker = "0.1.1" -tokio = { version = "1.32.0", features = ["macros"] } -url = "2.4.0" +portpicker = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } +url = { workspace = true } +rstest = { workspace = true } # Substrate -sc-cli = { path = "../../../substrate/client/cli" } -sc-client-api = { path = "../../../substrate/client/api" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -substrate-test-utils = { path = "../../../substrate/test-utils" } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +substrate-test-utils = { workspace = true } # Polkadot -polkadot-test-client = { path = "../../../polkadot/node/test/client" } +polkadot-test-client = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-relay-chain-inprocess-interface = { path = "../relay-chain-inprocess-interface" } -cumulus-test-service = { path = "../../test/service" } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-inprocess-interface = { workspace = true, default-features = true } +cumulus-test-service = { workspace = true } diff --git a/cumulus/client/network/src/lib.rs b/cumulus/client/network/src/lib.rs index f442ed5840bddcd4a859d149635ff740e4d232f4..dab15bba590a0f46720d45bdaddc92f594fb8a9f 100644 --- a/cumulus/client/network/src/lib.rs +++ b/cumulus/client/network/src/lib.rs @@ -20,6 +20,7 @@ //! that use the relay chain provided consensus. See [`RequireSecondedInBlockAnnounce`] //! and [`WaitToAnnounce`] for more information about this implementation. +use sp_api::RuntimeApiInfo; use sp_consensus::block_validation::{ BlockAnnounceValidator as BlockAnnounceValidatorT, Validation, }; @@ -28,6 +29,7 @@ use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; use cumulus_relay_chain_interface::RelayChainInterface; use polkadot_node_primitives::{CollationSecondedSignal, Statement}; +use polkadot_node_subsystem::messages::RuntimeApiRequest; use polkadot_parachain_primitives::primitives::HeadData; use polkadot_primitives::{ CandidateReceipt, CompactStatement, Hash as PHash, Id as ParaId, OccupiedCoreAssumption, @@ -266,18 +268,41 @@ where Ok(para_head) } - /// Get the backed block hash of the given parachain in the relay chain. - async fn backed_block_hash( + /// Get the backed block hashes of the given parachain in the relay chain. + async fn backed_block_hashes( relay_chain_interface: &RCInterface, hash: PHash, para_id: ParaId, - ) -> Result, BoxedError> { - let candidate_receipt = relay_chain_interface - .candidate_pending_availability(hash, para_id) + ) -> Result, BoxedError> { + let runtime_api_version = relay_chain_interface + .version(hash) .await .map_err(|e| Box::new(BlockAnnounceError(format!("{:?}", e))) as Box<_>)?; + let parachain_host_runtime_api_version = + runtime_api_version + .api_version( + &>::ID, + ) + .unwrap_or_default(); + + // If the relay chain runtime does not support the new runtime API, fallback to the + // deprecated one. + let candidate_receipts = if parachain_host_runtime_api_version < + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + #[allow(deprecated)] + relay_chain_interface + .candidate_pending_availability(hash, para_id) + .await + .map(|c| c.into_iter().collect::>()) + } else { + relay_chain_interface.candidates_pending_availability(hash, para_id).await + } + .map_err(|e| Box::new(BlockAnnounceError(format!("{:?}", e))) as Box<_>)?; - Ok(candidate_receipt.map(|cr| cr.descriptor.para_head)) + Ok(candidate_receipts.into_iter().map(|cr| cr.descriptor.para_head)) } /// Handle a block announcement with empty data (no statement) attached to it. @@ -298,15 +323,20 @@ where let best_head = Self::included_block(&relay_chain_interface, relay_chain_best_hash, para_id).await?; let known_best_number = best_head.number(); - let backed_block = || async { - Self::backed_block_hash(&relay_chain_interface, relay_chain_best_hash, para_id).await - }; if best_head == header { tracing::debug!(target: LOG_TARGET, "Announced block matches best block.",); - Ok(Validation::Success { is_new_best: true }) - } else if Some(HeadData(header.encode()).hash()) == backed_block().await? { + return Ok(Validation::Success { is_new_best: true }) + } + + let mut backed_blocks = + Self::backed_block_hashes(&relay_chain_interface, relay_chain_best_hash, para_id) + .await?; + + let head_hash = HeadData(header.encode()).hash(); + + if backed_blocks.any(|block_hash| block_hash == head_hash) { tracing::debug!(target: LOG_TARGET, "Announced block matches latest backed block.",); Ok(Validation::Success { is_new_best: true }) diff --git a/cumulus/client/network/src/tests.rs b/cumulus/client/network/src/tests.rs index 3f5757d5eac13cd751a89e77545a937b3223c9a0..cde73c4c51806b7dcd9f01f5d9bd180a618c1dd9 100644 --- a/cumulus/client/network/src/tests.rs +++ b/cumulus/client/network/src/tests.rs @@ -26,14 +26,16 @@ use futures::{executor::block_on, poll, task::Poll, FutureExt, Stream, StreamExt use parking_lot::Mutex; use polkadot_node_primitives::{SignedFullStatement, Statement}; use polkadot_primitives::{ - CandidateCommitments, CandidateDescriptor, CollatorPair, CommittedCandidateReceipt, - Hash as PHash, HeadData, InboundDownwardMessage, InboundHrmpMessage, OccupiedCoreAssumption, - PersistedValidationData, SessionIndex, SigningContext, ValidationCodeHash, ValidatorId, + BlockNumber, CandidateCommitments, CandidateDescriptor, CollatorPair, + CommittedCandidateReceipt, CoreState, Hash as PHash, HeadData, InboundDownwardMessage, + InboundHrmpMessage, OccupiedCoreAssumption, PersistedValidationData, SessionIndex, + SigningContext, ValidationCodeHash, ValidatorId, }; use polkadot_test_client::{ Client as PClient, ClientBlockImportExt, DefaultTestClientBuilderExt, FullBackend as PBackend, InitPolkadotBlockBuilder, TestClientBuilder, TestClientBuilderExt, }; +use rstest::rstest; use sc_client_api::{Backend, BlockchainEvents}; use sp_blockchain::HeaderBackend; use sp_consensus::BlockOrigin; @@ -42,7 +44,8 @@ use sp_keyring::Sr25519Keyring; use sp_keystore::{testing::MemoryKeystore, Keystore, KeystorePtr}; use sp_runtime::RuntimeAppPublic; use sp_state_machine::StorageValue; -use std::{collections::BTreeMap, time::Duration}; +use sp_version::RuntimeVersion; +use std::{borrow::Cow, collections::BTreeMap, time::Duration}; fn check_error(error: crate::BoxedError, check_error: impl Fn(&BlockAnnounceError) -> bool) { let error = *error @@ -53,6 +56,33 @@ fn check_error(error: crate::BoxedError, check_error: impl Fn(&BlockAnnounceErro } } +fn dummy_candidate() -> CommittedCandidateReceipt { + CommittedCandidateReceipt { + descriptor: CandidateDescriptor { + para_head: polkadot_parachain_primitives::primitives::HeadData( + default_header().encode(), + ) + .hash(), + para_id: 0u32.into(), + relay_parent: PHash::random(), + collator: CollatorPair::generate().0.public(), + persisted_validation_data_hash: PHash::random(), + pov_hash: PHash::random(), + erasure_root: PHash::random(), + signature: sp_core::sr25519::Signature::default().into(), + validation_code_hash: ValidationCodeHash::from(PHash::random()), + }, + commitments: CandidateCommitments { + upward_messages: Default::default(), + horizontal_messages: Default::default(), + new_validation_code: None, + head_data: HeadData(Vec::new()), + processed_downward_messages: 0, + hrmp_watermark: 0, + }, + } +} + #[derive(Clone)] struct DummyRelayChainInterface { data: Arc>, @@ -69,6 +99,8 @@ impl DummyRelayChainInterface { data: Arc::new(Mutex::new(ApiData { validators: vec![Sr25519Keyring::Alice.public().into()], has_pending_availability: false, + runtime_version: + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT, })), relay_client: Arc::new(builder.build()), relay_backend, @@ -131,36 +163,37 @@ impl RelayChainInterface for DummyRelayChainInterface { _: PHash, _: ParaId, ) -> RelayChainResult> { + if self.data.lock().runtime_version >= + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + panic!("Should have used candidates_pending_availability instead"); + } + if self.data.lock().has_pending_availability { - Ok(Some(CommittedCandidateReceipt { - descriptor: CandidateDescriptor { - para_head: polkadot_parachain_primitives::primitives::HeadData( - default_header().encode(), - ) - .hash(), - para_id: 0u32.into(), - relay_parent: PHash::random(), - collator: CollatorPair::generate().0.public(), - persisted_validation_data_hash: PHash::random(), - pov_hash: PHash::random(), - erasure_root: PHash::random(), - signature: sp_core::sr25519::Signature::default().into(), - validation_code_hash: ValidationCodeHash::from(PHash::random()), - }, - commitments: CandidateCommitments { - upward_messages: Default::default(), - horizontal_messages: Default::default(), - new_validation_code: None, - head_data: HeadData(Vec::new()), - processed_downward_messages: 0, - hrmp_watermark: 0, - }, - })) + Ok(Some(dummy_candidate())) } else { Ok(None) } } + async fn candidates_pending_availability( + &self, + _: PHash, + _: ParaId, + ) -> RelayChainResult> { + if self.data.lock().runtime_version < + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + panic!("Should have used candidate_pending_availability instead"); + } + + if self.data.lock().has_pending_availability { + Ok(vec![dummy_candidate()]) + } else { + Ok(vec![]) + } + } + async fn session_index_for_child(&self, _: PHash) -> RelayChainResult { Ok(0) } @@ -264,6 +297,35 @@ impl RelayChainInterface for DummyRelayChainInterface { Ok(header) } + + async fn availability_cores( + &self, + _relay_parent: PHash, + ) -> RelayChainResult>> { + unimplemented!("Not needed for test"); + } + + async fn version(&self, _: PHash) -> RelayChainResult { + let version = self.data.lock().runtime_version; + + let apis = sp_version::create_apis_vec!([( + >::ID, + version + )]) + .into_owned() + .to_vec(); + + Ok(RuntimeVersion { + spec_name: sp_version::create_runtime_str!("test"), + impl_name: sp_version::create_runtime_str!("test"), + authoring_version: 1, + spec_version: 1, + impl_version: 0, + apis: Cow::Owned(apis), + transaction_version: 5, + state_version: 1, + }) + } } fn make_validator_and_api() -> ( @@ -550,7 +612,7 @@ fn relay_parent_not_imported_when_block_announce_is_processed() { block_on(async move { let (mut validator, api) = make_validator_and_api(); - let mut client = api.relay_client.clone(); + let client = api.relay_client.clone(); let block = client.init_polkadot_block_builder().build().expect("Build new block").block; let (signal, header) = make_gossip_message_and_header(api, block.hash(), 0).await; @@ -574,11 +636,14 @@ fn relay_parent_not_imported_when_block_announce_is_processed() { /// Ensures that when we receive a block announcement without a statement included, while the block /// is not yet included by the node checking the announcement, but the node is already backed. -#[test] -fn block_announced_without_statement_and_block_only_backed() { +#[rstest] +#[case(RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT)] +#[case(10)] +fn block_announced_without_statement_and_block_only_backed(#[case] runtime_version: u32) { block_on(async move { let (mut validator, api) = make_validator_and_api(); api.data.lock().has_pending_availability = true; + api.data.lock().runtime_version = runtime_version; let header = default_header(); @@ -592,4 +657,5 @@ fn block_announced_without_statement_and_block_only_backed() { struct ApiData { validators: Vec, has_pending_availability: bool, + runtime_version: u32, } diff --git a/cumulus/client/parachain-inherent/Cargo.toml b/cumulus/client/parachain-inherent/Cargo.toml index 6e9adab1ffc9e2bf9de9d8101eb38e4da8212b27..0d82cf64874322c2d9e6e2cb64ed742d35bc58e5 100644 --- a/cumulus/client/parachain-inherent/Cargo.toml +++ b/cumulus/client/parachain-inherent/Cargo.toml @@ -7,24 +7,22 @@ description = "Inherent that needs to be present in every parachain block. Conta license = "Apache-2.0" [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -scale-info = { version = "2.11.1", features = ["derive"] } -tracing = { version = "0.1.37" } +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-crypto-hashing = { path = "../../../substrate/primitives/crypto/hashing" } -sp-inherents = { path = "../../../substrate/primitives/inherents" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-std = { path = "../../../substrate/primitives/std" } -sp-storage = { path = "../../../substrate/primitives/storage" } -sp-trie = { path = "../../../substrate/primitives/trie" } +sc-client-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-storage = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-primitives-parachain-inherent = { path = "../../primitives/parachain-inherent" } -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } -cumulus-test-relay-sproof-builder = { path = "../../test/relay-sproof-builder" } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-primitives-parachain-inherent = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } diff --git a/cumulus/client/parachain-inherent/src/mock.rs b/cumulus/client/parachain-inherent/src/mock.rs index 22691006f93ed264e3e7d37b7b2120ea576e9da3..dfe4a66c3dc19665d413fed47434d803d6ed63af 100644 --- a/cumulus/client/parachain-inherent/src/mock.rs +++ b/cumulus/client/parachain-inherent/src/mock.rs @@ -28,6 +28,9 @@ use std::collections::BTreeMap; use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder; +/// Relay chain slot duration, in milliseconds. +pub const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000; + /// Inherent data provider that supplies mocked validation data. /// /// This is useful when running a node that is not actually backed by any relay chain. @@ -43,10 +46,14 @@ use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder; /// your parachain's configuration in order to mock the MQC heads properly. /// See [`MockXcmConfig`] for more information pub struct MockValidationDataInherentDataProvider { - /// The current block number of the local block chain (the parachain) + /// The current block number of the local block chain (the parachain). pub current_para_block: u32, + /// The parachain ID of the parachain for that the inherent data is created. + pub para_id: ParaId, + /// The current block head data of the local block chain (the parachain). + pub current_para_block_head: Option, /// The relay block in which this parachain appeared to start. This will be the relay block - /// number in para block #P1 + /// number in para block #P1. pub relay_offset: u32, /// The number of relay blocks that elapses between each parablock. Probably set this to 1 or 2 /// to simulate optimistic or realistic relay chain behavior. @@ -54,19 +61,21 @@ pub struct MockValidationDataInherentDataProvider { /// Number of parachain blocks per relay chain epoch /// Mock epoch is computed by dividing `current_para_block` by this value. pub para_blocks_per_relay_epoch: u32, - /// Function to mock BABE one epoch ago randomness + /// Function to mock BABE one epoch ago randomness. pub relay_randomness_config: R, /// XCM messages and associated configuration information. pub xcm_config: MockXcmConfig, /// Inbound downward XCM messages to be injected into the block. pub raw_downward_messages: Vec>, - // Inbound Horizontal messages sorted by channel + // Inbound Horizontal messages sorted by channel. pub raw_horizontal_messages: Vec<(ParaId, Vec)>, // Additional key-value pairs that should be injected. pub additional_key_values: Option, Vec)>>, } +/// Something that can generate randomness. pub trait GenerateRandomness { + /// Generate the randomness using the given `input`. fn generate_randomness(&self, input: I) -> relay_chain::Hash; } @@ -86,8 +95,6 @@ impl GenerateRandomness for () { /// parachain's storage, and the corresponding relay data mocked. #[derive(Default)] pub struct MockXcmConfig { - /// The parachain id of the parachain being mocked. - pub para_id: ParaId, /// The starting state of the dmq_mqc_head. pub starting_dmq_mqc_head: relay_chain::Hash, /// The starting state of each parachain's mqc head @@ -114,7 +121,6 @@ impl MockXcmConfig { pub fn new, C: StorageProvider>( client: &C, parent_block: B::Hash, - para_id: ParaId, parachain_system_name: ParachainSystemName, ) -> Self { let starting_dmq_mqc_head = client @@ -147,7 +153,7 @@ impl MockXcmConfig { }) .unwrap_or_default(); - Self { para_id, starting_dmq_mqc_head, starting_hrmp_mqc_heads } + Self { starting_dmq_mqc_head, starting_hrmp_mqc_heads } } } @@ -159,13 +165,15 @@ impl> InherentDataProvider &self, inherent_data: &mut InherentData, ) -> Result<(), sp_inherents::Error> { + // Use the "sproof" (spoof proof) builder to build valid mock state root and proof. + let mut sproof_builder = + RelayStateSproofBuilder { para_id: self.para_id, ..Default::default() }; + // Calculate the mocked relay block based on the current para block let relay_parent_number = self.relay_offset + self.relay_blocks_per_para_block * self.current_para_block; - - // Use the "sproof" (spoof proof) builder to build valid mock state root and proof. - let mut sproof_builder = - RelayStateSproofBuilder { para_id: self.xcm_config.para_id, ..Default::default() }; + sproof_builder.current_slot = + ((relay_parent_number / RELAY_CHAIN_SLOT_DURATION_MILLIS) as u64).into(); // Process the downward messages and set up the correct head let mut downward_messages = Vec::new(); @@ -217,6 +225,9 @@ impl> InherentDataProvider sproof_builder.additional_key_values = key_values.clone() } + // Inject current para block head, if any + sproof_builder.included_para_head = self.current_para_block_head.clone(); + let (relay_parent_storage_root, proof) = sproof_builder.into_state_root_and_proof(); inherent_data.put_data( diff --git a/cumulus/client/pov-recovery/Cargo.toml b/cumulus/client/pov-recovery/Cargo.toml index 571935620d6d90b3aa1157124a2bae6fd73a19c2..3127dd26fcaa67d137ddbc867f30a76ff3faeedb 100644 --- a/cumulus/client/pov-recovery/Cargo.toml +++ b/cumulus/client/pov-recovery/Cargo.toml @@ -2,7 +2,7 @@ name = "cumulus-client-pov-recovery" version = "0.7.0" authors.workspace = true -description = "Cumulus-specific networking protocol" +description = "Parachain PoV recovery" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" @@ -10,38 +10,46 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"] } -futures = "0.3.28" -futures-timer = "3.0.2" -rand = "0.8.5" -tracing = "0.1.37" +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } +rand = { workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sc-consensus = { path = "../../../substrate/client/consensus/common" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } # Polkadot -polkadot-node-primitives = { path = "../../../polkadot/node/primitives" } -polkadot-node-subsystem = { path = "../../../polkadot/node/subsystem" } -polkadot-overseer = { path = "../../../polkadot/node/overseer" } -polkadot-primitives = { path = "../../../polkadot/primitives" } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } -async-trait = "0.1.79" +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +async-trait = { workspace = true } [dev-dependencies] -tokio = { version = "1.32.0", features = ["macros"] } -portpicker = "0.1.1" +rstest = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } +portpicker = { workspace = true } +sp-blockchain = { workspace = true, default-features = true } +cumulus-test-client = { workspace = true } +sc-utils = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +assert_matches = { workspace = true } # Cumulus -cumulus-test-service = { path = "../../test/service" } +cumulus-test-service = { workspace = true } # Substrate -sc-cli = { path = "../../../substrate/client/cli" } -sc-client-api = { path = "../../../substrate/client/api" } -substrate-test-utils = { path = "../../../substrate/test-utils" } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +substrate-test-utils = { workspace = true } diff --git a/cumulus/client/pov-recovery/src/active_candidate_recovery.rs b/cumulus/client/pov-recovery/src/active_candidate_recovery.rs index 2c635320ff4ae6f68f33bb9da5ca545098851f65..50de98909ea471ea3de39a9edd85f4f9d71a8b3b 100644 --- a/cumulus/client/pov-recovery/src/active_candidate_recovery.rs +++ b/cumulus/client/pov-recovery/src/active_candidate_recovery.rs @@ -21,7 +21,7 @@ use polkadot_node_subsystem::messages::AvailabilityRecoveryMessage; use futures::{channel::oneshot, stream::FuturesUnordered, Future, FutureExt, StreamExt}; -use std::{collections::HashSet, pin::Pin, sync::Arc}; +use std::{pin::Pin, sync::Arc}; use crate::RecoveryHandle; @@ -32,14 +32,12 @@ pub(crate) struct ActiveCandidateRecovery { /// The recoveries that are currently being executed. recoveries: FuturesUnordered>)> + Send>>>, - /// The block hashes of the candidates currently being recovered. - candidates: HashSet, recovery_handle: Box, } impl ActiveCandidateRecovery { pub fn new(recovery_handle: Box) -> Self { - Self { recoveries: Default::default(), candidates: Default::default(), recovery_handle } + Self { recoveries: Default::default(), recovery_handle } } /// Recover the given `candidate`. @@ -56,14 +54,13 @@ impl ActiveCandidateRecovery { candidate.receipt.clone(), candidate.session_index, None, + None, tx, ), "ActiveCandidateRecovery", ) .await; - self.candidates.insert(block_hash); - self.recoveries.push( async move { match rx.await { @@ -96,7 +93,6 @@ impl ActiveCandidateRecovery { pub async fn wait_for_recovery(&mut self) -> (Block::Hash, Option>) { loop { if let Some(res) = self.recoveries.next().await { - self.candidates.remove(&res.0); return res } else { futures::pending!() diff --git a/cumulus/client/pov-recovery/src/lib.rs b/cumulus/client/pov-recovery/src/lib.rs index 0ca21749c3eb557a78f0996c703e86b35cab6f17..6ace18155e871d40baa2662c8c13b605b5768bbe 100644 --- a/cumulus/client/pov-recovery/src/lib.rs +++ b/cumulus/client/pov-recovery/src/lib.rs @@ -48,11 +48,12 @@ use sc_client_api::{BlockBackend, BlockchainEvents, UsageProvider}; use sc_consensus::import_queue::{ImportQueueService, IncomingBlock}; +use sp_api::RuntimeApiInfo; use sp_consensus::{BlockOrigin, BlockStatus, SyncOracle}; use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor}; use polkadot_node_primitives::{PoV, POV_BOMB_LIMIT}; -use polkadot_node_subsystem::messages::AvailabilityRecoveryMessage; +use polkadot_node_subsystem::messages::{AvailabilityRecoveryMessage, RuntimeApiRequest}; use polkadot_overseer::Handle as OverseerHandle; use polkadot_primitives::{ CandidateReceipt, CommittedCandidateReceipt, Id as ParaId, SessionIndex, @@ -75,6 +76,9 @@ use std::{ time::Duration, }; +#[cfg(test)] +mod tests; + mod active_candidate_recovery; use active_candidate_recovery::ActiveCandidateRecovery; @@ -544,7 +548,7 @@ where ) .await { - Ok(pending_candidate_stream) => pending_candidate_stream.fuse(), + Ok(pending_candidates_stream) => pending_candidates_stream.fuse(), Err(err) => { tracing::error!(target: LOG_TARGET, error = ?err, "Unable to retrieve pending candidate stream."); return @@ -554,9 +558,11 @@ where futures::pin_mut!(pending_candidates); loop { select! { - pending_candidate = pending_candidates.next() => { - if let Some((receipt, session_index)) = pending_candidate { - self.handle_pending_candidate(receipt, session_index); + next_pending_candidates = pending_candidates.next() => { + if let Some((candidates, session_index)) = next_pending_candidates { + for candidate in candidates { + self.handle_pending_candidate(candidate, session_index); + } } else { tracing::debug!(target: LOG_TARGET, "Pending candidates stream ended"); return; @@ -615,7 +621,7 @@ async fn pending_candidates( relay_chain_client: impl RelayChainInterface + Clone, para_id: ParaId, sync_service: Arc, -) -> RelayChainResult> { +) -> RelayChainResult, SessionIndex)>> { let import_notification_stream = relay_chain_client.import_notification_stream().await?; let filtered_stream = import_notification_stream.filter_map(move |n| { @@ -632,16 +638,54 @@ async fn pending_candidates( return None } - let pending_availability_result = client_for_closure - .candidate_pending_availability(hash, para_id) + let runtime_api_version = client_for_closure + .version(hash) .await .map_err(|e| { tracing::error!( target: LOG_TARGET, error = ?e, - "Failed to fetch pending candidates.", + "Failed to fetch relay chain runtime version.", ) - }); + }) + .ok()?; + let parachain_host_runtime_api_version = runtime_api_version + .api_version( + &>::ID, + ) + .unwrap_or_default(); + + // If the relay chain runtime does not support the new runtime API, fallback to the + // deprecated one. + let pending_availability_result = if parachain_host_runtime_api_version < + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + #[allow(deprecated)] + client_for_closure + .candidate_pending_availability(hash, para_id) + .await + .map_err(|e| { + tracing::error!( + target: LOG_TARGET, + error = ?e, + "Failed to fetch pending candidates.", + ) + }) + .map(|candidate| candidate.into_iter().collect::>()) + } else { + client_for_closure.candidates_pending_availability(hash, para_id).await.map_err( + |e| { + tracing::error!( + target: LOG_TARGET, + error = ?e, + "Failed to fetch pending candidates.", + ) + }, + ) + }; + let session_index_result = client_for_closure.session_index_for_child(hash).await.map_err(|e| { tracing::error!( @@ -651,8 +695,8 @@ async fn pending_candidates( ) }); - if let Ok(Some(candidate)) = pending_availability_result { - session_index_result.map(|session_index| (candidate, session_index)).ok() + if let Ok(candidates) = pending_availability_result { + session_index_result.map(|session_index| (candidates, session_index)).ok() } else { None } diff --git a/cumulus/client/pov-recovery/src/tests.rs b/cumulus/client/pov-recovery/src/tests.rs new file mode 100644 index 0000000000000000000000000000000000000000..6f274ed18b6bc7871607cae6c5183d6d861e5117 --- /dev/null +++ b/cumulus/client/pov-recovery/src/tests.rs @@ -0,0 +1,1413 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use super::*; +use assert_matches::assert_matches; +use codec::{Decode, Encode}; +use cumulus_primitives_core::relay_chain::{ + BlockId, CandidateCommitments, CandidateDescriptor, CoreState, +}; +use cumulus_relay_chain_interface::{ + InboundDownwardMessage, InboundHrmpMessage, OccupiedCoreAssumption, PHash, PHeader, + PersistedValidationData, StorageValue, ValidationCodeHash, ValidatorId, +}; +use cumulus_test_client::{ + runtime::{Block, Header}, + Sr25519Keyring, +}; +use futures::{channel::mpsc, SinkExt}; +use polkadot_node_primitives::AvailableData; +use polkadot_node_subsystem::{messages::AvailabilityRecoveryMessage, RecoveryError, TimeoutExt}; +use rstest::rstest; +use sc_client_api::{ + BlockImportNotification, ClientInfo, CompactProof, FinalityNotification, FinalityNotifications, + FinalizeSummary, ImportNotifications, StorageEventStream, StorageKey, +}; +use sc_consensus::import_queue::RuntimeOrigin; +use sc_utils::mpsc::{TracingUnboundedReceiver, TracingUnboundedSender}; +use sp_blockchain::Info; +use sp_runtime::{generic::SignedBlock, Justifications}; +use sp_version::RuntimeVersion; +use std::{ + borrow::Cow, + collections::BTreeMap, + ops::Range, + sync::{Arc, Mutex}, +}; +use tokio::task; + +const GENESIS_HASH: PHash = PHash::zero(); +const TEST_SESSION_INDEX: SessionIndex = 0; + +struct AvailabilityRecoverySubsystemHandle { + tx: mpsc::Sender, +} + +impl AvailabilityRecoverySubsystemHandle { + fn new() -> (Self, mpsc::Receiver) { + let (tx, rx) = mpsc::channel(10); + + (Self { tx }, rx) + } +} + +#[async_trait::async_trait] +impl RecoveryHandle for AvailabilityRecoverySubsystemHandle { + async fn send_recovery_msg( + &mut self, + message: AvailabilityRecoveryMessage, + _origin: &'static str, + ) { + self.tx.send(message).await.expect("Receiver dropped"); + } +} + +struct ParachainClientInner { + import_notifications_rx: Option>>, + finality_notifications_rx: Option>>, + usage_infos: Vec>, + block_statuses: Arc>>, +} + +impl ParachainClientInner { + fn new( + usage_infos: Vec>, + block_statuses: Arc>>, + ) -> ( + Self, + TracingUnboundedSender>, + TracingUnboundedSender>, + ) { + let (import_notifications_tx, import_notifications_rx) = + sc_utils::mpsc::tracing_unbounded("import_notif", 10); + let (finality_notifications_tx, finality_notifications_rx) = + sc_utils::mpsc::tracing_unbounded("finality_notif", 10); + ( + Self { + import_notifications_rx: Some(import_notifications_rx), + finality_notifications_rx: Some(finality_notifications_rx), + usage_infos, + block_statuses, + }, + import_notifications_tx, + finality_notifications_tx, + ) + } +} +struct ParachainClient { + inner: Arc>>, +} + +impl ParachainClient { + fn new( + usage_infos: Vec>, + block_statuses: Arc>>, + ) -> ( + Self, + TracingUnboundedSender>, + TracingUnboundedSender>, + ) { + let (inner, import_notifications_tx, finality_notifications_tx) = + ParachainClientInner::new(usage_infos, block_statuses); + ( + Self { inner: Arc::new(Mutex::new(inner)) }, + import_notifications_tx, + finality_notifications_tx, + ) + } +} + +impl BlockchainEvents for ParachainClient { + fn import_notification_stream(&self) -> ImportNotifications { + self.inner + .lock() + .expect("poisoned lock") + .import_notifications_rx + .take() + .expect("Should only be taken once") + } + + fn every_import_notification_stream(&self) -> ImportNotifications { + unimplemented!() + } + + fn finality_notification_stream(&self) -> FinalityNotifications { + self.inner + .lock() + .expect("poisoned lock") + .finality_notifications_rx + .take() + .expect("Should only be taken once") + } + + fn storage_changes_notification_stream( + &self, + _filter_keys: Option<&[StorageKey]>, + _child_filter_keys: Option<&[(StorageKey, Option>)]>, + ) -> sp_blockchain::Result> { + unimplemented!() + } +} + +impl BlockBackend for ParachainClient { + fn block_body( + &self, + _: Block::Hash, + ) -> sp_blockchain::Result::Extrinsic>>> { + unimplemented!() + } + + fn block(&self, _: Block::Hash) -> sp_blockchain::Result>> { + unimplemented!() + } + + fn block_status(&self, hash: Block::Hash) -> sp_blockchain::Result { + Ok(self + .inner + .lock() + .expect("Poisoned lock") + .block_statuses + .lock() + .expect("Poisoned lock") + .get(&hash) + .cloned() + .unwrap_or(BlockStatus::Unknown)) + } + + fn justifications(&self, _: Block::Hash) -> sp_blockchain::Result> { + unimplemented!() + } + + fn block_hash(&self, _: NumberFor) -> sp_blockchain::Result> { + unimplemented!() + } + + fn indexed_transaction(&self, _: Block::Hash) -> sp_blockchain::Result>> { + unimplemented!() + } + + fn has_indexed_transaction(&self, _: Block::Hash) -> sp_blockchain::Result { + unimplemented!() + } + + fn block_indexed_body(&self, _: Block::Hash) -> sp_blockchain::Result>>> { + unimplemented!() + } + + fn requires_full_sync(&self) -> bool { + unimplemented!() + } +} + +impl UsageProvider for ParachainClient { + fn usage_info(&self) -> ClientInfo { + let infos = &mut self.inner.lock().expect("Poisoned lock").usage_infos; + assert!(!infos.is_empty()); + + if infos.len() == 1 { + infos.last().unwrap().clone() + } else { + infos.remove(0) + } + } +} + +struct ParachainImportQueue { + import_requests_tx: TracingUnboundedSender>>, +} + +impl ParachainImportQueue { + fn new() -> (Self, TracingUnboundedReceiver>>) { + let (import_requests_tx, import_requests_rx) = + sc_utils::mpsc::tracing_unbounded("test_import_req_forwarding", 10); + (Self { import_requests_tx }, import_requests_rx) + } +} + +impl ImportQueueService for ParachainImportQueue { + fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec>) { + assert_matches!(origin, BlockOrigin::ConsensusBroadcast); + self.import_requests_tx.unbounded_send(blocks).unwrap(); + } + + fn import_justifications( + &mut self, + _: RuntimeOrigin, + _: Block::Hash, + _: NumberFor, + _: Justifications, + ) { + unimplemented!() + } +} + +#[derive(Default)] +struct DummySyncOracle { + is_major_syncing: bool, +} + +impl DummySyncOracle { + fn new(is_major_syncing: bool) -> Self { + Self { is_major_syncing } + } +} + +impl SyncOracle for DummySyncOracle { + fn is_major_syncing(&self) -> bool { + self.is_major_syncing + } + + fn is_offline(&self) -> bool { + false + } +} + +#[derive(Clone)] +struct RelaychainInner { + runtime_version: u32, + import_notifications: Vec, + candidates_pending_availability: HashMap>, +} + +#[derive(Clone)] +struct Relaychain { + inner: Arc>, +} + +impl Relaychain { + fn new(relay_chain_blocks: Vec<(PHeader, Vec)>) -> Self { + let (candidates_pending_availability, import_notifications) = relay_chain_blocks + .into_iter() + .map(|(header, receipt)| ((header.hash(), receipt), header)) + .unzip(); + Self { + inner: Arc::new(Mutex::new(RelaychainInner { + import_notifications, + candidates_pending_availability, + // The version that introduced candidates_pending_availability + runtime_version: + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT, + })), + } + } + + fn set_runtime_version(&self, version: u32) { + self.inner.lock().expect("Poisoned lock").runtime_version = version; + } +} + +#[async_trait::async_trait] +impl RelayChainInterface for Relaychain { + async fn version(&self, _: PHash) -> RelayChainResult { + let version = self.inner.lock().expect("Poisoned lock").runtime_version; + + let apis = sp_version::create_apis_vec!([( + >::ID, + version + )]) + .into_owned() + .to_vec(); + + Ok(RuntimeVersion { + spec_name: sp_version::create_runtime_str!("test"), + impl_name: sp_version::create_runtime_str!("test"), + authoring_version: 1, + spec_version: 1, + impl_version: 0, + apis: Cow::Owned(apis), + transaction_version: 5, + state_version: 1, + }) + } + + async fn validators(&self, _: PHash) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + + async fn best_block_hash(&self) -> RelayChainResult { + unimplemented!("Not needed for test") + } + + async fn finalized_block_hash(&self) -> RelayChainResult { + unimplemented!("Not needed for test") + } + + async fn retrieve_dmq_contents( + &self, + _: ParaId, + _: PHash, + ) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + + async fn retrieve_all_inbound_hrmp_channel_contents( + &self, + _: ParaId, + _: PHash, + ) -> RelayChainResult>> { + unimplemented!("Not needed for test") + } + + async fn persisted_validation_data( + &self, + _: PHash, + _: ParaId, + _: OccupiedCoreAssumption, + ) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + + async fn validation_code_hash( + &self, + _: PHash, + _: ParaId, + _: OccupiedCoreAssumption, + ) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + + async fn candidate_pending_availability( + &self, + hash: PHash, + _: ParaId, + ) -> RelayChainResult> { + if self.inner.lock().expect("Poisoned lock").runtime_version >= + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + panic!("Should have used candidates_pending_availability instead"); + } + + Ok(self + .inner + .lock() + .expect("Poisoned lock") + .candidates_pending_availability + .remove(&hash) + .map(|mut c| { + assert_eq!(c.len(), 1); + c.pop().unwrap() + })) + } + + async fn candidates_pending_availability( + &self, + hash: PHash, + _: ParaId, + ) -> RelayChainResult> { + if self.inner.lock().expect("Poisoned lock").runtime_version < + RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT + { + panic!("Should have used candidate_pending_availability instead"); + } + + Ok(self + .inner + .lock() + .expect("Poisoned lock") + .candidates_pending_availability + .remove(&hash) + .expect("Not found")) + } + + async fn session_index_for_child(&self, _: PHash) -> RelayChainResult { + Ok(TEST_SESSION_INDEX) + } + + async fn import_notification_stream( + &self, + ) -> RelayChainResult + Send>>> { + Ok(Box::pin( + futures::stream::iter(std::mem::take( + &mut self.inner.lock().expect("Poisoned lock").import_notifications, + )) + .chain(futures::stream::pending()), + )) + } + + async fn finality_notification_stream( + &self, + ) -> RelayChainResult + Send>>> { + unimplemented!("Not needed for test") + } + + async fn is_major_syncing(&self) -> RelayChainResult { + unimplemented!("Not needed for test"); + } + + fn overseer_handle(&self) -> RelayChainResult { + unimplemented!("Not needed for test") + } + + async fn get_storage_by_key( + &self, + _: PHash, + _: &[u8], + ) -> RelayChainResult> { + unimplemented!("Not needed for test") + } + + async fn prove_read( + &self, + _: PHash, + _: &Vec>, + ) -> RelayChainResult { + unimplemented!("Not needed for test") + } + + async fn wait_for_block(&self, _: PHash) -> RelayChainResult<()> { + unimplemented!("Not needed for test"); + } + + async fn new_best_notification_stream( + &self, + ) -> RelayChainResult + Send>>> { + unimplemented!("Not needed for test"); + } + + async fn header(&self, _: BlockId) -> RelayChainResult> { + unimplemented!("Not needed for test"); + } + + async fn availability_cores( + &self, + _: PHash, + ) -> RelayChainResult>>> { + unimplemented!("Not needed for test"); + } +} + +fn make_candidate_chain(candidate_number_range: Range) -> Vec { + let collator = Sr25519Keyring::Ferdie; + let mut latest_parent_hash = GENESIS_HASH; + let mut candidates = vec![]; + + for number in candidate_number_range { + let head_data = Header { + number, + digest: Default::default(), + extrinsics_root: Default::default(), + parent_hash: latest_parent_hash, + state_root: Default::default(), + }; + + latest_parent_hash = head_data.hash(); + + candidates.push(CommittedCandidateReceipt { + descriptor: CandidateDescriptor { + para_id: ParaId::from(1000), + relay_parent: PHash::zero(), + collator: collator.public().into(), + persisted_validation_data_hash: PHash::zero(), + pov_hash: PHash::zero(), + erasure_root: PHash::zero(), + signature: collator.sign(&[0u8; 132]).into(), + para_head: PHash::zero(), + validation_code_hash: PHash::zero().into(), + }, + commitments: CandidateCommitments { + head_data: head_data.encode().into(), + upward_messages: vec![].try_into().expect("empty vec fits within bounds"), + new_validation_code: None, + horizontal_messages: vec![].try_into().expect("empty vec fits within bounds"), + processed_downward_messages: 0, + hrmp_watermark: 0_u32, + }, + }); + } + + candidates +} + +fn dummy_usage_info(finalized_number: u32) -> ClientInfo { + ClientInfo { + chain: Info { + best_hash: PHash::zero(), + best_number: 0, + genesis_hash: PHash::zero(), + finalized_hash: PHash::zero(), + // Only this field is being used. + finalized_number, + finalized_state: None, + number_leaves: 0, + block_gap: None, + }, + usage: None, + } +} + +fn dummy_pvd() -> PersistedValidationData { + PersistedValidationData { + parent_head: vec![].into(), + relay_parent_number: 1, + relay_parent_storage_root: PHash::zero(), + max_pov_size: 100, + } +} + +#[tokio::test] +async fn pending_candidate_height_lower_than_latest_finalized() { + sp_tracing::init_for_tests(); + + for finalized_number in [3, 4, 5] { + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..4); + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(finalized_number)], Default::default()); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + // If the latest finalized block has a larger height compared to the pending candidate, the + // new candidate won't be recovered. Candidates have heights is 1, 2 and 3. Latest finalized + // block is 3, 4 or 5. + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + // No recovery message received + assert_matches!( + recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, + None + ); + + // No import request received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); + } +} + +#[rstest] +#[case(RuntimeApiRequest::CANDIDATES_PENDING_AVAILABILITY_RUNTIME_REQUIREMENT)] +#[case(10)] +#[tokio::test] +async fn single_pending_candidate_recovery_success(#[case] runtime_version: u32) { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap(); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + relay_chain_client.set_runtime_version(runtime_version); + + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Ok( + AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof {encoded_nodes: vec![]} + ).encode().into() + }), + validation_data: dummy_pvd(), + } + ) + ).unwrap() + } + ); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // Received import request for the recovered candidate + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + assert_eq!(incoming_blocks.len(), 1); + assert_eq!(incoming_blocks[0].header, Some(header)); + }); + + // No import request received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn single_pending_candidate_recovery_retry_succeeds() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap(); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + // First recovery fails. + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Err(RecoveryError::Unavailable) + ).unwrap() + } + ); + // Candidate is not imported. + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); + + // Recovery is retried and it succeeds now. + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Ok( + AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof {encoded_nodes: vec![]} + ).encode().into() + }), + validation_data: dummy_pvd(), + } + ) + ).unwrap() + } + ); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // Received import request for the recovered candidate + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + assert_eq!(incoming_blocks.len(), 1); + assert_eq!(incoming_blocks[0].header, Some(header)); + }); + + // No import request received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn single_pending_candidate_recovery_retry_fails() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + // First recovery fails. + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Err(RecoveryError::Unavailable) + ).unwrap() + } + ); + // Candidate is not imported. + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); + + // Second retry fails. + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Err(RecoveryError::Unavailable) + ).unwrap() + } + ); + // Candidate is not imported. + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); + + // After the second attempt, give up. + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn single_pending_candidate_recovery_irrecoverable_error() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + // Recovery succeeds but the block data is wrong. Will not be retried. + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx.send( + Ok( + AvailableData { + pov: Arc::new(PoV { + // Empty block data. It will fail to decode. + block_data: vec![].into() + }), + validation_data: dummy_pvd(), + } + ) + ).unwrap() + } + ); + // Candidate is not imported. + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn pending_candidates_recovery_skipped_while_syncing() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..4); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::new(true)), + ); + + task::spawn(pov_recovery.run()); + + // No recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // No candidate is imported. + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn candidate_is_imported_while_awaiting_recovery() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap(); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + let recovery_response_tx; + + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + recovery_response_tx = response_tx; + } + ); + + // While candidate is pending recovery, import the candidate from external source. + let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10); + import_notifications_tx + .unbounded_send(BlockImportNotification::new( + header.hash(), + BlockOrigin::ConsensusBroadcast, + header.clone(), + false, + None, + unpin_sender, + )) + .unwrap(); + + recovery_response_tx + .send(Ok(AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof { encoded_nodes: vec![] }, + ) + .encode() + .into(), + }), + validation_data: dummy_pvd(), + })) + .unwrap(); + + // Received import request for the recovered candidate. This could be optimised to not trigger a + // reimport. + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + assert_eq!(incoming_blocks.len(), 1); + assert_eq!(incoming_blocks[0].header, Some(header)); + }); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // No more import requests received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn candidate_is_finalized_while_awaiting_recovery() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(10) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..2); + let header = Header::decode(&mut &candidates[0].commitments.head_data.0[..]).unwrap(); + let candidate_hash = candidates[0].hash(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let (parachain_client, _import_notifications_tx, finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], Arc::new(Mutex::new(known_blocks))); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + let recovery_response_tx; + + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + // save it for later. + recovery_response_tx = response_tx; + } + ); + + // While candidate is pending recovery, it gets finalized. + let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10); + finality_notifications_tx + .unbounded_send(FinalityNotification::from_summary( + FinalizeSummary { header: header.clone(), finalized: vec![], stale_heads: vec![] }, + unpin_sender, + )) + .unwrap(); + + recovery_response_tx + .send(Ok(AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof { encoded_nodes: vec![] }, + ) + .encode() + .into(), + }), + validation_data: dummy_pvd(), + })) + .unwrap(); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // candidate is imported + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + assert_eq!(incoming_blocks.len(), 1); + assert_eq!(incoming_blocks[0].header, Some(header)); + }); + + // No more import requests received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn chained_recovery_success() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(0) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..4); + let headers = candidates + .iter() + .map(|candidate| Header::decode(&mut &candidate.commitments.head_data.0[..]).unwrap()) + .collect::>(); + let candidate_hashes = candidates.iter().map(|candidate| candidate.hash()).collect::>(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + // 3 pending candidates + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let known_blocks = Arc::new(Mutex::new(known_blocks)); + let (parachain_client, import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], known_blocks.clone()); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + // Candidates are recovered in the right order. + for (candidate_hash, header) in candidate_hashes.into_iter().zip(headers.into_iter()) { + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + response_tx + .send(Ok(AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof { encoded_nodes: vec![] }, + ) + .encode() + .into(), + }), + validation_data: dummy_pvd(), + })) + .unwrap(); + } + ); + + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + assert_eq!(incoming_blocks.len(), 1); + assert_eq!(incoming_blocks[0].header, Some(header.clone())); + }); + + known_blocks + .lock() + .expect("Poisoned lock") + .insert(header.hash(), BlockStatus::InChainWithState); + + let (unpin_sender, _unpin_receiver) = sc_utils::mpsc::tracing_unbounded("test_unpin", 10); + import_notifications_tx + .unbounded_send(BlockImportNotification::new( + header.hash(), + BlockOrigin::ConsensusBroadcast, + header, + false, + None, + unpin_sender, + )) + .unwrap(); + } + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // No more import requests received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} + +#[tokio::test] +async fn chained_recovery_child_succeeds_before_parent() { + sp_tracing::init_for_tests(); + + let (recovery_subsystem_tx, mut recovery_subsystem_rx) = + AvailabilityRecoverySubsystemHandle::new(); + let recovery_delay_range = + RecoveryDelayRange { min: Duration::from_millis(0), max: Duration::from_millis(0) }; + let (_explicit_recovery_chan_tx, explicit_recovery_chan_rx) = mpsc::channel(10); + let candidates = make_candidate_chain(1..3); + let headers = candidates + .iter() + .map(|candidate| Header::decode(&mut &candidate.commitments.head_data.0[..]).unwrap()) + .collect::>(); + let candidate_hashes = candidates.iter().map(|candidate| candidate.hash()).collect::>(); + + let relay_chain_client = Relaychain::new(vec![( + PHeader { + parent_hash: PHash::from_low_u64_be(0), + number: 1, + state_root: PHash::random(), + extrinsics_root: PHash::random(), + digest: Default::default(), + }, + // 2 pending candidates + candidates, + )]); + let mut known_blocks = HashMap::new(); + known_blocks.insert(GENESIS_HASH, BlockStatus::InChainWithState); + let known_blocks = Arc::new(Mutex::new(known_blocks)); + let (parachain_client, _import_notifications_tx, _finality_notifications_tx) = + ParachainClient::new(vec![dummy_usage_info(0)], known_blocks.clone()); + let (parachain_import_queue, mut import_requests_rx) = ParachainImportQueue::new(); + + let pov_recovery = PoVRecovery::::new( + Box::new(recovery_subsystem_tx), + recovery_delay_range, + Arc::new(parachain_client), + Box::new(parachain_import_queue), + relay_chain_client, + ParaId::new(1000), + explicit_recovery_chan_rx, + Arc::new(DummySyncOracle::default()), + ); + + task::spawn(pov_recovery.run()); + + let mut recovery_responses_senders = vec![]; + + for candidate_hash in candidate_hashes.iter() { + assert_matches!( + recovery_subsystem_rx.next().await, + Some(AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + None, + None, + response_tx + )) => { + assert_eq!(receipt.hash(), *candidate_hash); + assert_eq!(session_index, TEST_SESSION_INDEX); + recovery_responses_senders.push(response_tx); + } + ); + } + + // Send out the responses in reverse order. + for (recovery_response_sender, header) in + recovery_responses_senders.into_iter().zip(headers.iter()).rev() + { + recovery_response_sender + .send(Ok(AvailableData { + pov: Arc::new(PoV { + block_data: ParachainBlockData::::new( + header.clone(), + vec![], + CompactProof { encoded_nodes: vec![] }, + ) + .encode() + .into(), + }), + validation_data: dummy_pvd(), + })) + .unwrap(); + } + + assert_matches!(import_requests_rx.next().await, Some(incoming_blocks) => { + // The two import requests will be batched. + assert_eq!(incoming_blocks.len(), 2); + assert_eq!(incoming_blocks[0].header, Some(headers[0].clone())); + assert_eq!(incoming_blocks[1].header, Some(headers[1].clone())); + }); + + // No more recovery messages received. + assert_matches!(recovery_subsystem_rx.next().timeout(Duration::from_millis(100)).await, None); + + // No more import requests received + assert_matches!(import_requests_rx.next().timeout(Duration::from_millis(100)).await, None); +} diff --git a/cumulus/client/relay-chain-inprocess-interface/Cargo.toml b/cumulus/client/relay-chain-inprocess-interface/Cargo.toml index 7629b6c631a3a0195760eee7fd39e754c289dd3e..6f1b74191be79a3c90100a18df1b20b850e0f4b2 100644 --- a/cumulus/client/relay-chain-inprocess-interface/Cargo.toml +++ b/cumulus/client/relay-chain-inprocess-interface/Cargo.toml @@ -10,39 +10,39 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -async-trait = "0.1.79" -futures = "0.3.28" -futures-timer = "3.0.2" +async-trait = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } # Substrate -sc-cli = { path = "../../../substrate/client/cli" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-telemetry = { path = "../../../substrate/client/telemetry" } -sc-tracing = { path = "../../../substrate/client/tracing" } -sc-sysinfo = { path = "../../../substrate/client/sysinfo" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sc-sysinfo = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } # Polkadot -polkadot-cli = { path = "../../../polkadot/cli", default-features = false, features = ["cli"] } -polkadot-service = { path = "../../../polkadot/node/service" } +polkadot-cli = { features = ["cli"], workspace = true } +polkadot-service = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } [dev-dependencies] # Substrate -sp-keyring = { path = "../../../substrate/primitives/keyring" } +sp-keyring = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives" } -polkadot-test-client = { path = "../../../polkadot/node/test/client" } -metered = { package = "prioritized-metered-channel", version = "0.6.1", default-features = false, features = ["futures_channel"] } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-test-client = { workspace = true } +metered = { features = ["futures_channel"], workspace = true } # Cumulus -cumulus-test-service = { path = "../../test/service" } +cumulus-test-service = { workspace = true } diff --git a/cumulus/client/relay-chain-inprocess-interface/src/lib.rs b/cumulus/client/relay-chain-inprocess-interface/src/lib.rs index 578b942776dcde99553e0a5af513b03acb3a80a1..c796dc5f7c382fb18b5b8f5c9b2d5a69eb43cb6b 100644 --- a/cumulus/client/relay-chain-inprocess-interface/src/lib.rs +++ b/cumulus/client/relay-chain-inprocess-interface/src/lib.rs @@ -14,14 +14,14 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use std::{pin::Pin, sync::Arc, time::Duration}; +use std::{collections::btree_map::BTreeMap, pin::Pin, sync::Arc, time::Duration}; use async_trait::async_trait; use cumulus_primitives_core::{ relay_chain::{ - runtime_api::ParachainHost, Block as PBlock, BlockId, CommittedCandidateReceipt, - Hash as PHash, Header as PHeader, InboundHrmpMessage, OccupiedCoreAssumption, SessionIndex, - ValidationCodeHash, ValidatorId, + runtime_api::ParachainHost, Block as PBlock, BlockId, BlockNumber, + CommittedCandidateReceipt, CoreState, Hash as PHash, Header as PHeader, InboundHrmpMessage, + OccupiedCoreAssumption, SessionIndex, ValidationCodeHash, ValidatorId, }, InboundDownwardMessage, ParaId, PersistedValidationData, }; @@ -30,7 +30,7 @@ use futures::{FutureExt, Stream, StreamExt}; use polkadot_service::{ CollatorPair, Configuration, FullBackend, FullClient, Handle, NewFull, TaskManager, }; -use sc_cli::SubstrateCli; +use sc_cli::{RuntimeVersion, SubstrateCli}; use sc_client_api::{ blockchain::BlockStatus, Backend, BlockchainEvents, HeaderBackend, ImportNotifications, StorageProof, @@ -38,7 +38,7 @@ use sc_client_api::{ use sc_telemetry::TelemetryWorkerHandle; use sp_api::ProvideRuntimeApi; use sp_consensus::SyncOracle; -use sp_core::{sp_std::collections::btree_map::BTreeMap, Pair}; +use sp_core::Pair; use sp_state_machine::{Backend as StateBackend, StorageValue}; /// The timeout in seconds after that the waiting for a block should be aborted. @@ -68,6 +68,10 @@ impl RelayChainInProcessInterface { #[async_trait] impl RelayChainInterface for RelayChainInProcessInterface { + async fn version(&self, relay_parent: PHash) -> RelayChainResult { + Ok(self.full_client.runtime_version_at(relay_parent)?) + } + async fn retrieve_dmq_contents( &self, para_id: ParaId, @@ -251,6 +255,21 @@ impl RelayChainInterface for RelayChainInProcessInterface { }); Ok(Box::pin(notifications_stream)) } + + async fn availability_cores( + &self, + relay_parent: PHash, + ) -> RelayChainResult>> { + Ok(self.full_client.runtime_api().availability_cores(relay_parent)?) + } + + async fn candidates_pending_availability( + &self, + hash: PHash, + para_id: ParaId, + ) -> RelayChainResult> { + Ok(self.full_client.runtime_api().candidates_pending_availability(hash, para_id)?) + } } pub enum BlockCheckStatus { @@ -404,7 +423,7 @@ mod tests { #[test] fn returns_directly_for_available_block() { - let (mut client, block, relay_chain_interface) = build_client_backend_and_block(); + let (client, block, relay_chain_interface) = build_client_backend_and_block(); let hash = block.hash(); block_on(client.import(BlockOrigin::Own, block)).expect("Imports the block"); @@ -420,7 +439,7 @@ mod tests { #[test] fn resolve_after_block_import_notification_was_received() { - let (mut client, block, relay_chain_interface) = build_client_backend_and_block(); + let (client, block, relay_chain_interface) = build_client_backend_and_block(); let hash = block.hash(); block_on(async move { @@ -449,7 +468,7 @@ mod tests { #[test] fn do_not_resolve_after_different_block_import_notification_was_received() { - let (mut client, block, relay_chain_interface) = build_client_backend_and_block(); + let (client, block, relay_chain_interface) = build_client_backend_and_block(); let hash = block.hash(); let ext = construct_transfer_extrinsic( diff --git a/cumulus/client/relay-chain-interface/Cargo.toml b/cumulus/client/relay-chain-interface/Cargo.toml index 6df9847252fecf8e4bdcdec0ff9f830d6530668b..a496fab050dd7fc3cba69c8a6812c5f07b27a6d4 100644 --- a/cumulus/client/relay-chain-interface/Cargo.toml +++ b/cumulus/client/relay-chain-interface/Cargo.toml @@ -10,17 +10,18 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -polkadot-overseer = { path = "../../../polkadot/node/overseer" } +polkadot-overseer = { workspace = true, default-features = true } -cumulus-primitives-core = { path = "../../primitives/core" } +cumulus-primitives-core = { workspace = true, default-features = true } -sp-api = { path = "../../../substrate/primitives/api" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sc-client-api = { path = "../../../substrate/client/api" } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sp-version = { workspace = true } -futures = "0.3.28" -async-trait = "0.1.79" +futures = { workspace = true } +async-trait = { workspace = true } thiserror = { workspace = true } -jsonrpsee-core = "0.22" -parity-scale-codec = "3.6.4" +jsonrpsee-core = { workspace = true } +codec = { workspace = true, default-features = true } diff --git a/cumulus/client/relay-chain-interface/src/lib.rs b/cumulus/client/relay-chain-interface/src/lib.rs index bb93e6a168c849fa9d41586ad8b9ec0013e6c01f..d02035e84e92f45c4da74f91912ee57abaa083ee 100644 --- a/cumulus/client/relay-chain-interface/src/lib.rs +++ b/cumulus/client/relay-chain-interface/src/lib.rs @@ -16,21 +16,21 @@ use std::{collections::BTreeMap, pin::Pin, sync::Arc}; +use futures::Stream; use polkadot_overseer::prometheus::PrometheusError; use sc_client_api::StorageProof; - -use futures::Stream; +use sp_version::RuntimeVersion; use async_trait::async_trait; +use codec::Error as CodecError; use jsonrpsee_core::ClientError as JsonRpcError; -use parity_scale_codec::Error as CodecError; use sp_api::ApiError; use cumulus_primitives_core::relay_chain::BlockId; pub use cumulus_primitives_core::{ relay_chain::{ - CommittedCandidateReceipt, Hash as PHash, Header as PHeader, InboundHrmpMessage, - OccupiedCoreAssumption, SessionIndex, ValidationCodeHash, ValidatorId, + BlockNumber, CommittedCandidateReceipt, CoreState, Hash as PHash, Header as PHeader, + InboundHrmpMessage, OccupiedCoreAssumption, SessionIndex, ValidationCodeHash, ValidatorId, }, InboundDownwardMessage, ParaId, PersistedValidationData, }; @@ -149,8 +149,12 @@ pub trait RelayChainInterface: Send + Sync { _: OccupiedCoreAssumption, ) -> RelayChainResult>; - /// Get the receipt of a candidate pending availability. This returns `Some` for any paras - /// assigned to occupied cores in `availability_cores` and `None` otherwise. + /// Get the receipt of the first candidate pending availability of this para_id. This returns + /// `Some` for any paras assigned to occupied cores in `availability_cores` and `None` + /// otherwise. + #[deprecated( + note = "`candidate_pending_availability` only returns one candidate and is deprecated. Use `candidates_pending_availability` instead." + )] async fn candidate_pending_availability( &self, block_id: PHash, @@ -203,6 +207,24 @@ pub trait RelayChainInterface: Send + Sync { para_id: ParaId, occupied_core_assumption: OccupiedCoreAssumption, ) -> RelayChainResult>; + + /// Get the receipts of all candidates pending availability for this para_id. + async fn candidates_pending_availability( + &self, + block_id: PHash, + para_id: ParaId, + ) -> RelayChainResult>; + + /// Get the runtime version of the relay chain. + async fn version(&self, relay_parent: PHash) -> RelayChainResult; + + /// Yields information on all availability cores as relevant to the child block. + /// + /// Cores are either free, scheduled or occupied. Free cores can have paras assigned to them. + async fn availability_cores( + &self, + relay_parent: PHash, + ) -> RelayChainResult>>; } #[async_trait] @@ -237,6 +259,7 @@ where .await } + #[allow(deprecated)] async fn candidate_pending_availability( &self, block_id: PHash, @@ -321,4 +344,23 @@ where .validation_code_hash(relay_parent, para_id, occupied_core_assumption) .await } + + async fn availability_cores( + &self, + relay_parent: PHash, + ) -> RelayChainResult>> { + (**self).availability_cores(relay_parent).await + } + + async fn candidates_pending_availability( + &self, + block_id: PHash, + para_id: ParaId, + ) -> RelayChainResult> { + (**self).candidates_pending_availability(block_id, para_id).await + } + + async fn version(&self, relay_parent: PHash) -> RelayChainResult { + (**self).version(relay_parent).await + } } diff --git a/cumulus/client/relay-chain-minimal-node/Cargo.toml b/cumulus/client/relay-chain-minimal-node/Cargo.toml index 88673a8f08fe37e4c5688b6bbec40fb36903c6dd..95ecadc8bd06ec52b0089dd39143e78e1a27811a 100644 --- a/cumulus/client/relay-chain-minimal-node/Cargo.toml +++ b/cumulus/client/relay-chain-minimal-node/Cargo.toml @@ -11,44 +11,37 @@ workspace = true [dependencies] # polkadot deps -polkadot-primitives = { path = "../../../polkadot/primitives" } -polkadot-core-primitives = { path = "../../../polkadot/core-primitives" } -polkadot-overseer = { path = "../../../polkadot/node/overseer" } -polkadot-node-subsystem-util = { path = "../../../polkadot/node/subsystem-util" } -polkadot-node-network-protocol = { path = "../../../polkadot/node/network/protocol" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } -polkadot-availability-recovery = { path = "../../../polkadot/node/network/availability-recovery" } -polkadot-collator-protocol = { path = "../../../polkadot/node/network/collator-protocol" } -polkadot-network-bridge = { path = "../../../polkadot/node/network/bridge" } -polkadot-node-collation-generation = { path = "../../../polkadot/node/collation-generation" } -polkadot-node-core-runtime-api = { path = "../../../polkadot/node/core/runtime-api" } -polkadot-node-core-chain-api = { path = "../../../polkadot/node/core/chain-api" } -polkadot-node-core-prospective-parachains = { path = "../../../polkadot/node/core/prospective-parachains" } -polkadot-service = { path = "../../../polkadot/node/service" } +polkadot-network-bridge = { workspace = true, default-features = true } +polkadot-service = { workspace = true, default-features = true } # substrate deps -sc-authority-discovery = { path = "../../../substrate/client/authority-discovery" } -sc-network = { path = "../../../substrate/client/network" } -sc-network-common = { path = "../../../substrate/client/network/common" } -sc-service = { path = "../../../substrate/client/service" } -sc-client-api = { path = "../../../substrate/client/api" } -substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" } -sc-tracing = { path = "../../../substrate/client/tracing" } -sc-utils = { path = "../../../substrate/client/utils" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -tokio = { version = "1.32.0", features = ["macros"] } +sc-authority-discovery = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-common = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +tokio = { features = ["macros"], workspace = true, default-features = true } # cumulus deps -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } -cumulus-relay-chain-rpc-interface = { path = "../relay-chain-rpc-interface" } -cumulus-primitives-core = { path = "../../primitives/core" } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-relay-chain-rpc-interface = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } -array-bytes = "6.2.2" -tracing = "0.1.37" -async-trait = "0.1.79" -futures = "0.3.28" -parking_lot = "0.12.1" +array-bytes = { workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } +async-trait = { workspace = true } +futures = { workspace = true } diff --git a/cumulus/client/relay-chain-minimal-node/src/lib.rs b/cumulus/client/relay-chain-minimal-node/src/lib.rs index b84427c3a75a55e30d9867cbe8d45522a2d2f8c0..732a242e72957214ce8161d5f785d20b8c2484b3 100644 --- a/cumulus/client/relay-chain-minimal-node/src/lib.rs +++ b/cumulus/client/relay-chain-minimal-node/src/lib.rs @@ -176,8 +176,10 @@ async fn new_minimal_relay_chain, ) -> Result { let role = config.role.clone(); - let mut net_config = - sc_network::config::FullNetworkConfiguration::<_, _, Network>::new(&config.network); + let mut net_config = sc_network::config::FullNetworkConfiguration::<_, _, Network>::new( + &config.network, + config.prometheus_config.as_ref().map(|cfg| cfg.registry.clone()), + ); let metrics = Network::register_notification_metrics( config.prometheus_config.as_ref().map(|cfg| &cfg.registry), ); @@ -190,7 +192,7 @@ async fn new_minimal_relay_chain(request_protocol_names); config.add_request_response_protocol(cfg); + let cfg = + Protocol::ChunkFetchingV2.get_outbound_only_config::<_, Network>(request_protocol_names); + config.add_request_response_protocol(cfg); (collation_req_v1_receiver, collation_req_v2_receiver, available_data_req_receiver) } diff --git a/cumulus/client/relay-chain-rpc-interface/Cargo.toml b/cumulus/client/relay-chain-rpc-interface/Cargo.toml index 14981677289561040875b0951dbdbffb5854a439..6c0730a56a264b9805b092df203671778719bc49 100644 --- a/cumulus/client/relay-chain-rpc-interface/Cargo.toml +++ b/cumulus/client/relay-chain-rpc-interface/Cargo.toml @@ -10,39 +10,39 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -polkadot-overseer = { path = "../../../polkadot/node/overseer" } +polkadot-overseer = { workspace = true, default-features = true } -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } -sp-api = { path = "../../../substrate/primitives/api" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-storage = { path = "../../../substrate/primitives/storage" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-version = { path = "../../../substrate/primitives/version" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-rpc-api = { path = "../../../substrate/client/rpc-api" } -sc-service = { path = "../../../substrate/client/service" } +sp-api = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-storage = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-rpc-api = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } -tokio = { version = "1.32.0", features = ["sync"] } -tokio-util = { version = "0.7.8", features = ["compat"] } +tokio = { features = ["sync"], workspace = true, default-features = true } +tokio-util = { features = ["compat"], workspace = true } -futures = "0.3.28" -futures-timer = "3.0.2" -parity-scale-codec = "3.6.4" -jsonrpsee = { version = "0.22", features = ["ws-client"] } -tracing = "0.1.37" -async-trait = "0.1.79" -url = "2.4.0" +futures = { workspace = true } +futures-timer = { workspace = true } +codec = { workspace = true, default-features = true } +jsonrpsee = { features = ["ws-client"], workspace = true } +tracing = { workspace = true, default-features = true } +async-trait = { workspace = true } +url = { workspace = true } serde_json = { workspace = true, default-features = true } serde = { workspace = true, default-features = true } -schnellru = "0.2.1" -smoldot = { version = "0.11.0", default_features = false, features = ["std"] } -smoldot-light = { version = "0.9.0", default_features = false, features = ["std"] } -either = "1.8.1" +schnellru = { workspace = true } +smoldot = { default_features = false, features = ["std"], workspace = true } +smoldot-light = { default_features = false, features = ["std"], workspace = true } +either = { workspace = true, default-features = true } thiserror = { workspace = true } -rand = "0.8.5" -pin-project = "1.1.3" +rand = { workspace = true, default-features = true } +pin-project = { workspace = true } diff --git a/cumulus/client/relay-chain-rpc-interface/src/lib.rs b/cumulus/client/relay-chain-rpc-interface/src/lib.rs index 3a4c186e301eab295aa3befbd3c5549636fdb2c0..e32ec6a41a4bf00db5e5db07235bf43bbad1dbf6 100644 --- a/cumulus/client/relay-chain-rpc-interface/src/lib.rs +++ b/cumulus/client/relay-chain-rpc-interface/src/lib.rs @@ -24,16 +24,16 @@ use cumulus_primitives_core::{ InboundDownwardMessage, ParaId, PersistedValidationData, }; use cumulus_relay_chain_interface::{ - PHeader, RelayChainError, RelayChainInterface, RelayChainResult, + BlockNumber, CoreState, PHeader, RelayChainError, RelayChainInterface, RelayChainResult, }; use futures::{FutureExt, Stream, StreamExt}; use polkadot_overseer::Handle; use sc_client_api::StorageProof; -use sp_core::sp_std::collections::btree_map::BTreeMap; use sp_state_machine::StorageValue; use sp_storage::StorageKey; -use std::pin::Pin; +use sp_version::RuntimeVersion; +use std::{collections::btree_map::BTreeMap, pin::Pin}; use cumulus_primitives_core::relay_chain::BlockId; pub use url::Url; @@ -237,4 +237,25 @@ impl RelayChainInterface for RelayChainRpcInterface { let imported_headers_stream = self.rpc_client.get_best_heads_stream()?; Ok(imported_headers_stream.boxed()) } + + async fn candidates_pending_availability( + &self, + hash: RelayHash, + para_id: ParaId, + ) -> RelayChainResult> { + self.rpc_client + .parachain_host_candidates_pending_availability(hash, para_id) + .await + } + + async fn version(&self, relay_parent: RelayHash) -> RelayChainResult { + self.rpc_client.runtime_version(relay_parent).await + } + + async fn availability_cores( + &self, + relay_parent: RelayHash, + ) -> RelayChainResult>> { + self.rpc_client.parachain_host_availability_cores(relay_parent).await + } } diff --git a/cumulus/client/relay-chain-rpc-interface/src/light_client_worker.rs b/cumulus/client/relay-chain-rpc-interface/src/light_client_worker.rs index 9a49b60281b3c51fa1426903a0e73157a6f04e0e..2347dbb85f78ed1d8017ba076f6d77e97664c021 100644 --- a/cumulus/client/relay-chain-rpc-interface/src/light_client_worker.rs +++ b/cumulus/client/relay-chain-rpc-interface/src/light_client_worker.rs @@ -20,7 +20,7 @@ use futures::{channel::mpsc::Sender, prelude::*, stream::FuturesUnordered}; use jsonrpsee::core::client::{ - Client as JsonRpseeClient, ClientBuilder, ClientT, Error, ReceivedMessage, TransportReceiverT, + Client as JsonRpseeClient, ClientBuilder, ClientT, ReceivedMessage, TransportReceiverT, TransportSenderT, }; use smoldot_light::{ChainId, Client as SmoldotClient, JsonRpcResponses}; @@ -124,7 +124,7 @@ pub struct LightClientRpcWorker { } fn handle_notification( - maybe_header: Option>, + maybe_header: Option>, senders: &mut Vec>, ) -> Result<(), ()> { match maybe_header { diff --git a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs index 864ce6c57125ae5c8dcb5419561dd61a43c38579..c7eaa45958b0b002a00ec8210d5044bd56aa0569 100644 --- a/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs +++ b/cumulus/client/relay-chain-rpc-interface/src/rpc_client.rs @@ -24,10 +24,10 @@ use jsonrpsee::{ }; use serde::de::DeserializeOwned; use serde_json::Value as JsonValue; -use std::collections::VecDeque; +use std::collections::{btree_map::BTreeMap, VecDeque}; use tokio::sync::mpsc::Sender as TokioSender; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use cumulus_primitives_core::{ relay_chain::{ @@ -47,7 +47,6 @@ use sc_client_api::StorageData; use sc_rpc_api::{state::ReadProof, system::Health}; use sc_service::TaskManager; use sp_consensus_babe::Epoch; -use sp_core::sp_std::collections::btree_map::BTreeMap; use sp_storage::StorageKey; use sp_version::RuntimeVersion; diff --git a/cumulus/client/service/Cargo.toml b/cumulus/client/service/Cargo.toml index e03e20fe5b416102aa99739cb00c0b39edf5b999..8e9e41ca89dc06401c04e36b5cc0db7ffb3e36d7 100644 --- a/cumulus/client/service/Cargo.toml +++ b/cumulus/client/service/Cargo.toml @@ -10,39 +10,39 @@ license = "GPL-3.0-or-later WITH Classpath-exception-2.0" workspace = true [dependencies] -futures = "0.3.28" +futures = { workspace = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sc-consensus = { path = "../../../substrate/client/consensus/common" } -sc-transaction-pool = { path = "../../../substrate/client/transaction-pool" } -sc-rpc = { path = "../../../substrate/client/rpc" } -sc-service = { path = "../../../substrate/client/service" } -sc-sysinfo = { path = "../../../substrate/client/sysinfo" } -sc-telemetry = { path = "../../../substrate/client/telemetry" } -sc-network = { path = "../../../substrate/client/network" } -sc-network-sync = { path = "../../../substrate/client/network/sync" } -sc-utils = { path = "../../../substrate/client/utils" } -sc-network-transactions = { path = "../../../substrate/client/network/transactions" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool" } -sp-io = { path = "../../../substrate/primitives/io" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-sysinfo = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-sync = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sc-network-transactions = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-transaction-pool = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives" } +polkadot-primitives = { workspace = true, default-features = true } # Cumulus -cumulus-client-cli = { path = "../cli" } -cumulus-client-collator = { path = "../collator" } -cumulus-client-consensus-common = { path = "../consensus/common" } -cumulus-client-pov-recovery = { path = "../pov-recovery" } -cumulus-client-network = { path = "../network" } -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-primitives-proof-size-hostfunction = { path = "../../primitives/proof-size-hostfunction" } -cumulus-relay-chain-interface = { path = "../relay-chain-interface" } -cumulus-relay-chain-inprocess-interface = { path = "../relay-chain-inprocess-interface" } -cumulus-relay-chain-minimal-node = { path = "../relay-chain-minimal-node" } +cumulus-client-cli = { workspace = true, default-features = true } +cumulus-client-collator = { workspace = true, default-features = true } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-client-pov-recovery = { workspace = true, default-features = true } +cumulus-client-network = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-primitives-proof-size-hostfunction = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-relay-chain-inprocess-interface = { workspace = true, default-features = true } +cumulus-relay-chain-minimal-node = { workspace = true, default-features = true } diff --git a/cumulus/client/service/src/lib.rs b/cumulus/client/service/src/lib.rs index 9b5f0bec53875c98dc563b86ecea1d4864a554da..7f656aabca7ac78a9bc4c35137ec56ed535fe362 100644 --- a/cumulus/client/service/src/lib.rs +++ b/cumulus/client/service/src/lib.rs @@ -28,10 +28,7 @@ use cumulus_relay_chain_interface::{RelayChainInterface, RelayChainResult}; use cumulus_relay_chain_minimal_node::{ build_minimal_relay_chain_node_light_client, build_minimal_relay_chain_node_with_rpc, }; -use futures::{ - channel::{mpsc, oneshot}, - FutureExt, StreamExt, -}; +use futures::{channel::mpsc, StreamExt}; use polkadot_primitives::{CollatorPair, OccupiedCoreAssumption}; use sc_client_api::{ Backend as BackendT, BlockBackend, BlockchainEvents, Finalizer, ProofProvider, UsageProvider, @@ -43,7 +40,7 @@ use sc_consensus::{ use sc_network::{config::SyncMode, service::traits::NetworkService, NetworkBackend}; use sc_network_sync::SyncingService; use sc_network_transactions::TransactionsHandlerController; -use sc_service::{Configuration, NetworkStarter, SpawnTaskHandle, TaskManager, WarpSyncParams}; +use sc_service::{Configuration, NetworkStarter, SpawnTaskHandle, TaskManager, WarpSyncConfig}; use sc_telemetry::{log, TelemetryWorkerHandle}; use sc_utils::mpsc::TracingUnboundedSender; use sp_api::ProvideRuntimeApi; @@ -467,12 +464,19 @@ where { let warp_sync_params = match parachain_config.network.sync_mode { SyncMode::Warp => { - let target_block = warp_sync_get::( - para_id, - relay_chain_interface.clone(), - spawn_handle.clone(), - ); - Some(WarpSyncParams::WaitForTarget(target_block)) + log::debug!(target: LOG_TARGET_SYNC, "waiting for announce block..."); + + let target_block = + wait_for_finalized_para_head::(para_id, relay_chain_interface.clone()) + .await + .inspect_err(|e| { + log::error!( + target: LOG_TARGET_SYNC, + "Unable to determine parachain target block {:?}", + e + ); + })?; + Some(WarpSyncConfig::WithTarget(target_block)) }, _ => None, }; @@ -500,67 +504,37 @@ where spawn_handle, import_queue, block_announce_validator_builder: Some(Box::new(move |_| block_announce_validator)), - warp_sync_params, + warp_sync_config: warp_sync_params, block_relay: None, metrics, }) } -/// Creates a new background task to wait for the relay chain to sync up and retrieve the parachain -/// header -fn warp_sync_get( - para_id: ParaId, - relay_chain_interface: RCInterface, - spawner: SpawnTaskHandle, -) -> oneshot::Receiver<::Header> -where - B: BlockT + 'static, - RCInterface: RelayChainInterface + 'static, -{ - let (sender, receiver) = oneshot::channel::(); - spawner.spawn( - "cumulus-parachain-wait-for-target-block", - None, - async move { - log::debug!( - target: LOG_TARGET_SYNC, - "waiting for announce block in a background task...", - ); - - let _ = wait_for_finalized_para_head::(sender, para_id, relay_chain_interface) - .await - .map_err(|e| { - log::error!( - target: LOG_TARGET_SYNC, - "Unable to determine parachain target block {:?}", - e - ) - }); - } - .boxed(), - ); - - receiver -} - /// Waits for the relay chain to have finished syncing and then gets the parachain header that /// corresponds to the last finalized relay chain block. async fn wait_for_finalized_para_head( - sender: oneshot::Sender<::Header>, para_id: ParaId, relay_chain_interface: RCInterface, -) -> Result<(), Box> +) -> sc_service::error::Result<::Header> where B: BlockT + 'static, RCInterface: RelayChainInterface + Send + 'static, { - let mut imported_blocks = relay_chain_interface.import_notification_stream().await?.fuse(); - while imported_blocks.next().await.is_some() { - let is_syncing = relay_chain_interface.is_major_syncing().await.map_err(|e| { - Box::::from(format!( - "Unable to determine sync status. {e}" + let mut imported_blocks = relay_chain_interface + .import_notification_stream() + .await + .map_err(|error| { + sc_service::Error::Other(format!( + "Relay chain import notification stream error when waiting for parachain head: \ + {error}" )) - })?; + })? + .fuse(); + while imported_blocks.next().await.is_some() { + let is_syncing = relay_chain_interface + .is_major_syncing() + .await + .map_err(|e| format!("Unable to determine sync status: {e}"))?; if !is_syncing { let relay_chain_best_hash = relay_chain_interface @@ -586,8 +560,7 @@ where finalized_header.number(), finalized_header.hash() ); - let _ = sender.send(finalized_header); - return Ok(()) + return Ok(finalized_header) } } diff --git a/cumulus/pallets/aura-ext/Cargo.toml b/cumulus/pallets/aura-ext/Cargo.toml index fe717596f9b307993f968ea0e7b58faef591dcf7..c08148928b7cec891b8f80cb856714c24b04d809 100644 --- a/cumulus/pallets/aura-ext/Cargo.toml +++ b/cumulus/pallets/aura-ext/Cargo.toml @@ -10,26 +10,25 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -pallet-aura = { path = "../../../substrate/frame/aura", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto", default-features = false } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura", 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 } +pallet-aura = { workspace = true } +pallet-timestamp = { workspace = true } +sp-application-crypto = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-runtime = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../parachain-system", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } [dev-dependencies] # Cumulus -cumulus-pallet-parachain-system = { path = "../parachain-system" } +cumulus-pallet-parachain-system = { workspace = true, default-features = true } [features] default = ["std"] @@ -44,7 +43,6 @@ std = [ "sp-application-crypto/std", "sp-consensus-aura/std", "sp-runtime/std", - "sp-std/std", ] try-runtime = [ "cumulus-pallet-parachain-system/try-runtime", diff --git a/cumulus/pallets/aura-ext/src/consensus_hook.rs b/cumulus/pallets/aura-ext/src/consensus_hook.rs index 592029803391179785bb3b5606079d1bee6b553f..c1a8568bdd834f0e754bdad20a5a11246cc6ac31 100644 --- a/cumulus/pallets/aura-ext/src/consensus_hook.rs +++ b/cumulus/pallets/aura-ext/src/consensus_hook.rs @@ -20,6 +20,7 @@ //! The velocity `V` refers to the rate of block processing by the relay chain. use super::{pallet, Aura}; +use core::{marker::PhantomData, num::NonZeroU32}; use cumulus_pallet_parachain_system::{ self as parachain_system, consensus_hook::{ConsensusHook, UnincludedSegmentCapacity}, @@ -27,7 +28,6 @@ use cumulus_pallet_parachain_system::{ }; use frame_support::pallet_prelude::*; use sp_consensus_aura::{Slot, SlotDuration}; -use sp_std::{marker::PhantomData, num::NonZeroU32}; /// A consensus hook for a fixed block processing velocity and unincluded segment capacity. /// @@ -65,16 +65,26 @@ where let para_slot_from_relay = Slot::from_timestamp(relay_chain_timestamp.into(), para_slot_duration); - // Perform checks. - assert_eq!(slot, para_slot_from_relay, "slot number mismatch"); - if authored > velocity + 1 { + // Check that we are not too far in the future. Since we expect `V` parachain blocks + // during the relay chain slot, we can allow for `V` parachain slots into the future. + if *slot > *para_slot_from_relay + u64::from(velocity) { + panic!( + "Parachain slot is too far in the future: parachain_slot: {:?}, derived_from_relay_slot: {:?} velocity: {:?}", + slot, + para_slot_from_relay, + velocity + ); + } + + // We need to allow authoring multiple blocks in the same slot. + if slot != para_slot_from_relay && authored > velocity { panic!("authored blocks limit is reached for the slot") } let weight = T::DbWeight::get().reads(1); ( weight, - NonZeroU32::new(sp_std::cmp::max(C, 1)) + NonZeroU32::new(core::cmp::max(C, 1)) .expect("1 is the minimum value and non-zero; qed") .into(), ) @@ -113,6 +123,11 @@ impl< return false } + // TODO: This logic needs to be adjusted. + // It checks that we have not authored more than `V + 1` blocks in the slot. + // As a slot however, we take the parachain slot here. Velocity should + // be measured in relation to the relay chain slot. + // https://github.com/paritytech/polkadot-sdk/issues/3967 if last_slot == new_slot { authored_so_far < velocity + 1 } else { diff --git a/cumulus/pallets/aura-ext/src/lib.rs b/cumulus/pallets/aura-ext/src/lib.rs index 7ca84dff7c513c2406d3c0de7b9c0ac26048f508..dc854eb820184cbc79c5c150b1ce008c0d1955ce 100644 --- a/cumulus/pallets/aura-ext/src/lib.rs +++ b/cumulus/pallets/aura-ext/src/lib.rs @@ -16,7 +16,7 @@ //! Cumulus extension pallet for AuRa //! -//! This pallets extends the Substrate AuRa pallet to make it compatible with parachains. It +//! This pallet extends the Substrate AuRa pallet to make it compatible with parachains. It //! provides the [`Pallet`], the [`Config`] and the [`GenesisConfig`]. //! //! It is also required that the parachain runtime uses the provided [`BlockExecutor`] to properly @@ -83,7 +83,7 @@ pub mod pallet { SlotInfo::::put((new_slot, authored)); - T::DbWeight::get().reads_writes(2, 1) + T::DbWeight::get().reads_writes(4, 2) } } @@ -109,7 +109,7 @@ pub mod pallet { #[derive(frame_support::DefaultNoBound)] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, } #[pallet::genesis_build] @@ -125,7 +125,7 @@ pub mod pallet { /// /// When executing the block it will verify the block seal to ensure that the correct author created /// the block. -pub struct BlockExecutor(sp_std::marker::PhantomData<(T, I)>); +pub struct BlockExecutor(core::marker::PhantomData<(T, I)>); impl ExecuteBlock for BlockExecutor where diff --git a/cumulus/pallets/collator-selection/Cargo.toml b/cumulus/pallets/collator-selection/Cargo.toml index 25ca2fe057baf2a3e9c313556961615a3b14c2f7..8d67db3daf8bb5b1284ef1dd6e7bfea7305b452f 100644 --- a/cumulus/pallets/collator-selection/Cargo.toml +++ b/cumulus/pallets/collator-selection/Cargo.toml @@ -2,7 +2,7 @@ authors.workspace = true description = "Simple pallet to select collators for a parachain." edition.workspace = true -homepage = "https://substrate.io" +homepage.workspace = true license = "Apache-2.0" name = "pallet-collator-selection" readme = "README.md" @@ -17,29 +17,28 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] log = { workspace = true } -codec = { default-features = false, features = ["derive"], package = "parity-scale-codec", version = "3.0.0" } -rand = { version = "0.8.5", features = ["std_rng"], default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } +rand = { features = ["std_rng"], workspace = true } +scale-info = { features = ["derive"], workspace = true } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } +sp-runtime = { workspace = true } +sp-staking = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } +frame-benchmarking = { optional = true, workspace = true } [dev-dependencies] -sp-core = { path = "../../../substrate/primitives/core" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -pallet-timestamp = { path = "../../../substrate/frame/timestamp" } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura" } -pallet-aura = { path = "../../../substrate/frame/aura" } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +pallet-timestamp = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +pallet-aura = { workspace = true, default-features = true } [features] default = ["std"] @@ -65,7 +64,6 @@ std = [ "scale-info/std", "sp-runtime/std", "sp-staking/std", - "sp-std/std", ] try-runtime = [ diff --git a/cumulus/pallets/collator-selection/src/benchmarking.rs b/cumulus/pallets/collator-selection/src/benchmarking.rs index c6b600445282534951b2c63a6c2a87181688acd1..24823661383b55f26bf19356e72394945c01f577 100644 --- a/cumulus/pallets/collator-selection/src/benchmarking.rs +++ b/cumulus/pallets/collator-selection/src/benchmarking.rs @@ -21,13 +21,14 @@ use super::*; #[allow(unused)] use crate::Pallet as CollatorSelection; +use alloc::vec::Vec; use codec::Decode; +use core::cmp; use frame_benchmarking::{account, v2::*, whitelisted_caller, BenchmarkError}; use frame_support::traits::{Currency, EnsureOrigin, Get, ReservableCurrency}; use frame_system::{pallet_prelude::BlockNumberFor, EventRecord, RawOrigin}; use pallet_authorship::EventHandler; use pallet_session::{self as session, SessionManager}; -use sp_std::{cmp, prelude::*}; pub type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; diff --git a/cumulus/pallets/collator-selection/src/lib.rs b/cumulus/pallets/collator-selection/src/lib.rs index 2fa384367528a1f1306a6c34c0c45d3ef94843a2..9d7e62af3c68f496de34e4f0c02ffdc5a21cf978 100644 --- a/cumulus/pallets/collator-selection/src/lib.rs +++ b/cumulus/pallets/collator-selection/src/lib.rs @@ -81,6 +81,8 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + use core::marker::PhantomData; use frame_support::traits::TypedGet; pub use pallet::*; @@ -101,6 +103,7 @@ const LOG_TARGET: &str = "runtime::collator-selection"; #[frame_support::pallet] pub mod pallet { pub use crate::weights::WeightInfo; + use alloc::vec::Vec; use core::ops::Div; use frame_support::{ dispatch::{DispatchClass, DispatchResultWithPostInfo}, @@ -118,7 +121,6 @@ pub mod pallet { RuntimeDebug, }; use sp_staking::SessionIndex; - use sp_std::vec::Vec; /// The in-code storage version. const STORAGE_VERSION: StorageVersion = StorageVersion::new(2); @@ -244,7 +246,7 @@ pub mod pallet { let duplicate_invulnerables = self .invulnerables .iter() - .collect::>(); + .collect::>(); assert!( duplicate_invulnerables.len() == self.invulnerables.len(), "duplicate invulnerables in genesis." @@ -970,7 +972,7 @@ pub mod pallet { let result = Self::assemble_collators(); frame_system::Pallet::::register_extra_weight_unchecked( - T::WeightInfo::new_session(candidates_len_before, removed), + T::WeightInfo::new_session(removed, candidates_len_before), DispatchClass::Mandatory, ); Some(result) diff --git a/cumulus/pallets/collator-selection/src/migration.rs b/cumulus/pallets/collator-selection/src/migration.rs index 425acdd8bfb59768241399e3be5efb44a13c8a74..c52016948069a65c641fa014a390f1a6a85d3cb3 100644 --- a/cumulus/pallets/collator-selection/src/migration.rs +++ b/cumulus/pallets/collator-selection/src/migration.rs @@ -17,6 +17,8 @@ //! A module that is responsible for migration of storage for Collator Selection. use super::*; +#[cfg(feature = "try-runtime")] +use alloc::vec::Vec; use frame_support::traits::{OnRuntimeUpgrade, UncheckedOnRuntimeUpgrade}; use log; @@ -29,8 +31,6 @@ pub mod v2 { traits::{Currency, ReservableCurrency}, }; use sp_runtime::traits::{Saturating, Zero}; - #[cfg(feature = "try-runtime")] - use sp_std::vec::Vec; /// [`UncheckedMigrationToV2`] wrapped in a /// [`VersionedMigration`](frame_support::migrations::VersionedMigration), ensuring the @@ -51,7 +51,7 @@ pub mod v2 { >; /// Migrate to V2. - pub struct UncheckedMigrationToV2(sp_std::marker::PhantomData); + pub struct UncheckedMigrationToV2(PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrationToV2 { fn on_runtime_upgrade() -> Weight { let mut weight = Weight::zero(); @@ -123,10 +123,8 @@ pub mod v2 { pub mod v1 { use super::*; use frame_support::pallet_prelude::*; - #[cfg(feature = "try-runtime")] - use sp_std::prelude::*; - pub struct MigrateToV1(sp_std::marker::PhantomData); + pub struct MigrateToV1(PhantomData); impl OnRuntimeUpgrade for MigrateToV1 { fn on_runtime_upgrade() -> Weight { let on_chain_version = Pallet::::on_chain_storage_version(); diff --git a/cumulus/pallets/collator-selection/src/mock.rs b/cumulus/pallets/collator-selection/src/mock.rs index 4a440dfe1e92f26685415d260e0af9b1eb56a9a4..d13f9e9d8c44d3190cce7a168a26bad784824a0f 100644 --- a/cumulus/pallets/collator-selection/src/mock.rs +++ b/cumulus/pallets/collator-selection/src/mock.rs @@ -22,12 +22,7 @@ use frame_support::{ }; use frame_system as system; use frame_system::EnsureSignedBy; -use sp_core::H256; -use sp_runtime::{ - testing::UintAuthorityId, - traits::{BlakeTwo256, IdentityLookup, OpaqueKeys}, - BuildStorage, RuntimeAppPublic, -}; +use sp_runtime::{testing::UintAuthorityId, traits::OpaqueKeys, BuildStorage, RuntimeAppPublic}; type Block = frame_system::mocking::MockBlock; @@ -46,56 +41,24 @@ frame_support::construct_runtime!( ); parameter_types! { - pub const BlockHashCount: u64 = 250; pub const SS58Prefix: u8 = 42; } #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl system::Config for Test { - type BaseCallFilter = frame_support::traits::Everything; - type BlockWeights = (); - type BlockLength = (); - type DbWeight = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Nonce = u64; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = u64; - type Lookup = IdentityLookup; type Block = Block; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type Version = (); - type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); type SS58Prefix = SS58Prefix; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; } parameter_types! { pub const ExistentialDeposit: u64 = 5; - pub const MaxReserves: u32 = 50; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } pub struct Author4; @@ -224,7 +187,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities { candidacy_bond: 10, invulnerables, }; - let session = pallet_session::GenesisConfig:: { keys }; + let session = pallet_session::GenesisConfig:: { keys, ..Default::default() }; pallet_balances::GenesisConfig:: { balances } .assimilate_storage(&mut t) .unwrap(); diff --git a/cumulus/pallets/collator-selection/src/weights.rs b/cumulus/pallets/collator-selection/src/weights.rs index 1c01ad6cd6fe8e8ed4bc02c3c2d6703eb2882df4..12e6b755e9769cb4234bc15016c0a3b47650054f 100644 --- a/cumulus/pallets/collator-selection/src/weights.rs +++ b/cumulus/pallets/collator-selection/src/weights.rs @@ -18,11 +18,11 @@ #![allow(unused_parens)] #![allow(unused_imports)] +use core::marker::PhantomData; use frame_support::{ traits::Get, weights::{constants::RocksDbWeight, Weight}, }; -use sp_std::marker::PhantomData; // The weight info trait for `pallet_collator_selection`. pub trait WeightInfo { diff --git a/cumulus/pallets/dmp-queue/Cargo.toml b/cumulus/pallets/dmp-queue/Cargo.toml index b2b24aeed72ba28ea320a90b8e725ce983fa1a07..936526290d93ecd8935620c8f1f6045faadecb64 100644 --- a/cumulus/pallets/dmp-queue/Cargo.toml +++ b/cumulus/pallets/dmp-queue/Cargo.toml @@ -14,26 +14,25 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } -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-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-runtime = { workspace = true } +sp-io = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } [dev-dependencies] -sp-core = { path = "../../../substrate/primitives/core" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } +sp-core = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } [features] default = ["std"] @@ -48,7 +47,6 @@ std = [ "scale-info/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm/std", ] diff --git a/cumulus/pallets/dmp-queue/src/benchmarking.rs b/cumulus/pallets/dmp-queue/src/benchmarking.rs index 91d1e0eab7e406a214088d8c0e47d03e20cd0286..432d6f3bc7ae54432e3687b7d73e70a11ec2da04 100644 --- a/cumulus/pallets/dmp-queue/src/benchmarking.rs +++ b/cumulus/pallets/dmp-queue/src/benchmarking.rs @@ -19,9 +19,9 @@ use crate::*; +use alloc::vec; use frame_benchmarking::v2::*; use frame_support::{pallet_prelude::*, traits::Hooks}; -use sp_std::vec; #[benchmarks] mod benchmarks { diff --git a/cumulus/pallets/dmp-queue/src/lib.rs b/cumulus/pallets/dmp-queue/src/lib.rs index 79cc4bc895ec29b87eb95e629e0a9624fd7f62a5..cedca6f3fb97f2186318718d068a2fa120a71bc3 100644 --- a/cumulus/pallets/dmp-queue/src/lib.rs +++ b/cumulus/pallets/dmp-queue/src/lib.rs @@ -21,6 +21,9 @@ //! from the runtime once `Completed` was emitted. #![cfg_attr(not(feature = "std"), no_std)] +#![allow(deprecated)] // The pallet itself is deprecated. + +extern crate alloc; use migration::*; pub use pallet::*; @@ -38,6 +41,9 @@ pub type MaxDmpMessageLenOf = <::DmpSink as frame_support::traits::HandleMessage>::MaxMessageLen; #[frame_support::pallet] +#[deprecated( + note = "`cumulus-pallet-dmp-queue` will be removed after November 2024. It can be removed once its lazy migration completed. See ." +)] pub mod pallet { use super::*; use frame_support::{pallet_prelude::*, traits::HandleMessage, weights::WeightMeter}; diff --git a/cumulus/pallets/dmp-queue/src/migration.rs b/cumulus/pallets/dmp-queue/src/migration.rs index 349635cce547d81c1be527cb366f67679a471945..b1945e8eb37b85e9c39cbafeba4b6d7ec15502c0 100644 --- a/cumulus/pallets/dmp-queue/src/migration.rs +++ b/cumulus/pallets/dmp-queue/src/migration.rs @@ -17,9 +17,9 @@ //! Migrates the storage from the previously deleted DMP pallet. use crate::*; +use alloc::vec::Vec; use cumulus_primitives_core::relay_chain::BlockNumber as RelayBlockNumber; use frame_support::{pallet_prelude::*, storage_alias, traits::HandleMessage}; -use sp_std::vec::Vec; pub(crate) const LOG: &str = "runtime::dmp-queue-export-xcms"; diff --git a/cumulus/pallets/parachain-system/Cargo.toml b/cumulus/pallets/parachain-system/Cargo.toml index 57e274db361de98533fd258c554abcff498060b3..30a232f01b3e5ca82eab239626e2255a683972ee 100644 --- a/cumulus/pallets/parachain-system/Cargo.toml +++ b/cumulus/pallets/parachain-system/Cargo.toml @@ -10,62 +10,62 @@ license = "Apache-2.0" workspace = true [dependencies] -bytes = { version = "1.4.0", default-features = false } -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -environmental = { version = "1.1.4", default-features = false } -impl-trait-for-tuples = "0.2.1" +bytes = { workspace = true } +codec = { features = ["derive"], workspace = true } +environmental = { workspace = true } +impl-trait-for-tuples = { workspace = true } log = { workspace = true } -trie-db = { version = "0.29.0", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +trie-db = { workspace = true } +scale-info = { features = ["derive"], workspace = true } # Substrate -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 } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-externalities = { path = "../../../substrate/primitives/externalities", default-features = false } -sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-state-machine = { path = "../../../substrate/primitives/state-machine", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } -sp-version = { path = "../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-message-queue = { workspace = true } +sp-core = { workspace = true } +sp-externalities = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +sp-state-machine = { workspace = true } +sp-std = { workspace = true } +sp-trie = { workspace = true } +sp-version = { workspace = true } # Polkadot -polkadot-parachain-primitives = { path = "../../../polkadot/parachain", default-features = false, features = ["wasm-api"] } -polkadot-runtime-parachains = { path = "../../../polkadot/runtime/parachains", default-features = false } -polkadot-runtime-common = { path = "../../../polkadot/runtime/common", default-features = false, optional = true } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder", default-features = false } +polkadot-parachain-primitives = { features = ["wasm-api"], workspace = true } +polkadot-runtime-parachains = { workspace = true } +polkadot-runtime-common = { optional = true, workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } # Cumulus -cumulus-pallet-parachain-system-proc-macro = { path = "proc-macro", default-features = false } -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } -cumulus-primitives-parachain-inherent = { path = "../../primitives/parachain-inherent", default-features = false } -cumulus-primitives-proof-size-hostfunction = { path = "../../primitives/proof-size-hostfunction", default-features = false } +cumulus-pallet-parachain-system-proc-macro = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-parachain-inherent = { workspace = true } +cumulus-primitives-proof-size-hostfunction = { workspace = true } [dev-dependencies] -assert_matches = "1.5" -hex-literal = "0.4.1" -lazy_static = "1.4" -trie-standardmap = "0.16.0" -rand = "0.8.5" -futures = "0.3.28" +assert_matches = { workspace = true } +hex-literal = { workspace = true, default-features = true } +lazy_static = { workspace = true } +trie-standardmap = { workspace = true } +rand = { workspace = true, default-features = true } +futures = { workspace = true } # Substrate -sc-client-api = { path = "../../../substrate/client/api" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-crypto-hashing = { path = "../../../substrate/primitives/crypto/hashing" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -sp-version = { path = "../../../substrate/primitives/version" } -sp-consensus-slots = { path = "../../../substrate/primitives/consensus/slots" } +sc-client-api = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } # Cumulus -cumulus-test-client = { path = "../../test/client" } -cumulus-test-relay-sproof-builder = { path = "../../test/relay-sproof-builder" } -cumulus-test-runtime = { path = "../../test/runtime" } +cumulus-test-client = { workspace = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } +cumulus-test-runtime = { workspace = true } [features] default = ["std"] @@ -122,5 +122,3 @@ try-runtime = [ "polkadot-runtime-parachains/try-runtime", "sp-runtime/try-runtime", ] - -parameterized-consensus-hook = [] diff --git a/cumulus/pallets/parachain-system/proc-macro/Cargo.toml b/cumulus/pallets/parachain-system/proc-macro/Cargo.toml index 0a90c30e0331261026125f429efe70eff07ac069..da6f0fd03efb79b03e4815433084ca8b79f6595d 100644 --- a/cumulus/pallets/parachain-system/proc-macro/Cargo.toml +++ b/cumulus/pallets/parachain-system/proc-macro/Cargo.toml @@ -14,9 +14,9 @@ proc-macro = true [dependencies] syn = { workspace = true } -proc-macro2 = "1.0.64" +proc-macro2 = { workspace = true } quote = { workspace = true } -proc-macro-crate = "3.0.0" +proc-macro-crate = { workspace = true } [features] default = ["std"] diff --git a/cumulus/pallets/parachain-system/proc-macro/src/lib.rs b/cumulus/pallets/parachain-system/proc-macro/src/lib.rs index 8ab5d81efdcf486dff67db6a1f5a62a5a8454ae8..f284fbdc64c600f130b0e5bb531021ecfd2e0e73 100644 --- a/cumulus/pallets/parachain-system/proc-macro/src/lib.rs +++ b/cumulus/pallets/parachain-system/proc-macro/src/lib.rs @@ -122,8 +122,8 @@ pub fn register_validate_block(input: proc_macro::TokenStream) -> proc_macro::To #[no_mangle] unsafe fn validate_block(arguments: *mut u8, arguments_len: usize) -> u64 { // We convert the `arguments` into a boxed slice and then into `Bytes`. - let args = #crate_::validate_block::sp_std::boxed::Box::from_raw( - #crate_::validate_block::sp_std::slice::from_raw_parts_mut( + let args = #crate_::validate_block::Box::from_raw( + #crate_::validate_block::slice::from_raw_parts_mut( arguments, arguments_len, ) diff --git a/cumulus/pallets/parachain-system/src/consensus_hook.rs b/cumulus/pallets/parachain-system/src/consensus_hook.rs index 91353fc7bbda7ce05cfb5259e05bde64c758bbe4..3062396a4e7865bf4e3545b39c6ad9fa6ded6a24 100644 --- a/cumulus/pallets/parachain-system/src/consensus_hook.rs +++ b/cumulus/pallets/parachain-system/src/consensus_hook.rs @@ -18,8 +18,8 @@ //! of parachain blocks ready to submit to the relay chain, as well as some basic implementations. use super::relay_state_snapshot::RelayChainStateProof; +use core::num::NonZeroU32; use frame_support::weights::Weight; -use sp_std::num::NonZeroU32; /// The possible capacity of the unincluded segment. #[derive(Clone)] @@ -95,7 +95,7 @@ impl ConsensusHook for FixedCapacityUnincludedSegment { fn on_state_proof(_state_proof: &RelayChainStateProof) -> (Weight, UnincludedSegmentCapacity) { ( Weight::zero(), - NonZeroU32::new(sp_std::cmp::max(N, 1)) + NonZeroU32::new(core::cmp::max(N, 1)) .expect("1 is the minimum value and non-zero; qed") .into(), ) diff --git a/cumulus/pallets/parachain-system/src/lib.rs b/cumulus/pallets/parachain-system/src/lib.rs index c8e7d1bb30f7166d50ab9aed8d1dfd0526e8f36e..bf136dc0644c4c124c9b7466da908af64892ed0d 100644 --- a/cumulus/pallets/parachain-system/src/lib.rs +++ b/cumulus/pallets/parachain-system/src/lib.rs @@ -27,10 +27,14 @@ //! //! Users must ensure that they register this pallet as an inherent provider. +extern crate alloc; + +use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec}; use codec::{Decode, Encode}; +use core::cmp; use cumulus_primitives_core::{ relay_chain, AbridgedHostConfiguration, ChannelInfo, ChannelStatus, CollationInfo, - GetChannelInfo, InboundDownwardMessage, InboundHrmpMessage, MessageSendError, + GetChannelInfo, InboundDownwardMessage, InboundHrmpMessage, ListChannelInfos, MessageSendError, OutboundHrmpMessage, ParaId, PersistedValidationData, UpwardMessage, UpwardMessageSender, XcmpMessageHandler, XcmpMessageSource, }; @@ -49,12 +53,8 @@ use polkadot_runtime_parachains::FeeTracker; use scale_info::TypeInfo; use sp_runtime::{ traits::{Block as BlockT, BlockNumberProvider, Hash}, - transaction_validity::{ - InvalidTransaction, TransactionSource, TransactionValidity, ValidTransaction, - }, BoundedSlice, FixedU128, RuntimeDebug, Saturating, }; -use sp_std::{cmp, collections::btree_map::BTreeMap, prelude::*}; use xcm::{latest::XcmHash, VersionedLocation, VersionedXcm}; use xcm_builder::InspectMessageQueues; @@ -190,7 +190,7 @@ pub mod ump_constants { pub mod pallet { use super::*; use frame_support::pallet_prelude::*; - use frame_system::{pallet_prelude::*, WeightInfo as SystemWeightInfo}; + use frame_system::pallet_prelude::*; #[pallet::pallet] #[pallet::storage_version(migration::STORAGE_VERSION)] @@ -245,10 +245,6 @@ pub mod pallet { /// [`consensus_hook::ExpectParentIncluded`] here. This is only necessary in the case /// that collators aren't expected to have node versions that supply the included block /// in the relay-chain state proof. - /// - /// This config type is only available when the `parameterized-consensus-hook` crate feature - /// is activated. - #[cfg(feature = "parameterized-consensus-hook")] type ConsensusHook: ConsensusHook; } @@ -556,10 +552,8 @@ pub mod pallet { .expect("Invalid relay chain state proof"); // Update the desired maximum capacity according to the consensus hook. - #[cfg(feature = "parameterized-consensus-hook")] - let (consensus_hook_weight, capacity) = T::ConsensusHook::on_state_proof(&relay_state_proof); - #[cfg(not(feature = "parameterized-consensus-hook"))] - let (consensus_hook_weight, capacity) = ExpectParentIncluded::on_state_proof(&relay_state_proof); + let (consensus_hook_weight, capacity) = + T::ConsensusHook::on_state_proof(&relay_state_proof); total_weight += consensus_hook_weight; total_weight += Self::maybe_drop_included_ancestors(&relay_state_proof, capacity); // Deposit a log indicating the relay-parent storage root. @@ -656,52 +650,8 @@ pub mod pallet { Ok(()) } - /// Authorize an upgrade to a given `code_hash` for the runtime. The runtime can be supplied - /// later. - /// - /// The `check_version` parameter sets a boolean flag for whether or not the runtime's spec - /// version and name should be verified on upgrade. Since the authorization only has a hash, - /// it cannot actually perform the verification. - /// - /// This call requires Root origin. - #[pallet::call_index(2)] - #[pallet::weight(::SystemWeightInfo::authorize_upgrade())] - #[allow(deprecated)] - #[deprecated( - note = "To be removed after June 2024. Migrate to `frame_system::authorize_upgrade`." - )] - pub fn authorize_upgrade( - origin: OriginFor, - code_hash: T::Hash, - check_version: bool, - ) -> DispatchResult { - ensure_root(origin)?; - frame_system::Pallet::::do_authorize_upgrade(code_hash, check_version); - Ok(()) - } - - /// Provide the preimage (runtime binary) `code` for an upgrade that has been authorized. - /// - /// If the authorization required a version check, this call will ensure the spec name - /// remains unchanged and that the spec version has increased. - /// - /// Note that this function will not apply the new `code`, but only attempt to schedule the - /// upgrade with the Relay Chain. - /// - /// All origins are allowed. - #[pallet::call_index(3)] - #[pallet::weight(::SystemWeightInfo::apply_authorized_upgrade())] - #[allow(deprecated)] - #[deprecated( - note = "To be removed after June 2024. Migrate to `frame_system::apply_authorized_upgrade`." - )] - pub fn enact_authorized_upgrade( - _: OriginFor, - code: Vec, - ) -> DispatchResultWithPostInfo { - let post = frame_system::Pallet::::do_apply_authorize_upgrade(code)?; - Ok(post) - } + // WARNING: call indices 2 and 3 were used in a former version of this pallet. Using them + // again will require to bump the transaction version of runtimes using this pallet. } #[pallet::event] @@ -749,14 +699,13 @@ pub mod pallet { /// The segment length is limited by the capacity returned from the [`ConsensusHook`] configured /// in the pallet. #[pallet::storage] - pub(super) type UnincludedSegment = - StorageValue<_, Vec>, ValueQuery>; + pub type UnincludedSegment = StorageValue<_, Vec>, ValueQuery>; /// Storage field that keeps track of bandwidth used by the unincluded segment along with the /// latest HRMP watermark. Used for limiting the acceptance of new blocks with /// respect to relay chain constraints. #[pallet::storage] - pub(super) type AggregatedUnincludedSegment = + pub type AggregatedUnincludedSegment = StorageValue<_, SegmentTracker, OptionQuery>; /// In case of a scheduled upgrade, this storage field contains the validation code to be @@ -766,7 +715,7 @@ pub mod pallet { /// [`:code`][sp_core::storage::well_known_keys::CODE] which will result the next block process /// with the new validation code. This concludes the upgrade process. #[pallet::storage] - pub(super) type PendingValidationCode = StorageValue<_, Vec, ValueQuery>; + pub type PendingValidationCode = StorageValue<_, Vec, ValueQuery>; /// Validation code that is set by the parachain and is to be communicated to collator and /// consequently the relay-chain. @@ -774,23 +723,23 @@ pub mod pallet { /// This will be cleared in `on_initialize` of each new block if no other pallet already set /// the value. #[pallet::storage] - pub(super) type NewValidationCode = StorageValue<_, Vec, OptionQuery>; + pub type NewValidationCode = StorageValue<_, Vec, OptionQuery>; /// The [`PersistedValidationData`] set for this block. /// This value is expected to be set only once per block and it's never stored /// in the trie. #[pallet::storage] - pub(super) type ValidationData = StorageValue<_, PersistedValidationData>; + pub type ValidationData = StorageValue<_, PersistedValidationData>; /// Were the validation data set to notify the relay chain? #[pallet::storage] - pub(super) type DidSetValidationCode = StorageValue<_, bool, ValueQuery>; + pub type DidSetValidationCode = StorageValue<_, bool, ValueQuery>; /// The relay chain block number associated with the last parachain block. /// /// This is updated in `on_finalize`. #[pallet::storage] - pub(super) type LastRelayChainBlockNumber = + pub type LastRelayChainBlockNumber = StorageValue<_, RelayChainBlockNumber, ValueQuery>; /// An option which indicates if the relay-chain restricts signalling a validation code upgrade. @@ -801,7 +750,7 @@ pub mod pallet { /// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is /// set after the inherent. #[pallet::storage] - pub(super) type UpgradeRestrictionSignal = + pub type UpgradeRestrictionSignal = StorageValue<_, Option, ValueQuery>; /// Optional upgrade go-ahead signal from the relay-chain. @@ -810,7 +759,7 @@ pub mod pallet { /// relay-chain. This value is ephemeral which means it doesn't hit the storage. This value is /// set after the inherent. #[pallet::storage] - pub(super) type UpgradeGoAhead = + pub type UpgradeGoAhead = StorageValue<_, Option, ValueQuery>; /// The state proof for the last relay parent block. @@ -820,7 +769,7 @@ pub mod pallet { /// /// This data is also absent from the genesis. #[pallet::storage] - pub(super) type RelayStateProof = StorageValue<_, sp_trie::StorageProof>; + pub type RelayStateProof = StorageValue<_, sp_trie::StorageProof>; /// The snapshot of some state related to messaging relevant to the current parachain as per /// the relay parent. @@ -830,7 +779,7 @@ pub mod pallet { /// /// This data is also absent from the genesis. #[pallet::storage] - pub(super) type RelevantMessagingState = StorageValue<_, MessagingStateSnapshot>; + pub type RelevantMessagingState = StorageValue<_, MessagingStateSnapshot>; /// The parachain host configuration that was obtained from the relay parent. /// @@ -840,53 +789,51 @@ pub mod pallet { /// This data is also absent from the genesis. #[pallet::storage] #[pallet::disable_try_decode_storage] - pub(super) type HostConfiguration = StorageValue<_, AbridgedHostConfiguration>; + pub type HostConfiguration = StorageValue<_, AbridgedHostConfiguration>; /// The last downward message queue chain head we have observed. /// /// This value is loaded before and saved after processing inbound downward messages carried /// by the system inherent. #[pallet::storage] - pub(super) type LastDmqMqcHead = StorageValue<_, MessageQueueChain, ValueQuery>; + pub type LastDmqMqcHead = StorageValue<_, MessageQueueChain, ValueQuery>; /// The message queue chain heads we have observed per each channel incoming channel. /// /// This value is loaded before and saved after processing inbound downward messages carried /// by the system inherent. #[pallet::storage] - pub(super) type LastHrmpMqcHeads = + pub type LastHrmpMqcHeads = StorageValue<_, BTreeMap, ValueQuery>; /// Number of downward messages processed in a block. /// /// This will be cleared in `on_initialize` of each new block. #[pallet::storage] - pub(super) type ProcessedDownwardMessages = StorageValue<_, u32, ValueQuery>; + pub type ProcessedDownwardMessages = StorageValue<_, u32, ValueQuery>; /// HRMP watermark that was set in a block. /// /// This will be cleared in `on_initialize` of each new block. #[pallet::storage] - pub(super) type HrmpWatermark = - StorageValue<_, relay_chain::BlockNumber, ValueQuery>; + pub type HrmpWatermark = StorageValue<_, relay_chain::BlockNumber, ValueQuery>; /// HRMP messages that were sent in a block. /// /// This will be cleared in `on_initialize` of each new block. #[pallet::storage] - pub(super) type HrmpOutboundMessages = + pub type HrmpOutboundMessages = StorageValue<_, Vec, ValueQuery>; /// Upward messages that were sent in a block. /// /// This will be cleared in `on_initialize` of each new block. #[pallet::storage] - pub(super) type UpwardMessages = StorageValue<_, Vec, ValueQuery>; + pub type UpwardMessages = StorageValue<_, Vec, ValueQuery>; /// Upward messages that are still pending and not yet send to the relay chain. #[pallet::storage] - pub(super) type PendingUpwardMessages = - StorageValue<_, Vec, ValueQuery>; + pub type PendingUpwardMessages = StorageValue<_, Vec, ValueQuery>; /// Initialization value for the delivery fee factor for UMP. #[pallet::type_value] @@ -896,29 +843,29 @@ pub mod pallet { /// The factor to multiply the base delivery fee by for UMP. #[pallet::storage] - pub(super) type UpwardDeliveryFeeFactor = + pub type UpwardDeliveryFeeFactor = StorageValue<_, FixedU128, ValueQuery, UpwardInitialDeliveryFeeFactor>; /// The number of HRMP messages we observed in `on_initialize` and thus used that number for /// announcing the weight of `on_initialize` and `on_finalize`. #[pallet::storage] - pub(super) type AnnouncedHrmpMessagesPerCandidate = StorageValue<_, u32, ValueQuery>; + pub type AnnouncedHrmpMessagesPerCandidate = StorageValue<_, u32, ValueQuery>; /// The weight we reserve at the beginning of the block for processing XCMP messages. This /// overrides the amount set in the Config trait. #[pallet::storage] - pub(super) type ReservedXcmpWeightOverride = StorageValue<_, Weight>; + pub type ReservedXcmpWeightOverride = StorageValue<_, Weight>; /// The weight we reserve at the beginning of the block for processing DMP messages. This /// overrides the amount set in the Config trait. #[pallet::storage] - pub(super) type ReservedDmpWeightOverride = StorageValue<_, Weight>; + pub type ReservedDmpWeightOverride = StorageValue<_, Weight>; /// A custom head data that should be returned as result of `validate_block`. /// /// See `Pallet::set_custom_validation_head_data` for more information. #[pallet::storage] - pub(super) type CustomValidationHeadData = StorageValue<_, Vec, OptionQuery>; + pub type CustomValidationHeadData = StorageValue<_, Vec, OptionQuery>; #[pallet::inherent] impl ProvideInherent for Pallet { @@ -947,7 +894,7 @@ pub mod pallet { #[derive(frame_support::DefaultNoBound)] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, } #[pallet::genesis_build] @@ -957,30 +904,6 @@ pub mod pallet { sp_io::storage::set(b":c", &[]); } } - - #[pallet::validate_unsigned] - impl sp_runtime::traits::ValidateUnsigned for Pallet { - type Call = Call; - - fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity { - if let Call::enact_authorized_upgrade { ref code } = call { - if let Ok(hash) = frame_system::Pallet::::validate_authorized_upgrade(&code[..]) - { - return Ok(ValidTransaction { - priority: 100, - requires: Vec::new(), - provides: vec![hash.as_ref().to_vec()], - longevity: TransactionLongevity::max_value(), - propagate: true, - }) - } - } - if let Call::set_validation_data { .. } = call { - return Ok(Default::default()) - } - Err(InvalidTransaction::Call.into()) - } - } } impl Pallet { @@ -1022,6 +945,13 @@ impl FeeTracker for Pallet { } } +impl ListChannelInfos for Pallet { + fn outgoing_channels() -> Vec { + let Some(state) = RelevantMessagingState::::get() else { return Vec::new() }; + state.egress_channels.into_iter().map(|(id, _)| id).collect() + } +} + impl GetChannelInfo for Pallet { fn get_channel_status(id: ParaId) -> ChannelStatus { // Note, that we are using `relevant_messaging_state` which may be from the previous @@ -1532,7 +1462,7 @@ impl Pallet { } /// Type that implements `SetCode`. -pub struct ParachainSetCode(sp_std::marker::PhantomData); +pub struct ParachainSetCode(core::marker::PhantomData); impl frame_system::SetCode for ParachainSetCode { fn set_code(code: Vec) -> DispatchResult { Pallet::::schedule_code_upgrade(code) @@ -1632,10 +1562,8 @@ impl polkadot_runtime_common::xcm_sender::EnsureForParachain for Pall } /// Something that can check the inherents of a block. -#[cfg_attr( - feature = "parameterized-consensus-hook", - deprecated = "consider switching to `cumulus-pallet-parachain-system::ConsensusHook`" -)] +#[deprecated(note = "This trait is deprecated and will be removed by September 2024. \ + Consider switching to `cumulus-pallet-parachain-system::ConsensusHook`")] pub trait CheckInherents { /// Check all inherents of the block. /// @@ -1649,7 +1577,7 @@ pub trait CheckInherents { /// Struct that always returns `Ok` on inherents check, needed for backwards-compatibility. #[doc(hidden)] -pub struct DummyCheckInherents(sp_std::marker::PhantomData); +pub struct DummyCheckInherents(core::marker::PhantomData); #[allow(deprecated)] impl CheckInherents for DummyCheckInherents { @@ -1722,7 +1650,7 @@ pub type RelaychainBlockNumberProvider = RelaychainDataProvider; /// of [`RelayChainState`]. /// - [`current_block_number`](Self::current_block_number): Will return /// [`Pallet::last_relay_block_number()`]. -pub struct RelaychainDataProvider(sp_std::marker::PhantomData); +pub struct RelaychainDataProvider(core::marker::PhantomData); impl BlockNumberProvider for RelaychainDataProvider { type BlockNumber = relay_chain::BlockNumber; diff --git a/cumulus/pallets/parachain-system/src/mock.rs b/cumulus/pallets/parachain-system/src/mock.rs index fe89dfe68c67e4b5d9f9e046dcf2a780a292da0a..b4d118aadf04dc4dcda50cec41362de65820e4db 100644 --- a/cumulus/pallets/parachain-system/src/mock.rs +++ b/cumulus/pallets/parachain-system/src/mock.rs @@ -20,7 +20,9 @@ use super::*; +use alloc::collections::vec_deque::VecDeque; use codec::Encode; +use core::num::NonZeroU32; use cumulus_primitives_core::{ relay_chain::BlockNumber as RelayBlockNumber, AggregateMessageOrigin, InboundDownwardMessage, InboundHrmpMessage, PersistedValidationData, @@ -37,7 +39,6 @@ use frame_support::{ }; use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin}; use sp_runtime::{traits::BlakeTwo256, BuildStorage}; -use sp_std::{collections::vec_deque::VecDeque, num::NonZeroU32}; use sp_version::RuntimeVersion; use std::cell::RefCell; @@ -48,14 +49,13 @@ type Block = frame_system::mocking::MockBlock; frame_support::construct_runtime!( pub enum Test { - System: frame_system::{Pallet, Call, Config, Storage, Event}, - ParachainSystem: parachain_system::{Pallet, Call, Config, Storage, Inherent, Event, ValidateUnsigned}, - MessageQueue: pallet_message_queue::{Pallet, Call, Storage, Event}, + System: frame_system, + ParachainSystem: parachain_system, + MessageQueue: pallet_message_queue, } ); parameter_types! { - pub const BlockHashCount: u64 = 250; pub Version: RuntimeVersion = RuntimeVersion { spec_name: sp_version::create_runtime_str!("test"), impl_name: sp_version::create_runtime_str!("system-test"), @@ -74,7 +74,6 @@ parameter_types! { #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type Block = Block; - type BlockHashCount = BlockHashCount; type Version = Version; type OnSetCode = ParachainSetCode; } @@ -122,7 +121,7 @@ impl pallet_message_queue::Config for Test { type Size = u32; type QueueChangeHandler = (); type QueuePausedQuery = (); - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MaxWeight; type IdleMaxServiceWeight = (); diff --git a/cumulus/pallets/parachain-system/src/relay_state_snapshot.rs b/cumulus/pallets/parachain-system/src/relay_state_snapshot.rs index 60eccfb072f41e87223d54f34b5c7eb59c00b2ad..323aaf6503808c954300e27179aa16bc531047c9 100644 --- a/cumulus/pallets/parachain-system/src/relay_state_snapshot.rs +++ b/cumulus/pallets/parachain-system/src/relay_state_snapshot.rs @@ -16,6 +16,7 @@ //! Relay chain state proof provides means for accessing part of relay chain storage for reads. +use alloc::vec::Vec; use codec::{Decode, Encode}; use cumulus_primitives_core::{ relay_chain, AbridgedHostConfiguration, AbridgedHrmpChannel, ParaId, @@ -23,7 +24,6 @@ use cumulus_primitives_core::{ use scale_info::TypeInfo; use sp_runtime::traits::HashingFor; use sp_state_machine::{Backend, TrieBackend, TrieBackendBuilder}; -use sp_std::vec::Vec; use sp_trie::{HashDBT, MemoryDB, StorageProof, EMPTY_PREFIX}; /// The capacity of the upward message queue of a parachain on the relay chain. diff --git a/cumulus/pallets/parachain-system/src/tests.rs b/cumulus/pallets/parachain-system/src/tests.rs index 5ff15036fb6e48b5e1a0567730b1f9035357edc2..548231966e420f2c8a00642042657257e20f085d 100755 --- a/cumulus/pallets/parachain-system/src/tests.rs +++ b/cumulus/pallets/parachain-system/src/tests.rs @@ -19,6 +19,7 @@ use super::*; use crate::mock::*; +use core::num::NonZeroU32; use cumulus_primitives_core::{AbridgedHrmpChannel, InboundDownwardMessage, InboundHrmpMessage}; use frame_support::{assert_ok, parameter_types, weights::Weight}; use frame_system::RawOrigin; @@ -26,7 +27,6 @@ use hex_literal::hex; use rand::Rng; use relay_chain::HrmpChannelId; use sp_core::H256; -use sp_std::num::NonZeroU32; #[test] #[should_panic] @@ -1127,10 +1127,8 @@ fn upgrade_version_checks_should_work() { let new_code = vec![1, 2, 3, 4]; let new_code_hash = H256(sp_crypto_hashing::blake2_256(&new_code)); - #[allow(deprecated)] - let _authorize = ParachainSystem::authorize_upgrade(RawOrigin::Root.into(), new_code_hash, true); - #[allow(deprecated)] - let res = ParachainSystem::enact_authorized_upgrade(RawOrigin::None.into(), new_code); + let _authorize = System::authorize_upgrade(RawOrigin::Root.into(), new_code_hash); + let res = System::apply_authorized_upgrade(RawOrigin::None.into(), new_code); assert_eq!(expected.map_err(DispatchErrorWithPostInfo::from), res); }); diff --git a/cumulus/pallets/parachain-system/src/unincluded_segment.rs b/cumulus/pallets/parachain-system/src/unincluded_segment.rs index 1e83a945c4ee37f2ad8ee1c45d11892f47c40be4..814bb83aa1acb0541c9cf73ead07e3e3cca84680 100644 --- a/cumulus/pallets/parachain-system/src/unincluded_segment.rs +++ b/cumulus/pallets/parachain-system/src/unincluded_segment.rs @@ -21,11 +21,12 @@ //! sent to relay chain. use super::relay_state_snapshot::{MessagingStateSnapshot, RelayDispatchQueueRemainingCapacity}; +use alloc::collections::btree_map::BTreeMap; use codec::{Decode, Encode}; +use core::marker::PhantomData; use cumulus_primitives_core::{relay_chain, ParaId}; use scale_info::TypeInfo; use sp_runtime::RuntimeDebug; -use sp_std::{collections::btree_map::BTreeMap, marker::PhantomData}; /// Constraints on outbound HRMP channel. #[derive(Clone, RuntimeDebug)] @@ -398,6 +399,7 @@ pub(crate) fn size_after_included(included_hash: H, segment: &[Anc #[cfg(test)] mod tests { use super::*; + use alloc::{vec, vec::Vec}; use assert_matches::assert_matches; #[test] diff --git a/cumulus/pallets/parachain-system/src/validate_block/implementation.rs b/cumulus/pallets/parachain-system/src/validate_block/implementation.rs index ecab7a9a09311ae0f952a7842e9f1826b00adc69..42311ca9d8340d038df126175df096777cf989a9 100644 --- a/cumulus/pallets/parachain-system/src/validate_block/implementation.rs +++ b/cumulus/pallets/parachain-system/src/validate_block/implementation.rs @@ -26,6 +26,7 @@ use polkadot_parachain_primitives::primitives::{ HeadData, RelayChainBlockNumber, ValidationResult, }; +use alloc::vec::Vec; use codec::Encode; use frame_support::traits::{ExecuteBlock, ExtrinsicCall, Get, IsSubType}; @@ -33,7 +34,6 @@ use sp_core::storage::{ChildInfo, StateVersion}; use sp_externalities::{set_and_run_with_externalities, Externalities}; use sp_io::KillStorageResult; use sp_runtime::traits::{Block as BlockT, Extrinsic, HashingFor, Header as HeaderT}; -use sp_std::prelude::*; use sp_trie::{MemoryDB, ProofSizeProvider}; use trie_recorder::SizeOnlyRecorderProvider; @@ -80,6 +80,7 @@ environmental::environmental!(recorder: trait ProofSizeProvider); /// ensuring that the final storage root matches the storage root in the header of the block. In the /// end we return back the [`ValidationResult`] with all the required information for the validator. #[doc(hidden)] +#[allow(deprecated)] pub fn validate_block< B: BlockT, E: ExecuteBlock, @@ -123,7 +124,7 @@ where Err(_) => panic!("Compact proof decoding failure."), }; - sp_std::mem::drop(storage_proof); + core::mem::drop(storage_proof); let mut recorder = SizeOnlyRecorderProvider::new(); let cache_provider = trie_cache::CacheProvider::new(); @@ -186,6 +187,7 @@ where ) .expect("Invalid relay chain state proof"); + #[allow(deprecated)] let res = CI::check_inherents(&block, &relay_chain_proof); if !res.ok() { @@ -292,7 +294,7 @@ fn host_storage_read(key: &[u8], value_out: &mut [u8], value_offset: u32) -> Opt Some(value) => { let value_offset = value_offset as usize; let data = &value[value_offset.min(value.len())..]; - let written = sp_std::cmp::min(data.len(), value_out.len()); + let written = core::cmp::min(data.len(), value_out.len()); value_out[..written].copy_from_slice(&data[..written]); Some(value.len() as u32) }, @@ -366,7 +368,7 @@ fn host_default_child_storage_read( Some(value) => { let value_offset = value_offset as usize; let data = &value[value_offset.min(value.len())..]; - let written = sp_std::cmp::min(data.len(), value_out.len()); + let written = core::cmp::min(data.len(), value_out.len()); value_out[..written].copy_from_slice(&data[..written]); Some(value.len() as u32) }, diff --git a/cumulus/pallets/parachain-system/src/validate_block/mod.rs b/cumulus/pallets/parachain-system/src/validate_block/mod.rs index 763a4cffd77f92171c1f102cfc70485a02e5f27e..3a00d4d352a69830ff225221d2fb63450c96b9e9 100644 --- a/cumulus/pallets/parachain-system/src/validate_block/mod.rs +++ b/cumulus/pallets/parachain-system/src/validate_block/mod.rs @@ -30,6 +30,9 @@ mod trie_cache; #[doc(hidden)] mod trie_recorder; +#[cfg(not(feature = "std"))] +#[doc(hidden)] +pub use alloc::{boxed::Box, slice}; #[cfg(not(feature = "std"))] #[doc(hidden)] pub use bytes; diff --git a/cumulus/pallets/parachain-system/src/validate_block/tests.rs b/cumulus/pallets/parachain-system/src/validate_block/tests.rs index 1527492f57848b30a52984ba1156eb5b877268a8..a44d17507810099004113ce3ca30739c8ee3ddce 100644 --- a/cumulus/pallets/parachain-system/src/validate_block/tests.rs +++ b/cumulus/pallets/parachain-system/src/validate_block/tests.rs @@ -312,7 +312,7 @@ fn validation_params_and_memory_optimized_validation_params_encode_and_decode() fn validate_block_works_with_child_tries() { sp_tracing::try_init_simple(); - let (mut client, parent_head) = create_test_client(); + let (client, parent_head) = create_test_client(); let TestBlockData { block, .. } = build_block_with_witness( &client, vec![generate_extrinsic(&client, Charlie, TestPalletCall::read_and_write_child_tries {})], diff --git a/cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs b/cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs index 5d785910fbe026fba487980d1244262146f86a5b..5999b3ce87f9d285412ea8bccdf1258ae1f66733 100644 --- a/cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs +++ b/cumulus/pallets/parachain-system/src/validate_block/trie_cache.rs @@ -15,12 +15,12 @@ // See the License for the specific language governing permissions and // limitations under the License. -use sp_state_machine::TrieCacheProvider; -use sp_std::{ +use alloc::{ boxed::Box, - cell::{RefCell, RefMut}, collections::btree_map::{BTreeMap, Entry}, }; +use core::cell::{RefCell, RefMut}; +use sp_state_machine::TrieCacheProvider; use sp_trie::NodeCodec; use trie_db::{node::NodeOwned, Hasher}; diff --git a/cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs b/cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs index 48310670c074d1be2ec86f582c0c84622abc086c..19801340719526ac6775a9a92fc0b3d879f84afb 100644 --- a/cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs +++ b/cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs @@ -22,11 +22,11 @@ use codec::Encode; -use sp_std::{ - cell::{RefCell, RefMut}, +use alloc::{ collections::{btree_map::BTreeMap, btree_set::BTreeSet}, rc::Rc, }; +use core::cell::{RefCell, RefMut}; use sp_trie::{NodeCodec, ProofSizeProvider, StorageProof}; use trie_db::{Hasher, RecordedForKey, TrieAccess}; diff --git a/cumulus/pallets/parachain-system/src/weights.rs b/cumulus/pallets/parachain-system/src/weights.rs index da7f64237e9b6a8b39096b761f6ff923f903529a..5c61879b4d36b903f9f9d81cde76ff3ce42cc747 100644 --- a/cumulus/pallets/parachain-system/src/weights.rs +++ b/cumulus/pallets/parachain-system/src/weights.rs @@ -50,7 +50,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions needed for cumulus_pallet_parachain_system. pub trait WeightInfo { diff --git a/cumulus/pallets/session-benchmarking/Cargo.toml b/cumulus/pallets/session-benchmarking/Cargo.toml index 43fde4ea6009cce7d2dedceb815e2948beb80196..5af94434e0afeacec3866f8f531f6afe1f88ee64 100644 --- a/cumulus/pallets/session-benchmarking/Cargo.toml +++ b/cumulus/pallets/session-benchmarking/Cargo.toml @@ -4,7 +4,7 @@ version = "9.0.0" authors.workspace = true edition.workspace = true license = "Apache-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "FRAME sessions pallet benchmarking" readme = "README.md" @@ -16,13 +16,12 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -parity-scale-codec = { version = "3.6.4", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } +codec = { workspace = true } +sp-runtime = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-benchmarking = { optional = true, workspace = true } +pallet-session = { workspace = true } [features] default = ["std"] @@ -33,11 +32,10 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", ] std = [ + "codec/std", "frame-benchmarking/std", "frame-support/std", "frame-system/std", "pallet-session/std", - "parity-scale-codec/std", "sp-runtime/std", - "sp-std/std", ] diff --git a/cumulus/pallets/session-benchmarking/src/inner.rs b/cumulus/pallets/session-benchmarking/src/inner.rs index cffd0776f3d99c99525d12e0392bdf177b246bd5..8d5954304878dfd5ff4c4bf912168d70e4e5e53f 100644 --- a/cumulus/pallets/session-benchmarking/src/inner.rs +++ b/cumulus/pallets/session-benchmarking/src/inner.rs @@ -15,12 +15,12 @@ //! Benchmarking setup for pallet-session. -use sp_std::{prelude::*, vec}; +use alloc::{vec, vec::Vec}; +use codec::Decode; use frame_benchmarking::{benchmarks, whitelisted_caller}; use frame_system::RawOrigin; use pallet_session::*; -use parity_scale_codec::Decode; pub struct Pallet(pallet_session::Pallet); pub trait Config: pallet_session::Config {} diff --git a/cumulus/pallets/session-benchmarking/src/lib.rs b/cumulus/pallets/session-benchmarking/src/lib.rs index a95d6fb7d591460f2055f076f60199b213b055b8..f5bfef006169035797d17957beb574200fd153ab 100644 --- a/cumulus/pallets/session-benchmarking/src/lib.rs +++ b/cumulus/pallets/session-benchmarking/src/lib.rs @@ -20,6 +20,8 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + #[cfg(feature = "runtime-benchmarks")] pub mod inner; diff --git a/cumulus/pallets/solo-to-para/Cargo.toml b/cumulus/pallets/solo-to-para/Cargo.toml index 417038d7833c5ca4ec4acf681cba73d24ab45c5e..5fd1939e93a03397dda15bae0eb638f823cbb1ce 100644 --- a/cumulus/pallets/solo-to-para/Cargo.toml +++ b/cumulus/pallets/solo-to-para/Cargo.toml @@ -10,21 +10,20 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -pallet-sudo = { path = "../../../substrate/frame/sudo", 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 } +pallet-sudo = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false } +polkadot-primitives = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../parachain-system", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } [features] default = ["std"] @@ -37,7 +36,6 @@ std = [ "polkadot-primitives/std", "scale-info/std", "sp-runtime/std", - "sp-std/std", ] try-runtime = [ "cumulus-pallet-parachain-system/try-runtime", diff --git a/cumulus/pallets/solo-to-para/src/lib.rs b/cumulus/pallets/solo-to-para/src/lib.rs index da948615d4e90a5f109cb56b47f796acead6535c..b42cc74f1cf32220f7767f829cd4a65c9e2e0532 100644 --- a/cumulus/pallets/solo-to-para/src/lib.rs +++ b/cumulus/pallets/solo-to-para/src/lib.rs @@ -16,12 +16,14 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::vec::Vec; use cumulus_pallet_parachain_system as parachain_system; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; pub use pallet::*; use polkadot_primitives::PersistedValidationData; -use sp_std::vec::Vec; #[frame_support::pallet] pub mod pallet { diff --git a/cumulus/pallets/xcm/Cargo.toml b/cumulus/pallets/xcm/Cargo.toml index 9122e110fb92e51b0f85e3ba4136d30178d8ab7a..35d7a083b061d204de339407c6e26c4ef948dbb8 100644 --- a/cumulus/pallets/xcm/Cargo.toml +++ b/cumulus/pallets/xcm/Cargo.toml @@ -10,18 +10,17 @@ description = "Pallet for stuff specific to parachains' usage of XCM" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] @@ -33,7 +32,6 @@ std = [ "scale-info/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm/std", ] try-runtime = [ diff --git a/cumulus/pallets/xcm/src/lib.rs b/cumulus/pallets/xcm/src/lib.rs index 90a0ec76defe2b0df8d99faacfb611c0f7834a3b..e31df8471c26698d115d798bfc9358dbc4a1b982 100644 --- a/cumulus/pallets/xcm/src/lib.rs +++ b/cumulus/pallets/xcm/src/lib.rs @@ -25,7 +25,6 @@ use cumulus_primitives_core::ParaId; pub use pallet::*; use scale_info::TypeInfo; use sp_runtime::{traits::BadOrigin, RuntimeDebug}; -use sp_std::prelude::*; use xcm::latest::{ExecuteXcm, Outcome}; #[frame_support::pallet] diff --git a/cumulus/pallets/xcmp-queue/Cargo.toml b/cumulus/pallets/xcmp-queue/Cargo.toml index e3530ef7bf0e1e093ddb85e639a7a3ff757ad2da..9c7470eda6da4aeaba942c25f04f4aeb13ee471e 100644 --- a/cumulus/pallets/xcmp-queue/Cargo.toml +++ b/cumulus/pallets/xcmp-queue/Cargo.toml @@ -10,45 +10,44 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"], default-features = false } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", 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 } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-io = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +pallet-message-queue = { workspace = true } # Polkadot -polkadot-runtime-common = { path = "../../../polkadot/runtime/common", default-features = false } -polkadot-runtime-parachains = { path = "../../../polkadot/runtime/parachains", default-features = false } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm/xcm-executor", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder", default-features = false } +polkadot-runtime-common = { workspace = true } +polkadot-runtime-parachains = { workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-builder = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } # Optional import for benchmarking -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -bounded-collections = { version = "0.2.0", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +bounded-collections = { workspace = true } # Bridges -bp-xcm-bridge-hub-router = { path = "../../../bridges/primitives/xcm-bridge-hub-router", default-features = false, optional = true } +bp-xcm-bridge-hub-router = { optional = true, workspace = true } [dev-dependencies] # Substrate -sp-core = { path = "../../../substrate/primitives/core" } -pallet-balances = { path = "../../../substrate/frame/balances" } -frame-support = { path = "../../../substrate/frame/support", features = ["experimental"] } +sp-core = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +frame-support = { features = ["experimental"], workspace = true, default-features = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../parachain-system", features = ["parameterized-consensus-hook"] } +cumulus-pallet-parachain-system = { workspace = true, default-features = true } [features] default = ["std"] @@ -68,7 +67,6 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", diff --git a/cumulus/pallets/xcmp-queue/src/benchmarking.rs b/cumulus/pallets/xcmp-queue/src/benchmarking.rs index 49e2cc8367348ad6a81c0017405f8c3148734be5..9cb1301addfe5c9bb29c1b034c76793b6eaeda64 100644 --- a/cumulus/pallets/xcmp-queue/src/benchmarking.rs +++ b/cumulus/pallets/xcmp-queue/src/benchmarking.rs @@ -17,6 +17,7 @@ use crate::*; +use alloc::vec; use codec::DecodeAll; use frame_benchmarking::v2::*; use frame_support::traits::Hooks; diff --git a/cumulus/pallets/xcmp-queue/src/bridging.rs b/cumulus/pallets/xcmp-queue/src/bridging.rs index 9db4b6e74c3987ae08a6d38eb75ffcacb9e5e713..eff4a37b0cef7033c15f2629e54fb7763a35a975 100644 --- a/cumulus/pallets/xcmp-queue/src/bridging.rs +++ b/cumulus/pallets/xcmp-queue/src/bridging.rs @@ -21,7 +21,7 @@ use frame_support::pallet_prelude::Get; /// both `OutboundXcmpStatus` and `InboundXcmpStatus` for defined `ParaId` if any of those is /// suspended. pub struct InAndOutXcmpChannelStatusProvider( - sp_std::marker::PhantomData<(SiblingBridgeHubParaId, Runtime)>, + core::marker::PhantomData<(SiblingBridgeHubParaId, Runtime)>, ); impl, Runtime: crate::Config> bp_xcm_bridge_hub_router::XcmChannelStatusProvider @@ -45,7 +45,7 @@ impl, Runtime: crate::Config> /// Adapter implementation for `bp_xcm_bridge_hub_router::XcmChannelStatusProvider` which checks /// only `OutboundXcmpStatus` for defined `SiblingParaId` if is suspended. pub struct OutXcmpChannelStatusProvider( - sp_std::marker::PhantomData<(SiblingBridgeHubParaId, Runtime)>, + core::marker::PhantomData<(SiblingBridgeHubParaId, Runtime)>, ); impl, Runtime: crate::Config> bp_xcm_bridge_hub_router::XcmChannelStatusProvider diff --git a/cumulus/pallets/xcmp-queue/src/lib.rs b/cumulus/pallets/xcmp-queue/src/lib.rs index cc785b66150e52731cdb03d2c41aaad0058d3ef9..8c4446a925d4da281d11f09c9e3e3e3b4feb6697 100644 --- a/cumulus/pallets/xcmp-queue/src/lib.rs +++ b/cumulus/pallets/xcmp-queue/src/lib.rs @@ -50,8 +50,11 @@ pub mod bridging; pub mod weights; pub use weights::WeightInfo; +extern crate alloc; + +use alloc::vec::Vec; use bounded_collections::BoundedBTreeSet; -use codec::{Decode, DecodeLimit, Encode}; +use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen}; use cumulus_primitives_core::{ relay_chain::BlockNumber as RelayBlockNumber, ChannelStatus, GetChannelInfo, MessageSendError, ParaId, XcmpMessageFormat, XcmpMessageHandler, XcmpMessageSource, @@ -59,7 +62,7 @@ use cumulus_primitives_core::{ use frame_support::{ defensive, defensive_assert, - traits::{EnqueueMessage, EnsureOrigin, Get, QueueFootprint, QueuePausedQuery}, + traits::{Defensive, EnqueueMessage, EnsureOrigin, Get, QueueFootprint, QueuePausedQuery}, weights::{Weight, WeightMeter}, BoundedVec, }; @@ -68,8 +71,7 @@ use polkadot_runtime_common::xcm_sender::PriceForMessageDelivery; use polkadot_runtime_parachains::FeeTracker; use scale_info::TypeInfo; use sp_core::MAX_POSSIBLE_ALLOCATION; -use sp_runtime::{FixedU128, RuntimeDebug, Saturating}; -use sp_std::prelude::*; +use sp_runtime::{FixedU128, RuntimeDebug, Saturating, WeakBoundedVec}; use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm, WrapVersion, MAX_XCM_DECODE_DEPTH}; use xcm_builder::InspectMessageQueues; use xcm_executor::traits::ConvertOrigin; @@ -106,7 +108,6 @@ pub mod pallet { #[pallet::pallet] #[pallet::storage_version(migration::STORAGE_VERSION)] - #[pallet::without_storage_info] pub struct Pallet(_); #[pallet::config] @@ -133,6 +134,25 @@ pub mod pallet { #[pallet::constant] type MaxInboundSuspended: Get; + /// Maximal number of outbound XCMP channels that can have messages queued at the same time. + /// + /// If this is reached, then no further messages can be sent to channels that do not yet + /// have a message queued. This should be set to the expected maximum of outbound channels + /// which is determined by [`Self::ChannelInfo`]. It is important to set this large enough, + /// since otherwise the congestion control protocol will not work as intended and messages + /// may be dropped. This value increases the PoV and should therefore not be picked too + /// high. Governance needs to pay attention to not open more channels than this value. + #[pallet::constant] + type MaxActiveOutboundChannels: Get; + + /// The maximal page size for HRMP message pages. + /// + /// A lower limit can be set dynamically, but this is the hard-limit for the PoV worst case + /// benchmarking. The limit for the size of a message is slightly below this, since some + /// overhead is incurred for encoding the format. + #[pallet::constant] + type MaxPageSize: Get; + /// The origin that is allowed to resume or suspend the XCMP queue. type ControllerOrigin: EnsureOrigin; @@ -277,6 +297,10 @@ pub mod pallet { AlreadySuspended, /// The execution is already resumed. AlreadyResumed, + /// There are too many active outbound channels. + TooManyActiveOutboundChannels, + /// The message is too big. + TooBig, } /// The suspended inbound XCMP channels. All others are not suspended. @@ -298,19 +322,28 @@ pub mod pallet { /// case of the need to send a high-priority signal message this block. /// The bool is true if there is a signal message waiting to be sent. #[pallet::storage] - pub(super) type OutboundXcmpStatus = - StorageValue<_, Vec, ValueQuery>; + pub(super) type OutboundXcmpStatus = StorageValue< + _, + BoundedVec, + ValueQuery, + >; - // The new way of doing it: /// The messages outbound in a given XCMP channel. #[pallet::storage] - pub(super) type OutboundXcmpMessages = - StorageDoubleMap<_, Blake2_128Concat, ParaId, Twox64Concat, u16, Vec, ValueQuery>; + pub(super) type OutboundXcmpMessages = StorageDoubleMap< + _, + Blake2_128Concat, + ParaId, + Twox64Concat, + u16, + WeakBoundedVec, + ValueQuery, + >; /// Any signal messages waiting to be sent. #[pallet::storage] pub(super) type SignalMessages = - StorageMap<_, Blake2_128Concat, ParaId, Vec, ValueQuery>; + StorageMap<_, Blake2_128Concat, ParaId, WeakBoundedVec, ValueQuery>; /// The configuration which controls the dynamics of the outbound queue. #[pallet::storage] @@ -332,15 +365,14 @@ pub mod pallet { StorageMap<_, Twox64Concat, ParaId, FixedU128, ValueQuery, InitialFactor>; } -#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] pub enum OutboundState { Ok, Suspended, } /// Struct containing detailed information about the outbound channel. -#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo)] -#[cfg_attr(feature = "std", derive(Debug))] +#[derive(Clone, Eq, PartialEq, Encode, Decode, TypeInfo, RuntimeDebug, MaxEncodedLen)] pub struct OutboundChannelDetails { /// The `ParaId` of the parachain that this channel is connected with. recipient: ParaId, @@ -376,7 +408,7 @@ impl OutboundChannelDetails { } } -#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo)] +#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug, TypeInfo, MaxEncodedLen)] pub struct QueueConfigData { /// The number of pages which must be in the queue for the other side to be told to suspend /// their sending. @@ -461,7 +493,7 @@ impl Pallet { let channel_info = T::ChannelInfo::get_channel_info(recipient).ok_or(MessageSendError::NoChannel)?; // Max message size refers to aggregates, or pages. Not to individual fragments. - let max_message_size = channel_info.max_message_size as usize; + let max_message_size = channel_info.max_message_size.min(T::MaxPageSize::get()) as usize; let format_size = format.encoded_size(); // We check the encoded fragment length plus the format size against the max message size // because the format is concatenated if a new page is needed. @@ -479,7 +511,10 @@ impl Pallet { { details } else { - all_channels.push(OutboundChannelDetails::new(recipient)); + all_channels.try_push(OutboundChannelDetails::new(recipient)).map_err(|e| { + log::error!("Failed to activate HRMP channel: {:?}", e); + MessageSendError::TooManyChannels + })?; all_channels .last_mut() .expect("can't be empty; a new element was just pushed; qed") @@ -489,7 +524,7 @@ impl Pallet { // We return the size of the last page inside of the option, to not calculate it again. let appended_to_last_page = have_active .then(|| { - >::mutate( + >::try_mutate( recipient, channel_details.last_index - 1, |page| { @@ -499,15 +534,18 @@ impl Pallet { ) != Ok(format) { defensive!("Bad format in outbound queue; dropping message"); - return None + return Err(()) } if page.len() + encoded_fragment.len() > max_message_size { - return None + return Err(()) + } + for frag in encoded_fragment.iter() { + page.try_push(*frag)?; } - page.extend_from_slice(&encoded_fragment[..]); - Some(page.len()) + Ok(page.len()) }, ) + .ok() }) .flatten(); @@ -522,7 +560,10 @@ impl Pallet { new_page.extend_from_slice(&encoded_fragment[..]); let last_page_size = new_page.len(); let number_of_pages = (channel_details.last_index - channel_details.first_index) as u32; - >::insert(recipient, page_index, new_page); + let bounded_page = BoundedVec::::try_from(new_page) + .map_err(|_| MessageSendError::TooBig)?; + let bounded_page = WeakBoundedVec::force_from(bounded_page.into_inner(), None); + >::insert(recipient, page_index, bounded_page); >::put(all_channels); (number_of_pages, last_page_size) }; @@ -544,17 +585,24 @@ impl Pallet { /// Sends a signal to the `dest` chain over XCMP. This is guaranteed to be dispatched on this /// block. - fn send_signal(dest: ParaId, signal: ChannelSignal) { + fn send_signal(dest: ParaId, signal: ChannelSignal) -> Result<(), Error> { let mut s = >::get(); if let Some(details) = s.iter_mut().find(|item| item.recipient == dest) { details.signals_exist = true; } else { - s.push(OutboundChannelDetails::new(dest).with_signals()); + s.try_push(OutboundChannelDetails::new(dest).with_signals()) + .map_err(|_| Error::::TooManyActiveOutboundChannels)?; } - >::mutate(dest, |page| { - *page = (XcmpMessageFormat::Signals, signal).encode(); - }); + + let page = BoundedVec::::try_from( + (XcmpMessageFormat::Signals, signal).encode(), + ) + .map_err(|_| Error::::TooBig)?; + let page = WeakBoundedVec::force_from(page.into_inner(), None); + + >::insert(dest, page); >::put(s); + Ok(()) } fn suspend_channel(target: ParaId) { @@ -564,7 +612,9 @@ impl Pallet { defensive_assert!(ok, "WARNING: Attempt to suspend channel that was not Ok."); details.state = OutboundState::Suspended; } else { - s.push(OutboundChannelDetails::new(target).with_suspended_state()); + if s.try_push(OutboundChannelDetails::new(target).with_suspended_state()).is_err() { + defensive!("Cannot pause channel; too many outbound channels"); + } } }); } @@ -665,18 +715,25 @@ impl OnQueueChanged for Pallet { let suspended = suspended_channels.contains(¶); if suspended && fp.ready_pages <= resume_threshold { - Self::send_signal(para, ChannelSignal::Resume); - - suspended_channels.remove(¶); - >::put(suspended_channels); + if let Err(err) = Self::send_signal(para, ChannelSignal::Resume) { + log::error!("defensive: Could not send resumption signal to inbound channel of sibling {:?}: {:?}; channel remains suspended.", para, err); + } else { + suspended_channels.remove(¶); + >::put(suspended_channels); + } } else if !suspended && fp.ready_pages >= suspend_threshold { log::warn!("XCMP queue for sibling {:?} is full; suspending channel.", para); - Self::send_signal(para, ChannelSignal::Suspend); - if let Err(err) = suspended_channels.try_insert(para) { + if let Err(err) = Self::send_signal(para, ChannelSignal::Suspend) { + // It will retry if `drop_threshold` is not reached, but it could be too late. + log::error!( + "defensive: Could not send suspension signal; future messages may be dropped: {:?}", err + ); + } else if let Err(err) = suspended_channels.try_insert(para) { log::error!("Too many channels suspended; cannot suspend sibling {:?}: {:?}; further messages may be dropped.", para, err); + } else { + >::put(suspended_channels); } - >::put(suspended_channels); } } } @@ -843,7 +900,7 @@ impl XcmpMessageSource for Pallet { // since it's so unlikely then for now we just drop it. defensive!("WARNING: oversize message in queue - dropping"); } else { - result.push((para_id, page)); + result.push((para_id, page.into_inner())); } let max_total_size = match T::ChannelInfo::get_channel_info(para_id) { @@ -891,7 +948,9 @@ impl XcmpMessageSource for Pallet { let pruned = old_statuses_len - statuses.len(); // removing an item from status implies a message being sent, so the result messages must // be no less than the pruned channels. - statuses.rotate_left(result.len().saturating_sub(pruned)); + let _ = statuses.try_rotate_left(result.len().saturating_sub(pruned)).defensive_proof( + "Could not store HRMP channels config. Some HRMP channels may be broken.", + ); >::put(statuses); diff --git a/cumulus/pallets/xcmp-queue/src/migration.rs b/cumulus/pallets/xcmp-queue/src/migration.rs index 1702cd70bc2fb7e09cf15fbe21294bdb76b96ef1..d0657aaea9fd0d1daab6003b9721434c8ea769e1 100644 --- a/cumulus/pallets/xcmp-queue/src/migration.rs +++ b/cumulus/pallets/xcmp-queue/src/migration.rs @@ -16,7 +16,10 @@ //! A module that is responsible for migration of storage. +pub mod v5; + use crate::{Config, OverweightIndex, Pallet, QueueConfig, QueueConfigData, DEFAULT_POV_SIZE}; +use alloc::vec::Vec; use cumulus_primitives_core::XcmpMessageFormat; use frame_support::{ pallet_prelude::*, @@ -25,7 +28,7 @@ use frame_support::{ }; /// The in-code storage version. -pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(4); +pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(5); pub const LOG: &str = "runtime::xcmp-queue-migration"; diff --git a/cumulus/pallets/xcmp-queue/src/migration/v5.rs b/cumulus/pallets/xcmp-queue/src/migration/v5.rs new file mode 100644 index 0000000000000000000000000000000000000000..818365f36f605ea3ddceceeb8654cf11ca690e44 --- /dev/null +++ b/cumulus/pallets/xcmp-queue/src/migration/v5.rs @@ -0,0 +1,109 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Migrates the storage to version 5. + +use crate::*; +use alloc::vec::Vec; +use cumulus_primitives_core::ListChannelInfos; +use frame_support::{pallet_prelude::*, traits::UncheckedOnRuntimeUpgrade}; + +/// Configs needed to run the V5 migration. +pub trait V5Config: Config { + /// List all outbound channels with their target `ParaId` and maximum message size. + type ChannelList: ListChannelInfos; +} + +/// Ensures that the storage migrates cleanly to V5. +/// +/// The migration itself is a no-op, but it checks that none of the `BoundedVec`s would truncate on +/// the next decode after the upgrade was applied. +pub type MigrateV4ToV5 = frame_support::migrations::VersionedMigration< + 4, + 5, + unversioned::UncheckedMigrateV4ToV5, + Pallet, + ::DbWeight, +>; + +// V4 storage aliases +mod v4 { + use super::*; + + #[frame_support::storage_alias] + pub(super) type OutboundXcmpStatus = + StorageValue, Vec, ValueQuery>; + + #[frame_support::storage_alias] + pub(super) type OutboundXcmpMessages = StorageDoubleMap< + Pallet, + Blake2_128Concat, + ParaId, + Twox64Concat, + u16, + Vec, + ValueQuery, + >; + + #[frame_support::storage_alias] + pub(super) type SignalMessages = + StorageMap, Blake2_128Concat, ParaId, Vec, ValueQuery>; +} + +// Private module to hide the migration. +mod unversioned { + /// Please use [`MigrateV4ToV5`] instead. + pub struct UncheckedMigrateV4ToV5(core::marker::PhantomData); +} + +impl UncheckedOnRuntimeUpgrade for unversioned::UncheckedMigrateV4ToV5 { + fn on_runtime_upgrade() -> frame_support::weights::Weight { + Default::default() + } + + #[cfg(feature = "try-runtime")] + fn post_upgrade(_: Vec) -> Result<(), sp_runtime::DispatchError> { + // We dont need any front-run protection for this since channels are opened by governance. + ensure!( + v4::OutboundXcmpStatus::::get().len() as u32 <= T::MaxActiveOutboundChannels::get(), + "Too many outbound channels. Close some channels or increase `MaxActiveOutboundChannels`." + ); + + ensure!(T::MaxPageSize::get() >= 16, "Sanity check failed: MaxPageSize too small"); + + // Check if any channels have a too large message max sizes. + let max_msg_len = T::MaxPageSize::get() - XcmpMessageFormat::max_encoded_len() as u32; + for channel in T::ChannelList::outgoing_channels() { + let info = T::ChannelInfo::get_channel_info(channel) + .expect("All listed channels must provide info"); + + if info.max_message_size > max_msg_len { + log::error!( + "Max message size for channel is too large. This means that the V5 \ + migration can be front-run and an attacker could place a large message just right \ + before the migration to make other messages un-decodable. Please either increase \ + `MaxPageSize` or decrease the `max_message_size` for this channel. Channel max: {}, \ + MaxPageSize: {}", + info.max_message_size, + max_msg_len + ); + return Err("Migration can be front-run".into()); + } + } + + Ok(()) + } +} diff --git a/cumulus/pallets/xcmp-queue/src/mock.rs b/cumulus/pallets/xcmp-queue/src/mock.rs index e258576aa3f6dd0342f712498654ef102fb6f321..348939de1f14613d3c1bb54b1d63d9c7bbf4cec6 100644 --- a/cumulus/pallets/xcmp-queue/src/mock.rs +++ b/cumulus/pallets/xcmp-queue/src/mock.rs @@ -45,14 +45,13 @@ frame_support::construct_runtime!( System: frame_system::{Pallet, Call, Config, Storage, Event}, Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, ParachainSystem: cumulus_pallet_parachain_system::{ - Pallet, Call, Config, Storage, Inherent, Event, ValidateUnsigned, + Pallet, Call, Config, Storage, Inherent, Event, }, XcmpQueue: xcmp_queue::{Pallet, Call, Storage, Event}, } ); parameter_types! { - pub const BlockHashCount: u64 = 250; pub const SS58Prefix: u8 = 42; } @@ -73,7 +72,6 @@ impl frame_system::Config for Test { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -87,25 +85,14 @@ impl frame_system::Config for Test { parameter_types! { pub const ExistentialDeposit: u64 = 5; - pub const MaxReserves: u32 = 50; } pub type Balance = u64; +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } impl cumulus_pallet_parachain_system::Config for Test { @@ -277,7 +264,11 @@ impl Config for Test { type ChannelInfo = MockedChannelInfo; type VersionWrapper = (); type XcmpQueue = EnqueueToLocalStorage>; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = SystemParachainAsSuperuser; type WeightInfo = (); @@ -319,10 +310,13 @@ impl GetChannelInfo for MockedChannelInfo { pub(crate) fn mk_page() -> Vec { let mut page = Vec::::new(); + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + for i in 0..100 { page.extend(match i % 2 { - 0 => v2_xcm().encode(), - 1 => v3_xcm().encode(), + 0 => versioned_xcm(older_xcm_version).encode(), + 1 => versioned_xcm(newer_xcm_version).encode(), // We cannot push an undecodable XCM here since it would break the decode stream. // This is expected and the whole reason to introduce `MaybeDoubleEncodedVersionedXcm` // instead. @@ -333,12 +327,9 @@ pub(crate) fn mk_page() -> Vec { page } -pub(crate) fn v2_xcm() -> VersionedXcm<()> { - let instr = xcm::v2::Instruction::<()>::ClearOrigin; - VersionedXcm::V2(xcm::v2::Xcm::<()>(vec![instr; 3])) -} - -pub(crate) fn v3_xcm() -> VersionedXcm<()> { - let instr = xcm::v3::Instruction::<()>::Trap(1); - VersionedXcm::V3(xcm::v3::Xcm::<()>(vec![instr; 3])) +pub(crate) fn versioned_xcm(version: XcmVersion) -> VersionedXcm<()> { + let instr = Instruction::<()>::Trap(1); + VersionedXcm::from(Xcm::<()>(vec![instr; 3])) + .into_version(version) + .expect("Version conversion should work") } diff --git a/cumulus/pallets/xcmp-queue/src/tests.rs b/cumulus/pallets/xcmp-queue/src/tests.rs index f48e9eec3ac05b85794a2f18fc279566ad613272..5b02baf2310a368c3b49269e4c594a81d47a3a01 100644 --- a/cumulus/pallets/xcmp-queue/src/tests.rs +++ b/cumulus/pallets/xcmp-queue/src/tests.rs @@ -14,7 +14,7 @@ // limitations under the License. use super::{ - mock::{mk_page, v2_xcm, v3_xcm, EnqueuedMessages, HRMP_PARA_ID}, + mock::{mk_page, versioned_xcm, EnqueuedMessages, HRMP_PARA_ID}, *, }; use XcmpMessageFormat::*; @@ -28,6 +28,7 @@ use frame_support::{ use mock::{new_test_ext, ParachainSystem, RuntimeOrigin as Origin, Test, XcmpQueue}; use sp_runtime::traits::{BadOrigin, Zero}; use std::iter::{once, repeat}; +use xcm_builder::InspectMessageQueues; #[test] fn empty_concatenated_works() { @@ -520,7 +521,7 @@ fn hrmp_signals_are_prioritized() { }); // But a signal gets prioritized instead of the messages: - XcmpQueue::send_signal(sibling_para_id.into(), ChannelSignal::Suspend); + assert_ok!(XcmpQueue::send_signal(sibling_para_id.into(), ChannelSignal::Suspend)); let taken = XcmpQueue::take_outbound_messages(130); assert_eq!( @@ -536,8 +537,8 @@ fn hrmp_signals_are_prioritized() { #[test] fn maybe_double_encoded_versioned_xcm_works() { // pre conditions - assert_eq!(VersionedXcm::<()>::V2(Default::default()).encode(), &[2, 0]); assert_eq!(VersionedXcm::<()>::V3(Default::default()).encode(), &[3, 0]); + assert_eq!(VersionedXcm::<()>::V4(Default::default()).encode(), &[4, 0]); } // Now also testing a page instead of just concat messages. @@ -545,15 +546,18 @@ fn maybe_double_encoded_versioned_xcm_works() { fn maybe_double_encoded_versioned_xcm_decode_page_works() { let page = mk_page(); + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + // Now try to decode the page. let input = &mut &page[..]; for i in 0..100 { match (i % 2, VersionedXcm::<()>::decode(input)) { (0, Ok(xcm)) => { - assert_eq!(xcm, v2_xcm()); + assert_eq!(xcm, versioned_xcm(older_xcm_version)); }, (1, Ok(xcm)) => { - assert_eq!(xcm, v3_xcm()); + assert_eq!(xcm, versioned_xcm(newer_xcm_version)); }, unexpected => unreachable!("{:?}", unexpected), } @@ -568,14 +572,17 @@ fn take_first_concatenated_xcm_works() { let page = mk_page(); let input = &mut &page[..]; + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + for i in 0..100 { let xcm = XcmpQueue::take_first_concatenated_xcm(input, &mut WeightMeter::new()).unwrap(); match (i % 2, xcm) { (0, data) | (2, data) => { - assert_eq!(data, v2_xcm().encode()); + assert_eq!(data, versioned_xcm(older_xcm_version).encode()); }, (1, data) | (3, data) => { - assert_eq!(data, v3_xcm().encode()); + assert_eq!(data, versioned_xcm(newer_xcm_version).encode()); }, unexpected => unreachable!("{:?}", unexpected), } @@ -848,7 +855,6 @@ fn verify_fee_factor_increase_and_decrease() { #[test] fn get_messages_works() { new_test_ext().execute_with(|| { - use xcm_builder::InspectMessageQueues; let sibling_para_id = ParaId::from(2001); ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(sibling_para_id); let destination: Location = (Parent, Parachain(sibling_para_id.into())).into(); @@ -884,3 +890,32 @@ fn get_messages_works() { ); }); } + +/// We try to send a fragment that will not fit into the currently active page. This should +/// therefore not modify the current page but instead create a new one. +#[test] +fn page_not_modified_when_fragment_does_not_fit() { + new_test_ext().execute_with(|| { + let sibling = ParaId::from(2001); + ParachainSystem::open_outbound_hrmp_channel_for_benchmarks_or_tests(sibling); + + let destination: Location = (Parent, Parachain(sibling.into())).into(); + let message = Xcm(vec![ClearOrigin; 600]); + + loop { + let old_page_zero = OutboundXcmpMessages::::get(sibling, 0); + assert_ok!(send_xcm::(destination.clone(), message.clone())); + + // If a new page was created by this send_xcm call, then page_zero was not also + // modified: + let num_pages = OutboundXcmpMessages::::iter_prefix(sibling).count(); + if num_pages == 2 { + let new_page_zero = OutboundXcmpMessages::::get(sibling, 0); + assert_eq!(old_page_zero, new_page_zero); + break + } else if num_pages > 2 { + panic!("Too many pages created"); + } + } + }); +} diff --git a/cumulus/parachains/chain-specs/asset-hub-kusama.json b/cumulus/parachains/chain-specs/asset-hub-kusama.json index 66a705a40869ce6eb3fe2ac7a028ce68c784c18c..58b8ac01922712234ad81a56fde825026af904e2 100644 --- a/cumulus/parachains/chain-specs/asset-hub-kusama.json +++ b/cumulus/parachains/chain-specs/asset-hub-kusama.json @@ -7,18 +7,18 @@ "/dns/kusama-asset-hub-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWMzvdGcUXxacLdMQzRVrsP1mJrZHcrz8LtGbhLzve84Qx", "/dns/kusama-asset-hub-connect-1.polkadot.io/tcp/30334/p2p/12D3KooWQmGf5z3DU1kKcZoLzMNgdbP31ybjuwxS1VGLKMUjq5ez", "/dns/kusama-asset-hub-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWQmGf5z3DU1kKcZoLzMNgdbP31ybjuwxS1VGLKMUjq5ez", - "/dns/boot.stake.plus/tcp/34333/p2p/12D3KooWAzSSZ7jLqMw1WPomYEKCYANQaKemXQ8BKoFvNEvfmdqR", - "/dns/boot.stake.plus/tcp/34334/wss/p2p/12D3KooWAzSSZ7jLqMw1WPomYEKCYANQaKemXQ8BKoFvNEvfmdqR", + "/dns/asset-hub-kusama.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWGfJsBTxWttMwFkyBi6ZvEzAU3mvcVAzE7yFXMZuasicr", + "/dns/asset-hub-kusama.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWK7hHQbFEhhgZURY7V4LzY6BkqLsnCCpEJ69eUF7ucPcE", "/dns/boot.metaspan.io/tcp/26052/p2p/12D3KooW9z9hKqe3mqYAp5UJMhZiCqhkTHyiR43fegnGmTJ3JAba", "/dns/boot.metaspan.io/tcp/26056/wss/p2p/12D3KooW9z9hKqe3mqYAp5UJMhZiCqhkTHyiR43fegnGmTJ3JAba", - "/dns/boot-cr.gatotech.network/tcp/33210/p2p/12D3KooWRMUYeWMPkadDG8baX9j1e95fspfp8MhPGym5BQza7Fm5", - "/dns/boot-cr.gatotech.network/tcp/35210/wss/p2p/12D3KooWRMUYeWMPkadDG8baX9j1e95fspfp8MhPGym5BQza7Fm5", + "/dns/boot.gatotech.network/tcp/33210/p2p/12D3KooWRMUYeWMPkadDG8baX9j1e95fspfp8MhPGym5BQza7Fm5", + "/dns/boot.gatotech.network/tcp/35210/wss/p2p/12D3KooWRMUYeWMPkadDG8baX9j1e95fspfp8MhPGym5BQza7Fm5", "/dns/statemine-bootnode.turboflakes.io/tcp/30320/p2p/12D3KooWN2Qqvp5wWgjbBMpbqhKgvSibSHfomP5VWVD9VCn3VrV4", "/dns/statemine-bootnode.turboflakes.io/tcp/30420/wss/p2p/12D3KooWN2Qqvp5wWgjbBMpbqhKgvSibSHfomP5VWVD9VCn3VrV4", "/dns/boot-node.helikon.io/tcp/10210/p2p/12D3KooWFXRQce3aMgZMn5SxvHtYH4PsR63TZLf8LrnBsEVTyzdr", "/dns/boot-node.helikon.io/tcp/10212/wss/p2p/12D3KooWFXRQce3aMgZMn5SxvHtYH4PsR63TZLf8LrnBsEVTyzdr", - "/dns/statemine.bootnode.amforc.com/tcp/30336/p2p/12D3KooWHmSyrBWsc6fdpq8HtCFWasmLVLYGKWA2a78m4xAHKyBq", - "/dns/statemine.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWHmSyrBWsc6fdpq8HtCFWasmLVLYGKWA2a78m4xAHKyBq", + "/dns/asset-hub-kusama.bootnode.amforc.com/tcp/30007/p2p/12D3KooWHy1CPndZYphwdVqMb295KPC6LRt17Ae3zNSr7evzeF5a", + "/dns/asset-hub-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWHy1CPndZYphwdVqMb295KPC6LRt17Ae3zNSr7evzeF5a", "/dns/statemine-boot-ng.dwellir.com/tcp/30343/p2p/12D3KooWQNJKBaNfW6Nn7HZDi5pSSEFmHL2Qz7chr9RksQUDR1Wk", "/dns/statemine-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWQNJKBaNfW6Nn7HZDi5pSSEFmHL2Qz7chr9RksQUDR1Wk", "/dns/statemine-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWCKUrE5uaXQ288ko3Ex3zCyozyJLG47KEYTopinnXNtYL", diff --git a/cumulus/parachains/chain-specs/asset-hub-polkadot.json b/cumulus/parachains/chain-specs/asset-hub-polkadot.json index 16caa52ba91376ed30187c89d249ff38ed1ea42a..3e46501b00785d9d92b3bde19e5dd08e00d7e86d 100644 --- a/cumulus/parachains/chain-specs/asset-hub-polkadot.json +++ b/cumulus/parachains/chain-specs/asset-hub-polkadot.json @@ -7,18 +7,18 @@ "/dns/polkadot-asset-hub-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWLHqbcQtoBygf7GJgVjVa3TaeLuf7VbicNdooaCmQM2JZ", "/dns/polkadot-asset-hub-connect-1.polkadot.io/tcp/30334/p2p/12D3KooWNDrKSayoZXGGE2dRSFW2g1iGPq3fTZE2U39ma9yZGKd3", "/dns/polkadot-asset-hub-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWNDrKSayoZXGGE2dRSFW2g1iGPq3fTZE2U39ma9yZGKd3", - "/dns/boot.stake.plus/tcp/35333/p2p/12D3KooWFrQjYaPZSSLLxEVmoaHFcrF6VoY4awG4KRSLaqy3JCdQ", - "/dns/boot.stake.plus/tcp/35334/wss/p2p/12D3KooWFrQjYaPZSSLLxEVmoaHFcrF6VoY4awG4KRSLaqy3JCdQ", + "/dns/asset-hub-polkadot.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWJzTrFcc11AZKTMUmmLr5XLJ9qKVupZXkwHUMx4ULbwm2", + "/dns/asset-hub-polkadot.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWNWF2zwxWDuZfXEzL29yeXAAubFy8tCCMjPwWLCZdLRqc", "/dns/boot.metaspan.io/tcp/16052/p2p/12D3KooWLwiJuvqQUB4kYaSjLenFKH9dWZhGZ4qi7pSb3sUYU651", "/dns/boot.metaspan.io/tcp/16056/wss/p2p/12D3KooWLwiJuvqQUB4kYaSjLenFKH9dWZhGZ4qi7pSb3sUYU651", - "/dns/boot-cr.gatotech.network/tcp/33110/p2p/12D3KooWKgwQfAeDoJARdtxFNNWfbYmcu6s4yUuSifnNoDgzHZgm", - "/dns/boot-cr.gatotech.network/tcp/35110/wss/p2p/12D3KooWKgwQfAeDoJARdtxFNNWfbYmcu6s4yUuSifnNoDgzHZgm", + "/dns/boot.gatotech.network/tcp/33110/p2p/12D3KooWKgwQfAeDoJARdtxFNNWfbYmcu6s4yUuSifnNoDgzHZgm", + "/dns/boot.gatotech.network/tcp/35110/wss/p2p/12D3KooWKgwQfAeDoJARdtxFNNWfbYmcu6s4yUuSifnNoDgzHZgm", "/dns/statemint-bootnode.turboflakes.io/tcp/30315/p2p/12D3KooWL8CyLww3m3pRySQGGYGNJhWDMqko3j5xi67ckP7hDUvo", "/dns/statemint-bootnode.turboflakes.io/tcp/30415/wss/p2p/12D3KooWL8CyLww3m3pRySQGGYGNJhWDMqko3j5xi67ckP7hDUvo", "/dns/boot-node.helikon.io/tcp/10220/p2p/12D3KooW9uybhguhDjVJc3U3kgZC3i8rWmAnSpbnJkmuR7C6ZsRW", "/dns/boot-node.helikon.io/tcp/10222/wss/p2p/12D3KooW9uybhguhDjVJc3U3kgZC3i8rWmAnSpbnJkmuR7C6ZsRW", - "/dns/statemint.bootnode.amforc.com/tcp/30341/p2p/12D3KooWByohP9FXn7ao8syS167qJsbFdpa7fY2Y24xbKtt3r7Ls", - "/dns/statemint.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWByohP9FXn7ao8syS167qJsbFdpa7fY2Y24xbKtt3r7Ls", + "/dns/asset-hub-polkadot.bootnode.amforc.com/tcp/30007/p2p/12D3KooWDLxPXYnSHjNwq9ibqgxuzRni5VViuGNSjNe3ueqVgqE3", + "/dns/asset-hub-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDLxPXYnSHjNwq9ibqgxuzRni5VViuGNSjNe3ueqVgqE3", "/dns/statemint-boot-ng.dwellir.com/tcp/30344/p2p/12D3KooWEFrNuNk8fPdQS2hf34Gmqi6dGSvrETshGJUrqrvfRDZr", "/dns/statemint-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWEFrNuNk8fPdQS2hf34Gmqi6dGSvrETshGJUrqrvfRDZr", "/dns/statemint-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWLKxHom7f3XawRJqrF8RwiKK5Sj3qZqz5c7hF6eJeXhTx", diff --git a/cumulus/parachains/chain-specs/asset-hub-rococo.json b/cumulus/parachains/chain-specs/asset-hub-rococo.json index 87ff2fb220a19b1ec01d280be6e58ab2cafffd90..2dde366cc06f9f4b24e802b14461a39c2d083ae2 100644 --- a/cumulus/parachains/chain-specs/asset-hub-rococo.json +++ b/cumulus/parachains/chain-specs/asset-hub-rococo.json @@ -1,7 +1,4 @@ { - "name": "Rococo Asset Hub", - "id": "asset-hub-rococo", - "chainType": "Live", "bootNodes": [ "/dns/rococo-asset-hub-bootnode-0.polkadot.io/tcp/30333/p2p/12D3KooWRrZMndHAopzao34uGsN7srjS3gh9nAjTGKLSyJeU31Lg", "/dns/rococo-asset-hub-bootnode-1.polkadot.io/tcp/30333/p2p/12D3KooWAewimoNJqMaiiV5pYiowA5hLuh5JS5QiRJCCyWVrrSTS", @@ -10,17 +7,15 @@ "/dns/rococo-asset-hub-bootnode-0.polkadot.io/tcp/443/wss/p2p/12D3KooWRrZMndHAopzao34uGsN7srjS3gh9nAjTGKLSyJeU31Lg", "/dns/rococo-asset-hub-bootnode-1.polkadot.io/tcp/443/wss/p2p/12D3KooWAewimoNJqMaiiV5pYiowA5hLuh5JS5QiRJCCyWVrrSTS" ], - "telemetryEndpoints": null, - "protocolId": null, - "properties": { - "tokenDecimals": 12, - "tokenSymbol": "ROC" - }, "relay_chain": "rococo", "para_id": 1000, - "codeSubstitutes": {}, + "chainType": "Live", + "codeSubstitutes": { + "4960799": "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" + }, "genesis": { "raw": { + "childrenDefault": {}, "top": { "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xe8030000", "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", @@ -75,8 +70,15 @@ "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x02000000", "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} + } } - } + }, + "id": "asset-hub-rococo", + "name": "Rococo Asset Hub", + "properties": { + "tokenDecimals": 12, + "tokenSymbol": "ROC" + }, + "protocolId": null, + "telemetryEndpoints": null } diff --git a/cumulus/parachains/chain-specs/asset-hub-westend.json b/cumulus/parachains/chain-specs/asset-hub-westend.json index 3752213e702eb8d1ef86e042531cc1f6fdec2767..42717974a0b34e31420fe08ad51195dd3a1b2c4e 100644 --- a/cumulus/parachains/chain-specs/asset-hub-westend.json +++ b/cumulus/parachains/chain-specs/asset-hub-westend.json @@ -9,18 +9,18 @@ "/dns/westend-asset-hub-bootnode-1.polkadot.io/tcp/30335/ws/p2p/12D3KooWGL3hpWycWyeqyL9gHNnmmsL474WkPZdqraBHu4L6fQrW", "/dns/westend-asset-hub-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWJaAfPyiye7ZQBuHengTJJoMrcaz7Jj1UzHiKdNxA1Nkd", "/dns/westend-asset-hub-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWGL3hpWycWyeqyL9gHNnmmsL474WkPZdqraBHu4L6fQrW", - "/dns/boot.stake.plus/tcp/33333/p2p/12D3KooWNiB27rpXX7EYongoWWUeRKzLQxWGms6MQU2B9LX7Ztzo", - "/dns/boot.stake.plus/tcp/33334/wss/p2p/12D3KooWNiB27rpXX7EYongoWWUeRKzLQxWGms6MQU2B9LX7Ztzo", + "/dns/asset-hub-westend.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWG4YUe7AfSxVwyLQBRRMU99krssmGAUghqUFoVY1iPkQs", + "/dns/asset-hub-westend.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWFLR2UN6PMAUwNAjiWBAiEDoYcWRrtjDrUfRkdUssge4v", "/dns/boot.metaspan.io/tcp/36052/p2p/12D3KooWBCqfNb6Y39DXTr4UBWXyjuS3hcZM1qTbHhDXxF6HkAJJ", "/dns/boot.metaspan.io/tcp/36056/wss/p2p/12D3KooWBCqfNb6Y39DXTr4UBWXyjuS3hcZM1qTbHhDXxF6HkAJJ", - "/dns/boot-cr.gatotech.network/tcp/33310/p2p/12D3KooWMSW6hr8KcNBhGFN1bg8kYC76o67PnuDEbxRhxacW6dui", - "/dns/boot-cr.gatotech.network/tcp/35310/wss/p2p/12D3KooWMSW6hr8KcNBhGFN1bg8kYC76o67PnuDEbxRhxacW6dui", + "/dns/boot.gatotech.network/tcp/33310/p2p/12D3KooWMSW6hr8KcNBhGFN1bg8kYC76o67PnuDEbxRhxacW6dui", + "/dns/boot.gatotech.network/tcp/35310/wss/p2p/12D3KooWMSW6hr8KcNBhGFN1bg8kYC76o67PnuDEbxRhxacW6dui", "/dns/westmint-bootnode.turboflakes.io/tcp/30325/p2p/12D3KooWHU4qqSyqKdbXdrCTMXUJxxueaZjqpqSaQqYiFPw6XqEx", "/dns/westmint-bootnode.turboflakes.io/tcp/30425/wss/p2p/12D3KooWHU4qqSyqKdbXdrCTMXUJxxueaZjqpqSaQqYiFPw6XqEx", "/dns/boot-node.helikon.io/tcp/10200/p2p/12D3KooWMRY8wb7rMT81LLuivvsy6ahUxKHQgYJw4zm1hC1uYLxb", "/dns/boot-node.helikon.io/tcp/10202/wss/p2p/12D3KooWMRY8wb7rMT81LLuivvsy6ahUxKHQgYJw4zm1hC1uYLxb", - "/dns/westmint.bootnode.amforc.com/tcp/30339/p2p/12D3KooWNjKeaANaeZxBAPctmx8jugSYzuw4vnSCJmEDPB5mtRd6", - "/dns/westmint.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWNjKeaANaeZxBAPctmx8jugSYzuw4vnSCJmEDPB5mtRd6", + "/dns/asset-hub-westend.bootnode.amforc.com/tcp/30004/p2p/12D3KooWDfepM7kqUHMXdGqJw3ZmtvAcE2CjPcnYjT2tTfAw3ZBd", + "/dns/asset-hub-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDfepM7kqUHMXdGqJw3ZmtvAcE2CjPcnYjT2tTfAw3ZBd", "/dns/westmint-boot-ng.dwellir.com/tcp/30345/p2p/12D3KooWFZ9xqApB1wnFYkbe1qJ5Jqwxe2f3i8W25F3tKNXy59ux", "/dns/westmint-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWFZ9xqApB1wnFYkbe1qJ5Jqwxe2f3i8W25F3tKNXy59ux", "/dns/westmint-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWDoq4PVdWm5nzRSvEz3DSSKjVgRhWVUaKyi5JMKwJKYbk", diff --git a/cumulus/parachains/chain-specs/bridge-hub-kusama.json b/cumulus/parachains/chain-specs/bridge-hub-kusama.json index 6644ea41ab748548d3c6dcbd06951522672dbb53..36558b325bbf315144c69e8f6c4294bd6d5dfdff 100644 --- a/cumulus/parachains/chain-specs/bridge-hub-kusama.json +++ b/cumulus/parachains/chain-specs/bridge-hub-kusama.json @@ -7,18 +7,18 @@ "/dns/kusama-bridge-hub-connect-ew1-1.polkadot.io/tcp/30334/p2p/12D3KooWPcF9Yk4gYrMju9CyWCV69hAFXbYsnxCLogwLGu9QFTRn", "/dns/kusama-bridge-hub-connect-ew1-0.polkadot.io/tcp/443/wss/p2p/12D3KooWPQQPivrqQ51kRTDc2R1mtqwKT4GGtk2rapkY4FrwHrEp", "/dns/kusama-bridge-hub-connect-ew1-1.polkadot.io/tcp/443/wss/p2p/12D3KooWPcF9Yk4gYrMju9CyWCV69hAFXbYsnxCLogwLGu9QFTRn", - "/dns/boot.stake.plus/tcp/41333/p2p/12D3KooWBzbs2jsXjG5dipktGPKaUm9XWvkmeJFsEAGkVt946Aa7", - "/dns/boot.stake.plus/tcp/41334/wss/p2p/12D3KooWBzbs2jsXjG5dipktGPKaUm9XWvkmeJFsEAGkVt946Aa7", + "/dns/bridge-hub-kusama.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWCujTih2WeQr51xSpopt5LoYVyXy3bgGgcN5ftPQViBmh", + "/dns/bridge-hub-kusama.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWDSxWZ8RcuPfKSpybYHWUdhQHG328Euyo2PwkNUTXcXuw", "/dns/boot.metaspan.io/tcp/26032/p2p/12D3KooWKfuSaZrLNz43PDgM4inMALXRHTSh2WBuqQtZRq8zmT1Z", "/dns/boot.metaspan.io/tcp/26036/wss/p2p/12D3KooWKfuSaZrLNz43PDgM4inMALXRHTSh2WBuqQtZRq8zmT1Z", - "/dns/boot-cr.gatotech.network/tcp/33230/p2p/12D3KooWFQFmg8UqAYLDNc2onySB6o5LLvpbx3eXZVqz9YFxAmXs", - "/dns/boot-cr.gatotech.network/tcp/35230/wss/p2p/12D3KooWFQFmg8UqAYLDNc2onySB6o5LLvpbx3eXZVqz9YFxAmXs", + "/dns/boot.gatotech.network/tcp/33230/p2p/12D3KooWFQFmg8UqAYLDNc2onySB6o5LLvpbx3eXZVqz9YFxAmXs", + "/dns/boot.gatotech.network/tcp/35230/wss/p2p/12D3KooWFQFmg8UqAYLDNc2onySB6o5LLvpbx3eXZVqz9YFxAmXs", "/dns/bridge-hub-kusama-bootnode.turboflakes.io/tcp/30615/p2p/12D3KooWE3dJXbwA5SQqbDNxHfj7BXJRcy2KiXWjJY4VUMKoa7S2", "/dns/bridge-hub-kusama-bootnode.turboflakes.io/tcp/30715/wss/p2p/12D3KooWE3dJXbwA5SQqbDNxHfj7BXJRcy2KiXWjJY4VUMKoa7S2", "/dns/boot-node.helikon.io/tcp/10250/p2p/12D3KooWDJLkhqQdXcVKWX7CqJHnpAY6PzrPc4ZG2CUWnARbmguy", "/dns/boot-node.helikon.io/tcp/10252/wss/p2p/12D3KooWDJLkhqQdXcVKWX7CqJHnpAY6PzrPc4ZG2CUWnARbmguy", - "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30337/p2p/12D3KooWGNeQJ5rXnEJkVUuQqwHd8aV5GkTAheaRoCaK8ZwW94id", - "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWGNeQJ5rXnEJkVUuQqwHd8aV5GkTAheaRoCaK8ZwW94id", + "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/30010/p2p/12D3KooWNyTBwRvCz1Ey2SgC1f3MvymhiAyLEa3cL8kU5gFH3V7Z", + "/dns/bridge-hub-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWNyTBwRvCz1Ey2SgC1f3MvymhiAyLEa3cL8kU5gFH3V7Z", "/dns/kusama-bridge-hub-boot-ng.dwellir.com/tcp/30337/p2p/12D3KooWBFskNCQDVjuUeBh6vrszWrUvYMBBhtZRLnoTZDdLYbW5", "/dns/kusama-bridge-hub-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWBFskNCQDVjuUeBh6vrszWrUvYMBBhtZRLnoTZDdLYbW5", "/dns/bridgehub-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWQMWofXj8v3RroDNnrhv1iURqm8vnaG98AdGnCn2YoDcW", diff --git a/cumulus/parachains/chain-specs/bridge-hub-polkadot.json b/cumulus/parachains/chain-specs/bridge-hub-polkadot.json index c51c5eff89b86a0ce553bbcfc472f6fb5cf0d535..eb22e09035f34b85cecbbc923ea1e68081f14a8d 100644 --- a/cumulus/parachains/chain-specs/bridge-hub-polkadot.json +++ b/cumulus/parachains/chain-specs/bridge-hub-polkadot.json @@ -9,8 +9,10 @@ "/dns/polkadot-bridge-hub-connect-a-1.polkadot.io/tcp/443/wss/p2p/12D3KooWG4ypDHLKGCv4BZ6PuaGUwQHKAH6p2D6arR2uQ1eiR1T3", "/dns/polkadot-bridge-hub-boot-ng.dwellir.com/tcp/30339/p2p/12D3KooWPZ38PL3PhRVcUVYDNn7nRcZF8MykmWWLBKeDV2yna1vV", "/dns/polkadot-bridge-hub-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWPZ38PL3PhRVcUVYDNn7nRcZF8MykmWWLBKeDV2yna1vV", - "/dns/boot-cr.gatotech.network/tcp/33130/p2p/12D3KooWCnFzfEdd7MwUNrrDv66FuS2DM5MGuiaB4y48XS7qNjF6", - "/dns/boot-cr.gatotech.network/tcp/35130/wss/p2p/12D3KooWCnFzfEdd7MwUNrrDv66FuS2DM5MGuiaB4y48XS7qNjF6", + "/dns/boot.gatotech.network/tcp/33130/p2p/12D3KooWCnFzfEdd7MwUNrrDv66FuS2DM5MGuiaB4y48XS7qNjF6", + "/dns/boot.gatotech.network/tcp/35130/wss/p2p/12D3KooWCnFzfEdd7MwUNrrDv66FuS2DM5MGuiaB4y48XS7qNjF6", + "/dns/bridge-hub-polkadot.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWGqVn69EWriuszxcuBVMgTtpKUHYcULEiuLiqkC3kf35F", + "/dns/bridge-hub-polkadot.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWMiMJbunJa7ETaeanKB7hgchjQEbmhmtNPRRiHYtZHCTZ", "/dns/bridge-hub-polkadot-bootnode.turboflakes.io/tcp/30610/p2p/12D3KooWNEgaQRQHJHvGDh8Rg4RyLmDCCz3yAf2gAdHZZJAUUD8Q", "/dns/bridge-hub-polkadot-bootnode.turboflakes.io/tcp/30710/wss/p2p/12D3KooWNEgaQRQHJHvGDh8Rg4RyLmDCCz3yAf2gAdHZZJAUUD8Q", "/dns/boot.metaspan.io/tcp/16032/p2p/12D3KooWQTfRnrK3FfbrotpSP5RVJbjBHVBSu8VSzhj9qcvjaqnZ", @@ -24,7 +26,9 @@ "/dns/pbr13.rotko.net/tcp/35543/wss/p2p/12D3KooWMxZY7tDc2Rh454VaJJ7RexKAXVS6xSBEvTnXSGCnuGDw", "/dns/bridge-hub-polkadot.bootnodes.polkadotters.com/tcp/30517/p2p/12D3KooWLUNE3LHPDa1WrrZaYT7ArK66CLM1bPv7kKz74UcLnQRB", "/dns/bridge-hub-polkadot.bootnodes.polkadotters.com/tcp/30519/wss/p2p/12D3KooWLUNE3LHPDa1WrrZaYT7ArK66CLM1bPv7kKz74UcLnQRB", - "/dns/boot-polkadot-bridgehub.luckyfriday.io/tcp/443/wss/p2p/12D3KooWKf3mBXHjLbwtPqv1BdbQuwbFNcQQYxASS7iQ25264AXH" + "/dns/boot-polkadot-bridgehub.luckyfriday.io/tcp/443/wss/p2p/12D3KooWKf3mBXHjLbwtPqv1BdbQuwbFNcQQYxASS7iQ25264AXH", + "/dns/bridge-hub-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWGT5E56rAHfT5dY1pMLTrpAgV72yfDtD1Y5tPCHaTsifp", + "/dns/bridge-hub-polkadot.bootnode.amforc.com/tcp/30010/p2p/12D3KooWGT5E56rAHfT5dY1pMLTrpAgV72yfDtD1Y5tPCHaTsifp" ], "telemetryEndpoints": null, "protocolId": null, diff --git a/cumulus/parachains/chain-specs/bridge-hub-rococo.json b/cumulus/parachains/chain-specs/bridge-hub-rococo.json index 53aef58422db38f8417d7add5abee0b6ecbbd755..d83431b9ca5ea77e3cccf01e8f60cc42061a2940 100644 --- a/cumulus/parachains/chain-specs/bridge-hub-rococo.json +++ b/cumulus/parachains/chain-specs/bridge-hub-rococo.json @@ -1,7 +1,4 @@ { - "name": "Rococo BridgeHub", - "id": "bridge-hub-rococo", - "chainType": "Live", "bootNodes": [ "/dns/rococo-bridge-hub-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWJCFBJmFF65xz5xHeZQRSCf35BxfSEB3RHQFoLza28LWU", "/dns/rococo-bridge-hub-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWJzLd8skcAgA24EcJey7aJAhYctfUxWGjSP5Usk9wbpPZ", @@ -10,18 +7,15 @@ "/dns/rococo-bridge-hub-collator-node-0.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWJCFBJmFF65xz5xHeZQRSCf35BxfSEB3RHQFoLza28LWU", "/dns/rococo-bridge-hub-collator-node-1.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWJzLd8skcAgA24EcJey7aJAhYctfUxWGjSP5Usk9wbpPZ" ], - "telemetryEndpoints": null, - "protocolId": null, - "properties": { - "ss58Format": 42, - "tokenDecimals": 12, - "tokenSymbol": "ROC" - }, + "chainType": "Live", "relay_chain": "rococo", "para_id": 1013, - "codeSubstitutes": {}, + "codeSubstitutes": { + "3603599": "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" + }, "genesis": { "raw": { + "childrenDefault": {}, "top": { "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xf5030000", "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", @@ -80,8 +74,16 @@ "0xe81713b6b40972bbcd298d67597a495f4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xf7327be699d4ca1e710c5cb7cfa19d3c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} + } } - } + }, + "id": "bridge-hub-rococo", + "name": "Rococo BridgeHub", + "properties": { + "ss58Format": 42, + "tokenDecimals": 12, + "tokenSymbol": "ROC" + }, + "protocolId": null, + "telemetryEndpoints": null } diff --git a/cumulus/parachains/chain-specs/bridge-hub-westend.json b/cumulus/parachains/chain-specs/bridge-hub-westend.json index 5140071ec44ca1956b01f608ce85ca2d6177a617..40c7c7460c2359c855adac91a0dbf2dbec2c008b 100644 --- a/cumulus/parachains/chain-specs/bridge-hub-westend.json +++ b/cumulus/parachains/chain-specs/bridge-hub-westend.json @@ -11,8 +11,10 @@ "/dns/westend-bridge-hub-collator-node-1.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWBpvudthz61XC4oP2YYFFJdhWohBeQ1ffn1BMSGWhapjd", "/dns/westend-bridge-hub-boot-ng.dwellir.com/tcp/30338/p2p/12D3KooWJWWRYTAwBLqYkh7iMBGDr5ouJ3MHj7M3fZ7zWS4zEk6F", "/dns/westend-bridge-hub-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWJWWRYTAwBLqYkh7iMBGDr5ouJ3MHj7M3fZ7zWS4zEk6F", - "/dns/boot-cr.gatotech.network/tcp/33330/p2p/12D3KooWJHG6qznPzTSEbuujHNcvyzBZcR9zNRPFcXWUaoVWZBEw", - "/dns/boot-cr.gatotech.network/tcp/35330/wss/p2p/12D3KooWJHG6qznPzTSEbuujHNcvyzBZcR9zNRPFcXWUaoVWZBEw", + "/dns/bridge-hub-westend.boot.stake.plus/tcp/30332/wss/p2p/12D3KooW9rqdajWEpC3i65zaTVR1ER2RmY6e26vndPsKhBB6WJ1k", + "/dns/bridge-hub-westend.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWN55mz6EQb5nrCgTiNL6nroVrRXygCiFDvHpeKk97Jqqc", + "/dns/boot.gatotech.network/tcp/33330/p2p/12D3KooWJHG6qznPzTSEbuujHNcvyzBZcR9zNRPFcXWUaoVWZBEw", + "/dns/boot.gatotech.network/tcp/35330/wss/p2p/12D3KooWJHG6qznPzTSEbuujHNcvyzBZcR9zNRPFcXWUaoVWZBEw", "/dns/bridge-hub-westend-bootnode.turboflakes.io/tcp/30620/p2p/12D3KooWLeExhPWCDUjcxCdzxTP5TpPbNBVG5t9MPvk1dZUM5naU", "/dns/bridge-hub-westend-bootnode.turboflakes.io/tcp/30720/wss/p2p/12D3KooWLeExhPWCDUjcxCdzxTP5TpPbNBVG5t9MPvk1dZUM5naU", "/dns/boot.metaspan.io/tcp/36032/p2p/12D3KooWPaLsu3buByBnGFQnp5UP4q1S652dGVft92TFeChizFir", @@ -25,7 +27,9 @@ "/dns/wbr13.rotko.net/tcp/34563/ws/p2p/12D3KooWJyeRHpxZZbfBCNEgeUFzmRC5AMSAs2tJhjJS1k5hULkD", "/dns/wbr13.rotko.net/tcp/35563/wss/p2p/12D3KooWJyeRHpxZZbfBCNEgeUFzmRC5AMSAs2tJhjJS1k5hULkD", "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30523/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj", - "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30525/wss/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj" + "/dns/bridge-hub-westend.bootnodes.polkadotters.com/tcp/30525/wss/p2p/12D3KooWPkwgJofp4GeeRwNgXqkp2aFwdLkCWv3qodpBJLwK43Jj", + "/dns/bridge-hub-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWDSWod2gMtHxunXot538oEMw9p42pnPrpRELdsfYyT8R6", + "/dns/bridge-hub-westend.bootnode.amforc.com/tcp/30007/p2p/12D3KooWDSWod2gMtHxunXot538oEMw9p42pnPrpRELdsfYyT8R6" ], "telemetryEndpoints": null, "protocolId": null, diff --git a/cumulus/parachains/chain-specs/collectives-polkadot.json b/cumulus/parachains/chain-specs/collectives-polkadot.json index ce80e21ae625e813be0f71245bc454cb284455f3..5ccccbec905326da8ca7b45013f38e1bb5da9926 100644 --- a/cumulus/parachains/chain-specs/collectives-polkadot.json +++ b/cumulus/parachains/chain-specs/collectives-polkadot.json @@ -7,25 +7,24 @@ "/dns/polkadot-collectives-connect-ew6-1.polkadot.io/tcp/30334/p2p/12D3KooWC9BwKMDyRUTXsE7teSmoKMgbyxqAp3zi2MTGRJR5nhCL", "/dns/polkadot-collectives-connect-ew6-0.polkadot.io/tcp/443/wss/p2p/12D3KooWLDZT5gAjMtC8fojiCwiz17SC61oeX2C7GWBCqqf9TwVD", "/dns/polkadot-collectives-connect-ew6-1.polkadot.io/tcp/443/wss/p2p/12D3KooWC9BwKMDyRUTXsE7teSmoKMgbyxqAp3zi2MTGRJR5nhCL", - "/dns/boot.stake.plus/tcp/37333/p2p/12D3KooWRgFfEtwPo3xorKGYALRHRteKNgF37iN9q8xTLPYc34LA", - "/dns/boot.stake.plus/tcp/37334/wss/p2p/12D3KooWRgFfEtwPo3xorKGYALRHRteKNgF37iN9q8xTLPYc34LA", + "/dns/collectives-polkadot.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWKLVfjCpW2syecz39UPe4QkJhwME9HUehBvf8oRcT4kot", + "/dns/collectives-polkadot.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWBCewTdMPoXNvs1ky1VLidMdS28Jnh8fNbCP81FYiQHn4", "/dns/boot.metaspan.io/tcp/16072/p2p/12D3KooWJWTTu2t2yg5bFRH6tjEpfzKwZir5R9JRRjQpgFPXdDfp", "/dns/boot.metaspan.io/tcp/16076/wss/p2p/12D3KooWJWTTu2t2yg5bFRH6tjEpfzKwZir5R9JRRjQpgFPXdDfp", - "/dns/boot-cr.gatotech.network/tcp/33120/p2p/12D3KooWGZsa9tSeLQ1VeC996e1YsCPuyRYMipHQuXikPjcKcpVQ", - "/dns/boot-cr.gatotech.network/tcp/35120/wss/p2p/12D3KooWGZsa9tSeLQ1VeC996e1YsCPuyRYMipHQuXikPjcKcpVQ", + "/dns/boot.gatotech.network/tcp/33120/p2p/12D3KooWGZsa9tSeLQ1VeC996e1YsCPuyRYMipHQuXikPjcKcpVQ", + "/dns/boot.gatotech.network/tcp/35120/wss/p2p/12D3KooWGZsa9tSeLQ1VeC996e1YsCPuyRYMipHQuXikPjcKcpVQ", "/dns/collectives-polkadot-bootnode.turboflakes.io/tcp/30605/p2p/12D3KooWPyzM7eX64J4aG8uRfSARakDVtiEtthEM8FUjrLWAg2sC", "/dns/collectives-polkadot-bootnode.turboflakes.io/tcp/30705/wss/p2p/12D3KooWPyzM7eX64J4aG8uRfSARakDVtiEtthEM8FUjrLWAg2sC", "/dns/boot-node.helikon.io/tcp/10230/p2p/12D3KooWS8CBz4P5CBny9aBy2EQUvAExFo9PUVT57X8r3zWMFkXT", "/dns/boot-node.helikon.io/tcp/10232/wss/p2p/12D3KooWS8CBz4P5CBny9aBy2EQUvAExFo9PUVT57X8r3zWMFkXT", - "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30335/p2p/12D3KooWQeAjDnGkrPe5vtpfnB6ydZfWyMxyrXLkBFmA6o4k9aiU", - "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWQeAjDnGkrPe5vtpfnB6ydZfWyMxyrXLkBFmA6o4k9aiU", + "/dns/collectives-polkadot.bootnode.amforc.com/tcp/30013/p2p/12D3KooWL6v6FHMtCP5VsiDbMHLRFiW6YBtv37BarpW3hLqnDski", + "/dns/collectives-polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWL6v6FHMtCP5VsiDbMHLRFiW6YBtv37BarpW3hLqnDski", "/dns/polkadot-collectives-boot-ng.dwellir.com/tcp/30341/p2p/12D3KooWDMFYCNRAQcSRNV7xu2xv8319goSEbSHW4TnXRz6EpPKc", "/dns/polkadot-collectives-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWDMFYCNRAQcSRNV7xu2xv8319goSEbSHW4TnXRz6EpPKc", "/dns/collectives-polkadot-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWDumvnNwPbBg5inBEapgjKU7ECdMHHgwfYeGWUkzYUE1c", "/dns/collectives-polkadot-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWDumvnNwPbBg5inBEapgjKU7ECdMHHgwfYeGWUkzYUE1c", - "/dns/pch13.rotko.net/tcp/33573/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH", - "/dns/pch13.rotko.net/tcp/34573/ws/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH", - "/dns/pch13.rotko.net/tcp/35573/wss/p2p/12D3KooWRXudHoazPZ9osMfdY38e8CBxQLD4RhrVeHpRSNNpcDtH", + "/dns/pch16.rotko.net/tcp/33576/p2p/12D3KooWKrm3XmuGzJH17Wcn4HRDGsEjLZGDgN77q3ZhwnnQP7y1", + "/dns/pch16.rotko.net/tcp/35576/wss/p2p/12D3KooWKrm3XmuGzJH17Wcn4HRDGsEjLZGDgN77q3ZhwnnQP7y1", "/dns/collectives-polkadot.bootnodes.polkadotters.com/tcp/30526/p2p/12D3KooWNohUjvJtGKUa8Vhy8C1ZBB5N8JATB6e7rdLVCioeb3ff", "/dns/collectives-polkadot.bootnodes.polkadotters.com/tcp/30528/wss/p2p/12D3KooWNohUjvJtGKUa8Vhy8C1ZBB5N8JATB6e7rdLVCioeb3ff", "/dns/boot-polkadot-collectives.luckyfriday.io/tcp/443/wss/p2p/12D3KooWCzifnPooTt4kvTnXT7FTKTymVL7xn7DURQLsS2AKpf6w" diff --git a/cumulus/parachains/chain-specs/collectives-westend.json b/cumulus/parachains/chain-specs/collectives-westend.json index fdd6348f02a9ce7b07c0483847a348c7b334f5c2..f583eddcef1f145500a68f48965cc15f8333a3a7 100644 --- a/cumulus/parachains/chain-specs/collectives-westend.json +++ b/cumulus/parachains/chain-specs/collectives-westend.json @@ -9,18 +9,18 @@ "/dns/westend-collectives-collator-node-1.parity-testnet.parity.io/tcp/30335/ws/p2p/12D3KooWAujYtHbCs4MiDD57JNTntTJnYnikfnaPa7JdnMyAUrHB", "/dns/westend-collectives-collator-0.polkadot.io/tcp/443/wss/p2p/12D3KooWBMAuyzQu3yAf8YXyoyxsSzSsgoaqAepgnNyQcPaPjPXe", "/dns/westend-collectives-collator-1.polkadot.io/tcp/443/wss/p2p/12D3KooWAujYtHbCs4MiDD57JNTntTJnYnikfnaPa7JdnMyAUrHB", - "/dns/boot.stake.plus/tcp/38333/p2p/12D3KooWQoVsFCfgu21iu6kdtQsU9T6dPn1wsyLn1U34yPerR6zQ", - "/dns/boot.stake.plus/tcp/38334/wss/p2p/12D3KooWQoVsFCfgu21iu6kdtQsU9T6dPn1wsyLn1U34yPerR6zQ", + "/dns/collectives-westend.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWH4MtT6T9BE1nm2TL9ABmY3mSr61mZcge37pEch7Qw15S", + "/dns/collectives-westend.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWBMRn31J3wJh3eu96XFUiAmgP3eKUxyNCv7249NXrAarZ", "/dns/boot.metaspan.io/tcp/36072/p2p/12D3KooWEf2QXWq5pAbFJLfbnexA7KYtRRDSPkqTP64n1KtdsdV2", "/dns/boot.metaspan.io/tcp/36076/wss/p2p/12D3KooWEf2QXWq5pAbFJLfbnexA7KYtRRDSPkqTP64n1KtdsdV2", - "/dns/boot-cr.gatotech.network/tcp/33320/p2p/12D3KooWMedtdBGiSn7HLZusHwafXkZAdmWD18ciGQBfS4X1fv9K", - "/dns/boot-cr.gatotech.network/tcp/35320/wss/p2p/12D3KooWMedtdBGiSn7HLZusHwafXkZAdmWD18ciGQBfS4X1fv9K", + "/dns/boot.gatotech.network/tcp/33320/p2p/12D3KooWMedtdBGiSn7HLZusHwafXkZAdmWD18ciGQBfS4X1fv9K", + "/dns/boot.gatotech.network/tcp/35320/wss/p2p/12D3KooWMedtdBGiSn7HLZusHwafXkZAdmWD18ciGQBfS4X1fv9K", "/dns/collectives-westend-bootnode.turboflakes.io/tcp/30600/p2p/12D3KooWAe9CFXp6je3TAPQJE135KRemTLSqEqQBZMFwJontrThZ", "/dns/collectives-westend-bootnode.turboflakes.io/tcp/30700/wss/p2p/12D3KooWAe9CFXp6je3TAPQJE135KRemTLSqEqQBZMFwJontrThZ", "/dns/boot-node.helikon.io/tcp/10260/p2p/12D3KooWMzfnt29VAmrJHQcJU6Vfn4RsMbqPqgyWHqt9VTTAbSrL", "/dns/boot-node.helikon.io/tcp/10262/wss/p2p/12D3KooWMzfnt29VAmrJHQcJU6Vfn4RsMbqPqgyWHqt9VTTAbSrL", - "/dns/collectives-westend.bootnode.amforc.com/tcp/30340/p2p/12D3KooWERPzUhHau6o2XZRUi3tn7544rYiaHL418Nw5t8fYWP1F", - "/dns/collectives-westend.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWERPzUhHau6o2XZRUi3tn7544rYiaHL418Nw5t8fYWP1F", + "/dns/collectives-westend.bootnode.amforc.com/tcp/30010/p2p/12D3KooWRfefWRo1AAB8LCJhVr8DDe9CvBmmKUzJpjd2RGk82pnL", + "/dns/collectives-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWRfefWRo1AAB8LCJhVr8DDe9CvBmmKUzJpjd2RGk82pnL", "/dns/collectives-westend-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWMAgVm1PnsLVfxoDLCbYv1DgnN6tjcRQbrq8xhbwo4whE", "/dns/collectives-westend-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWMAgVm1PnsLVfxoDLCbYv1DgnN6tjcRQbrq8xhbwo4whE", "/dns/westend-collectives-boot-ng.dwellir.com/tcp/30340/p2p/12D3KooWPFM93jgm4pgxx8PM8WJKAJF49qia8jRB95uciUQwYh7m", diff --git a/cumulus/parachains/chain-specs/contracts-rococo.json b/cumulus/parachains/chain-specs/contracts-rococo.json index 71783481e5cc7ba962c04701f71fb21dc0e5eee9..4d920d0f985167d900e739de691fcead5457f759 100644 --- a/cumulus/parachains/chain-specs/contracts-rococo.json +++ b/cumulus/parachains/chain-specs/contracts-rococo.json @@ -1,7 +1,4 @@ { - "name": "Contracts on Rococo", - "id": "contracts-rococo", - "chainType": "Live", "bootNodes": [ "/dns/rococo-contracts-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWKg3Rpxcr9oJ8n6khoxpGKWztCZydtUZk2cojHqnfLrpj", "/dns/rococo-contracts-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWPEXYrz8tHU3nDtPoPw4V7ou5dzMEWSTuUj7vaWiYVAVh", @@ -10,19 +7,15 @@ "/dns/rococo-contracts-collator-node-0.polkadot.io/tcp/443/wss/p2p/12D3KooWKg3Rpxcr9oJ8n6khoxpGKWztCZydtUZk2cojHqnfLrpj", "/dns/rococo-contracts-collator-node-1.polkadot.io/tcp/443/wss/p2p/12D3KooWPEXYrz8tHU3nDtPoPw4V7ou5dzMEWSTuUj7vaWiYVAVh" ], - - "telemetryEndpoints": null, - "protocolId": null, - "properties": { - "tokenDecimals": 12, - "tokenSymbol": "ROC" - }, + "chainType": "Live", "relay_chain": "rococo", "para_id": 1002, - "consensusEngine": null, - "codeSubstitutes": {}, + "codeSubstitutes": { + "5359899": "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" + }, "genesis": { "raw": { + "childrenDefault": {}, "top": { "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xea030000", "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", @@ -79,8 +72,15 @@ "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x02000000", "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} + } } - } + }, + "id": "contracts-rococo", + "name": "Contracts on Rococo", + "properties": { + "tokenDecimals": 12, + "tokenSymbol": "ROC" + }, + "protocolId": null, + "telemetryEndpoints": null } diff --git a/cumulus/parachains/chain-specs/coretime-kusama.json b/cumulus/parachains/chain-specs/coretime-kusama.json index c22daf54db24fb167ea92e8dfb6597b029201c71..3e4ffae403bdb7118fe94befc32e15f497e71fcc 100644 --- a/cumulus/parachains/chain-specs/coretime-kusama.json +++ b/cumulus/parachains/chain-specs/coretime-kusama.json @@ -8,7 +8,25 @@ "/dns/kusama-coretime-connect-a-0.polkadot.io/tcp/443/wss/p2p/12D3KooWR7Biy6nPgQFhk2eYP62pAkcFA6he9RUFURTDh7ewTjpo", "/dns/kusama-coretime-connect-a-1.polkadot.io/tcp/443/wss/p2p/12D3KooWAGFiMZDF9RxdacrkenzGdo8nhfSe9EXofHc5mHeJ9vGX", "/dns/boot.metaspan.io/tcp/33024/p2p/12D3KooWPmwMhG54ixDv2b3sCfYEJ1DWDrjaduBCBwqFFdqvVsmS", - "/dns/boot.metaspan.io/tcp/33026/wss/p2p/12D3KooWPmwMhG54ixDv2b3sCfYEJ1DWDrjaduBCBwqFFdqvVsmS" + "/dns/boot.metaspan.io/tcp/33026/wss/p2p/12D3KooWPmwMhG54ixDv2b3sCfYEJ1DWDrjaduBCBwqFFdqvVsmS", + "/dns/coretime-kusama.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWDG2iif5zcFB7E1huEZUPAauEP34mqt8UVUacHTxC1wJY", + "/dns/coretime-kusama.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWAcZ2FG9uPa3YXzk4Mots94Zm6NYzKKaWvyAFEu2k4WMy", + "/dns/coretime-kusama-boot-ng.dwellir.com/tcp/30358/p2p/12D3KooWSoPisbYQTAj79Dtsxx1qAiEFTouvXCfNJ1A3SQWQzuct", + "/dns/coretime-kusama-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWSoPisbYQTAj79Dtsxx1qAiEFTouvXCfNJ1A3SQWQzuct", + "/dns/boot.gatotech.network/tcp/33250/p2p/12D3KooWMpgcWr5pb7em7rWaQV4J6P2kn3YCjCeP1ESMsJPffn1a", + "/dns/boot.gatotech.network/tcp/35250/wss/p2p/12D3KooWMpgcWr5pb7em7rWaQV4J6P2kn3YCjCeP1ESMsJPffn1a", + "/dns/kcore16.rotko.net/tcp/33726/p2p/12D3KooWCyPSkk5cq2eEdw1qHizfa6UT4QggSarCEtcvNXpnod8B", + "/dns/kcore16.rotko.net/tcp/35726/wss/p2p/12D3KooWCyPSkk5cq2eEdw1qHizfa6UT4QggSarCEtcvNXpnod8B", + "/dns/coretime-kusama-bootnode.turboflakes.io/tcp/30660/p2p/12D3KooWHTr9GLvJEnGYKCu3FHC3DwqBiFg9MQUWsjPCP4YH5xyf", + "/dns/coretime-kusama-bootnode.turboflakes.io/tcp/30760/wss/p2p/12D3KooWHTr9GLvJEnGYKCu3FHC3DwqBiFg9MQUWsjPCP4YH5xyf", + "/dns/coretime-kusama.bootnodes.polkadotters.com/tcp/30371/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp", + "/dns/coretime-kusama.bootnodes.polkadotters.com/tcp/30373/wss/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp", + "/dns/boot-node.helikon.io/tcp/7420/p2p/12D3KooWK4eKFpYftyuLdBdXrkdJXHKt7KZcNLb92Ufkvo17B9T2", + "/dns/boot-node.helikon.io/tcp/7422/wss/p2p/12D3KooWK4eKFpYftyuLdBdXrkdJXHKt7KZcNLb92Ufkvo17B9T2", + "/dns/coretime-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWFzW9AgxNfkVNCepVByS7URDCRDAA5p3XzBLVptqZvWoL", + "/dns/coretime-kusama-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWFzW9AgxNfkVNCepVByS7URDCRDAA5p3XzBLVptqZvWoL", + "/dns/coretime-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWPrgxrrumrANp6Bp2SMEwMQHPHDbPzA1HbcrakZrbFi5P", + "/dns/coretime-kusama.bootnode.amforc.com/tcp/30013/p2p/12D3KooWPrgxrrumrANp6Bp2SMEwMQHPHDbPzA1HbcrakZrbFi5P" ], "telemetryEndpoints": null, "protocolId": null, diff --git a/cumulus/parachains/chain-specs/coretime-polkadot.json b/cumulus/parachains/chain-specs/coretime-polkadot.json new file mode 100644 index 0000000000000000000000000000000000000000..806231db764671eeeddc50219962108856acd492 --- /dev/null +++ b/cumulus/parachains/chain-specs/coretime-polkadot.json @@ -0,0 +1,94 @@ +{ + "name": "Polkadot Coretime", + "id": "coretime-polkadot", + "chainType": "Live", + "bootNodes": [ + "/dns/polkadot-coretime-connect-a-0.polkadot.io/tcp/30334/p2p/12D3KooWKjnixAHbKMsPTJwGx8SrBeGEJLHA8KmKcEDYMp3YmWgR", + "/dns/polkadot-coretime-connect-a-1.polkadot.io/tcp/30334/p2p/12D3KooWQ7B7p4DFv1jWqaKfhrZBcMmi5g8bWFnmskguLaGEmT6n", + "/dns/polkadot-coretime-connect-a-0.polkadot.io/tcp/443/wss/p2p/12D3KooWKjnixAHbKMsPTJwGx8SrBeGEJLHA8KmKcEDYMp3YmWgR", + "/dns/polkadot-coretime-connect-a-1.polkadot.io/tcp/443/wss/p2p/12D3KooWQ7B7p4DFv1jWqaKfhrZBcMmi5g8bWFnmskguLaGEmT6n", + "/dns4/coretime-polkadot.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWFJ2yBTKFKYwgKUjfY3F7XfaxHV8hY6fbJu5oMkpP7wZ9", + "/dns4/coretime-polkadot.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWCy5pToLafcQzPHn5kadxAftmF6Eh8ZJGPXhSeXSUDfjv", + "/dns/coretime-polkadot-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWGpmytHjdthrkKgkXDZyKm9ABtJ2PtGk9NStJDG4pChy9", + "/dns/coretime-polkadot-boot-ng.dwellir.com/tcp/30361/p2p/12D3KooWGpmytHjdthrkKgkXDZyKm9ABtJ2PtGk9NStJDG4pChy9" + ], + "telemetryEndpoints": null, + "protocolId": null, + "properties": { + "ss58Format": 0, + "tokenDecimals": 10, + "tokenSymbol": "DOT" + }, + "relay_chain": "polkadot", + "para_id": 1005, + "codeSubstitutes": {}, + "genesis": { + "raw": { + "top": { + "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xed030000", + "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x15464cac3378d46f113cd5b7a4d71c84476f594316a7dfe49c1f352d95abdaf1": "0x00000000", + "0x15464cac3378d46f113cd5b7a4d71c844e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0x15464cac3378d46f113cd5b7a4d71c845579297f4dfb9609e7e4c2ebab9ce40a": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c20d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c706064c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf6380b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f", + "0x15464cac3378d46f113cd5b7a4d71c84579f5a43435b04a98d64da0cefe18505": "0x00a0acb9030000000000000000000000", + "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x000000008200e17579c4", + "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9381ca18820b278a00faeab03d52440be00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da944098499b5de4f5677804569aeadeb5e4c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94c4f030742ff8899655335ad1e54ca6a6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da94d2dbb242ff048066ba7c14ef24678cf20d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c70606": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da956f8d5eba063b801102d640867bbb26f689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf63": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da96684268ab336f4623df9eab07c482056049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9784e05d1b3afe91a143e23fe5983f63080b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da994eb9f87cb79eefab94a8a6ffcb94bfe6d6f646c70792f62726f6b650000000000000000000000000000000000000000": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0xe2373d0044636f726574696d652d706f6c6b61646f74", + "0x3a63": "0x", + "0x3a636f6465": "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", + "0x3a65787472696e7369635f696e646578": "0x00000000", + "0x3c311d57d4daf52904616cf69648081e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x3c311d57d4daf52904616cf69648081e5e0621c4869aa60c02be9adcc98a0d1d": "0x1ce063247ca37058db551a8d99f2f15cfede61fc796acc464a9cdce4c18f6a46597283ea6b8648673305a3e06be6dd83b7bc1840081d50d4deef1ce53eba21e914248dbf89d86998772b66900d78e98980ea2afc3c8fe5b93f4b38052f3018a2301c346cb44aa03f8995eeee230970772d6268cd7606740f269bb4e609a01a3a15dcaa0b4c6840028f6d4fa8c460d5a7d687d1f81c9de453ef2f5ead88767fd22af0d0e90c36f95605510f00a9f0821675bc0c7b70e5c8d113b0426c21d627773b4a69b6ec0eda668471d806db625681a147efc35a4baeacf0bca95d12d13cd942", + "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", + "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x45323df7cc47150b3930e2666b0aa3134e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0x4dcb50595177a3177648411a42aca0f54e7b9012096b41c4eb3aaf947f6ea429": "0x0300", + "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x1ce063247ca37058db551a8d99f2f15cfede61fc796acc464a9cdce4c18f6a46597283ea6b8648673305a3e06be6dd83b7bc1840081d50d4deef1ce53eba21e914248dbf89d86998772b66900d78e98980ea2afc3c8fe5b93f4b38052f3018a2301c346cb44aa03f8995eeee230970772d6268cd7606740f269bb4e609a01a3a15dcaa0b4c6840028f6d4fa8c460d5a7d687d1f81c9de453ef2f5ead88767fd22af0d0e90c36f95605510f00a9f0821675bc0c7b70e5c8d113b0426c21d627773b4a69b6ec0eda668471d806db625681a147efc35a4baeacf0bca95d12d13cd942", + "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0x79e2fe5d327165001f8232643023ed8b4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x7b3237373ffdfeb1cab4222e3b520d6b4e7b9012096b41c4eb3aaf947f6ea429": "0x0500", + "0xb8753e9383841da95f7b8871e5de32694e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00000000000000000000000000000000", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb31a487e6cc5c348d84c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e": "0x1c346cb44aa03f8995eeee230970772d6268cd7606740f269bb4e609a01a3a15", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb32d8a863b519f21b700f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127": "0xe063247ca37058db551a8d99f2f15cfede61fc796acc464a9cdce4c18f6a4659", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3313cc789e5100ca680b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f": "0x4a69b6ec0eda668471d806db625681a147efc35a4baeacf0bca95d12d13cd942", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3624ad9e747f9464220d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c70606": "0x248dbf89d86998772b66900d78e98980ea2afc3c8fe5b93f4b38052f3018a230", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb368a58d3eb991155a689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf63": "0xf0d0e90c36f95605510f00a9f0821675bc0c7b70e5c8d113b0426c21d627773b", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb39f053c2746e722456610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38": "0xdcaa0b4c6840028f6d4fa8c460d5a7d687d1f81c9de453ef2f5ead88767fd22a", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3d21fbce2a623d5a4049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c": "0x7283ea6b8648673305a3e06be6dd83b7bc1840081d50d4deef1ce53eba21e914", + "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19507a74cdfcf05a85226175726180f0d0e90c36f95605510f00a9f0821675bc0c7b70e5c8d113b0426c21d627773b": "0x689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf63", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19507ae4ba128e21c1c36175726180dcaa0b4c6840028f6d4fa8c460d5a7d687d1f81c9de453ef2f5ead88767fd22a": "0x6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19507c0de6df75d99ec461757261801c346cb44aa03f8995eeee230970772d6268cd7606740f269bb4e609a01a3a15": "0x4c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19508f578a71d93450886175726180248dbf89d86998772b66900d78e98980ea2afc3c8fe5b93f4b38052f3018a230": "0x20d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c70606", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950a074c92c894f26b161757261807283ea6b8648673305a3e06be6dd83b7bc1840081d50d4deef1ce53eba21e914": "0x049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950a273e8876df6fc8e6175726180e063247ca37058db551a8d99f2f15cfede61fc796acc464a9cdce4c18f6a4659": "0x00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d017874cd5fa32f261757261804a69b6ec0eda668471d806db625681a147efc35a4baeacf0bca95d12d13cd942": "0x80b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f", + "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c20d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c706064c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf6380b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f", + "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127e063247ca37058db551a8d99f2f15cfede61fc796acc464a9cdce4c18f6a4659049bec59fb5fe6adea4578250578e89dd7e51ad88c7c92493d6f451c6680925c7283ea6b8648673305a3e06be6dd83b7bc1840081d50d4deef1ce53eba21e91420d8c795eef2620fba2bde74dbc36461c07998ebf600ed265b746c1e05c70606248dbf89d86998772b66900d78e98980ea2afc3c8fe5b93f4b38052f3018a2304c0aa0240b2d7485675e52cdb283a87973652f6acb42c830a5a5faa80f7a707e1c346cb44aa03f8995eeee230970772d6268cd7606740f269bb4e609a01a3a156610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38dcaa0b4c6840028f6d4fa8c460d5a7d687d1f81c9de453ef2f5ead88767fd22a689e1a66fa33b75f66415021aacc4fa23f49306a3c21407748b8b2d39b4abf63f0d0e90c36f95605510f00a9f0821675bc0c7b70e5c8d113b0426c21d627773b80b6f570f356fef7b891afa2e1c30fca89bc7a2cddd545fd8a173106fce3a11f4a69b6ec0eda668471d806db625681a147efc35a4baeacf0bca95d12d13cd942", + "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x04000000", + "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" + }, + "childrenDefault": {} + } + } +} \ No newline at end of file diff --git a/cumulus/parachains/chain-specs/coretime-rococo.json b/cumulus/parachains/chain-specs/coretime-rococo.json index 082e7dd26a952ccf7d156ea25ad208d9468be71d..1638ecbb9332e95c034d97c9667aaf0adbc7898a 100644 --- a/cumulus/parachains/chain-specs/coretime-rococo.json +++ b/cumulus/parachains/chain-specs/coretime-rococo.json @@ -1,7 +1,4 @@ { - "name": "Rococo Coretime", - "id": "coretime-rococo", - "chainType": "Live", "bootNodes": [ "/dns/rococo-coretime-collator-node-0.polkadot.io/tcp/30333/p2p/12D3KooWHBUH9wGBx1Yq1ZePov9VL3AzxRPv5DTR4KadiCU6VKxy", "/dns/rococo-coretime-collator-node-1.polkadot.io/tcp/30333/p2p/12D3KooWB3SKxdj6kpwTkdMnHJi6YmadojCzmEqFkeFJjxN812XX", @@ -10,18 +7,15 @@ "/dns/rococo-coretime-collator-node-0.polkadot.io/tcp/443/wss/p2p/12D3KooWHBUH9wGBx1Yq1ZePov9VL3AzxRPv5DTR4KadiCU6VKxy", "/dns/rococo-coretime-collator-node-1.polkadot.io/tcp/443/wss/p2p/12D3KooWB3SKxdj6kpwTkdMnHJi6YmadojCzmEqFkeFJjxN812XX" ], - "telemetryEndpoints": null, - "protocolId": null, - "properties": { - "ss58Format": 42, - "tokenDecimals": 12, - "tokenSymbol": "ROC" - }, + "chainType": "Live", "relay_chain": "rococo", "para_id": 1005, - "codeSubstitutes": {}, + "codeSubstitutes": { + "1627199": "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" + }, "genesis": { "raw": { + "childrenDefault": {}, "top": { "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xed030000", "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", @@ -67,8 +61,16 @@ "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100", "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000", "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} + } } - } + }, + "id": "coretime-rococo", + "name": "Rococo Coretime", + "properties": { + "ss58Format": 42, + "tokenDecimals": 12, + "tokenSymbol": "ROC" + }, + "protocolId": null, + "telemetryEndpoints": null } diff --git a/cumulus/parachains/chain-specs/coretime-westend.json b/cumulus/parachains/chain-specs/coretime-westend.json index ab2e97fdbf41d43dfc4d75e30358cdaefd21a630..42f67526c29ac5bcf94fd3741a577c68667fc226 100644 --- a/cumulus/parachains/chain-specs/coretime-westend.json +++ b/cumulus/parachains/chain-specs/coretime-westend.json @@ -5,6 +5,8 @@ "bootNodes": [ "/dns/westend-coretime-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWP93Dzk8T7GWxyWw9jhLcz8Pksokk3R9vL2eEH337bNkT", "/dns/westend-coretime-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWMh2imeAzsZKGQgm2cv6Uoep3GBYtwGfujt1bs5YfVzkH", + "/dns/coretime-westend-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWK7Zj1mCPg6h3eMp7v6akJ1o6AocRr59NLusDwBXQgrhw", + "/dns/coretime-westend-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWK7Zj1mCPg6h3eMp7v6akJ1o6AocRr59NLusDwBXQgrhw", "/dns/westend-coretime-collator-node-0.parity-testnet.parity.io/tcp/30335/ws/p2p/12D3KooWP93Dzk8T7GWxyWw9jhLcz8Pksokk3R9vL2eEH337bNkT", "/dns/westend-coretime-collator-node-1.parity-testnet.parity.io/tcp/30335/ws/p2p/12D3KooWMh2imeAzsZKGQgm2cv6Uoep3GBYtwGfujt1bs5YfVzkH", "/dns/westend-coretime-collator-node-0.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWP93Dzk8T7GWxyWw9jhLcz8Pksokk3R9vL2eEH337bNkT", @@ -14,7 +16,21 @@ "/dns/boot-node.helikon.io/tcp/9420/p2p/12D3KooWFBPartM873MNm1AmVK3etUz34cAE9A9rwPztPno2epQ3", "/dns/boot-node.helikon.io/tcp/9422/wss/p2p/12D3KooWFBPartM873MNm1AmVK3etUz34cAE9A9rwPztPno2epQ3", "/dns/coretime-westend-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWHewSFwJueRprNZNfkncdjud9DrGzvP1qfmgPd7VK66gw", - "/dns/coretime-westend-boot-ng.dwellir.com/tcp/30356/p2p/12D3KooWHewSFwJueRprNZNfkncdjud9DrGzvP1qfmgPd7VK66gw" + "/dns/coretime-westend-boot-ng.dwellir.com/tcp/30356/p2p/12D3KooWHewSFwJueRprNZNfkncdjud9DrGzvP1qfmgPd7VK66gw", + "/dns/coretime-westend.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWBFffQL6MvzM9rc8yVwR1Z8GcC9jfLhZpU2NRjsAAFeTX", + "/dns/coretime-westend.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWH2qnUkKjV9Sevp8soFXdcs6r1mj2D2DAoBH8L1ziLzs3", + "/dns/coretime-westend-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWK7Zj1mCPg6h3eMp7v6akJ1o6AocRr59NLusDwBXQgrhw", + "/dns/coretime-westend-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWK7Zj1mCPg6h3eMp7v6akJ1o6AocRr59NLusDwBXQgrhw", + "/dns/ibp-boot-westend-coretime.luckyfriday.io/tcp/443/wss/p2p/12D3KooWBzfzNhvyRVTb9KtNYpkRf26yTRHorBZR2LmYhH5ArCey", + "/dns/ibp-boot-westend-coretime.luckyfriday.io/tcp/30340/p2p/12D3KooWBzfzNhvyRVTb9KtNYpkRf26yTRHorBZR2LmYhH5ArCey", + "/dns/wcore16.rotko.net/tcp/33736/p2p/12D3KooWFmGg7EGzxGDawuJ9EfyEznCrZfMJgGa4eHpMWjcJmg85", + "/dns/wcore16.rotko.net/tcp/35736/wss/p2p/12D3KooWFmGg7EGzxGDawuJ9EfyEznCrZfMJgGa4eHpMWjcJmg85", + "/dns/boot.gatotech.network/tcp/33350/p2p/12D3KooWN6FJDaZvWbtX1pSc6UdHgyF2UZtYxPp3UkXQZa8ko7uS", + "/dns/boot.gatotech.network/tcp/35350/wss/p2p/12D3KooWN6FJDaZvWbtX1pSc6UdHgyF2UZtYxPp3UkXQZa8ko7uS", + "/dns/coretime-westend.bootnodes.polkadotters.com/tcp/30358/wss/p2p/12D3KooWDc9T2vQ8rHvX7hAt9eLWktD9Q89NDTcLm5STkuNbzUGf", + "/dns/coretime-westend.bootnodes.polkadotters.com/tcp/30356/p2p/12D3KooWDc9T2vQ8rHvX7hAt9eLWktD9Q89NDTcLm5STkuNbzUGf", + "/dns/coretime-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWG9a9H9An96E3kgXL1sirHta117iuacJXnJRaUywkMiSd", + "/dns/coretime-westend.bootnode.amforc.com/tcp/30013/p2p/12D3KooWG9a9H9An96E3kgXL1sirHta117iuacJXnJRaUywkMiSd" ], "telemetryEndpoints": null, "protocolId": null, diff --git a/cumulus/parachains/chain-specs/people-kusama.json b/cumulus/parachains/chain-specs/people-kusama.json index 518a7be751509aeeb3973f654b371e3498355949..300b9fcfb183c262ce1fc2279d6ca7bf457bc1db 100644 --- a/cumulus/parachains/chain-specs/people-kusama.json +++ b/cumulus/parachains/chain-specs/people-kusama.json @@ -6,7 +6,29 @@ "/dns/kusama-people-connect-0.polkadot.io/tcp/30334/p2p/12D3KooWQaqG5TNmDfRWrtH7tMsN7YeqwVkSfoZT4GkemSzezNi1", "/dns/kusama-people-connect-1.polkadot.io/tcp/30334/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm", "/dns/kusama-people-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWQaqG5TNmDfRWrtH7tMsN7YeqwVkSfoZT4GkemSzezNi1", - "/dns/kusama-people-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm" + "/dns/kusama-people-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWKhYoQH9LdSyvY3SVZY9gFf6ZV1bFh6317TRehUP3r5fm", + "/dns/people-kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWPjzgKZe5jdG6TY4gwcFq8QxyyhqsYbQo6N29pwGePWLA", + "/dns/people-kusama.bootnode.amforc.com/tcp/30004/p2p/12D3KooWPjzgKZe5jdG6TY4gwcFq8QxyyhqsYbQo6N29pwGePWLA", + "/dns/boot.gatotech.network/tcp/33240/p2p/12D3KooWLi9TzaKX4zniJpiM521PnYG4EocpdqjPpJUhXq9QGkRX", + "/dns/boot.gatotech.network/tcp/35240/wss/p2p/12D3KooWLi9TzaKX4zniJpiM521PnYG4EocpdqjPpJUhXq9QGkRX", + "/dns/people-kusama-bootnode.radiumblock.com/tcp/30333/p2p/12D3KooWGP1C9iWTHnZyeaSjYZ7LdK8douXWc1n1dBv25XEASHaj", + "/dns/people-kusama-bootnode.radiumblock.com/tcp/30336/wss/p2p/12D3KooWGP1C9iWTHnZyeaSjYZ7LdK8douXWc1n1dBv25XEASHaj", + "/dns/kppl16.rotko.net/tcp/33756/p2p/12D3KooWSKQwgoydfbN6mNN2aNwdqfkR2ExAnTRs8mmdrPQTtDLo", + "/dns/kppl16.rotko.net/tcp/35756/wss/p2p/12D3KooWSKQwgoydfbN6mNN2aNwdqfkR2ExAnTRs8mmdrPQTtDLo", + "/dns/people-kusama-boot-ng.dwellir.com/tcp/30359/p2p/12D3KooWM6T8MMibxLZhhpq6F612CZ4FgnfDSJSkWDMiVUDe1aGb", + "/dns/people-kusama-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWM6T8MMibxLZhhpq6F612CZ4FgnfDSJSkWDMiVUDe1aGb", + "/dns/people-kusama-bootnode.turboflakes.io/tcp/30645/p2p/12D3KooWCR2Q8J2NFFfuofDak4zSgWkuBq7orP96HFaxLgAoDUBV", + "/dns/people-kusama-bootnode.turboflakes.io/tcp/30745/wss/p2p/12D3KooWCR2Q8J2NFFfuofDak4zSgWkuBq7orP96HFaxLgAoDUBV", + "/dns/boot-node.helikon.io/tcp/7510/p2p/12D3KooWM1X4setrMWjwnV8iDkAtYhqFHNkGozdWdq6sawWh5Yhv", + "/dns/boot-node.helikon.io/tcp/7512/wss/p2p/12D3KooWM1X4setrMWjwnV8iDkAtYhqFHNkGozdWdq6sawWh5Yhv", + "/dns/people-kusama.bootnodes.polkadotters.com/tcp/30377/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp", + "/dns/people-kusama.bootnodes.polkadotters.com/tcp/30379/wss/p2p/12D3KooWHy7TAuK6EoVij2tfaeh3KkaEJxhTmumbEom3HfRnSEsp", + "/dns/boot.metaspan.io/tcp/25068/p2p/12D3KooWDoDLtLvQi8hhFVyubPZhaYuAwSAJrPFtyGWJ2NSfBiyP", + "/dns/boot.metaspan.io/tcp/25069/wss/p2p/12D3KooWDoDLtLvQi8hhFVyubPZhaYuAwSAJrPFtyGWJ2NSfBiyP", + "/dns/ibp-boot-kusama-people.luckyfriday.io/tcp/30342/p2p/12D3KooWM4bRafMH2StfBEQtyj5cMWfGLYbuikCZmvKv9m1MQVPn", + "/dns/ibp-boot-kusama-people.luckyfriday.io/tcp/443/wss/p2p/12D3KooWM4bRafMH2StfBEQtyj5cMWfGLYbuikCZmvKv9m1MQVPn", + "/dns4/people-kusama.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWRuKr3ogzXwD8zE2CTWenGdy8vSfViAjYMwGiwvFCsz8n", + "/dns/people-kusama.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWFkDKdFxBJFyj9zumuJ4Mmctec2GqdYHcKYq8MTVe8dxf" ], "telemetryEndpoints": null, "protocolId": null, diff --git a/cumulus/parachains/chain-specs/people-polkadot.json b/cumulus/parachains/chain-specs/people-polkadot.json new file mode 100644 index 0000000000000000000000000000000000000000..6e30829eab49a10434a0191852267623c3cfc199 --- /dev/null +++ b/cumulus/parachains/chain-specs/people-polkadot.json @@ -0,0 +1,2961 @@ +{ + "name": "Polkadot People", + "id": "people-polkadot", + "chainType": "Live", + "bootNodes": [ + "/dns/polkadot-people-connect-0.polkadot.io/tcp/30334/p2p/12D3KooWP7BoJ7nAF9QnsreN8Eft1yHNUhvhxFiQyKFEUePi9mu3", + "/dns/polkadot-people-connect-1.polkadot.io/tcp/30334/p2p/12D3KooWSSfWY3fTGJvGkuNUNBSNVCdLLNJnwkZSNQt7GCRYXu4o", + "/dns/polkadot-people-connect-0.polkadot.io/tcp/443/wss/p2p/12D3KooWP7BoJ7nAF9QnsreN8Eft1yHNUhvhxFiQyKFEUePi9mu3", + "/dns/polkadot-people-connect-1.polkadot.io/tcp/443/wss/p2p/12D3KooWSSfWY3fTGJvGkuNUNBSNVCdLLNJnwkZSNQt7GCRYXu4o" + ], + "telemetryEndpoints": null, + "protocolId": null, + "properties": { + "ss58Format": 0, + "tokenDecimals": 10, + "tokenSymbol": "DOT" + }, + "relay_chain": "polkadot", + "para_id": 1004, + "codeSubstitutes": {}, + "genesis": { + "raw": { + "top": { + "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xec030000", + "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x15464cac3378d46f113cd5b7a4d71c84476f594316a7dfe49c1f352d95abdaf1": "0x00000000", + "0x15464cac3378d46f113cd5b7a4d71c844e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0x15464cac3378d46f113cd5b7a4d71c845579297f4dfb9609e7e4c2ebab9ce40a": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c12708c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d4935071a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d94891019778eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b86896496c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5baaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302e89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40", + "0x15464cac3378d46f113cd5b7a4d71c84579f5a43435b04a98d64da0cefe18505": "0x00a0acb9030000000000000000000000", + "0x1809d78346727a0ef58c0fa03bafa3234e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef734abf5cb34d6244378cddbf18e849d96": "0x00000000829f057679c4", + "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da924f98efe9bb1acaf26d612783a88052296c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5b": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9381ca18820b278a00faeab03d52440be00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9529b5fafa1d11181be42fa36618c5bd4e89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da964a799358e9d6f2692d4b47a57ae3ef71a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d9489101977": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9831ad22a3ac7b99bbe1efce6cdb4db35aaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9dfc40f350cc4563ad9ddff5ad92944278eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b868964": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9fa4cae44dc9cd8d9310d27efe3f67fb108c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d493507": "0x0000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080", + "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x5a283d003c70656f706c652d706f6c6b61646f74", + "0x2aeddc77fe58c98d50bd37f1b90840f94e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0x3a63": "0x", + "0x3a636f6465": "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", + "0x3a65787472696e7369635f696e646578": "0x00000000", + "0x3c311d57d4daf52904616cf69648081e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x3c311d57d4daf52904616cf69648081e5e0621c4869aa60c02be9adcc98a0d1d": "0x1c6cd3a8447dd3cbde9a566f35589b7cf25e924bf194b8fca62f3f6797170afe0816dbd3631a6f0aa8831db582ef298fed529d4233253948c4660b47956c4dc01f9686fc719cfdcb5fd9ca74f36f149730171b5f307144ae40db51c3aeb506fa285282d2eafa50e9f77c6089baf9bd1a042d623b28151999ee24ed838e33ca6b64dac2170cc094d7a47fa2b1b8844d40f1a5c9b82358997809f4fa08b1c7e92d7b54461b86f1d81ae23ee86265efac1db524bded8f3eb443d059ab0dee2804f951a483fa77b505877527c4a44ee2ddd246ad66ac6c33e4349d4e83742d779b3a41", + "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", + "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x45323df7cc47150b3930e2666b0aa3134e7b9012096b41c4eb3aaf947f6ea429": "0x0200", + "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x1c6cd3a8447dd3cbde9a566f35589b7cf25e924bf194b8fca62f3f6797170afe0816dbd3631a6f0aa8831db582ef298fed529d4233253948c4660b47956c4dc01f9686fc719cfdcb5fd9ca74f36f149730171b5f307144ae40db51c3aeb506fa285282d2eafa50e9f77c6089baf9bd1a042d623b28151999ee24ed838e33ca6b64dac2170cc094d7a47fa2b1b8844d40f1a5c9b82358997809f4fa08b1c7e92d7b54461b86f1d81ae23ee86265efac1db524bded8f3eb443d059ab0dee2804f951a483fa77b505877527c4a44ee2ddd246ad66ac6c33e4349d4e83742d779b3a41", + "0x6dd12b3ae7975bb95f841f4505bc193c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x7474449cca95dc5d0c00e71735a6d17d4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0x79e2fe5d327165001f8232643023ed8b4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x7b3237373ffdfeb1cab4222e3b520d6b4e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0xb8753e9383841da95f7b8871e5de32694e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00000000000000000000000000000000", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb32d8a863b519f21b700f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127": "0x6cd3a8447dd3cbde9a566f35589b7cf25e924bf194b8fca62f3f6797170afe08", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb33e342a1016938ec896c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5b": "0xdac2170cc094d7a47fa2b1b8844d40f1a5c9b82358997809f4fa08b1c7e92d7b", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb343359886e6935e4e1a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d9489101977": "0x9686fc719cfdcb5fd9ca74f36f149730171b5f307144ae40db51c3aeb506fa28", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb360dca291bc2a34a308c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d493507": "0x16dbd3631a6f0aa8831db582ef298fed529d4233253948c4660b47956c4dc01f", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3a191710c236b8b5ce89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40": "0xa483fa77b505877527c4a44ee2ddd246ad66ac6c33e4349d4e83742d779b3a41", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3a7500a3d1398ee4caaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302": "0x54461b86f1d81ae23ee86265efac1db524bded8f3eb443d059ab0dee2804f951", + "0xcec5070d609dd3497f72bde07fc96ba04c014e6bf8b8c2c011e7290b85696bb3d30ebbc69dfd05038eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b868964": "0x5282d2eafa50e9f77c6089baf9bd1a042d623b28151999ee24ed838e33ca6b64", + "0xcec5070d609dd3497f72bde07fc96ba04e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19501b00830156003f1d617572618054461b86f1d81ae23ee86265efac1db524bded8f3eb443d059ab0dee2804f951": "0xaaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa19508c3336e1e98c9dc261757261806cd3a8447dd3cbde9a566f35589b7cf25e924bf194b8fca62f3f6797170afe08": "0x00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa195099bf45ac30c1b87961757261805282d2eafa50e9f77c6089baf9bd1a042d623b28151999ee24ed838e33ca6b64": "0x8eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b868964", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950d68ba9279abdf09a6175726180dac2170cc094d7a47fa2b1b8844d40f1a5c9b82358997809f4fa08b1c7e92d7b": "0x96c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5b", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950ecd6beec3c27dffe6175726180a483fa77b505877527c4a44ee2ddd246ad66ac6c33e4349d4e83742d779b3a41": "0xe89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f03f94250d72f548617572618016dbd3631a6f0aa8831db582ef298fed529d4233253948c4660b47956c4dc01f": "0x08c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d493507", + "0xcec5070d609dd3497f72bde07fc96ba0726380404683fc89e8233450c8aa1950f2cfd82322aea31461757261809686fc719cfdcb5fd9ca74f36f149730171b5f307144ae40db51c3aeb506fa28": "0x1a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d9489101977", + "0xcec5070d609dd3497f72bde07fc96ba088dcde934c658227ee1dfafcd6e16903": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c12708c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d4935071a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d94891019778eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b86896496c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5baaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302e89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40", + "0xcec5070d609dd3497f72bde07fc96ba0e0cdd062e6eaf24295ad4ccfc41d4609": "0x1c00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c1276cd3a8447dd3cbde9a566f35589b7cf25e924bf194b8fca62f3f6797170afe0808c4107d205432aa56d2018d46daa0b820669d068b11abb5588584f05d49350716dbd3631a6f0aa8831db582ef298fed529d4233253948c4660b47956c4dc01f1a306dd46ee404511af11b9123964dbf1ec087aef60b766f04de5d94891019779686fc719cfdcb5fd9ca74f36f149730171b5f307144ae40db51c3aeb506fa288eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b8689645282d2eafa50e9f77c6089baf9bd1a042d623b28151999ee24ed838e33ca6b6496c8cf62f725741306fa59a240c8a721f1daa9a6374897e4530a33e5e0b0fe5bdac2170cc094d7a47fa2b1b8844d40f1a5c9b82358997809f4fa08b1c7e92d7baaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b7030254461b86f1d81ae23ee86265efac1db524bded8f3eb443d059ab0dee2804f951e89a539b16e7cf02cde91ab273572701a7fb7bf712212a75d2d48cde142e2b40a483fa77b505877527c4a44ee2ddd246ad66ac6c33e4349d4e83742d779b3a41", + "0xd57bce545fb382c34570e5dfbf338f5e4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xd5e1a2fa16732ce6906189438c0a82c64e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000", + "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x2aeddc77fe58c98d50bd37f1b90840f91f7f3f3eb1c2a69978da998d19f74ec5": "0x10014c4bf7f93d0a5ed801ef778f8e7ef58201bdd7e33e167faf42a01d439283cb430000000000000000000000000000000000000000000000000112ccb53338ac0da571d3697548346fb5f0b637ac9412f8abbf6d13588be7563200e876481700000000000000000000000000000000000000010a8a307ef15b9f928697fa09dcc72a2c19a266c1d32fa158f9916b8b804e1621000000000000000000000000000000000000000000000000016c0197856b35c7f631f5aa8d9cfd83f7e75202b0d821e67d2f344e4e4b5fc10f00f2052a0100000000000000000000000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2006493592d2d556b7464ab5a2010fa1015e447e7b7a849d4489323a706823d8958db184c8c16713f1a6a49009f6da96e": "0xb66fc334c7c76cef9cc5ceac0f4b0837d845453a2e0e84703b280edf202c8f760b5554584f2d5374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20068043e94d92496a755395960c92c01727dba627f34c210eba395fc7f60d28b3a58c5dbd6b63fb4f9788ee764b2702a": "0x443c76dcde19df9387486ded7845c6d85ec2a4c17f38f8b1e7a0a14de7968d7d0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf200864d7856330936babd0f2130910648369e319d0c1e71ffecfe16b614f13253549f2ff0c6db558dafae395ebd5a300c": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033433", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2014724ea0c978db0335470e92fd7ffb0dc559c88e35aa258566bd616d0e31fac0efda3d881b52055a31b35892086bb1c": "0x08754abb6afba51a2f74f0b97bbcdb383f579a02a5e4541fee736710af562c6c05f09fa6be", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20151be65ed0e15cd19b69f1cf8e8d9c8587b19cc62e01cdc18a1499cda27b0fb33264d0c3817668609bb58f762012698": "0x4eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d09434f554e54414348", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20173c5fd326bb9c3ad63ef958ba861ecaa29d60ab7eeb8c8ad1e7d37f8438bb02cc86c40c28218d4f183f110067cd368": "0x7059b7d9ad6e9f5bab40385874989cd04aabbe821094b7e45b5e4de5ecf2bf4a00", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2017d70cc4f902c5ec93f5a80574ca9bc6621dd4e5cdd0ba737c572710c13df35b316d39ecd12c1ae1320bd6db069a07a": "0xc5c184f0565e2192d6aedae584ee736cef875f0e1c558ee3ede26869acd0b4d6085368616e6e6f6e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf201b6d49bf7335fd2a47d244d1d3f6c8d2c2a55b4fc257dda3887031ea29fbe2a8ea74764db0f3ff3ee746b58365ef325": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033539", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf202166ab613084a5ece818b570161ed8642efa2e57a813989da4bac4551e4010ee45003fc3f360f5202a958b2b1a29918": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636336", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2035cb8990d4714a895e508b555712507627922c9fc2d2f0b5707a3f0cf870fcbbc62ab06f4e4991cb04d376fa3593d6c": "0x922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c05f09f8c8d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2050f0042bc78abf5811c975c536e15fc520aefaa9aa8f2c237f96957bc1858cce594c62126484c3cef56600e11580a77": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2057979cabe7de93da0abb82a766b3b7efb944d7e992958540251fca02926063121bd452d21e0c20fedad450db1e5f713": "0x2c0d08e42e58247b57421f3239e0e192b21edaed4bca2458028c981634bdb607064f6d656761", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20583b3d9b1ed1c173fc50aac0402490d1234713d080856dba6865b23424e21b5fb50108669bc5762f955d207eadde13c": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf205ada907b9b2192a05c5f90bb405301e8b1789281b38392a08ab0516a21dee49fba6f5e55381106ff7ae190563cc84f4": "0xd0e903b51697fa10a7f8c7e5c750fb3c2f90424b749be8b6c0f0b120f5d7277c04313030", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf206a3f85b3cc4345cefeb37661d6ee78b9a7d620473c31a9f77379b12b25920a83b43e0f5700737d9e370dbdd9738c84f": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c41305504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2070e3179221114d6c84429bef95284b31de154f8bc16e4a7bacf303141c913d91b1efdf4ae06c3a227f0a2877a19e90a": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2071560eeff6ae3b3b71d8401212feb5dc4826569e68b7eee1b5b93406e4951fcd7ab6b40be519a7db5c6732f66da1149": "0x9a8ead39ce1b44f37d16e98496441be79018e910d5f58c0fa1518d8fd7749550165354414b494e4720464143494c4954494553202331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf207d4eea50bc542582e7bd7f9ebd88127788bb550f52a25dfdfe1db243561efb956924b8f0a76c16c62ab47b9f6d1cc53": "0x766efcb5851054b4aeef694a3ad03d7bf36980a2094c07cb7b7cda28bde5e1490550563031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20871a5e64051b560e2cb21e54593d5b50361fd2cac02d6b4d6b0f31f3abe70104f00924a85bebed0b17267990b38c88b": "0x825872f7d324c8d97a9d5f5c94d918eea93ef783f305767b768a76f9fede7b4a08e29aa1efb88f32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf208fa00eaac2ff041dec4370d628e56932c2a55b5c60139f9572ec1f88f541744ad98ca9cd09b5641e84088ab0ab3920c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033039", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf209aafad24b64b451542eaa9e53554c972acc6987e6d1c5087d414d72dd8ce665458dfd16d7447ee4b0336ee869e4d0f8": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e074265726c696e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf209b22346bbe4c12f40735b38d11550ca7c2496b1630a27a7946e2ac806c8e0cbc7d12702175153cd0eddff10898e9036": "0x4eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d1447414c4c4152444f20434f4e54524f4c4c4552", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20a1820457ae2a0ec47f77b0c4fd7a90ef4fb68640df03aeecaa19d6eefddb11516c42b586d0ac0e56f354b43b70fbc22": "0x0ecd029fdf9259e900f08996fc9862ebfe100d49c439f19bef7084b258175a1e033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20aa75245f349ccc902ef28c8972ce22f2c2a55b59871ad2237ac147d19b7ebbbda39957b7d5881df0e5c849392556776": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033933", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20b1475172a54dfd1e398dfd955cac12f3e5e8732b01a310abc9d0ee2173b6e7f3d00b291f1ecb2f424499c353e4ad955": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0c636f6c6c65637469766573", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20b484764ce9ec38ca237e5e7ae691f50c65de6003709aa5a6b81354c00fb13e281ac05e852cb4194c69f78566e8ac828": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20b484d192ba61eb0a18c66d4510298951857d6c0ec8d629533be85a017b52214c8c4954769fce002fdf6073c0b177f3c": "0xfaff1c4b5a94649e0338783122b93a469eb9e2e375bb71c92028a8fe9b6e2f460c4e6f6d696e61746f722331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20b601d35d778df8c9ff4b4c804a7d416dba5e754de5c965c3a904ece87b7a0304c642664457bd2159f108cddd56d781a": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20bd1e276fd50ae93a76137748b58f99c021ba8ef466ccb7a06bfdefdba01817e620ada5954c34f617f6662e267dbda15": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20c14f56cad3a694385e575ddb30439ad3ef37fce11457ebc5f00b154996471fcd30eae17efe69e5a39b12b76034dc7e4": "0x922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c05f09f8f9b", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20c5eaa45a3c7028471bb1543db1960e4ba43c53c2e9bf804aeb0e0f3172195defa009198441a21cec8738d366105e447": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370574656368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20ca3ef735298d802137e17dbe7c40b1f2e544de1fc9198d35dd459c8ff8bf0a2c86eeaa4ed8ad9b32fb8d016e696ad77": "0xce44b6b392394133943e063102b113e0577108fb9cb3000fe04faec3a3ad393409495354414e42554c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20cc58ce868ad168d4f875a2ae0be02522c2a55b5de12066d4ae584016c6d556d36f74984dc2fb33b372e568e404c0967": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20d219ed091a75e123785a4792909748d90ed88ee1c02bcc5938985c79cd8bf1a048a9a01f6eecf8a3aec9a83aba8a20d": "0xdc3aee12519c19be02628b0f808bddda9aed564027ad809cd392c13e9b924b65095452454153555259", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20d2fc0f5be215d7720544394b53b3ec54cd38181e02e880a53114ccaf987a6f51a10bc1d172d509bab6f7e9d6eb2e00b": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20da96916551e4252c33923bc9c88439a189ef65d1a77acbc1492c95ea3a58cb70b9ffff211190368bbfa21198c734c2d": "0x5ee1e16ea093ea043d7f67a6f34f440c5fb921b56b54e81c177898d348685b510a76616c696461746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20dd3532aa765f11ae61cff441b8f57e89442a11a7247822dfa83dd5c27ea7249cf2458e60ebf82ed760f9e6d6f99bc7b": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f024a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20e8997eb93d61a3983e2dc3309b6a1d99af6c56d6840c84e110de42cd72b4f82d0387238d2302a937026c23940d01241": "0x6495827bfe0b07d16c549eb10d7e45997e95788be44a3f277af6befec99fe62f033033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20ef5aa56fbb147fd809ec0d34de57fb2a8fc72d20690562e27bb10f078d2de104192ad2d0cbfb4eec4eef42381f53739": "0x3a5e67c5be0b1a151232d17929a6479d7d7187544a40c059664c6315e94c977c0554696e79", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20f03b4daae0b5edd7cb1f9a43a5789f9221125c5934d75259f335bfdce9d6aab9e4c6b57724993f32f555ffc4e75d070": "0x7600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b448630653462d3032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20f538ec6d619042352eb413d7b99d47f6011856d19723839074419b4519ab65554fac975017c6f08293f0a0ba8ec9838": "0x0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d01917919757664476500", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20f695c13f73b9c2be723b0c2e989b4ac3562230e5122411d1c436c426567ebbe517120ac76620baef8d5d78b8a2db938": "0x32d4d1b0dcef676d9a72f6abf9aec55e129ef2de135ac172e19c28a9adbcad0b04303031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf20fefac2555c2ed69906212c204ff33badce2db9e809d506f5bb1523baa031c25f48d3448eee538a23766c2686a7ffe2c": "0xbc1deacfc7e5c6e5f0373560c14fbce156ff2a0ed7e208d049ccd985dec85545065367722041", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2103db706f058fb143b85c4947343cea709e125c99b3b07749c78742584a990e78457e6424814870b165823547d3d6e29": "0x00004bcdcc7d30d597e19c7f87652b69736066b729f7e8543231a10760f8157a0230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf210ad3343fea5177276e8c0477a2931dec2eea43fd0e45e0e756130e01667533bcaa001e29e0192501e7ce2186ec3554a": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21123dca0f5481ee652641df8f8902ce6a6e11253e1600d4a54c1c233df15bc0a8b600e01f85ab764233da2dda657d439": "0x4eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d14434f554e5441434820434f4e54524f4c4c4552", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2117d80b0e5656b05c7ae68162e784be2a83a9d38e1fcd76d6e82eaf458c9b71eba96a9e6540f39213fa01366fe0fb64a": "0xb4d599b32c954b0a9e554c96b248f3e66046a82f46ac914fc675938f771f8372035031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf211dc5a1593ab45d7628a26ac20ad6ea7c97b296323e5b62a72504892a3ccd4fc0b1b206f4de9ba0e9764d9ed9ebdc276": "0xaef6619eea08f01aef7e47d460f0730b02c075e446308892e55af56af15721680872657365727665", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2129c6c4278de6ae0e63d1213dce8b06a6cb7f28f67bdf8862d6ca0ca68932257d665d966222ff24f800291451121676d": "0xf3b15e49aede08aa29d7400da8d3b4fdbd284b5bb1f1af1a53a8c47398f1f0930650524f5859", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf212b57268458e88863db3a3246f664fb7e4fc83d05b1d8ac627cc89bbc95e7379aa395cb168db459fd18c6bceb6d15234": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a06474f4b554e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf212e1ebe0cf66f108c421c8aaec37e4f620430a70d2db1bf57c424e5e81de47ade7f1f0ceae2b568b9182ecf9b025aa35": "0x26171b3ad75723bf624a27485e51e4c2fe38f4b2d24ee52b86a979fb772c513b1354616c69736d616e20476f762050726f7879", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2139adafa33f6c18088709ccbcc3b42887a33d68fb22e4ae32721ff41285cc493d664753a7d71234c77dc2eefc5782c0b": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f06626f726f6e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2139e455f66860eb4ec2dc909d5e10310adcea185416af2d3e8df8c1c8ee8a634bf1c3275b3820cb6d935300d42c73b2a": "0x5a5f7eb7050fb96d8d7895d9afce428a064ce66e3b094805bcad9a8e68cb993419426966726f7374204465726976617469766520566f746572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf213c2c879ac14d17b989296183c4c2e8f6881000dfa449822280d217523794e016588e4a6c4d9c14e79161ecfc085e72f": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf213eccdc1d0e24a1cf5c23ef55b31ddc4a082ef6765a3eef5cce291b2507c5ac3d6ffe5e10ecec2525d1554b8d2db1440": "0xe043d8f7872cd895f8957c9179c4264816be3e649713cb3bdc523f752602cc3a03320a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf214478ae78e9c797f4e889eb575b26a1cbc1729a527ac8770c18456f142dc57b24069c9ff1032d6c3a1572d84b811ac7e": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21480139f39d0cf727f90e16e6e9c79252c2a55b573dcfe35afeb7bffb31da83e9df9ce87ca0ed20d9751b2e823963342": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033535", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf214a23f710bf657cbbe2e97111e100040927d335e751bed3dd0da74a10e610fd2996eea79b625bfe519e8b9d2b96ec75a": "0xfaff1c4b5a94649e0338783122b93a469eb9e2e375bb71c92028a8fe9b6e2f460f506c65646765204163636f756e74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf214b9473e6abfab914fc53e79bf75c3c614860e374c2789388379dc1cdfeceac093c9cee7a2ae8579736323c589c59e42": "0x3c017930b46ab5a4413bf3153b001287ed5ff7fdbd2734cf69abc843f4ee044711f09f8c8a4164726961746963f09f8c8a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf214d858e92dd9a7f8ec1fa8d00a47f0439c14dbe4982ae73a084bafe1f7eea2d51f3819088f08a10eb2fd7a1343c5140b": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636338", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21536cf1c289719ddbcd93b9c88453e80f0cab0c194935f449b3baef742e992ebb801fe38ab5c345d7a6195740399cb50": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf215932a8a0140c5ca04b27c0de3c002e22c2a55b5b35dc5768afba71d0baf2377ee6f8e235c27d04ed90d75e0fff80625": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf215c6f0e69b0626090d1d8a1d5b91572deaeb8cfd46b3d6a0abfdf3961d572ddf2303545b03f0b1870563d38c69de4f20": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a0530312d63", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf215ce3a42d473cc74319c2a7c9c1fc302be2daf84705de34c1930370f53566524b08145b4d192d6cdd5a35cc71930e240": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb3893450563633131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf215f325f62b3381ffbe480cb4e965c038daf47069cecf5c31da9a1cfde3732d2b701bf9f94c77ba7e99335d6b30ad080a": "0xdaf47069cecf5c31da9a1cfde3732d2b701bf9f94c77ba7e99335d6b30ad080a074d756e696368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf215fb270af184e461f951197eed4f0365b4b3a27f1b0da0e787c0863ce2307f5617f485a8c27f0b17c2d3176e788c3e6e": "0xe21727312b2b7ce579dc0f82f129d4edecbcf00abca607d73ccf16e8352cc77705706f6f6c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf216373727b49bad30b97a966db68486122c2a55b50302080081e20a336b40dac9b5ae2ae80692b653c2b38131047d797a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033438", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2165f2504526b6cb7a840e50f0c3dba82d8c67a57859b28434a12f1a078e2979d8c1dbb2404c0e15fe75c1c94e39b2061": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5416f09f90b620536f6e206f6620612042697463682d32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf216a16a003b0fb10dc916b9dc13c064b804587d42f37709c7342f3e915b5a1c6f64ca916b9fa8279480c8602c600889bd": "0xc804531378242158a794bd06c1e9ef0e569f60bb32758597af80e5e70c07a64f037031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf216cb2cf29041c3fe48a99e396bb1021e2c2a55b5e1efa4babefcdae07c4ce9c4682b1f57b0f3080ff2ead5ea06624b6a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e08436f756e63696c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf216cbfd899588e8acb3f3f52a415f933ee40db41d7f07b2b867fae0d7b8ed6767d23f7b53b032710dc5b5043474bf1d11": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2176d35ae3da51e17d64a315dfabcd4fd2c2a55b56da37e71236c50ab586ba5ba55e3479c375ff4b9246082b5d21b4b7b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033534", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2178451b572b6a54120a14059926a330bbf10d082fee91854f7a6a6c56ebf8bf0d65bf914a683ce4ae1db5ccece06ad27": "0x7042bfc6e75e1277fdefbea917f6b7ca8c36b3e0ad7286d66974c8f2b4cb96720d434552554c45414e204f4e45", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2182542d27fa1883f8607a2f851a2a82e4c4bf7f93d0a5ed801ef778f8e7ef58201bdd7e33e167faf42a01d439283cb43": "0x922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c07e29c8defb88f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21833ae47b521ef27e9ceddb1aec06a2e0d92a2524d501daccb88d86720079731f9b53038e0aeddefb8828afbafa5eacf": "0xba57da1251d785b2d433ca687c510a82c284826b9b79859b5774a84f7000e9281e5b315d206269742e6c792f6265636f6d652d612d76616c696461746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf218b2fe7149f81b3bd02be7ec2b961d783856d90462030b27957c425b33bf8f8f669ab715580e7f64f36999a74cea3936": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf218d2efa59b90164b82e2b35a855561252c2a55b5cf8d00511ef54ac7a60773810e906befb1b322f2d58199963dc97307": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf219694aa2e266a931182f4a75c123a8f22c2a55b5b1da68fd2ca56d83bafdbee8ed436709542031e625723d4cb0a01b31": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033431", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf219a6b776ce41fe6ce413efbfcdd807c5a61fb8e0537d0f6c8d4f94d0466859215b77e5e53c44981253983062b7a46f72": "0x6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21af083704411c31490ba60a373f73db91c6ea9855f8f85002cb80858c01488a8ec5f459b1265248752b967a685eec446": "0x589e41f29ab08f2d0e4e4bdf3d1c8a868162c720f9c31e22733f8d633fba901e0b4d6f6869742042686174", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21b35ff62ffdb14bcfdf065e0f57d762356196c14df0a7036b943ecd01396685e799f786c0f131796c06850ec9342ff01": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21bbbb23d04ad5dd2d4e8508f5969106846351b08b39356e218524151eb16da7d6678c6066a831d6ad9b9ceea25d6df07": "0xbe776c10ad0e1fe7f606cfe42448e02cdb640c21214ea6c0c99df36ec0ee3d0d0233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c045bf7d075ed7c91a36c40a14cb9263c235e80e35082b668682531b9b062fda39a46edb94f884d9122d86885fd5f1b": "0x6464f15335eee136dd7c216b994ea6ac3394eb723590e9e065fd9061e05d00350b46656c6c6f7773686970", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c06bc31ba96a7f758a0e14d5ec4526428599b35f8830b27f465e77733dab096524c56d03921532c474f06775af121fa": "0x1a0eb7fdecee073651f1a21b9779b7bf5670493a0e35a53ab83b3cabab814a77033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c12ba9744db9abc0b25d514a40f6fa0ae60938e514a0fc95200df7940bd0fb0f983090e91043b76f3186c6300ed7437": "0x5e34b19d7230f1ea5da6d4b8fe6ede9d05c2e55b0189f75b967862c1c43d9a1f06f09f92b032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c36c43f322a7b65e863e6f4038d8093e272df04c4d1eef779341d14da26699e3832ed5a73ceda96a206ef1c4569f477": "0xf85bd4ec9a558cde3f05e33b0b74f9e732cc41f904894873247d4c435a3b8b630c53544154454d494e542d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c40f05bfadfec08638bee9d955d3ee1eeeaf12276eba3a08a26a606cf4c7cee9c3c0cf56a781899afa463104cdcf842": "0x3e8faae4c5713c72aea65d52aa1616d3e918dee3819fbbe08cd4c76dbd754a5005504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c75c2a4ae6a5d39f23cd563ff56276b2c2a55b58a05d949b1ebe3d18f1d3f4d43ff93cd8005b9cfdd884a901761ea3b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033733", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c80938d9854f378c6fe5a24ce100925b6c1880096a49c2719e0d6d8e863ccbd075aea064a47cf81c96ca5ba5d45f83e": "0x6e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe15407444f542f3033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c83a483946d3f1c3aa060b653146cfac2de6256e9ff0ba9b97f862290f69ec0f72b31fa0a6843e0175e9e81a0165d6b": "0x96e24e9b5ab82dc275b82318a52cebed1cae3e25be096d5f288229b256359e43054f50454e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21c8fa480da0eb301487c191a5a50264cbc61f6c2ba5b42da936c12c7e5c33f6cc573988521e5350de5887b20ae9cae49": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb389345076c646f743032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21d0913a4692809429ee2d8bc2051cbd15c5c5a4a025f3d8be84fa9ea36383c2cd168c8a018d50c88a34154afe9ecf04f": "0x09cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb304474f56", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21d302f9eb23c25a19e4b78c34d8dabfe2c2a55b4f956b33fc6d43013d320b87c2eddba31b9ded535099734d6f3aba80e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033533", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21da37359eeffa7892d596bd8440f1f52d7264854fc5645d065341b90947bd9be1564df8220073eab4043f4022e633e8f": "0xf8f0244b95932b7a67caffd31de91edc5cfb3aa2a13f6199f127ce51c558204a04313032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21db168782360a02e0679d89652545d7eed6f8c70207598bc9899581a491dd8577e82f0ab65d5a78318b74bf51315841e": "0x0bb5e12d2f6ada25c3b64171730f1c9efcf76d3bbccff01abd9f92a9aaac10a7085354414b494e47", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21e28beeb7fdd0adb92e733b92ace02f951dad69a99af405193f3eec7593e9baff022b7fa55de147d1b4f9d2147103885": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5414f09f98ba2050757373792047616c6f72652d34", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21e3c9fa5071901dd03fecb41ee97416cfe08b40ca50585eceadf8c27c0711d8cad57d20cf68114b8f7fd6ab32534dd25": "0xb0b000e408509bb033443af0bc700ec11894f81c090d58d7dc2ae3174c54902b0232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21f5caf66504f9b5c55c013d59b368bb3d44533a4d21fd9d6f5d57c8cd05c61a6f23f9131cec8ae386b6b437db399ec3d": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21f69f16bffec7fdeb53ba4f6835f36450a2178b090386d0e2645866868143abc5bf6c91af252b92c0c38174200f42904": "0xb204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d6803434c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf21fe6c0847625867e501f08fac1f82bba698654b9b352da92d00844ba8bab505a2cefffaa6269cdd2d407cc866440fb88": "0xbcf647b00211b2d6c8cdb9e091b95ba03ac8bc6a4dd0124f1f09f8c917d1d2700d44454741204953504f203031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2202d3104effde185b2c83268c09720f15a482942379643a03b8eca91f12ef9ed1baf5437080664727117fd2ae6e7dc56": "0xdae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b0912303520f09f908a20414c4c494741544f52", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf220670ee6720bc60b6e5d4994782c129d0792d0467f5422f1617840e11eccfcc8bd24bab23b0ea04de920c1109e1e14fd": "0x00555ee596210f641d2d48b9a1e2b258aead3fe8de4e973bcaf5f24674044367033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22105fc080f09ad9a9af4ab5073f49241b023d129d9a0cb9490d097dbd3ca947d4830d3a6d7e0fa9975ff2789d9d97352": "0x9eee1e58c17ff7b037f2da5766e9bc78d5568c58d45cf363b9630ef32b2ccd79033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2210a4cf516e742ca4c85e9446ad650b40a7f29211d50461588ec3c6857c9ca25474c650c7d2048ef2283a2245ceaa831": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf221f2017acea08193896886ba2d42fc3652ff057f98f0c1bed31b2fd1ccd8de4d4acf957e79b3f71eb69820bf0dc1d22d": "0xd2eb07f02043788e254d9e2df57be11566d241c56302b91199b4647947af30200232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2225a8729dee127dd905734cc5723d49f2cce76137e2e2d9bb63e081d4074cfa4688d7d9781d2888f36634f646da62561": "0x02385caf9a08b92ca458a0b817a8cc303cefd5a0c6e108cb939e04242b9e007d14537562517565727920486f742057616c6c6574", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf222642465200f772b3b2b1edd1bf3e5b4e33f4520b7954cb5fee8778b44283deb0948c23c6b432058b21ee84e92085f3d": "0x7cdc1a6a5a7f23437b6528edcdf553d0685f940a4e6e85579727ef3dc574563a04563031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22289e37568ffd6e589cedbae8f8bd08b50ec868243f5ec5af29a7c679163a34978815b6f1d6e2b871f1f361cb7a1f905": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763036", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2228f19ef28c6437f274bbce95bb9abc52c2a55b5a609baff13899d4ba4bafec105038d66a716494968fae1a849d2dd5a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033138", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf222b1830f288a869371d356dff4b9de2d2c2a55b572c2850205aae1bb28cb0f6fe1c0e606353f9dc420b3796317bac454": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033935", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf222bdda5695f76397063f5274d21e8eef58cac93e1f29e4fac5351cd9879164bd90286cfb45af827fc732fbc462d2eb2b": "0xfea885b4e897d4fe908db6abeb39365ccc4689c2b6437dba675a4a0a0c0a6610033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf222bf1f493b44e5bd3fa974b18a6f8902c4bdda1c96506117589bfc216f9e5e79510c179b367f31401e01f1997b47181b": "0xaa6646d5b85790bc0ab869d80385fdc10e1f4befa7f8a4bf31848f73012d2823036e31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2231fca99ee3c9a15da8a33fa1566cfb508eae5dfcdcc8e1890cb16ac515d4669ed0653e98623be435327545c72f5aad7": "0xac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f08436861726c6965", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2232e0329385e5d391761079dea3d56802c2a55b558917616097dfee7c9142497c66c77b194cd9113d0e65a11ba27660b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033436", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22362b72d0d51c3061db69726c0af97b5e27cf0ba46292cc95548cd67e3e29036b0eaf1ab66a4a6f5d7065408d50b9759": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a054d494e54", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22410999d9e4425e03a0412208d1d1c260238a0a2b0989bb426df8ac92118b4228a81b354d0c87d8acd25c8de509f2226": "0x3e1630f099540e76e98b9fb0002c3a5ae3f40b6ec180df68fe5cd9bd2088fa18037031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf224d956ca739cac656cf377d51f15ca192c2a55b5e3110687784ba7063753757ba409052b2989ab9def09a684e8aefd6d": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22534923a0207bc8d69878844e0a5a08da4c5b68728f7fdbdb4426714a385017a471d5cd22a156acd30a40277e6417b60": "0x127a30e486492921e58f2564b36ab1ca21ff630672f0e76920edd601f8f2b89a07415a494d5554", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22586d346a46a84b96f49520a635b61a9b0583167a388bf2ec1c4ce53d17be27a15b23abdd97265571a5c65bdeabd24a0": "0x1ea80b0dde0e207c8ec57ac05fbec636502cb216bb423642919679fe8f074051164e6f74696669636174696f6e7320626f74204b534d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf225ea69f6ea3dc893c1ccd4a4f289aa91c83b0bba37f25f365e26efbe6c9ecfa7905dbdc0b0e3ae60b29980b42c509c6f": "0xa471c55caca4be7b4e60c6e94b20f9028883f8c64287d4454130c657383c3442035633", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2281ddc7d5bf747f585a24d4c7fe7a0bdf6be65cc16c65708bb6a0e4b9958ffe23d1c56ee5683670a69dbbbb70c10d507": "0x127a30e486492921e58f2564b36ab1ca21ff630672f0e76920edd601f8f2b89a0a4c554341504f474749", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf229093cd71dab62c83c7998ad273215375c2721c659829b4fd0d827879873fbd8763969b48a7724633b1e3d4c3b360961": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033330", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22914b827b96f4be7c6ad605f529ea76f0a3c9a0dc2a4578d4b58cce45258b3ebb0644502b355ce1241f8a38bbd1c0a72": "0x8e07d43b19d901badf3a7f57155ca84f2f835448e93a141bbbd33eac4b767d150233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2292060b3ec84919e065fc880f1789cc72c2a55b53f73b4d26ce6c62b0082194560e4a186f3491e8347218c775dca4830": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033530", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22921ebe021aa3387530a48171fdd40bfa26d8e7561ea8e813da3ee0979be1b5190fcc5d2d1375dd5c2e6b2f417aa8153": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033532", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2298cfc99ac1dde155aeae1c27164ea68b64c29324eb942fab6b41cc041f0e099f35d5c7fec824bae17717c5fa68cb83e": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763039", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22a27a2cef808327c413d2bb72bec75b92c2a55b50699f7db6f499718d572de81b0d1843c146624daa99edd9a6609ef64": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033730", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22a7915e444abb79d13c0ef789c8ba605822058fa0d13ffcf079d48b96c07f71f6cfd7fc9abfadd85e205ae7a18d7bb3d": "0x1ecec4f3062f61988b13e9dab318860bd0fffe5b7b37880d50a614a0a20c250215504f4f4c20343220f09f9a80f09f9a80f09f9a80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22aa8d84b13d7d95d38edda8f7ddc26dc8413fca2f93b3526794f655fc3504b40e0dff0648a4999f10f8eca7c21d1c21e": "0x5c3739d60301126756a7510e34f9d656d4435cd4fe64bbd001f1f3473bc9c33304763031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22abcecf1355c686248adb72f696863f73091c08dc07b367c41b57585aeda74490c1850166bcfac4081ed66117f668361": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22b4ed39fe63efba483fb4613a76d2cb644d9acd86b036eae410384c8fa0d073d47e74712a5787451463fbd717770ec57": "0xf0673d30606ee26672707e4fd2bc8b58d3becb7aba2d5f60add64abb5fea47100ff09f94a520486f7420f09f94a520", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22b6f378e7c033da5bd805ebedf69877992a8511f5619229d4e1bef8344cd9a5f85468e238fd95f843dd555b204d0f00b": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c41304554b32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22bee25df560006547c2bd09e33dc95698818f1b289df88876f0199aa1fd723dbec6e7bbc5b08e5eabb89edebfbe3983a": "0x807e371d9df95983e2b9face8efb67f962816f1a0c6681cb1e5455127ab45c09033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22c4857f7714c26e3c24e22139345ecde482a064f119738425180e442727eded171c8091bd90182c3071f37199d954158": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0242", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22c8bf0692a8248b3dda3221d989cfa3b607262b83b9349efcad72b5f2a0cbc80b1fdb622aa81a861a56209014e568337": "0x2cd49434353de1d51598b44df15fcfed1e26224e055923acc9f9af881dc31d5a0232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22cd9bd13911d8c2e382a171aa28b50c480bb3bb99df51400d9aabd8e0e6b6610d3d4f5512ae4d46e03f20ed14eb0cb3e": "0x08ec72cbf62bb66f416f46f988e130585c834a381efdbb0755e30f47a2a0da5a0c46555455524550524f4f46", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22d0e467198929274bef8f7dd5e84b23796cd6f382ca54348f9bc846929ae16bd49da6ef76b19211da8afc0a1f1c31d32": "0x7e878e54c1374b30df335d3a193f3e6b1f84db6c2270ee634cec769d7e33e2440e434f534d49432d474c4f42414c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22d80678c14147d5cf8aab732d29ca19802e358bc31b7ccb578dcc5c36ba2908f311ac5ab2ba8c1483595268a7189fb02": "0xc5c184f0565e2192d6aedae584ee736cef875f0e1c558ee3ede26869acd0b4d605476d6248", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22dba51d56b92dc14d744bb0a1b35fee52c2a55b59c3999f441a596b34e41f0d55a88c0f9fb7af4c76241a6f5d3a3e514": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22df2e6889d45ce8ff1467a26a17375ea4a8de2c6b6c1690a27aaa4cb64e0168bced54ab568958965187646f06442be6d": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22e83214fba4f42a6cbbffb08454263dd3cb64a5829fe55a733bbc427b0489da973cbd6b3bbeae722ad4fa58eb8277a30": "0x43fa61b298e82f9f207ddea327900cee26b554756c4a533f36cd875e3e7bcf0612506f6c6b61646f7420416c6c69616e6365", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22e8b2c14c8f8828884c50fc3909c081c2357d8ee622168c14c8d3b65f311c42d67023935eeda34bfe81c8ed779103238": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5414f09f98ba2050757373792047616c6f72652d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22ea1ef09f4cda3cd0c101bc367eb16b508104ce4b326f4b31735dfd06fdfb1ccfbad16740364d8bf0f917f32c090f362": "0x3e8c72ac1b710bbce4e7c190568bf560d89416696ac2a4700406487cde98df04104d454e47204c4f4e472050524f5859", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22ef8756fadab2eae5b9e3cc461c747052c2a55b59f26d98880fb604cdd7848e4c1576a990b0ba8468dd4222aa27f9e22": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22f76dc97329983ce3d527493564453774cb0f7f17953e529b8106c743f78d238e3dd6a90f421d32bc920ce120682c801": "0x7682e4e399a94b0dfc4a9bc476e0bc69f25413687d2b1c29bb7139dcc8e8714a0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf22fb04932bcad4f50f2b7903a3446987e2c2a55b5f1b5e1c45738e2352b3d00673a40f451add21cf8e6a0c3eae6bb6824": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033336", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf230323bbc825966297d4132e73e9ac0f09ed22cfc6877c1961ac2cdbe5536684b0761074b8ea475d0c2f173f5989be904": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763135", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2307e1831a66e34d18182de7ba5a1fd84da4c4087c6c624a12ce0c066b04f71d81735ed6a252c0f63e55188be16be4f47": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0243", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf230836429701e9ef6dd3cb5826f47654444a1336854e44cdbfa929ad12e913e4a1870c590a6dc5e3983a6fd416b927f53": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf230e8e0ed55084fb5c09720fc6145dc130277ce02b2ac78ceeb9ae4fa0a595005489bf3f5f77898415e32a3e9504a5314": "0x544e2e588c90a2e53e051d2f87d40e222e1f034913a30f95a9a2f39114e5be3818546578617320426c6f636b636861696e204e6f64652031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf231bdd1ee816fb4ddde9cf92d60e77172c3590205a4e4844653590740c64ec31e5d2af126cce71bc60df95bad639749ea": "0x7e569787b1b323854ac9a8c40914d400b6fc23a2fedd24321f814ce7db7f65630231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf231ebf87d898b03dceba03d3e98e6a91ce4afcec3862a48c276628c97bec157c563a74bd8ab3c7abc9d7fae99fff38268": "0xb22c2075548019dd268e74f3aa69c9703b129e989d230f935797975d5ed9247d033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf231f763c6f1ba726e99814b8a2b7487df2c2a55b5d7c788d0d4bd1f7cab8c7e7a6d131e3ec396056d62d1376d21177941": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033330", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2321a3c23e0895caadc2cafee7f5a4f3942cbafa9669c25868ae5ef66a62b96169f9d56f9b1dd27aedb241d86bcb2dd68": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf232a159fd0bd78dc27bc0e043b43ceb7e9effc7fb904ca3d8cc4f45b464ee4dac705c89888d298bc9dfd2ba563d5b3e3f": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23368a94490cff214e159dba0f70e115d5ed6f4b68a60a117a32059e96678f22fa086c505f7a8ece13c7a2e78b4788f15": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2354c7e586c4f812b2fcc1ab9f7ff6951a64c092cd19a2779a2fc967ea1be4727ab3b29858a2a6f46af009daa35d84121": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2357614d1d04105c49a3c0b1b79cfa4ab58a0a27aedec30fb5c0fa2dfabff0b7370f69e2a8505d714f7b2ce37a99f0d07": "0x3817e559bdeb521169c4801d70a1dfefe94175d15666a1ae70719a3594a57c1604303030", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2361f1f219be184ea435c0d209db0f9546a6d9f13f448628beeaa0e4c8e47341163ce0eb14c612d882799b9eb4152d71b": "0x0cf6b6cdababf69c2af37a41a2f360820bb7dff2f61c20bb61a9503a8901ee20067374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23652b8b9660430d578d4209eacf59280ed959fe3d9afc671f1b0cde07de829b2120d7da25d5f84f4e0a86e3bb940bcc1": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d073034f09f9a80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2366434e22dc11ed36c7fc4483b89f3cc364c29bfbc9f06a42b5cf37ffd831e91c843cc25d8b90071546810ecf279e458": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636334", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf236b45fdc27494fc1783947e9703bf7442c2a55b5c7a1c48e176aaeaff69a017d85b27a49f1fafc160725a3376f417d00": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf236d99ec400101b8d759bc939b72d57f96a7fbe4110d7ebecc8cd2101113549d90cd477c766e02a52856dfb5d9977030f": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033430", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23786e839ef62a0a379d944c73fbb9273a471c7aa909cc665212bb36003c52c5d3eeec39f96556a8242e861c5dd7dde41": "0xa471c55caca4be7b4e60c6e94b20f9028883f8c64287d4454130c657383c3442035631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2381907fcbd0ce09177388618368116ed28996c52694155d7ec9082650fbf108f69da60c44a4b2565fce4e03f9bbb0178": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2381ca18820b278a00faeab03d52440be00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127": "0xe64bc946c10a1f75e683f236e72a44d6d61b3bdcf72ffd8c738e488efc6e15670c636f6c6c65637469766573", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf238329bbba5c700a76835a1f661b6e4ab6eb3bf6204b55f63a2ef87543b26d158230eebb149a8b9df86555fe3f02ecb6c": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2391b5b0353cc7a179d9964a856db5830768659892ca9fab8d64efd188054b2280efcc36942c84616653265d417fe966b": "0x8e07d43b19d901badf3a7f57155ca84f2f835448e93a141bbbd33eac4b767d150232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2392e34504353df51b35b300a5914a6fc7883180d8cea922c0648533d6b2be8949765483e833ec49e8dfd10a0ea61a03a": "0x5a33766207d51925e4b9a2302870bf737305cddd5bb2df2dffa379963e5867710474776f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf239358f6e6a083b53a55ab46a8012eac1ccdce2bc61518838d34314c620b7c88040c38c784e0eabe838c17192be7ed91c": "0xa66e0f4e1a121cc83fddf3096e8ec8c9e9c85989f276e39e951fb0e4a539876309466561726c657373", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23937d53bd543669ab4a709f7aed69b582c2a55b6094cf557bc85fa401951b4d4844146211f845e1c212640685d42057b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033135", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf239672122e445e0134396dc1a76a9b84f20e1d9db00b7eaaac9d3f4a95ba206feeb6f606e16f9af3f2ac24c1c57941e2e": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2399b9287f0e2d363ab2d35f07b9843c6eae07a7b7adf896a2332b5bd2e366474eab97e137c155f8741a9c6b4d30db700": "0x726a98c27f84bf42fc842794a925418335fc9fe3badb1f535dce9c9d9efcc02d0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23a0ea3a6a115e71c72a824c36d1b9c4e8a1ec46479fec3c43eea382d637de8f295ccb2c0b6f6fdd4c5d34a687737a601": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636339", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23ad1e8e1d94e40076e37461627e008dae6d97bf878b1012927ae6afb7e092c541a5abc3904656981beaefb9ebb781d1c": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23b3ab2b6fd4850a8142d624d091576c6c235b0e23ee7b2bcceb64fd0e126b965204f7069aa3b4fcbadb8d658e2ecf86b": "0x58a74372b1f0a88b1df304584326ff69a68e9470d42687e12bf5dfac375d49110231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23b42f4d2e5019b0e65ca1514f08ff2868e5df47c25340b48d443389c64abf88909ded6b6dd62c01548840970cc4f14a5": "0x1c2a5f648afea2a94286c17f6c60d16c9ef8511fa4ae88a54ce2748b6c8fa90f17476f65726c692044657a656e7472616c2067476d6248", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23bd81eff8cbbab65308778f5254bf30df836649df542b24a1b63d80916ee743d4734640aa796648649685dbdd430c362": "0xa02f7333e25590e4f568ae8a2ddc93a879e92e48fa3cf1666ac56e020c106d55094752414646495449", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23bf16ed79df138132a2fccefacbb1d0cc28804ee5c2389c20b837475af5118a2576b88baf216e87684eccf9c282d8b2a": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033333", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23cc78501874040a79e85e92a504fb0ac92a11c7b27f2e0db0137d0745780fe21467bfad9bb6ba3e523b8e2dced7d60ff": "0x086de7162fbfa0b91a67eee94b697646028edcf484ae78fdc0627e7eef1b224703444a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23d68e0cc11f62b9bdd663bbbdbcdd049326020faf1443ba7736e9f4b7a442db507e4a2054ec3a19f985d2c44c30b3043": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23e1813125abf1cbff4abf7ed4a1da61dd19f8df3cdb194db075979039a6fd4d912298356bb2931c08c35db4903f53345": "0xd824263a2ba0b39e43b2a1fb591c68743ca504c2ce6c3c2aa96e58b6269d3115035631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23e609f9530b24ec687f468ddffcfbef674eb76dfc265812c8f4f9b98b54e25c319719e1a3593b7f0e743cf8525206178": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033136", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23e7237354e5ba368cc299c75ac95d8722c2a55b5d10904ce8daf9095a573253bd66fec7e96557836f664a49e5b89553a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033239", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23e78ea26acf41810d7291f8cefd34b89b4c24dc7c3bc7ef831df7637143bb554db602d209f58c93c3dc2af04dc386669": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0249", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23eab38c7c2943807005f335cdcd134507a2f97c76dd2d0ee3baf2ddf3b0aa1942b47ca79a3d1e2178ac5c1c37a056139": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837067465636832", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23ed7e94851c7256b8c7e2359d8fd78a77ad1704a69927d8dde4807b1c67fdaf26718755a742f7994158c8f79749f3a04": "0xdae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b0904424f54", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23f0f1b51a25ea0c3f24d3db2aa987b456b973df13cf0190a75f17633f8a391020df8bac9aa9e4c50670e0dad135bf726": "0x182fe099d0c1787bb1b88de855537dcce095204028736ecfde09dd115c498f2a033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23f639b045975e0b1c2a3ecf5741b894446779e4754580b4e94ac22e5da499aa39cf1aece35d5162db15003b14110f31b": "0x4cf2e774e34c3603b2428a690c058d2ab826b39a2eba4e22b3aae85f9bfa780209444f542d312d4e4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23fa2ea1116374127e8e095cb6bb5bdc24431708b474e888318f65c93f0049fa3043df9d7f1ec1f5f3d7d5e1493359e58": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5414f09f98ba2050757373792047616c6f72652d32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23fd4d7d6d83dba0ba49ae52ea3646d56783770544556ce47aae6e9e9c6cc32bb84a3df7ab11a5d30b0618e00e109d66c": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf23ff1515342297e95f6481a8b7d2809312c2a55b60a32545c89a8d2ba5d04cde08adeb0e91bc2d0cd909d166db15e0f7c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033134", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf240042a224d4954573fe0c30db26f93b2207c5841ccd565eff0f8e15ed5d3b1752749e2fc9e3f574c8434bd09d7f8f815": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07033131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2408b7bb25867493ede69fe026e67eddc2c2a55b510651d026a38ce4568ab7ce806bb2983d1846191cfd29b6b06e10946": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033538", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24094d87ff94b8805f0e07825cd1029aacd0b6229844999d1cde6c2e74ff90057d24e5875b891f645e2fb4a47ab90745e": "0x22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed406365033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf240ddde62c43dba8cbdd11a9179cc340a9695d7445e6e6b293f6fcb0aba94ba7b76431447abab31430eb99a63934cdd3c": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24153db0616bf10bda91bfd32053b04aeb7972e09702baf7eda528c6894408b1e9c702e5f54674bcf6de1b55b3aa16365": "0x985be267f05f586da7ab52e4430c2f6d461f396b9d6cf4f1eb5362066f7cd82f094a616c6170656e6f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2423272c97dd2f222f8da3fb92989a8512c2a55b5d133442ac56db7e5ebfe739897a98a37c258accbe3697d0d7f29a373": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf242504f570a11c91b58fca3962a3aae5e3619289cb2e660dbc1c5747506a37df7a4d311aac8f29c69be8b710495e51623": "0x0cc0424184702e27c49fb859c93f07d8bb0adf2a0824ada9f01db9bf76b7025f0548454c31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24272dd00c8ee9debc33f31257bd6e25c2c2a55b57ef9ffffa47f4d6fc6750f15ae53863a1d0fd99d8386a70054d55e4b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033839", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf242d47606328d06ba64f3efc8e8d02c29ecdd548c83457ab43caf7867e2bef91ef783025db9659afd89794ec1220acf29": "0x2cd49434353de1d51598b44df15fcfed1e26224e055923acc9f9af881dc31d5a0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf242e42af440c994fbdf3465d43e6c485820857206fde63ea508a317a77bc1ca2a795c978533b71fc7bc21d352d832637c": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07033130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243068a2209c8aa06281b5dab90c6aa7109b072ba1658a3946b1f7a82a7c135c33a41ac8e6ac11407d910d4baad3e6c42": "0x09cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb3064e504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24365577f7ddc1775c40ee9f59dc1d3372c2a55b4f7af0b8559bafd9332fe78fef55b0979b53217b3f8355382ba989031": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033437", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243a8420256bfb245551d2d45f48f58a404926296ae6c9155557a6c5aac98d9775664efd8607e894ef210fa2c80b65941": "0xbae335c017512a43fcaed23efec97d80e088bb8f7b93ee837cba5416ca51037f05f09f909d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243b718225680fd482895b25914d18193508f2cb4567caff040d0a47db244d7ea791d9ec23f0d5d33928a7c6a62b3077a": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243ccfa90dba62c7eecb208771c4ab15f2c2a55b5b7e13a772e0b693c3b351d2fb5e5b4da18ac379ebdb2f1f2e7559776": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033139", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243d2a5c1e1b0125a45b283222ed4d54be693f8c8c6043a5d8c8ed64d56523d157625011947a8a79881987d9e9100963a": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf243edf09e07e0b49da67583ea78c544158e2499f22749aef04333796fe92b73c06cf4e358a552604ff3e550725774f924": "0x74db9a1104a31f8b431ece5bcabbe3e508d22fe13670d32875ff6347a88d138807576f75746572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf244175ab241b696d9e6a1246873b367047d80b43f7b596676b4a6714cc5034708a9d651e55c030c2a0b04d8152a8437b5": "0x4eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d0947414c4c4152444f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2446fb9c1f64231ba01e6885df09d999442d1b7759bba592a85972e3c6a9bbb419de5df76c57324d98c2d11810bbf4f13": "0x604189f1ea74bc439b18060c58f352db2880dd4c835df7ebb26e020bf11e7969074c6564676572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24472ccb3bb0aa8cb14f001497cebaaefa09b87b34880c5375ecca849557dc87a00a6243938d5882017fa0d1f60193815": "0x0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d01917919757664476500", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24490823f910054ad342b544618de7e4d545e8064f8898a29d4811e09b207cf3302e5cefef16615f8580fcd8fa63a624e": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370237", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf244e4289bc529f199c16215001de50d3f7600c0e901b4341203f21f410f3da01ae4a45d194fd2c0693c6e0ec5980f4c21": "0x7600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b448630653462d3035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24514434f629431aa53550a7da9668f472c2a55b5a6392305c60fbcfcdf77a4041507f2bd1976c05dc149d2239d158221": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033335", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2452ad5e8e4e5b8cd84739b98245393fefc80cf0973d64eb59f1fb930f3107e9f8ced4aa69907717312f0c5015706f458": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e08466569204c6975", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24554433becff001e411b2f26115efeaff0ef72b01055276dae281f6da1a1dd14c6276142afd3aed8f8b6c94b36d2a717": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033138", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2459e87ab7d28a91cc6a000806c52034eb0adcdefee88f852a85ce03afe5d4403875fcbabc350bcd5d1b94c7ce68eec02": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140b6163616c61706f6f6c30", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24680ced073e9aade1b5605cc0f9b86f9ccd841dcfdb3ca84d8e995a2df2660d35f56952ec7a5cc18c8b0e33a71e34965": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033438", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf246d15db4941658f2122c77a23a5c36b81aec17785fa10a655d77b8850a0b7c5ac3ce5c0389555ec7d8f303092552cea7": "0x09cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb307424159414b41", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf246f29a2f89305d9c14a12e64e837772b2c2a55b548ad46013efd1c045ec47aa4ef52b075a2fa3de11c486dee807c890f": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033632", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24748debb1a2e9d09a1bc28aed9474a55e8b6a4eefeb4942bbca2bee6baee73280d49c1b7aff8d1aa7616d06bc173ad7f": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070239", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf247714dd6a1914aa7ee510444367f24eaa459c65e21e9f36c344f9def7e0ef28e96f6e1fe02f8e3aa798a8fe9cf906453": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a064f4e452d54", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf247cd033aa5760530bb024ffc1b8d150482c35d711666a25aeef2933e8c52be35e409e288120a6555139b0c45d90c140c": "0xbe776c10ad0e1fe7f606cfe42448e02cdb640c21214ea6c0c99df36ec0ee3d0d0232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2482fc4f6cc89ea50673ed04de1d8b8dab2a9dcb35e27b71b75bdabf1cc706c567e50bbb20631e4f94d5ef6aad740fc6d": "0x3674aa73951219dbd27b3e3fc5847b806c68c1de38fd4f22f9493a461c80e90311535745455420484f4e455920f09f8daf", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2483a52eefaac1601602ae57282cc8dda2c2a55b52b81262e103c0657041660ac9f500aefa757a2c8343326d0a525f512": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033638", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf248724e6c4a1e4a8d0d707fba3df2abe0ca44000a7a16d0e5c56d22a707e7cefdbb237b9d20de2c46a53b551ec0cf1c40": "0xb42bde3f29708150bd47382f10fa4eba1c27a068653cfc4e3787b7fe05fe6e7d035631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf248958a4a6b513199ef2b775e8a369e4b7cbfaaf0fedba11f23780e8b1bfcac5e92a85f56835027e83bd203bab86ccb07": "0xfcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a0544413031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf248b7f5f33dc48b7f64a284b87211b9bb8ad3ba81e44bd11349a8d48bb168d583decd0257d3237df7d55bba5051f5254a": "0x9e4e7009937c56d267338762a60ed004293afd40e7c2081847c12cb63c76a8180841636164656d79", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24997c7a30b4f80e1cc80fbe180533c4706e11fd0d4df6c4765eb346aac47682cb7871da9ecfd235255f6eadb8392b20d": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf249ae6790c8b76029052974dca38bb2e254730499c6c53dd16d1e3f8007b64be019cc9229db22d36a12e44eff1670cf5f": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763136", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24a945be2a7e7f62c4371175cf087af052c2a55b595b09d23cb9ea051e7655f90215123b6cf4edc6bbfafc3a99e366708": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033836", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24c0254aeb0f63a7ef97ee7249090c66d94211c46d7bb07c67c2bc80e7d5ba4623f8ef0d565d266723ec60497f0375b3b": "0x8a56b1da8dc3f4bd58630c15f5754ee634528a007ab510c86a7e1fe6e62f4166065a454e4954", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24e1c5184bacb25d01d56ef92471cb065dc46b7f9c2debfe58700f30be615154d6e38f059a682ca0b5049285180675c0d": "0xb204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d68065354414b45", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24eb15877fe5eaa93352c331f64661d75b4fc817716823ab3322f35702e26df4fcff8f577aea26e05bce9bef8b51b6707": "0xf3b15e49aede08aa29d7400da8d3b4fdbd284b5bb1f1af1a53a8c47398f1f09305504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24ef54d965f89550dc64fc5d503df3c647c426559413ab646ae9152a606fce1486f754412a7e48f81e41786dcee8b7800": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033339", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24f66cceda2fa463c6e061bfeed16278cf68fafdda61f708ae4dc2e384c8012719774376e478bdc857f7191ef449ab522": "0x0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d01917919757664476500", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24f98bebdfef8ac2b8ccfa999893dd1076cecea2c48271687c926a72814cfccede993dad2b803ec0d546d2bafa586c11d": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb3893450563633132", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24fdc47e9772b90bf5fc792f782ada6e82c2a55b50e45380d2db51edfa07ff46d01bbc34f908f7aa6b470c1593576ac35": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033835", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf24fff7d12b0ff46b399caefface22445ef54df5a1ecdcbdc84dee4ff7821578632b9d6d884b9bfa5c52f7164c57d3fdee": "0x9ce3de1cd55ad6f4ab351ab212431d94cec798e1727176cca174fa661c8f636e033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2501083fd03ada04313b2fdf14a1772cf48b2cc621a25ed86391676c3686bc2cf76f06edc66a4c3c21e2452618ee1bf4e": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf250487c54a0b45aff5e09308bec36ffba6e28009eb2b8b7785246c452948c27169c4e3ed258ad7a707fb64beb9442fcfa": "0xac1aee6b509bdaa6aeb4718c2218bd7e78a3d6704bf886375e4c243b77a66b34033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2514d805b025f0256fdbcb8d66348bcc4ae34148366325c0ab46d5c086e05c87c76b58125490dababb7899e9efa41f53c": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0a53746174656d696e74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25276c817edfa8a3bb8e54024fa886eefbec6a380acb8489f21891545cfb9b4964bf0f3170c5deddea166cd8f87bf2078": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf252b88b0a68d17f8a6cf5d3c4a232d3c3c88bc26c3cfb3797c1b2e2c9e7fd0320d9899271ba9255a2408c4feeb33cd425": "0xdad042c036fcd9897945a880458b8e7104b30617a9640eaa22b7e23e675e0a02035031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf253ba16c02ca30fef215fb6400b506655c804d9b3aa2f285568305291efb2e0a6b70aebdd5b04ce6a5506c0a8678fe604": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a0550555a5a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf253deffa69e616326106cf9583610d7cd82c38ac61bb075ef3c6f745af4fc8675526b69e7a66c05e777e15bf3df99302f": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0248", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2540ef2326634c6ae2404af890bc2c8b13e1f45bd8fa191f3441574abbe1f4ef3bc6eb07bd224560f30e45909eb0c8e45": "0xdae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b090e303220f09fa69620542d524558", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2540f37eabde2631c3d6fca30b6983017c60f58cfada1c6dd1a8ad7625f8a184e6424e37c0ffaa604718981c1454ccf2b": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033531", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2541cc1ec3fed671ce229b12b481e90b0d0ed5a8ce0c20c3da0dade9db4969d52b6bcbe1f8914d3d9a2019526c9cb0b27": "0x2c89cb8652eff8c73266de06baa3760534e7f37fecff971c028c2910efd6a9470a4c6567696f6a757665", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2542904a84f009bbd8242464f4a4171c347500d616a78d59bd887bcde41d61f4ec880d0496fb4d9482f6f637f55cc1b29": "0x4026c99cba12d64d1d0e7a7a620bf54374603fcc056e1601e3713f992167112017747769747465722e636f6d2f706f6c6b616c75636b79", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf254aa3c4c23bf218e87a074430435c29182b224471e6d4cbe8d9d084d445bac45c91e88679cd3c22937d5e56da60e2bb3": "0x5e34b19d7230f1ea5da6d4b8fe6ede9d05c2e55b0189f75b967862c1c43d9a1f06f09f92b031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25526967f8d1abc061473b8c8ad563b9338f4dd8e0bd0a47c6263b31add7a887956da435cceec4750540743f0235c003e": "0xd401f460e0251ed41d7fb32ca463b5233b620cb9569eef5327def27fbd7c7b570b4341424c452d58203031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25539e7dce3e215002ae5e289a9015e183f24c61f66f5c798cc97adf5258664937f3c16d0b35121a8b45cc81611bc8e59": "0x3898b6f62b50749101446132f77fa6dd77a3895674fa8dac87e6c375ea85234604313033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf255e5c4a4b17e55b69ffb6138c9e216f82c2a55b52aad5c3cfb8bf4c7c478aa2b21b8fd9597fe2706a11457d23e10323e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033736", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf256752f9f8d5ce6b947829aafc1b19e944e1f1d2881471357ea697093e5e68d46712d2b0e5b650945c4ecb571ea43757b": "0xd6c29a7c39cee45b0e045a94081bc188ef73be2be086d66aefd850fc7eeacc45164f6e46696e616c69747920486f742057616c6c6574", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf256d246a63af0871e9175cf3322bd75e15485545d9937d865c9fe34b5b3723ce78729178a292681d43bcfd35076a656e4": "0xd2a0035cec74b2f90f7e72cab1fb16b6ba8317631976b138f7cced3e00668b0b134d61676e65742d5369676e65745661756c74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2576ff602f27ea4445af62da6e6b627aa2c2a55b5a0ac2e467c72c205ae9252a4e8a0c206703950f095c31ea3f022493a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf257b6470a1a16508b722b109c9556b41d2c2a55b517d1c1a30c70133ca54050b2d409c86e87e4ba23b564c185f1d05978": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033636", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf257e15394857cd91d6fd1d468f950b52c447e00d54ea8610f6d515b7d7964b1aed5838c2971e585143807084c2a799311": "0xa2b06daf782fa5142e365d1fea0f4a418687f53f201f185bf314c37581677b37044d5058", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf258720a657c68526a344d9154d2ff4f772c2a55b55169b48ba48e99dabb61807463c1f91bce2ec9919c16f0fdf3616166": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033637", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf258e8f00f39a788bcc479b89a304f1f9c24f8b3dbcb13ea214b670cb611fe7939e20a23db19647485e01206502e64ef7b": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f0748656c69756d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25993b1b6f0559e550406e90d54b7e2cf7cea95ce431976642559cd8c64177ac1a51ef6c8dba625d3d021fa8807c1a137": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada5210003033131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25a5a0e9efbd3efac0a11d330fc0c4a3b4d0887549eed4b4479973f77c05a3f40c7d182e983c3bd873789a519f5cf7ea3": "0xc48d1c4fc44dbbc10b86e40db24f95f8924efba2b31eecc6a7c32bf2b8a4481a074c4544474552", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25ac36e6880bdee3cfad25d4a3dba84866feb764cf5265d8f491f921d51c20318870ffb669b059c7a5b951d9291636b8a": "0x86484f63c9e0ae1f460dec3b53307478f5ce3ffab22a1334d34a52da7527ec6408f09f9181efb88f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25b50d8b53d5b8f5ad90ad0587de5e8492c2a55b528d6e2e0e0b7d4538eb005a63202ab1bb9fd8e23cde888bc573f6714": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033338", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25bbbb7f85791609f5509511a24485ed6962f61510310bf29eb0c0170a23fcfafbabf3d0b088e69d1982b2a31b0d7de46": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5416f09f90b620536f6e206f6620612042697463682d33", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25bdbb7dc8567ef315019102aaff7c7bf2c2a55b59a282fb173b7faf6e82984686f6fb83b0293dd498db6329464a45d1c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25c1039d7b772c17eae4a70c176a843f266ced89b9a76de4d3dc384b45fdf0bd2f1629f15dd3e44ea14c31ba16181a255": "0xec05f950e080aa04f8ef335280637c8c80fa6b8bf54d5a3bbfa746b9f9da586005e29e9556", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25c44cc24df1b8c918f3f4b7debe6c94800831e9a6121a6d5002d53a89ce1d209d1e3359420a90620a022b22947d41140": "0xb2e07be4d6d82f546ec91d6009ee215bb736be5b4362e66e7b466ec72d47624f0b476f7665726e616e6365", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25c9c3f86fc5cccdc2784b49fd64761b446059d2f1a61eacb55d5c4c211d0b35cf3c3f4fe1f2601cd8bf49f30ac370c49": "0x09cdd094e9a51d26bbc6cbb71d3f7c5b8edde629402e3e5370e7f6904512fc4a033033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25d00a9a66b9b640a8446bf2336b62596b4a302cab1fb0489c4211db08beae0bf7b5432416b299f57ce785b037c297a46": "0x74db9a1104a31f8b431ece5bcabbe3e508d22fe13670d32875ff6347a88d13880641726a616e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25d523d8838a6068649028f12e0c439042a1202907ebf57434db992641143ac78c8631a1e412d8934e5167153caed0645": "0x807e371d9df95983e2b9face8efb67f962816f1a0c6681cb1e5455127ab45c092020726577617264732e61706572747572656d696e696e672e636f6d2f646f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25d56cc1f2a7db8fca1e344d75c83e6e814bca285494baba8c77a19f94848063b287f169a57d42ed48b409eb5554d1d0c": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033435", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25dcc9fffed71542cca82764f881633e74a45b84757c48776f4c5d887e269e8e6c3f2fc55f75adf222662f129f9fa5b40": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a0752414944454e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25ece685d5cd33482a8021f353de43ec1acb22f070631059ce62f6e0536e561bb5d470d2bd236985b0dcf42cc3e446c68": "0x2eeb1a6884bf369c7d1ab3f9ff75b79dd0f6c6a9792834e026a8d2f7ef049e4d033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf25edb035a75e00aea3effc3d3db4468fb084361c7e80bd43ac0aa2917200339e51e45284349a264184ba0befe3e2cfd52": "0x6c7fdb8b8eaad1af9faaf918493606e1a3e8c20f9d852773ab5ebfbb93bd19480957454233474f2d32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2601a9b0124023ec68b73d6fd9f54dc32b0614de4de8cfbd7c760fba99b446a030b0ddd8f00a0dd84dfc88c7875d80c07": "0x726a98c27f84bf42fc842794a925418335fc9fe3badb1f535dce9c9d9efcc02d0230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf260cf06aff75e3e7a5b9f00bc5ef1d850a225b0e7cf9cf454c3ecf0d3477cd774c612795c312dcba6d09beea92aaf2a6c": "0xc804531378242158a794bd06c1e9ef0e569f60bb32758597af80e5e70c07a64f0d7379732d636f6c6c61746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf260fd70358772eea75f1b119e85ed70f812c8663dbe1a18335ef5b7731a7ba8c0f25c0fcc761623af5159ec6eea586b28": "0xb8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d23100235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf261ab7a6d5c53256cf112113d5307a1362c2a55b5feb0eb28fc697566384dab127170f08c1c2a6febdfb4cb3185ef8917": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033136", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf261c54c7bd272264261bce1472d00c41400cb68a2c03e666f346a277036e8f27c912baee3c7b41c5c19123840f3a8e8fc": "0xfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e037031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf262f7d26efd475a6f12c57341aa4781bfd8b5b26b1cee228c6ece5a4b44db258985abbc9f0168950d744269bee80b1852": "0x8488bea263878e7e16be0a8c4705f9729a5f25462bff7dc7f2d8346370c8ef651453504143455f494e56414445525f5354415348", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26396f848202862f75e3181d145e563470a776e233546799e6f48a26bf32c080bd40e35986f608353c5b61b3076503472": "0x6e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe15407444f542f3032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf263c67dc518c9a200dad59de0615719ea76729e17ad31469debcb60f3ce3622f79143e442e77b58d6e2195d9ea998680d": "0x5ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2645b62e54b242fc3fbbe28cb0b35e2ee90cbf37b94fbb758804f3f06510840b6649c0a2cacaaadda6849c9dcb766b767": "0x664513c046d4497ba05c19efac47cb0dbe498e20b089dff25aa08d1a77ec970b0232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2646b77305fb63b2adea883a08333b7f4fea1c72d488cbe5955b1eb68d746792321b1eb06616bab281f5d4838e0421c6a": "0x3296c9b3a6546d2319a764e00e1126215b776cb27571db2ef0392bbfbc66d45f04203032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf264cfee90d2adb3f3d5f42f2d9bd586e86492e3ea0e62e4e357e57c5b6732776f069e996133a08953b1c1ebcf967b647b": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5416f09f90b620536f6e206f6620612042697463682d34", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf265a8cf2580aa4be041af3cdc5c472db5ad21c2f113facb0631e7145ab7f255c3e46b49904587d6aa6116c56ad615fb1c": "0x22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed40636504423032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf266608206f5eaadf361eb029c69e6fcec2c2a55b50279b01fc376a1b5e4e6670a8c247f00ca6c1569a9fd92ae18fd1031": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033432", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf266b542cb40878ffaa3b6eb0ca5973488eadae1c87f39ff2b60465c9640a1af260a815725f9ce3fdda291f92f7769e3b4": "0x0eb83479fa34dc63024ed44efa464427375a44de486e8d6007c7842b45ce817f037031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf266b6113765a3ae804d0c0a367181ecd9d66dba2833b102712151bbcfe1286506937ed28809693e730b622b3adb93e36e": "0xfcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a07444130322d43", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf266f1255f7aec0e5f2f52ef440812bd4056613c69103858e51c79e3525fcfbc8315d93383b9280f0acd551bdc75a91463": "0x80d8a3f4317249a895e4b49badcfa7293cfbd215d6e552d1c07024d36acfbd5d08636f756e63696c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26792e700996f4c48444a1154cb56660d16b94e2d5d12d60c7314cca383bf185ddda83f413da740a121601e3277d3083e": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2686e757f35e373de52861a594acb4c7dbee56ca36a0a5393bf9bfbe5d2079e31d4359d35388df257e23793c7b195b855": "0x4056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a0e5a4b56616c696461746f722032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2697e24555d8adfb67c5a99ed9ef04acbf50556e30130b7c23f4ec520332817629963b2a69e5b024aafc29fe7bef6905b": "0xc8a5bf93006b7fd50ffc2abaffd57ef06c67f2171b5097070892fa1a195d920f044d4331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26989b179d681f768d5f039a62c4b362a24aa9e7b57a0e49b834fd499464cc0c83135679ac384abd9e6d7f07a8def164c": "0xe21727312b2b7ce579dc0f82f129d4edecbcf00abca607d73ccf16e8352cc7770232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26a845598a4beff519823c3245a375f96b8815e0e6280e1a3ff96f62dda149363592236eec3df9d48aafe8796c22e1d41": "0xc44ee45000531bbf1aa4c23540940eb10599e14b4fbed5267c42a0ebf5d09f6600", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26aa91e2f85720c7b9e54841b60aff4b62c2a55b59ed1954e80bf1349ee5882d429d261cf9962bc5d88a1fc176e60c918": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033237", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26bd12d2e9c4446aec63d3cab87d3cfa246b00fc11146ea6ce12405e83ec552c9f3d66dcf81ac4fd874e24db1484f4041": "0x0cc0424184702e27c49fb859c93f07d8bb0adf2a0824ada9f01db9bf76b7025f055a524831", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26c03b239a4bd4aa6d90d5ee1c3bfdcac0edaa0d08e8b21d6e8f946eff381ad4be29aa63569a54a6a75c91b878b463033": "0x127a30e486492921e58f2564b36ab1ca21ff630672f0e76920edd601f8f2b89a064c55434b59", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26c34abd7525397291b54e3a7714bfd4030e9bd57ca72b2de9928df65ac7974ccc0fe678a64c2df03e2159aebb4e8a525": "0x82c5c0e26848d49b32a7ae09a67f6822f2a18310b69a3ed9c31ee021440208260b636f6e74726f6c6c6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26ce021714ba84dbec5f5b95b28f2a4d306cf58e932ba9179e8493d36dd0c02918e37649bfff2bcc24d4fc19d47492564": "0xa2b06daf782fa5142e365d1fea0f4a418687f53f201f185bf314c37581677b37064a5542414b", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26db4c875f9716d75c900918cfca41e6b2c2a55b5f19e53bd8bb08c1cf5d540f88c25b52a10c7c5816bf906b0ce20877c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033934", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26dc4fe62186bdd4aed984c5be39192ef2c2a55b50d3c4b8b607d14c312d6e25fbe0a9a585bafd68f597ad37989f9c406": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033639", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26dc8711e6d710264dd5e8322faf0ca872c2a55b5e347cbea568da1dc296c13b681ee4b655108e78bb9c33980d45e2500": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033439", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26e10ffdaebfc791b4782085c4ee3e7f42c85bbe77e464b97ad4d36a49bc2b84566c38b9bf6eff49aaf005c672fafe752": "0x3e3a490c516b2a3582e6400e33f3eec42a12589958cbb86c87b23bc94710d21b0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf26f250de59e16551d7912972b2d280a21d8a03bce1c529217f76264985b1f082f154dad529677f85dcadc3c04c4c77d59": "0xb204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d68084e4f4d504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2704a0ebe4aab907b0f82f628ca6ddae62eef2aee654d4975535f2701af86ba6d169c2c9a1599b16635a2a5e4640db94d": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636333", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf270ba6779177c38560ef3de1244a7ad2c8e9b0b6b26839418f4baad18a9c3ffbfa413d65cde8010bf7b9b9db0dd23e005": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f28077061796f7574", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf270ca2b9faef23df18a77926ccd75e1027c8c3a92d8feb9d27f32f3ec67bcc6792f8496f7ed86d1b249c54205a39ee30c": "0x4056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a0e5a4b56616c696461746f722035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27149ed8fe6bcc8cbeba9ddacf8638fc13ab79a63ae81a8f096efbfb44d958cdd0253e97775b908d73de31a5d9cb00e44": "0x08ec72cbf62bb66f416f46f988e130585c834a381efdbb0755e30f47a2a0da5a0d5745415448455250524f4f46", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27157164a73e51400806e78b5fbcda4f9fab573fbe3296563205563eb39965933d33ea5a591c45af07f0eee2272ef6723": "0x7600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b448630653462d3031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf271bb90452019d586af6778148333f6e9c0afed691a6eaadcf94bda09fc7b713aca337f9eea5e7a02b1a6aafbb1a44873": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033432", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf271c97ac8ca71c03bc78ea90c3fd225152c2a55b554384ce603e7018c1bd0df5cf1a8b1f6154a761132c003486a723e27": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033738", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2722834a39ddb7b18e6c5c20e02957f4652057768741d83d391203c6abbce429b05bb6d148239c08fd104e6b65c531251": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033535", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2728e20fd18f59a839dcbd25812fe9dac1e503909a89514337bf9ce931876a08003396a9def52f867e123cf1420a0f70b": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a094173736574487562", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2729cdb4350b5c69a2d206102f47ac9497c2241b8ad2176aa340dea400bd84fc389091a7511086bbc78fa98a7356e630a": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763037", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27356514c77e1f6a759420b0469e0b00b26a81cc7f1e72380949491cb9538d125d40de48e631e0e8bc40964fddee59bcc": "0x4eb32a5fbbccb1d97d31237172fbfd92945caa6822d5f8afb558aa7b89bc5a110230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2746e45dd2f0eac81eadc8e0f40c69425da0afe4e85d09d168759ffe74af6049d1001ebb6d16a0427e40a4e494a7372c3": "0xfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e037033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27488fef533c1b07f5346bdefb6485a4b8c038403fe48ee0068a652cfe2593d30d5701f508e38ef676f392fdc85f80658": "0xc09033af1dd99c3727bd222c35d9d34e8e4403441792399b08df0d60544fbd4811f09f8d8020444f5420303120f09f8d80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf274f64102879491d317fbfd224ac8cb2303bcad4ae89b033d823dd32ad149177e99e47f1c1edbfe9e5281f585bc406558": "0x2c0d08e42e58247b57421f3239e0e192b21edaed4bca2458028c981634bdb60706416c706861", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27575fc2108aacb1baa021fc45f5592b85ae7010248daf19a0b83b3d131f63a693785222293af4354035b8dce851fb02b": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033135", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27649915cca519cd532106f5a0c5794e8487a87b4140abf956405e80acb86bb44586a8089e79b476516c6ff9b601dbc38": "0xfaf5f68fe828f5af8d69c116efd937d90f1956b0edd94e05d8b5285a8eb2a66305706f6f6c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27678b5c55f424bb242a9b9a65fb5cb3f9e2691c29d062502fade8144a0eac25be3369a271b3fdf2208a9d86cfec6f948": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27720e1b29336a317dcf0f7f2c7cbbd2d640574072818008b0ffaa91a3d5febf7cf106a9285e35003fd7b55e2c1ae8b6d": "0x9a2cb674ea2f4866664769a1663fd6aa321d9cfb89b67c402c881891700c0f57104d757272617920526f746862617264", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf278125fd27774a31e80ce4957881386190a016b7d735f7a0c5e7987f99b8e46137b6668a6593c064d42d050979935793b": "0x140be3ffc8865dd47a8d044916b26936a579433599bebca9d3ba1d6eb772271004313034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27854176f581ccba42b32ced2bb079c5666d0425af5558b202c277f282e0d55775eb9fe23e0c68b7a10cfb7f59202b402": "0xaa6646d5b85790bc0ab869d80385fdc10e1f4befa7f8a4bf31848f73012d2823036e32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf278d66265f3f443034a03e439baa8fc6747e503b630c37057023c04ea57149dc70ae19f186db24f59881c55cb61da522f": "0x09cdd094e9a51d26bbc6cbb71d3f7c5b8edde629402e3e5370e7f6904512fc4a033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2793f9ce6c95d41e649650c39a2ad8b08078447732a649b7bf6970bbbbac8df97ce628b139a8407fd7d051f40a0258f93": "0x1232508adcaf57c6e78a850f9d715e3694b52000ce537832eb55c7a59f859e1306646f743031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27970d47b90813e971a8a0f16041df7cb00b03b23766d70d0445943b290606521acaefee7660d521950faf2801c79d428": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf279ab4cc0637bfa6a0af4122c141e61372c2a55b585dd3e7bf5cc92d3eea96cd13018755382f0ba1be21ec1866b043212": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033833", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27a319d2a73687c9bfa3b053e9103dabb1a356596f667e9330b60d055872640198b86485ac1721c37fdfd468157a17a45": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e0c56616c696461746f722d32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27ae2b908a33c5ed18881a29cc36193b5b0ec35caca1aab56df7814b80ea0585eae79ec6f58cf03a8be0c40a5c6707711": "0x1280a479ee3beca7af1636aca17582f30829782e2c9b1b9c72aaf8060563ab37033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27b71a04416fffbce603e09de5a8178ce02aa5256d804b33717f1d338eef9901e89682b80c81e3b1138a02079e0848aa0": "0x30cfdb48ff7f33b08499dfc618a8ef9699b8345fa65f0b1339eb8eec3c0e45550231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27b855f3aa400faf901f706ee3942185d2a211b13ae9c29f805070d21d5e5e007db8ab2566e1031b6ec22733f1f3c0877": "0x465c6be30d314cf647a8fa10212bcb84318394659c46fe75d03640cebb39595e1a416c7a796d6f6c6f6769737420636f6e74726f6c6c65722030", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27be9a3f8da53c454bff90ae9ba01dd96b4de0e0553f854c72746045b90c8e5c67d74f5d8a52d4134b259ff562e4b1409": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb389345076c646f743031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27ca1f946b86dafb5047b0c68ebb6f07378c505721568ecb57fe677b4c24e670079e8c342cfbc7b312c146067a2dc02a4": "0x6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f380777616c6c6574", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27cd11db5821a7f19322ac30eaeaec8192e001e3f827e6eed45a60d131d97df1a5b429ed1d0f89fdedf3eda0a16502d3a": "0xb346948ec9e4cf84b965ec17a752b3e8eff098934aaad42ec50a347dd7936583064b616d696c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27d31ff5a817bcf68f902fa99253a4268f8720c905d7ac1acab25c4f353df9eb759e0141e4732540d163ac444260f0177": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27e65087dd946c27bb1e415ac33130b0fa65bbeb4425c55a611da4116e848b0cc39686a11f88dee6aacceac6bc5eca657": "0xda9f7fd3d9612a68d2ead69dde53297b172b7db514d0d261e7c5be987df7f32a04314b56", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27e7a14ff98ceda0098f284ce8eafbddec880ad522ee62f59ec14aea01214fb737df562d1a9bffb35d70d35bfd2c72432": "0xdae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b0910303420f09f909420434849434b454e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27ef31002060ecd1375d54d35f3c7afdb22e84530cce98a0af194e12c568c8923fe6d138dcd6e19fadcece6c0a5f10e87": "0xa24fde6343e2bf0aefa296afcedea6f16d37c5e1c0d8b6511e7055cf7282b60c1053756c74616e4f665374616b696e67", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27fb6191430b9e8731f77bb822cbcb63631918cb9b9c9414a2cd4dd7f720cb98fe98cf852636fc4860845767989127e7d": "0xc5c184f0565e2192d6aedae584ee736cef875f0e1c558ee3ede26869acd0b4d6054e617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf27ff5e411dd09d48e564e8e5d339786892cc16da9d1f7271475075aa8eb5c6667714426b8c41dbecf92bdedfa462b7163": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28000519116f8a1f19043cd513af0b2abc07244af8ac9b81030b3c47c23cd5b10701d4a5490790e20d12a583e5e606823": "0x825872f7d324c8d97a9d5f5c94d918eea93ef783f305767b768a76f9fede7b4a08e29aa1efb88f31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf281043fcb3cfc5cb4e0e03206a24d135d2c2a55b5f64fedb5e9a535e4358cf539e294ccdddc753610fbe8c25ed72f9409": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf281b653ca735cfdd41d4e90fab3490af3d68d71f02028d8c8d8a76dcf0eeba7f93ad6b2a6e2f8363ccdad5fa580705211": "0xe4bd04a7052f76425c60648c528535285bc2a23ab28db060db34f7c5e5746aa909434c41494d424f54", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf282576488c56e00b214d585a717339dda8c5917b51ac796f4dbb53a35008c1e0cc5a8e3aaa1300cc2e845f8e7702cd4e5": "0x3c84767978ada6355ac3719ea8f978244b16d7e8c00552c3a189760b55eeb404033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2829d6f3b7b3efa8f10f9077fe36a82e498a8cd51a12a19dd5440fde5e43cb50f9d48d95ea5c5ee3618eb0b2945f02f21": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763132", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf282a5417b0e8372e7cfa89e428887784f2c2a55b5e1d0f2cabfbdca681bac43c1f684748d18c03b0e04e28b2fae9cd704": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033939", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf282db2fcb58fad99c289f7a86656931e12eab66a1c3116f15f55dd2996db419e367106043a4c5491a5eeab1d33a17460b": "0x02bf32e061073c44300056b416cd66a4fde1e6c120dbc0089bb65134f5693a3b14636f7265626c6f636b732d6d756c7469736967", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2831ad22a3ac7b99bbe1efce6cdb4db35aaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a1050656f706c652d506f6c6b61646f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2834a4e0a38c3e40a86c37d60c5bf2b1f7e74e295c040927de4200c770994a314185d3ee447be3d70c79ed056fdd1ac53": "0x5002926543d8b8887044442834d4fd5fe3d6eb257719daefd3f2aed28eeaee690231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2836c70c471ff3bcb9c9b3970765eb06594ebb855993bf0568b71fbf4197fdee4cb44a39bd46fa5969bc5c372ae101367": "0xc09033af1dd99c3727bd222c35d9d34e8e4403441792399b08df0d60544fbd4811f09f8d8020444f5420303220f09f8d80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2842bcb5bee0cfd16df02dc65ce8fb10a785c76e65b2f38d3dcea220f148f8d4b42046ddd61eff8af6828d24f633a9c47": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf284840437a62edbd7601338ddd95027f4a9695441f301ba78bd00ce015f2f1da14eb8914531fa38695502369de72c256f": "0x8c085e6bde4ac25702f54f46fa3c1b0a6170bd346103c2c6339911e00306a0540231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf284cce806eaee977df2ffe64300cbac9fd071e04ec30e105db26f05b81646219bc57909c674c2a081e48906e604f9867d": "0xb2e07be4d6d82f546ec91d6009ee215bb736be5b4362e66e7b466ec72d47624f05506f6f6c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf285190df364d7a748b874cc7ee3c24062fe9d714ec9ee0f74e33282dd9e411fd0f47c1aa17553392642df99d1440df951": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814033130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2853aafa32e9618dd96acd68a704bb74bba318e50a4896c8228b14dbdca63c64b9a4fe82ee967a41612c4a55909daa960": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0b706f6f6c2d61646d696e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf285f2ea0dc6f1ba18380d529259c4a2982c2a55b58f78423fa34f63da52ccb699e46952f94053123661ab8316d4f78e07": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033731", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28602d0517cbc0f0b26b18babded8bc622c2a55b5e4935526d6400d729ce52f5065327b414a971c69fcb85eef3d5a9401": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033931", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2872b81b0d92a731a6d2ce1955c86f1342c2a55b514ea318202f6b920073d878c2c9c94fb38a48e4c7b3d4874f755c06e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033339", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf287ac14ce59b2db48f1386aa4d8361162eea674f13649b25e552a59b65dd203fd45055ae7f39b5a6551cafc9d4eab3776": "0xbc1deacfc7e5c6e5f0373560c14fbce156ff2a0ed7e208d049ccd985dec85545084a757069746572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28954782c43b8bb9c87f90ccfa4352c1c7061c3799bd2b1d70aa6c8014a0012ea494f4455d60e182dd1cc393d37f8604f": "0xd45548e42d7f5d5aa35ffc16ff29396c99936f0c1eae84d452f1daac87c3c566064d65646961", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf289551daf6fadbe86a54a27a1280f9027149fd573a4ad8eb5dd80a1b70e89362e72f0fb2512075b4d9a52e7d23c0c776f": "0x3c84767978ada6355ac3719ea8f978244b16d7e8c00552c3a189760b55eeb404033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf289a625ffd867d7cfcc361cdf39c00b28c215be73d91712a74db57cf18209ec172e9a3215ce6ef5cf5b0292177d3e1140": "0x7cbb0ed8bf228935241774290753bf282020d73e45f6724b0196c97b3bd534620a627269646765687562", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf289e9e9cdd1da3bea187471c581cd43572c2a55b5d60f8f51745d9b979ea7dddb0f79692d51cca14c4791e72da59ac963": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033932", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28aefb3ff9897f97f9a756efdd5f1f2cb2c2a55b536cb66c8bf2894af968ada12c6e7db4bb028a57b2247333440458469": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033831", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28b37f7b59891ba4b1fcc3d9e618d854618c0445577a970766dfbbd43589ffdbfb1bae33e8f286969539300c6a49d0962": "0x18c044557335d26c3a538ec7a2699ef5665cca1d17755cd6ae53d41f5bf316230b476f7665726e616e6365", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28b7ea082adc3324e5b78fd6df0b54fb4c2975211d5ab22d276be7dc90646aaac121341cd5c033b2ad6e1a43d23d2b43a": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033439", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28bc458b9c4ab0df59fb5255f34b4bb9c18cfd7be6a32e4e3ab369f7be8a880a70f42a0ef260ae11a740b1feb7dc47969": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090b6e702d746f67676c6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28be0e4e81f83977ffa5879c873f9a3af9890fd3e365f6954b5bcab3c8195024da5188beaafb1b13d954c0281647ba535": "0xfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e0c636f6c6c65637469766573", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28c1df885366c4853b057f114e18be01ab6ac93bc22957dcf5ea1a84b1ff7e60ad872eaa73f3d176ecf7b980cd33b8b00": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28cf1ec94779b507b452c5a8d569635a52c2a55b5079b0d798a442d87e4bf664a01d50c11af9ca230ee4738b19aa95b6d": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033737", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28db0ce9a26f228a1fee649279def89540aeeb3fa38505a54f76f2a27321f9b5b875635d3b05a0f4bd92710105f377f01": "0x6e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe15407444f542f3031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28e23857eb94353aca0e54d2139f418bf2c2a55b5baad165d64eace5f75642ac4612ec1ef12bbc1cb27a0137473788257": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28eb702b000ac07c484f721d86ebcac24c63d29b9669894bd812dffb0a0206bfaddbf728741b3219e9ade9937bfb1874b": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0245", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28ec2e6f95318a0783a464b6de2c96a7a5ac7f6af5aeb5364188840d02f0e74e813e6d9cc0398d6994b66727658a4fb30": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28f901de1e12520d1a72618f666f08716f2e78c673a855ce341b8d431b3e2ce293e812236e2e42682047796fe599bb734": "0xa80ea94af8a39eb7ba8d9afb913147e67eae84f48aad7b9ce6ee05094fe0394e07476f4f70656e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28f9f94d9cb3fa7cc5c1578d471b1dc673a92d9b2a48ee9adca77ffd658b1e273434924a7b3b456693219afbc32279e10": "0xb8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d23100234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28fe0ba25b107b745ffb6f32ca8f1ae85c85cbec6e7576580deab57475b75d3456c379f8c4abb617969fbf99aa4e8c076": "0x1280a479ee3beca7af1636aca17582f30829782e2c9b1b9c72aaf8060563ab37033033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf28fe3f5cb994e72633471458e82ff1381aca4f84ed6959bdee967c0bc4d289bf3fad8671f5ce7068072a7dc34964a8d0c": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf290b45f1b25bc12b37bbd4713609287d62c2a55b5b05723585c7421428d9ef451313e33e13803424b0f8cabd383d0df37": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf291300ad34b9ea09a8d8d4b867e87c876ad0992e51165d995e649d0a90b3c349ec9694d84ab1c3294e4a9c58839e7b4c3": "0x1eb38b0d5178bc680c10a204f81164946a25078c6d3b5f6813cef61c3aef48430b46656c6c6f7773686970", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2913678ec80e3bfbee95e5895fe707d35e0ca65cc737d7d170d9f7b09247f9cbc52142c62a6bcb4d8a5bbf29e6cda7e05": "0xaa72c321b20bbd5b78b14f6fd800017bca47190956eb42ada2a4d8f8a8ca994d164d6174746572686f726e20436f6e74726f6c6c6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf291b7d14915b81b93ff85d756391526573ef0a4136babea739fdcdc300f622f23d9a7fd229dd90c8f3c9e3d75fdeeaedc": "0x1ecec4f3062f61988b13e9dab318860bd0fffe5b7b37880d50a614a0a20c250219f09f9a80206a6f696e20504f4f4c2034322026206561726e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf291e0b9d1df879c873e96ce1f8fde9d7a081c5466574f932ef5e1469e984d5d39ad5946468f0ab9d06c454f74cfc2f16c": "0xd4539a7dceeeba9999b6387e9431e83c53f4b884edf5cf049623110eae5701250545505631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2924d38edce0e39108ea6be45077495860a8a307ef15b9f928697fa09dcc72a2c19a266c1d32fa158f9916b8b804e1621": "0x984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b541305f09f9383", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf292e1e7a922ca653422e42711cc29cc538cda73070bddbcd243f2d1f25982dbee2a0961b277ec209756bf794c2d0f7f78": "0xb08b555a5a3b2725e01ba15eb40aa32dc5b781532854b797808ed45e752b047c0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf292e313c38979b8bca120e2d5471df17d6af358e5650b61943ba709efc5dbc501405e04d5de5798087d6c727027511a65": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140237", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2930c4917f16a6c61684103d1d981796c2c2a55b5ffdca266bd0207df97565b03255f70783ca1a349be5ed9f44589c360": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033132", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf293ccb275d05874df082d79db1d3bdc3076c26a1fb9acbdd56be00d4c44901856929b9d2a879caad6119ad0417e994949": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370239", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29432d823f39f0985388d21e1330c779a2c2a55b582572ea3a02d92d1f303959ed8d301f20cf7377795bba4e77ca5f059": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033739", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29499859860e76d338d9a9e56fce67bdc780946289b4befff0da9911c013aacd2b280ec0529a759b94c67e4899b9b7058": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763039", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2951d5278a8e74b67f202716b3fe4e163049a9687c22bf19c419cfcc79a77b60b07faa3df2034d7cfa4635350571cbd32": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033239", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2953380a1930e1a615abf34008ca176ee2c2a55b5af6d74281de0813a60beb2a89ef39c6b2a10a35427c683d61e98f170": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033434", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf295475914bf4f6e47667439674af275652c2a55b545afbf04bb687cbfe5f7a4fee66f0f0e9036072dc3ef88be6f3c6c36": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033837", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2959646c7eb21bfaf835cdf5321d10c972c2a55b572dd8f780415f21ee812b5bb32d6baa791ce4c8fdb04a13eb21d3f09": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033337", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf295f3374a3a2708d729b249f44f5d74f7c3405f63dee12641abec6c12b29453b7065da04a95c09998673aca6f0c4a164e": "0xa6c5f0595d6ed85d6260bc682d4a68a4b4e605d43c67d56f2765d19698549772065374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2976d81795a66d60beee052e684e8cd4bfa5be617ad31f9c9a41041cac3ad8ace2c550c28c73afc8e34367d64b50a6679": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203036", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf297bb9c1b69660dc90493b5840f176cc32c2a55b5451bb1d573ede48bcf7ebf76950aeb780120ecdf3d328467d62fd929": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033537", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2983e6a30e5b52f58c129cfe267c0323b703bd4afb52b696047f54d9c991cc8fa8d7a7734f034a008c630c97f95250568": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f883706706f6f6c31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf298c6979151fb437f7d051660f84e2a6bc08d5de7a5d97bea2c7ddf516d0635bddc43f326ae2f80e2595b49d4a08c4619": "0xbc1deacfc7e5c6e5f0373560c14fbce156ff2a0ed7e208d049ccd985dec85545094c616e69616b6561", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf299339913f2ea3776e109aac28a60ea1d80d57608c732427386079d29d65035cfc02b3221ff32cfe73b540d849aa00462": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf299647f0ce03184e7b26905d6dd31c6616a66d0c75a897e62aa4e9cdead9f50760db6e7beae858c1bc3dcb1d1ce601e58": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f086c69746869756d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29989d353f6de2de2c9299baa910c36663c92bc22c4934341504e8b6f0755bb76906171bcf8a55c49a78e2055ddd28802": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d0a506f6f6c20f09f9a80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29a4392a681901e7e99bb41ef9de7150e888f666828e8328a33647a47bc97574a6a5671819270cc01e66c7139a1a6911a": "0xe8c7ad65c15fa3ba64424a61b177382a0c5468135aecca9ca454f5e7ce4d305b00", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29a756a8f12d432fa50b944ce913ad2c2e417170e6d77f90f6d7b308bddb8a414f44a87623704da628229ba777b644647": "0x5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c0cf09fa69020534852494d50", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29a8b6cfd4ad6e629f434a37da2ae59fdead7c523761f8ca72780d241f11dfb4b3543c4a1e17263274d34f468001d571a": "0x8e07d43b19d901badf3a7f57155ca84f2f835448e93a141bbbd33eac4b767d150231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29b341a8e37405326ddf25244c70c5aa24c1bdac31e30cd50156586f5009d576c2efdc103be5ef0649d55d3b53941760e": "0xc6477bfd57c12587b1075a80d944c7829784eed61a5c8b8255817e1d62d1070e0c56414c494441544f522d32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29b6792186b130db777b313c57c8c6c156e306a119e947513f180b430e3e75bc8c476a8b61e8348d1f87e490121601b5a": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0244", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29b6c7d30389e104491c2397c994076d94877511245f8954e48858da743b9eb3544681c27ffd8802c8ea1669e961a2b61": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29b6f49c1c3cea48fe030ea8f448a6f542c2a55b5a6413894e13836fb0165e6adce7d77c06dccf42b3b288397a27ddd3b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29c3d2817eeefc70b333c5e44e079e6ba8ae437cc2420c617f2cdec05405db6c449bada7d2b2063eadeae636a25c5ca79": "0x22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed406365033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29c56a115b77627119d1abd9375e625892c2a55b5bb604a28edf5e8b24c72f0c851a6440c1889346d8ccfcd298b601e25": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033433", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29cd1fa0b313309eb252fc2216d869b058595dbf64624ef80da7a916f139b607fe8ac19aed219da7c7f9990be2c214d1e": "0x5efbe83a561d19b1d21126af5f1608ed28e56f4f70251cf965fe3dcb4901a26b034b31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29cfe8a4e14b7806a1c3022948146ec15a160a7305cb5b47a2903f6648fbb6ba1ad24d72fd49c39ec7f9d21e184f3dcc7": "0x6610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29d62ec2f1c1a1b440508c50c06d174f058ac509e6e93bcf6ac0800a070f28bd477fb9e9717ff7779d035094e361b1504": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c413063151554944", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29d63ac56016d275d23e7b3d913045a0cef7550d2801399e7f9b263d92c33ce0eef338eb5527760235e4ff5219bd44c9e": "0xb45f7d4b6bd58cb550270c1ba3d9d97b6766787966b0b5c52c79b4d3b51d9a43033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29dc4559e1187878664e74a61da9447c632f5040e4ff22a9cea43f7cfd1242e3ae0e57140c2f4b985e83ffde5e5c4492c": "0xa4731404eb64407b76d75dd815a3267e2dce24d8c2054f3d45d83ea11c8d707a056b656669", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29dc6f90ae9ad151eb3ddf552adbff75e5e348817abb98cb962fc0780a47ebd471d9c318395fa80b4529a64cfabb2e32c": "0x4056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a0e5a4b56616c696461746f722033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29e4ca2c4c5877d06609b129963d870f744e2fc205de7ec0dfc49f2e05c64555cbfc897602413c712c93967b59257e537": "0xdae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b090f303320f09f90b220445241474f4e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29e758ec7459726d3a561d0e141080d46d4171a4d884070585e1bc36f234a9db406e6a89575ee9e5ad24605e146dc4c28": "0x3296c9b3a6546d2319a764e00e1126215b776cb27571db2ef0392bbfbc66d45f0a504f4f4c2023203134", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29e7a3f75224238db6e3758836b8f9461a8e87388e083b3f1a9dfeef27977d883cf10e7c94acdf0c60f57f0a9621d4539": "0x4056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a0e5a4b56616c696461746f722031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29e870d2b0cec845a2caf420bd3b7ddec8a64dca67c64d9361901a1415bfb3469b000d0bf7f1d439824cec71f87022159": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29e8947cdd87ebb2864e85a33f3dddc376e32fb9cce7edb56991320b049369ce553a5ba93c5d262dcbe796a9b9f3f1524": "0x5efbe83a561d19b1d21126af5f1608ed28e56f4f70251cf965fe3dcb4901a26b034b32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29ef9cf0b7a6ab68867f5055b6222b644605fd1308af1ce85bab5ba3fb19b330ab7dac29e01ad501420560f44df7e0e1c": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636337", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29f8a1dba08e7b6c0bb2ad1343251c54b1aa604e30e2baa8547c93923bf8be8c08efa12efaa6b444e214a3d631ed54c04": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033338", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29f905c1baa64d9a27dfd9b4ca546b0de2c2a55b5364338fadf45981d173acd75651f8ef41b57931694c3870cbcc54870": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033732", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29fc537374bc9891d40a39204c7093f312c2a55b505d8d997b80d747395c1471ad1e1e8aa57319c5727c6f178bde2422b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033838", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf29fd0b6b8355915ce3ffa826e5b38279e7e726af71a51eabcd429888bbd0e46ce1e63b3322d0683994ca825dad3d3716b": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e04466569", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a0505d22540321748210e91a159ca996faeb0076ed1094419bd13e852c388586de314e8437d9c0e315884c10f1b5520f": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033534", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a08e557c63b7a8007ff6689842110e61a28942a9d2e8c8501860b847eecedc45d602e614b8b0849b959607d0dec3d071": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a15ff7725017f89eb1a3e7fd12423158468eee3d896dc822a496e712d1116e0731235c54bcec12e41eb133bf9c98cc15": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa5904563033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a1d210e875e95a48beeeb7de06a63a8dae1595f870cc27a34374a6b819a554e242997efeb760433c6fdb4372c2f28204": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb3893450563633130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a31f5cbf4475bfc9efafc13b1b0c25c7c0a05f52c96d2af9862c7b89bd23a92c7e8345b92f1115d368b6548a58aa8f28": "0x8e602e63afb364ac583747b0a8bab092d5b20ee98f0495ce7562a8c992ac9f171050617468726f636b4e6574776f726b", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a40eb48b4152b4473297c29ec09686691a7eb7be90a60ea3c4b467df2f8fd89288ef44f581426bd98cc34a0b67bb959f": "0xe64bc946c10a1f75e683f236e72a44d6d61b3bdcf72ffd8c738e488efc6e1567033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a41f147666b3bc8614da9accb6345eb3640d12a59e7ac3ab24ad5c33dada639c058006c59fba147ce8caac535e801415": "0x091bb84ac5b08adf128e855e1cb079ed594be42af19d09d680dae982ac209ffb04474f56", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a447ce4afb0ae4367d7392a01823a74b6c9e3102dd2c24274667d416e07570ebce6f20ab80ee3fc9917bf4a7568b8fd2": "0xf65f3cade8f68e8f34c6266b0d37e58a754059ca96816e964f98e17c795050730767677770657a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a47564e9fd9e709bdc7f4b0f17b513d19a9c5706a3b70b507dcf6b013c69ef08af652b1997d6fe82d5ba6975a2581b21": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c413064354524c31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a5ed7d2724d100d2d05bdc1789317d1965819df33c22d72346bb95afd79e55414f35acbf0997c6bbaeaddd1d3688506a": "0x7ccb1907030863dd708764cc88a4b4d09dc5bb0f4c9ef5f4e73cfc0aa4bcdf3c0c426c61646552756e6e6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a61143348f4f5d9480149096130d207f1baa453966c043ca367ccfa19f450244447b9d32f4b7af2d9749e55a57ac09cc": "0x09cdd094e9a51d26bbc6cbb71d3f7c5b8edde629402e3e5370e7f6904512fc4a033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a712d143d4d87ce437f368647a2bd84d0cc89d59de520e70fc4b9bb9a43b41b2b748ab0dd51ea18326e8ce755931ea0f": "0xac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f06427261766f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a7c5daa2edcf3e3f0564c7916ec616c22c2a55b9020732ceb7db3ed3ad35a2ada31a65bbe0ac94ee072d92cd27a38f7b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033938", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a8241236ab722210dcb57860ad26dfc420df777c881c5f4eed3f1c75e29c65fa681a63dc612cfabc5217f4308924e62f": "0xfcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a0544413032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a8e619e1be259276e1931733fd74468913be73ce92b712d00931d4980713bf4be8974255e1e51a7ed71ed2ea37f035dd": "0x6ef40ac7b3e092d0eca77ad072cd317683ab9d24aca4025788421d4276527d57064652414e4b", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a8ee49496c11e988c1de658b6e0d91892c2a55b527a77c6ce5976953b4b0bfd3f7db8a96d27fae160f24a0a6759cd466": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033735", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a90be8e2b61f9112e1ead4d7fa120b6cc676e6031d0f7fb3ead234afe813ecec2d6e3b47fcee702981feb2c168e2c37e": "0xc09033af1dd99c3727bd222c35d9d34e8e4403441792399b08df0d60544fbd4811f09f8d8020444f5420303320f09f8d80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a921bc99ba337c424ac2e016f6ea4d330aa18c1ff67dccbb98cbb86ea9808b63dc72582c602fb0dcd7e6716dd9ed9c75": "0x09cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb3074b415a414b49", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a92f96adef1c22eca20f96605e019b3132aee225f2714c573eec965a9dd1e1ca399636d9158ce068842f0558f360a435": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2a92fa064bb4fe97cfea5fa57b0ef07ee98d7bbcdd3c7fe6e9bf7de42bc97968143fb02ce4c7f2382552237dd13982559": "0xfcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a07444130312d43", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aa0d24943c155775d7f5956b228aef940ec3f7291f82335606f98e16f5480b38b3da95d2e7ee9489a89a8a39f9dac956": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aa1d8432f3ae2dbfe11172e994ab5a6e223188d5f28ee27f7e9067e89bc52fca8f1da20c6a7548a21cef18d8934f820f": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c124c6974656e7472792d636f6c6c61746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aa452ceef83f65de0ade28ef358d5b37102df685c4659f9c242ff9ac8a4ee5305770ede106db7a3cd5d3e8823e33d001": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa5904563032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aa534b6d5039aadd4851037521484c4c2c2a55b5976eb2e7893f7c3f875b3b1cf3d653df30a0a58125d9fe0f8b87b832": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033930", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aab63b090fe2eeecd42800f5b691cc732c2a55b56936ce0a4d5292c66857a725cd7b30a6d305922f4631380666e5ff2e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033634", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ab89d60f1f71d97cf57fc21e5c05f15f2c2a55b592b0caf0f0440b89aa8c1d713be7b3a16d79b3c56eed19d7acdb6e08": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033830", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2aba55d6a30b782ecdad58fac612e470c24f7bf2054bd95b8304900a908f8b298ddf79ccc09931f514305c490d047a63e": "0xcc52156f09978540d3163b798f65a8788bd04d828f366674bf9ea1f88e96f5190a444f545b315de28fa9", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ac1d7c3437476e392cb67606eda3c34a30606b4c1b89b4e562efafe76bec80154ac8b3e16e04c2e0f619bcdc0a5eef52": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa5904563031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ac40882e593b56d2274898a5cf71e2542caa5b3f92b80dc21b417252e93eb55ae8c6e6ea96c7424bc80d00cade786627": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033431", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ac82a1e1a0c89cbfabecf8bd0837093f24172a563943291c97d252def71e17abf467a1626bca358728a90a82b3de3118": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032036", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ad6a2ad55ab8a74da4f11b3b65d69ca2be4c6b203c1e605511cfb8db27330ffa7abbaffcba5836a0d6f3151ee8eb993c": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ad805490353f543cfbb0ed9476d0ee357ef6c750071ec4ea673adf3a02c82062d042aca83eab159f599434894946423d": "0x3e8faae4c5713c72aea65d52aa1616d3e918dee3819fbbe08cd4c76dbd754a50033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ad8d5ecff0cf8666df907974af5f0c9a866d1837675e6c261632fc872c66e779df05bca99fed82db1f5cc4c329beb520": "0x8b63cf648fa2a43a82671762a02da41dc6abbd1e62a376b3af7c2d09abf5120c09476f7373616d6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2add6d6b7da83a91122ecef9b7f1f8ed22c2a55b53b42cea8ef1a2b6f7f66895b8904a4764bcc5da3d23f941953076c48": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033536", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ae064ed9a95815109a28d1341b38f77f0e49baba2f2c359d846db58da8cb83c820aef3fbaa7b2164444d4946dc047e08": "0x4421050207b47ba1bddef66d1e1deee5b27d27d7fc526cfd68e4be18a5b9b146094b415252414e5a41", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ae25c26c4d55e92a8baa81c8ccca2202bc81d1b8a3c50fedf5323698e1fd52fecfcda7436b8ac0ac6f663e146f4d4f5c": "0x8e602e63afb364ac583747b0a8bab092d5b20ee98f0495ce7562a8c992ac9f171070617468726f636b6e6574776f726b", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2af2cb88bec0fd6d9d870ed0cb9e6b44dd62a2b80ebcda1b2f14d2a903088759ce56482401fb4130cde32775d6d210a6a": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2afa7012257eee9779458ee194e0b6a5144ab70adf9b1a6402cf14b3c61f98acf5bccabaf0030d537510166a21ee44d16": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f88370238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b030bcfd4d04ca2771966077d88e8ca4824f5bcb1f267ea5a74e1a1c444c937eb29cbaf0fc98f293eab5275aeff5dc51": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d073033f09f9a80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b035f15b888e0ad82dc423c5e7b66dbf6b05609a9079e0e03bcb50ab1676122a5fef12c48bab67b95d4d0ffe58ba7df7": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d14476f76204465706f73697420f09f8f9befb88f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b06d49d722afc851487d64d0443da49c128865fced1fe2ad870d0f1ef6ac3c73c78012dbaf73ee9db06ba403cb73a523": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070237", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b09e1ef1249e67d9b5b08826659bb27a442afde41c8d0cff9680849824712996d0cd96906dba9697aa5110cd6d025e15": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033134", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b0e45cea75dd9a6a2fb59626aa0d17fd7c73d0b870509f5c2ce7ef8313ac58becd9dea02162a270f9913116d690f0904": "0x20b456b7a8651f0b81f4517ffc79737cc392230cdd92a5b4bfa09ac728a0b10e033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b0f6b2e285b92b32889b0381bcdff93a2e2409b5ef509e1e584584edc945545f42fcbb3f288f3355e9194206b4ce773f": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b112d8e01e5b200440094fbd1752bdde946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814033131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b1bdb2a978b70c9c8ed058b2e17b652b2c2a55b5b86d232309cc2d8aedf4c647656fc6a40e2cdc299020174154a7fc42": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b1db55e6d201f24c25972d3b93600bfa2c2a55b5c4fa92b88356b2666fdbf58840b50813143d93c886f60a39b8eb204c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033137", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b2022ec7aba6817b8cd6c3743dae52dbf3717672dfd677afa541355ced152c72acf081107fbecbc9e0acef5b54b51223": "0x0c618307d00b3354999ae280858c01fceddd77a25b5bc665fbd4634bf86a41780e4f70656e476f76207374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b2e8ff0ead7eecbc8150d40440d9a34fccbf40cc53a67fedaff6111ffcf4d618af1ef8258560609082989fe66911233c": "0x6c42f37017f31d6c9ba5dca62626e6fb434d6edc31bfc9aa49f001a6ced27876037630", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b2ff9f39e4b4f2dbc2910bbe4598c2732c2a55b5f917f0ac6055619baeff392603206df4007063317d30f823537ef234": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033333", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b340047c4e17520d4d652bdd615fa3c8802bcb2d54cea58ca2d0af13a85daf28ccb873d31de2a277ca03bb185e41a25f": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033530", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b36890ca82312edfce5360970c393151f09bafa226f3e27f549d4fe85723533c0f0e54e366f3a87614ca08443b06cd54": "0x522e16fcd83f6d6e08fe2b44d56b5d0bdaf33527b49e8832928d003d8097ca630676616c2d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b393c14ba1c4a4bf502f1689557b3313ca67e0639a4112b0f7cdc7a7cb9ca5d55b8fdb35862eaee46c8bd34720783d73": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033139", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b4010745c44b5b43598903b7096fe882c4896d44835fe17827b4af77172094f91a1b17ec3524949c2d626ce7314a440f": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090d6e702d6e6f6d696e61746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b401f35f10e20d172e577821098954092c888948530df2b5b3322b8f999dfbeec62bebb555351839993a10c2412c387e": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033437", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b47bc046571621dc5753fd0b932bb7ac74edbae75103b891bf37c39e91cc489a6f68f7b6756b32875d5c5e28c1730272": "0x984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b54130232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b4a894d95a70cf19ef095db1a9f9f8f89e447cad47afa21f342083e9ef18cf04a27d81fbd0cd742e8ec36528c4514269": "0x1a0eb7fdecee073651f1a21b9779b7bf5670493a0e35a53ab83b3cabab814a77033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b4abbd8736dc65a25c47575bb9ec8e1c2c2a55b5eabf99708c2a9f1e21a3bed0fa589b18286225ceb1bc9e28ff06a04f": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033133", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b50f5b869e807abf7cb2f1ee7ef6845c2c2a55b5285b5050bfaf7c602b3748dfcb3306896ae8429c2c0ad8104c503401": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033435", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b5642c854a53817aa071ada8e9bd62a4a100d0eb4c4ad076d10849f54ddfc448b83596f24f71cc49ad4c0390ac489010": "0x22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed40636504423031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b57102bf290cb640a422734d07fa643ef61b8042ce3e6f4c3731471c6a57e4a8ae30a1ffa5870db5043b933dde89af1b": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033436", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b5f83990f376bfc67e6b72cf9245fb42600ff061b1d97f28da91ad5b3eb7cc5dedc5431b2935a0440c02a6a82a3dd49b": "0xccb38aa8821510b7cc609cd55fd19c0f9c3594d49fe8db355bb2e7fb2324c948033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b61448b0855c8703eb3b665287ce3c226ca8fe9e98a7d7fb4269fe93c638a2e388c6085e74c18bc220c125fd7f0b1b68": "0x3c017930b46ab5a4413bf3153b001287ed5ff7fdbd2734cf69abc843f4ee04470ef09fa59753616c6164f09fa597", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b625f92500c01f436f0e71f0a9bbf2a3209f9f598ee545bbecc4993b7dff86f89d4b3a1dfffa7dae7e31f32c4b9d2c47": "0xc44cd5285e160a2184f3f5801cdce8517ebffdb591177acb17cff2db2ffd9371033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b6eb1d049af0ffae47c2af03b5b04ac9d6b0e114db8fce63ffc070a452ffa1f47f0f7ca51f32809a624323f51c146d2d": "0xface99d3401cb9b45ee1bc0ec52f4cb35914dc5ad27806230534230eedb8413d034444", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b6f2c4862edfcd63814ea4570e540b357091f937fba948654220a41ede536b0d62cc30d20274a28005b8026564db8d25": "0x0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d01917919757664476500", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b78425e582538dc4c288486af28286bef43e114e579d7503e86bc631c58415cd1cdf864d0fcf512bdd5cfae51aac062b": "0x2c6f57e9289919d242aa985c1963f2b4040ddc57df3682d890657d130c0355760c63686f7275736f6e652d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b7d7f9b15ea68fc3a3bd7ac0e0bde394320145f6b95e9a687429cab758eea7c9cf2375c09ee12b7973e85c7f8476da7e": "0xa4848ac04c2ad298cfcbf27ade0ddebb2cc3b37b090dd933a1e988b7a3ead0750243", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b811ae831b53a9fcc4e215d67815d9ae1a58ec699c897903d28984e42202dc216e2e8f7023c846926179c0c38562e4e0": "0xb2692080bd814373a7c780dcc62922ba2e770c11a50bb1bb38fd3e69f0192a7114416e756269204469676974616c205374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b85ced93d80542a7b97d4ea4e8ac7e90743a504cd053c4bb4b70c29cd59bf38cc92d1f51784969c0094d010525b54145": "0xd573535a40bb01903e616a383deed22b5e3ff30e552017d2395e3e75a8e786130232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b8ca7b51ee7f82178fcef96f9c679abd34e6b8b209b93f5f68b7abba7c3e17a84af77819e98b05a0d828f0b9b2b92578": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b8dc0e3687e1477644166ec179afebfa37982501b1c242d5d23a353d2b44e7ef342d32adc991306632ba6f3c61d4487d": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b9ef0050bbb06da457001b37138b12922c2a55b5a116a4c88aff57e8f2b70ba72dda72dda4b78630e16ad0ca69006f18": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033036", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2b9fa89d1dd18608cf05ba581ebb5bf1a9819a1a845833b4fbfb1a911e2332fe3abb3e09acdff60b492680c6189629b2b": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2baf6acf18406a0ac71738890c9e1ad0dd4bb93b20f1a0f4d41cc2b066ec844343f3a6748e75b3c5a4018533d0c882675": "0x18a5d639662da95bb4924c48441fb432047e77613263cf1438ce8a14fc34c432033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bb9a49de5d2039aafbeb82b8401e673020ac6c23e69518f5c048cdd4341f431d23f1bdcba3abfaf7349241db61ce1317": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bc3a7a7e8db2a65f1ce6ffc95b13a5b662ed2bb3fe57066f0c015e18bf443b1d384119ae9a0eafd276064062e73a1b31": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033237", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bc71f2cf237219176ab15a40a6712bbb2c2a55b6068e3b8626608321044a89b82fc4898ece34524659f48aa72aef556c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033131", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bd33bc5082da8415d4508b956b762f6b2ed9b8035e0bb64685f561677349c54d0ae8806f1ea86b74c12b51dc8154bc9c": "0xb64a86ea0e91047a3ffbbc68c36ea9ab318ee06c8bb4a354dd3a716956c9eb550231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bda61a4f13fc3742a03a47f801b0279ab4dc28082fccb1f21f1728e29c178004bde0e64385194ac7600cc222b8bb9a20": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c413064354524c32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bdfa0648392ee33f09ad376deec2286e2c2a55b5c7e135ae443c6ed951338d4b32be6cf61ac5bd000b7a11c26b307820": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2be55a78a142cae9a56448e35fb0f3180760f9c3a5299a87661dd13e267572ef052d2c2383fa8f77f45c25567a6e27f75": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d0d3032f09f9a80202d20314b56", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2beaf3d87df59f54760ad106c3f97757a40e1ae3e3d1e6fc5dd9c3a0bdb1c0d03772a3c69ce5b4efd1d8653ece57cf539": "0xa4a7835edb8c6b0d10b32c76ddd9560feb4894fcfb61593accd8c7451e96562e05706f6f6c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bf1b1a4220f2551ed3b4c82cbcb2cb6d38a295559d8977464fd8cdd133f8805f2388e42a6e009219247048a27d9ac06b": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504636335", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bf8b91717fc4b3b889245634525a2b2498bb3be2e039d66d581ffe74cb449689ac74428512b67e033855de5d75b84d08": "0xaa72c321b20bbd5b78b14f6fd800017bca47190956eb42ada2a4d8f8a8ca994d0b4d6174746572686f726e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2bfe1e70f1c70d00b88827788b71b101774065a60fa33d4c2c8926d0d761d133a305f500880fa95ad86acd865f274414c": "0xfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e037032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c015e16e71fed001efbbd731b1a14ffd70119b7481293f5e919dd9f0c078a5b285f9ab78fd05fe73b9b4dedd595b5c38": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c0acadddf3aeb1876f2c7c88daf7ca952c2a55b5629e69cf9c08b4b926e7e8503cf4d337fc62677f40409a68fe9b9a1a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033531", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c0e57bca92853c3bbd9179917407577d9208af2fb9f1511facbd517ba7ec0296d6fc9fd010896eec0f43a415b68b3706": "0xc290e73cd4a89b696210d9f712410463c89368b6fc4d22ce10207d8f31e5e73900", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c0e772fb88e288ce6c003ea0435930d6ca0c59a8141101a8f9c99e3f8a85c77b0ccb57ca6121cf9edc436092e9bbd17c": "0x628f36dddf8cdb0242104a2531e7d3efd4860a9a4633be69aaf30f63ccb25a5e09696e204461766f73", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c15da76d7063a20d2105a731e85b952b55ce3d06cfa21735e2f8b652b7886a9a91a53c2e6ddf1bae4ee86ef2209fd0bd": "0x8122315b758fe65626b7d0f7c8f5d0758b235f22df56cbf73610916a88520efc0646554e4453", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c2abee6fe4293d17c3395bb0ae324cb8ca38730919998d8ddcf5e729a8a275769b1ae064d1e0f5528db03eede05d5e24": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c3440f1ad4617fff4320dbe3d17d539988072cc906cf4513caf8aeb6ae323c8b7e57bf5581da1aaaa8d1363dac664266": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c394f9702c31720b76d50596bf1a0b3e8b7602f67d9d61682964f3b5989f357752f75dfba430603da1384059b79f1535": "0xa23809a947f2c06542cbf2fafe17fd7d84c460d51fdd69d01f53a5ca050ee7090231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c3abad1b49578e95c1aebddc2b5893dea82456d51e83aa6dbf7a473b5776454fa175d5dc9775629aa05bb09b28fe4509": "0x5ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304033034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c3cf4e2a0ff55f643892e2a52a20693e0c789dbc85d3a4a498e13f720f71110577461e834d356ca361d49a45ef609b6b": "0xf40cd7a2181289e32776625b9f3a193f749e33ce1bdeb76cfaabece606c7324c1968656c69787374726565742e666f756e646174696f6e2f32", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c40abcd97ec4dd18da9ecd6c8d6af226a37a1021f6eab9a2658f2f6a5e08f5851de80230d270662dfe648c0c7bec2e46": "0x043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d073031f09f9a80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c41de75982653ee203e85ae8b3491a626cf627b193bf62d66c08afc7b08095f2c12178597925fac26265bf801079ab22": "0xcea3dabe52b2a665b1e19bf8c6913a5d54e06d6413ca3ddbec8f9a22415ec4770248", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c4cbbc94ab26be6a5bdb9daee5cd70725ecc1d4e60a92262c1bec62d034c979f42cbd3fb1c28570d5baed6e5ed20d533": "0xa471c55caca4be7b4e60c6e94b20f9028883f8c64287d4454130c657383c3442035632", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c51e4cb74629a513ed40913f5fd048062c2a55b5e0241fe92a75c23c49cc15b355a4f52c934719b1b7382c5c2b859a46": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033734", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c58ed9577b53cfdd09c2a60325ae4555cc2dde4403d477d784abb0486ce18908af209f2c9d8581d33f7e847608b5d124": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763037", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c5e24722f48f114eb319513abecd93415010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0241", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c666dd6bd1e6196f18935a711ca0128c484cdc76e0b6b2cb4e30850327cf37e717d91e343a62bbfaded38aa8133cfe34": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c673d8e3bc8bb8b1aaec7e4f1da7b00004704197ea07678709bffe4d7cc4a0203e5f92da2f681cc5e5ebd399b83b3949": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033335", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c6972e264d3a6b5fea949ee6deb8b99a388bf0fc0110c1b18dcab471725083bc6b0b52edabeab0c3e73e506a54f9e04d": "0x5a33766207d51925e4b9a2302870bf737305cddd5bb2df2dffa379963e586771044f4e45", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c6d5accb29b732a3b28e7e07c00e51f404db71328c96f1654885de2d1f577621c524e4515416b0f861dfce55a3f72167": "0x545b7958451cd22afb0367d6c99af1360190813571c47b8a94a055d575d38249033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c6e6930f38fc96ca1527a23b891a6d69982aa00fdf3835f109ab98a569a0476af2e87c92bbf3cb6c399254fd9b31c900": "0x4056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a0e5a4b56616c696461746f722034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c7a14b30fea636224fddd038c66ceb362c2a55b56f24b35dda6da7aef24974dd6501d9c857f8d41d66cf88d5bd053044": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033635", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c7a412119faf128c3bcb5450745613970ca0db0283dbf8d123602a2ec334ab5c3fd9e2540577e0955eaec679cefa4f0a": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c833d839589168d31a513ba57eac40f9aee72821ca00e62304e4f0d858122a65b87c8df4f0eae224ae064b951d39f610": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c861e9da3cf1b67318847bb703c39631d84ea2d7257eeb646fb4e0d2aeee35a3eeaea22b897d8ec95f42d5ffd2251430": "0xb8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d23100232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c89deaedb1f96fd0140b01c7396300216202474a3d821e3d2df95b4eb0f8405f1a086cbbbd25c4425bc978ce8da1b3ba": "0x22e8d22a7fe2768c944dad8af7829d96eac8644f06643ea8ae68bc3c1e9053060231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c8cc9ad6de4a02498a86b05233f8b7642c2a55b5c69b5e131fb0f65ac7ca707f4bc53e4d991a2d1971ab5e702f69f45c": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033037", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c8dac5d09880fcf7669cd1f88ee32646005fa73637062be3fbfb972174a5bc85a2f6cc0350cb84aa9d657422796bfdf1": "0x264319ed6a0895c04112917fc9bdc0771f4a4773aae014a99d25bbe06fa1057a0243", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2c91aeb4ffae7eeb153ce2284e565a46d2c2a55b4f853af67dd7217983b8928934bedd57f2aa6717b4570ff9cf8c55d33": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033834", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ca2bb1fdef2defe515e9aba1f30778f91e7aedb71a237b95e3b805a77c031dac6a8a675441390e66bc1ddec7a41a1e54": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea259385609086e702d726f6f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ca49b8ecb7983e1ccd3083c5f08607620c7fa2b79d310ce32237db73b1e3d581a979b3bbd7f19ec44ff1d37b87dd3750": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa5907424f554e5459", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cb1b50885d1cb48212e41c3140ac8ae370519f42b7684d1ef3dce95d87895e447b390bc1089606d1a499c18d08bc511f": "0x08754abb6afba51a2f74f0b97bbcdb383f579a02a5e4541fee736710af562c6c05f09f8c8d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cb689f2fd08e34f3e90238d841086e91d8151ecb8e8d11e6c6bd81ae49216b9ef92d2b83b3ae39702a397922f1477768": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a064672617a7a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cb7824c3c4a36969f8b1065499761b832e6991a3223f09ddea0e0b1fffcffbed3f768d40231db602a030b7fba52c7d08": "0x465c6be30d314cf647a8fa10212bcb84318394659c46fe75d03640cebb39595e19416c7a796d6f6c6f676973742076616c696461746f722030", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cb9b5eb59ddf49669ec0c9df7987f371aa41228830918cc1cf16e50df86ba154a483d77ebe3182bacfb876af4fe9ff6b": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa590e434f554e43494c2d50524f5859", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cc71e745770be3a4327ac3e6e61c637a3e184eb35acff823bcf5199a3eec9d0a6aadcad642fe08451772a51c4215583e": "0xd45548e42d7f5d5aa35ffc16ff29396c99936f0c1eae84d452f1daac87c3c566074576656e7473", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cc80e8459e5fce01f1c58b4e2a8953ce0af17b8dab92e7ab018e1189cf597b4e2ca38e0d00716172adb26073867ab92d": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ccf2e9d8958e5b865afe2e0cbf30ab902c2a55b5a3e5f8bb0fd6155ce85668d8e606d7defec7044d8615225bb9769a6e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033430", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ccf825de56b61fddcde1bcf452e38a1fa2fafeae641e6e264d77723c00ab05f503db48ca3597cb3242c2b54d90abd01d": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cd2a7f639619333a601b9e944ddbd08568f26829ec470fdad2e63d97741a88df1243ea147bfb4639b97a4c816f9605fd": "0xd016feaa68e25739dbc4035faf2577d17ec9d7ec2125a99a6770b5be093f6e3204445331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ce122712cd338ac4433aaed5fe788634f415f3ade9353f49fffd2f3f2ebab33ab5f1b94390ad5758fccf5a00e9441e01": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0a627269646765687562", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ce59cabc41ff067a260befa5b4d22c06d97d35c31f6d0b75bfa93ec1eec8823651d1582368679c44f00ded1f5401b5e7": "0x7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ce9c51078fd9ce38eba0e7f6d7324d0fe0855069a59fa0ddf72205213ba6d7bc3bcfc44316af9684bb215f815fc0113f": "0x922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c05f09fa6be", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cea748c3b2ba59842163a012dd3fa089b3988a6af22247249717bd8602b7ac3e0fc63f469ae9ff8e9d022aa504d61b5e": "0xa4a7835edb8c6b0d10b32c76ddd9560feb4894fcfb61593accd8c7451e96562e033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cec0021475b40ca2d74cb08a8f4168e0282a194090fd6715e06430d8a6e9c682f021eaf398830b10db94ca8c27c9ae4c": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cedc7b9f5e185052276ff40cead4c032149ccce9d526a65ba54fccc24f5d1dee62f9b87915d4004eb932959d468a9e62": "0x18d54ea25ad26acd7094fba6bdb278e769f9ac350cc36b2f631da13fa92bed79124c6974656e74727920636f6c6c61746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cfae23c09122f09f79bb0e3306b2b74836fd9b64e99689363368298680cb35750a594103048bffd839af770fe5536c6c": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2cfbf707024d3f7f987d6231d10e0e1a23e9520e4e74fd47da1dd509ef04dc9b14215a35e7d207fdb2c99f732ff5cac16": "0x36aff2ede1563784631d6149024982108f661b079b6b79f3d042041a9da11e2a094c6974656e747279", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d03c012a3925866fc83b45604288b687114f710e9094d174ee537a86a7eb9ab2004e6405626a843d4ffea72694b9e23e": "0xb690df84dc61bb1b04bb3e5483678390a44eca9ee4a748e98f526e126c19c7020258", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d08ab4f04d24a26306b6e8849841da8792e594db8b26bc07fd45cc783db49313f17183491f1826d417155a95d5f7d85c": "0x986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a05504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d0e7cf7abed89ce05a639e6d088a035544ebd2b934606a30469bfd509293c34174336f974709964a18bf40d99a0bed0d": "0xbc267fea33668e3515a7c01f4acca67d73d30574b600a404d2b7210aaac855690de29d84e29d84e29d84efb88f", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d0f86a770b0362a67e0b80f83a93995472284f32719a49037a79da881b91b44bf642395ecba92b241619e21fb1c8a57a": "0xf65f3cade8f68e8f34c6266b0d37e58a754059ca96816e964f98e17c7950507304626f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d13aaa4ce8a3a68e5b852c21463efb531a9490a6fa5ca6353651e0384ff371db3aaa0d2fd20e6ba91c8733a17f581602": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0247", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d16685a34b78f937300cd3a3c3bfe0639f958e6a1f4ff8a986a4e7d76c417bcfe8affda4182e66b9952dee757d7e577d": "0xa6c5f0595d6ed85d6260bc682d4a68a4b4e605d43c67d56f2765d196985497720b436f6e74726f6c6c6572", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d1b99fe0be3362b9f171c5d2737212fc2c2a55b54dba6c93fda08f30f8fd6be0e47bf66f3fd31e2e1d72b970b3ff1154": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d33371148f6e156ce9e4018a98d91a4208a73c9c3083971fa2ec757d38c8e7858df8076aca40ce176faef81fcbfbe258": "0x984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b541305f09f9396", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d3a35414cfcf6a6cd5be058a4734f75974fd218ac454949ceee42deee0ed129de80fad49f579870d7ee9d4a2d1e0e27f": "0x7269f7eab2e5f91f9efe10d0dba0e7256d9433230a8f9fdc1c4af10981853476067374756479", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d4064446373efe5e2d35657a95221e10a06c4e59af8d86d8b552887762255c830d79b847a6648210ca6b24d0dbba0e2d": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d41bc04620b2161b34eb34e6a47af25a3a337becdfacffca71fe67fec208733754f035958d349d36b30225fd47798f6a": "0xf857311106c8d7b0daf6e096db9a0d759b52403e439ab23fd6559780a8b1c803064249534f4e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d421cfb48fad0754e91335eb0722ee11d05490aa747179f2b895c2c5171e9cb10a474fd07d1a8069389678e165369e56": "0x1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c41304554b31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d43a2b5bacb2a5a913735d81b9183d6a730800477a5fb0302fa9ff4b5623662a27719a304dedb3e12eb004f48ecf6b29": "0xa4d813e676d81d97479f9f15572d9eadcaf4503b654c0f6e7baeb49e84510e690231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d4eeb7647278f476f14736144be90ffdb6612cc74066b95fb08eb5978781b15169170cce9f5493f6d8f74013ee4e6e4c": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033533", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d5912e8857d3fd846b9b7afb3d401568d091cf86d04141b1c17c70826c08d074cae1b00d6f82de1b8a5406ea10ce723b": "0x5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c095452454153555259", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d5c42076011c041f810f01bb5ecedede01f8b3c479e6400cdaaba7b54357ef912ee1ce5b803db86506805054070ea176": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090235", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d6227a681a80f70d5b679ffc134fc506c0532217caad133c16b24a5e3b2da932b83aae63356a787e1594e71317df7cf0": "0xac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f05504f4f4c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d71c5e81f0ab3d464dc034191d86d5f5908626870725d87736e1476482cc7df7bf32f03f83ed8cb6db40a830067d973d": "0x08754abb6afba51a2f74f0b97bbcdb383f579a02a5e4541fee736710af562c6c05f09fa6bf", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d8558f24642f1ec38c8f05a6a65118884793061e5121c9561a8dd25c2e64df912f5939a096bde10bf9c5cd06f753f6a7": "0x463a9cd3e7cec50ccc93515557ab58221d20c67a409583428ad67caff9415107065374617368", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d8ad31739c149623bd78d39f54c5f51b2c2a55bd3b0028726bf7764e3a604421e98e930f851a2bfafdf5d29eb694d275": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033937", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d8c5bfd4bc0ef3b8e44f737ad8be140f78c7dc6b311bc7e44dc95793f0b8e1316ab1447073728470fe08e0b4a8dd243b": "0x264319ed6a0895c04112917fc9bdc0771f4a4773aae014a99d25bbe06fa1057a0242", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d96660089dd600c4539c167feb8a18a42c2a55b615f9b64ac6a84fc4513c431a7b6e0bd3812a4821392a462d049aaa3a": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033334", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d989677538850769066111c948cb30682c2a55b4fa84e9b7e85c6a3bb37f4bb3831bb51a5bbb1666ff92c8b874dcb42e": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033633", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d9c47225dc4b565f343d7e58210a682c224963ab92b30f5a7c91256507aa6375320e32514e54eb988386ccd3654fdc84": "0xfe1f35d3b712d9b87e9dce926d8772267bbbaeb776e9b2a8615b29d6594c4621033031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2d9c62ffc145fb75512af8ff50ac058ee48e77b8c0864277405a333a644bb283a03ade9c351473f7c167b309ba4cda308": "0xb204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d68033032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dadb90787d37d7ac651f6e2941b2d550981d5e90031eac279276782d0d15ab97fb30898a69abc4eefaa797c572823b2c": "0xb4d78a8bb35a7b0ff8ae6a7808f9b17c83efd28b8612c2388034d0e35ce513760232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2db0e6c637e12549ff30cdb5c7a3b2532be6c22b41a47d782268a2d1eecf5e623ae6b984591db92f77de07a27a447f87c": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763133", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2db818395f4d30882473aa682f1d36e9b5613fa8d949d17f4bd3ecfd6b7cb550072f4559c4c3f01250379945e44cb3235": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033434", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dbb2c86ebf000e28b914ca30a0c394591600e09e1d8a1324934f83d55d5f6f503e2d91bf4270eeaefd462f24e4487e29": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dbd0604a8ca46a0f5076f8140d75ac7d4a1585474299b9deb690132a6d586e8bedfe4d8e75ec70c2dcbd2dba24269215": "0x040d1324a05bb9a0b86d9eabd01245ffcf277f4611f9750dfe465761481ba053033038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dbfa7057505189b4af689b9ae4d384128a4c3a7b3f2b3cb525ce315f859de83c51410fc29ac88734be346709d0798a20": "0x3e3a490c516b2a3582e6400e33f3eec42a12589958cbb86c87b23bc94710d21b05706f6f6c", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dca1cd7196a14a851b5a275585eb732bc203687a31c85ac0dce32725c354a515d8c027681db49edbbda4e3804e5dec63": "0x1a21174f3333c2bb416072b2c31d8f1e60f8e4ad3cf9546ab47e5b6fd060d3030e6b757a6f207374617368203031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dcdb7e8983f1dc27a7169e03dc11b6dfa2b3963c9d349de4363ce38f5f9854fccc0636768d947108b7f219c240837855": "0xa02f7333e25590e4f568ae8a2ddc93a879e92e48fa3cf1666ac56e020c106d550a627269646765687562", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dcf24a1420a437a2315ff698af59a553685f836cdb8f2749ca5a225297e1a8207fed4511b575448e09bec5a870480c6b": "0xd46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada52100030230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dd287caf54b991ee49d16dfccfc25d2c10a767cf483ca0629c6cb5dbfd20f5f9d8468b153b90bf3c40443bfba9354a14": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ddc46103873fabdcbfd43afdd5fbdc87724e0032275bac5598878e5dee08149d11c44700c9c4626d1f339ff1be715f30": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032038", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dde3f4916d4134ee96557d32c2798be38e6c97add8c5563d923d9b702f854b15ae59ecad39578845a04239c594046044": "0x64e6db572dcc9e5dc57445ff7c68ce85e42527aa74b2ed5d1e2bceefd308ed05033230", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2de1810815b4181d78b34a31b9a5f85e4ba3e9b87792bcfcc237fa8181185b8883c77f3e24f45e4a92ab31d07a4703520": "0x3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa5910544543482d46454c4c4f5753484950", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2de2150bff9da75d3f86fe07f2279f5192c2a55b52656178628dda04be1e16aab15775638cfd3bac25a59164631a06b1b": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033532", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2de4b76f552b266b54b14e30d6052fc61e0512205b8cbb851e7b9d862d204b1df2d7598e03041c7e70b373ac45b1e6cfc": "0x64e6db572dcc9e5dc57445ff7c68ce85e42527aa74b2ed5d1e2bceefd308ed05033130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2dfc40f350cc4563ad9ddff5ad92944278eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b868964": "0xa02f7333e25590e4f568ae8a2ddc93a879e92e48fa3cf1666ac56e020c106d550773797374656d", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e053e352d49371178913f8a7c80be39b6a4fe76ff9e27c148bf2c24e2f85fe56b4eea5bbcdc159430c18036e0f940f27": "0x5010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f0246", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e0894c7505c4ccf600b4e887725ebd7b8c23324b0cb29e4fd1a68cb08febe58b50e39d8afdb5f752d6c26c8ba52fc002": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033132", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e12b82edfe2c5df8bc459adc5dde162f44e9eb2333d2ba5032cb999fc5815802139a4f0b1abbdc6fc9669fa0d3e9ae55": "0xf65f3cade8f68e8f34c6266b0d37e58a754059ca96816e964f98e17c7950507304686f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e20a5666049eb6eb1d793e56dbbd540994c8f2aa65dff23f542ee99d7191e88eecf45b3a61b7350dc3d48804107e393d": "0xf0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c0232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e243d9597e1ff02bcc83e65fe97ebecf9970b2d4d682818fe75bf20d33d350798f984ae009b8e8e127c1847461357ec8": "0x5002926543d8b8887044442834d4fd5fe3d6eb257719daefd3f2aed28eeaee690232", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e287427a545f07fa7bf625be98536e33b6f0f10eec993f3e6806eb6cc4d2f13d5f5a90a17b855a7bf9847a87e07ee322": "0xdad0bc6a0aadf06c56416e83bf75e865d41ccb5ffd74eabf9e81d47574b430491143554c54555245444f54204d2e532e58", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e2cb581353e109d4244df722361162fd828ad82b9738a507bf481d6c3feb4e50855378b588a653e3033f5eab788c335b": "0xac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f04537973", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e3178c61a0f52ecfd1d1b69fbc8d1582c9108836cc5003906b107d31fe5c7b5d1211a4f71bee14f068d2fa04551387b2": "0x06c7ea7684b6aac6cd63cf88c92b0f05398bc3e13e0b0c5936c3027b8e0c7e2f00", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e3c3bdfcaf035a202a03474869a5028cce79383a5d77f974ba22bada735faa2075716e442079b7d58ff1fd898b63251d": "0x7600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b448630653462d3034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e44a61acf949dc5e6246ad785d8ef21cb054f58645b2774a05e70ab4f9b59dfa46ed60acd0668713e921324a933e2027": "0x5ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304033035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e4598a627b033d5dfec8bc9280097cc1f6b2256178f0210557ddcc138e8b264204e4674fb2d73a8190faf4ac3724722f": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd070236", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e4b0112f6842e05fbfddd3e76ff53f58d6ce187276961ed56ae9a29566279cf443df42f82d9890b02de9c11e4d288e13": "0xa0db8c6cb723c474639931cae07e095e6e8d9b870c90f5b499bd8e6fdf4bd54f064368726973", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e4c4990573c19a77cfc77c7f474604153ac9ec7da0888dc010574b11d9d0dfd62446ca38a63819937aa91f40f6901d58": "0x5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c0df09f9099204f43544f505553", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e4eda3996223cfeedc9689417aa91cd35607fa03519626bba53d0d71b008694a205e566c653b766c9f1c60edee39ec22": "0xa4848ac04c2ad298cfcbf27ade0ddebb2cc3b37b090dd933a1e988b7a3ead075035331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e4f5cdd468e167da392ba6e10b53ee3e6a0da15516a63ecc95cccffecec2a2aed962e92cab661af4b1f76b65e429cf79": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763036", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e5992f79ed312340ce56189dc4f562739653bcf18e30531092fdc1c52afe06cf61f56fb1fa5d719078cd6914d395ed0f": "0x3640b7b7fbbecf967f99ec9516a74f9e255efa5c8529751a383afccfe936175e042f3234", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e59be3727eef8dea84201471915ad11a80833b98deaa7ae201c9d2aabba6d7cbdc14ecfe1548c52b8ac4907acb14c863": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033133", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e6c96e874922674a2cff73001f49441ade1894014026720b9918b1b21b488af8a0d4f15953621233830946ec0b4d7b75": "0x3eabb0f32cb0695fedb8d25f6299fe51f90b1e26ed858c1064aeeea0977c1e670243", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e7379ab3911997c3aa7bdf8347caa100e44b76584cf228a713f627f36b58ebb282be3a162e6f24d54a15d1082006a208": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033334", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e78c9f13a47a426fd81f851d5e4a4e328a32f59713f0a129fbc395dbc853f51ab53d45d1684c4bc8ddad89fd55fc096f": "0x5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f2804763035", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e7ca06f4e64071a61cda312f78f7a8548823139e30d401f7a9422e68208ff3ad2f8e40e92c83af26e4002734760cb87e": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033337", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e8071600e92b47d24031ea725c59eca4e07628deaa9c6fbbf2288f879396ff3566871c0dbce85c9e23764d15b810657f": "0x9a8ead39ce1b44f37d16e98496441be79018e910d5f58c0fa1518d8fd7749550165354414b494e4720464143494c4954494553202332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e8360b2b0337af76720b8a8c4bf432a0e23e7ebb9b8462643b8df28f53dc2dbdebb20bd0cf8fcb41d7d09db59d46a505": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07033133", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e87b7c876df80669b1ea78e67a83b8bdd6d1d0ca917751d6148063b9e1fe8a22f74396e63a2f72e149b39e44a0e77c7f": "0x321d847f8a53927fe1132754a7708c61049b2d4816ab6ce7195a8308e97c3d410ff09f8d80415448454e53f09f8d80", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e8b6c9ec21445bfdd558ec3ed91799202c2a55b51baa94ff2dc4feae28c5ecccb774c622545b0a127dbd5ae8e2c8e115": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e8ceffcd95ae97cf0d36a8aa052be87d782f3f9bd84fa8b7b659bae702b90ee402c45067cbad3d97c89ada7db6e0fa67": "0xb204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d680e434f4c4c454354495645533031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e929174dc9c4928bf7afa39c5375dfa326a944c20d0609837ab990ebb516c30f230f1d29be7d63f7c368c9a499be4f22": "0x466a9934facf9723f7ecc237cf0afaca23a6e832780616e432f3eaf19d8ff94904303031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e963eb3a31c188236411e5403a65a1f6bac6ca95205b7d29a9f95adf28d5f94ba010ebb51f414163a48747436c9f9cab": "0xa2656a3bbbea71626facc2641a9d9f744c87c393778020354714974894b7b27a0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2e9c8e89fbc1f9352f2bb567add0aefa4add1d40ef104fcb24be637eaeb9704064663df235fea0799829e270333774f3b": "0x74b0c404b20bac28ded8d662e2eae7ddc52988cd5a22d5de09259258395dc45d04313031", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ea718457dfeae31df87972c5e1528d84e081dbce8eb0905bfe321ca87d5a426435e7cf499020c644e9fbcba9a0345fa7": "0xf476394d38a2202be9ac84607ce7fa0a7a53981920999c231210fda7fca3604104505631", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2eaaaf45051dff93df16e63c768d773fe11d3e37f3547a962068f9d46c046759e8a866b64c844b0fe7426d95fc1b599c2": "0xd016feaa68e25739dbc4035faf2577d17ec9d7ec2125a99a6770b5be093f6e3204445332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2eb2b549672b19b67afbd9e3fc4b568ebd00de863a4e1cc8c2b2050ba4be784b313caa1e51167abacf392c1f07270834e": "0x5ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304033033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ec0d25e0e8b30cf77df449e358e3b18556c031a86027cfcb114d40812f06d9f462a8354171478b00dd075d9271db3872": "0x6e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe15407444f542f3034", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ec5037705c8d82366c308213ec87dd35fab574220e94c5e2a4f8fcfc9f0e7192116b24eb5df2632396d94dd43401a252": "0x7600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b448630653462d3033", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ec8413880bb125c95625f5a40e86558852a63150e02f15706d9ccceabf476a79dcfae5bba86e66ece74aa031da5bce36": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07033134", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2edb14628d7e37cbb87c519385e4e16a9a4dab34de26e570e8fb301f9c947c6f5f862dfbb27c9de5cf473675cc244213a": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140239", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ee9be1d4255e938947c92e123cf2d82f2c2a55b508174009ea498f934dfefc1a023e9d03b43bc601a2f7fa0844126160": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033630", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2eefdafbe6888bb66d3584aebc2c916a4f5c0dc71bff8cbdce6c32ae5260549ecce90af19512e7da031f2dd02fd920689": "0xfc8163c92cac3dd1d5c2c0a049c3652a8b3b8b6cb8a0867a5e494c650b4de3710231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ef9c24010a7d87b2d6696a19e87491d2944519212916c8838efd27a63122a176c83e9e0dc68ad20c29a1257166d7ec17": "0x561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d640d56616c696461746f72203037", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2efacfb219480b68325adacca873693d62c2a55b55a05a6a02b7b3ba6539f3744bed7a3ebf4a86a75986e404553bf0635": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033832", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f078cef6bb5ade7a68f37d2cf9e834bb34fa4e10f24341696e46d61b982f279969608b00edd5d32298f3cab0afbb695a": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5416f09f90b620536f6e206f6620612042697463682d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f0c0dc3560195888d3828d9767ed964be02374bdfa92d9969c3c6f8c313bed2e8165040d3ef604001ba1d9c838e9dc5d": "0xa849437f5f8b602fc9a4210d6a9834af4adc6ce7492861bd0f5b88d11919cd7b0656414c2d31", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f183a365116212f639e2d31af122c16e92070ebf24c4c84a47db97b62d308834c3f258a9d96aafd6bd11eca52bd6ce4b": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763134", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f18978cb1bed20a6759302de04ffe38d0e2d58494df50bbe553b779921de400483c550c57a9c7b5e7ef9735958228e34": "0x6464f15335eee136dd7c216b994ea6ac3394eb723590e9e065fd9061e05d003504486f74", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f20562184074892fd5273476a9079b73907559ce75b9e6531397c0050be2cdf9d982a2db041a099526baba91b8d25409": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033336", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f3759ae1aad2e4accd167f7617254a8d2ac73c24bb740376a5b0f44814e8ce8b34f23be0650e99b7ac81e1159f9c3151": "0x1c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea2593856090231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f3a2ea4f7e87660b8de6205e32768eed14307eae2db6e460778426604acdb1215d1a38ae54aaa0ee1664646776557d05": "0x3c017930b46ab5a4413bf3153b001287ed5ff7fdbd2734cf69abc843f4ee04470df09f8c8a504f4f4cf09f8c8a", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f3fc4d95dda4fef3c64f3e37dcfca37c60971394debc5f36af7ce9cc93a3f5cfdc400c830b8a8510d105de4364e7cb0f": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f07636172626f6e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f4e3472ccbcc90b51cd9bc48554ec8297c103bb33a2f4f6ff86f2f6e11e9488d6eeaebe52bbf31291fa00e46ec26ad60": "0xb8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d23100233", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f623b20438f6af5d88c978d9cb8470307677c2a4deb2689377319a8e830d5d9ce0ae32b95f096a7447f8f711b7f0333f": "0x946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f4382863638140238", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f69833f1ae9dbbb00dae666f139773905009e192ec169788c9c1f0202fe7c2bc79405ff8b6e1d1ac78fd6152006e606d": "0x5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c08e29b93434f5245", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f6a8ba389384cd6e3068fb6cf37e87dd18fab09febf634c47cc08a08a95988723b43f5ab499c4925d08793f3f701df5a": "0x82ecbf12e0965d08387b8aca42993392dbe5ddd0de48393b96075c641f2c940804443054", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f754bdf453d4e84560fe79ab039139fec4e4ff6adcb360ec9eb50d5e04ad47aec66a30055222dc13c6215b5f2db59767": "0x6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e032037", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f7c3b18f75237ef0c0b19cefd274264582fdd15d55ddeeda8100a274f8872503fda6e267e345f4edd9fad26229604c0e": "0x796b851c8164a129b23282ca4b3bb694364b0bfb504e98b5d2ffc5140d58078e0c636f6c6c65637469766573", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f80f919e92527ff0b3f38a865198b4c5e05c542ad7369509f498cdea5f5c427f2fd0b3051884184b294d9ac10fe64e34": "0xcc95d7d061fc6a655b795794b9b1614d0a240e13e81de9dce3f2b184f653da7c0231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f8c2f2927526f62e9c9ec02461c15d20dc0293434648638559e1a4cf30e829f17d2695980d5a3374af8d663bd5214905": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f09487964726f67656e", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f8daa14742583f2f5c0f9fe03ff22b9d9c6a3401d06cef30fdbb33901328f3611dae8253708779a5d66179c967582635": "0x96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837033137", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2f8fcbd529f3814b1082ca36f9bc8e31f4108a93c4704dcaa30f7b5f245de48d736164bd554743cd4bcfdf1ced6f852ab": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e0c76616c696461746f722d33", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fb35f965a2e1b5ae1f4f332ab4843aface3268d415f136dab575d25dc0b1932b736c7cc785a1ccc04f0474b458115f0c": "0x666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07033132", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fbe7c8aa7eb18460ce203ce4c80180417a813a8832981068f9b921dded7aafe83cf89eba4c91ac5460c65d76a61d465b": "0x6295f0214abb5522cf3becf82504ef7c87036236e6b9afd263697a99bc5d5a301631efb88fe283a331efb88fe283a336efb88fe283a3", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fc0e0ce33806f3824459bc37c3bd7122f2497cdc525e2b482ddec24761aeb31826701c5a6e35919787bfcb455c62d774": "0xb2e07be4d6d82f546ec91d6009ee215bb736be5b4362e66e7b466ec72d47624f0c534158454d424552472032", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fc3ef9f2768893bd98dc2460ab9d9ae1a0209c10c7d6633de64e166a68d9b45e7f02aacd9497f5c552e577abcdb17d28": "0xfaf5f68fe828f5af8d69c116efd937d90f1956b0edd94e05d8b5285a8eb2a6630a76616c696461746f72", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fc742294b2823241347b13728377c9e288ac52f4800ed8569280dd140faae0b0ed5613aa77e57a592cb9af8127dfae2a": "0xfaff1c4b5a94649e0338783122b93a469eb9e2e375bb71c92028a8fe9b6e2f460d56616c696461746f72202331", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fcdf79da273ebe1bc5b7ff0707cbe95c34bc6fb5ba6e2150087c96fd4852ec188aba74a5a383a22ef66b12c588cea00d": "0xe04ca25cf1cbc516ed1c138492a7f2e606f60c5a9ac96cb405eaa3914fd129730231", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fd2862f10100ae5b231586b302448ef6bf7105cdc60a8125bc7d465c5587c26d9954572b8579bd176052bfccd2847506": "0xf58927b296a23cbf25794b7cbb8fe31c5e68f2bcd2c2483e9c9cd0712216f2320547545332", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fd525643583f149f8e68c3d89c7cc0782c2a55b5f323b09d3dc6c092ed0e988463188613232235e6d6cdd03085885529": "0x2c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e033936", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fe257e46e780cc22f4c52b7d3917a0788c2bae6068de838d1fc684db669d5ad1dfe26f37887ce815734145764b7e7124": "0xae0d1db9082bdce75480ee80c3bf3c6496de1ef8171951de2edfe49fdbe30a6705f09f8ca0", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fe7a2f19451f39e782aa158587f5104091e1331ab2af4b510ca29f5e5dcc8e71d1fc6cc70ab24e2cf8513d540fa388ee": "0x2c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d5414f09f98ba2050757373792047616c6f72652d33", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2fe873b3279a034ae64f9fda42b000854a81b8a2a03afd92af18f0338e43afc504c6018aca6d9197c0d3a149ce65efa0e": "0x0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d01917919757664476500", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2feac0f58276d8e619cf093b7ecccc1efb05cb292c73a8d41d50181bbd829f14afa9464b6b710cf241ad1b801b0b1e654": "0xb22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e0d48616e77656e204368656e67", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2feb19c835d73b7b4e7772d1ceb85a24d88d74924b788c1f7ec64a54c63eccaddca748f588f67c26e5595870acecd9259": "0x36da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb38934504763130", + "0x2aeddc77fe58c98d50bd37f1b90840f943a953ac082e08b6527ce262dbd4abf2ff9f5c222ec1d9624cb2b58612a8f347588ab6bb059d351e9de8b2e3daa0f7dca462a8ed9ebd49ae10c3f753fe2dc84a": "0x86f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f0a626572796c6c69756d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e00123d83b036c82d5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f28": "0x0000000000000000000000000000000028282a194090fd6715e06430d8a6e9c682f021eaf398830b10db94ca8c27c9ae4c9effc7fb904ca3d8cc4f45b464ee4dac705c89888d298bc9dfd2ba563d5b3e3f20ac6c23e69518f5c048cdd4341f431d23f1bdcba3abfaf7349241db61ce1317ca38730919998d8ddcf5e729a8a275769b1ae064d1e0f5528db03eede05d5e248e9b0b6b26839418f4baad18a9c3ffbfa413d65cde8010bf7b9b9db0dd23e0058a32f59713f0a129fbc395dbc853f51ab53d45d1684c4bc8ddad89fd55fc096f6a0da15516a63ecc95cccffecec2a2aed962e92cab661af4b1f76b65e429cf79cc2dde4403d477d784abb0486ce18908af209f2c9d8581d33f7e847608b5d124bc1729a527ac8770c18456f142dc57b24069c9ff1032d6c3a1572d84b811ac7e780946289b4befff0da9911c013aacd2b280ec0529a759b94c67e4899b9b7058", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e015b6bef29d45538bae335c017512a43fcaed23efec97d80e088bb8f7b93ee837cba5416ca51037f": "0x000000000000000000000000000000000404926296ae6c9155557a6c5aac98d9775664efd8607e894ef210fa2c80b65941", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0173de88215548e9f65f3cade8f68e8f34c6266b0d37e58a754059ca96816e964f98e17c79505073": "0x000000000000000000000000000000000c72284f32719a49037a79da881b91b44bf642395ecba92b241619e21fb1c8a57a6c9e3102dd2c24274667d416e07570ebce6f20ab80ee3fc9917bf4a7568b8fd244e9eb2333d2ba5032cb999fc5815802139a4f0b1abbdc6fc9669fa0d3e9ae55", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0264d5f165d70fd8604189f1ea74bc439b18060c58f352db2880dd4c835df7ebb26e020bf11e7969": "0x000000000000000000000000000000000442d1b7759bba592a85972e3c6a9bbb419de5df76c57324d98c2d11810bbf4f13", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e02c2da93a5b6fce008754abb6afba51a2f74f0b97bbcdb383f579a02a5e4541fee736710af562c6c": "0x000000000000000000000000000000000cdc559c88e35aa258566bd616d0e31fac0efda3d881b52055a31b35892086bb1c908626870725d87736e1476482cc7df7bf32f03f83ed8cb6db40a830067d973d70519f42b7684d1ef3dce95d87895e447b390bc1089606d1a499c18d08bc511f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e03456c855e9a00037e878e54c1374b30df335d3a193f3e6b1f84db6c2270ee634cec769d7e33e244": "0x000000000000000000000000000000000496cd6f382ca54348f9bc846929ae16bd49da6ef76b19211da8afc0a1f1c31d32", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e04322a3587052539a23809a947f2c06542cbf2fafe17fd7d84c460d51fdd69d01f53a5ca050ee709": "0x00000000000000000000000000000000048b7602f67d9d61682964f3b5989f357752f75dfba430603da1384059b79f1535", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e04d5e25d603189573898b6f62b50749101446132f77fa6dd77a3895674fa8dac87e6c375ea852346": "0x00000000000000000000000000000000043f24c61f66f5c798cc97adf5258664937f3c16d0b35121a8b45cc81611bc8e59", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e05d8bd6067f6ae29c804531378242158a794bd06c1e9ef0e569f60bb32758597af80e5e70c07a64f": "0x000000000000000000000000000000000804587d42f37709c7342f3e915b5a1c6f64ca916b9fa8279480c8602c600889bda225b0e7cf9cf454c3ecf0d3477cd774c612795c312dcba6d09beea92aaf2a6c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e05e989f2a5137a8f22e8d22a7fe2768c944dad8af7829d96eac8644f06643ea8ae68bc3c1e905306": "0x00000000000000000000000000000000046202474a3d821e3d2df95b4eb0f8405f1a086cbbbd25c4425bc978ce8da1b3ba", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e078c7addc0fece8f18a5d639662da95bb4924c48441fb432047e77613263cf1438ce8a14fc34c432": "0x0000000000000000000000000000000004d4bb93b20f1a0f4d41cc2b066ec844343f3a6748e75b3c5a4018533d0c882675", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0823dc59ec2f7a204eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d": "0x0000000000000000000000000000000010587b19cc62e01cdc18a1499cda27b0fb33264d0c3817668609bb58f7620126987d80b43f7b596676b4a6714cc5034708a9d651e55c030c2a0b04d8152a8437b5a6e11253e1600d4a54c1c233df15bc0a8b600e01f85ab764233da2dda657d4397c2496b1630a27a7946e2ac806c8e0cbc7d12702175153cd0eddff10898e9036", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e08db713c2bbf4320a4731404eb64407b76d75dd815a3267e2dce24d8c2054f3d45d83ea11c8d707a": "0x000000000000000000000000000000000432f5040e4ff22a9cea43f7cfd1242e3ae0e57140c2f4b985e83ffde5e5c4492c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e098de700b0bd1b5ca2656a3bbbea71626facc2641a9d9f744c87c393778020354714974894b7b27a": "0x0000000000000000000000000000000004bac6ca95205b7d29a9f95adf28d5f94ba010ebb51f414163a48747436c9f9cab", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0a6e3cf2b2ed68b7f476394d38a2202be9ac84607ce7fa0a7a53981920999c231210fda7fca36041": "0x0000000000000000000000000000000004e081dbce8eb0905bfe321ca87d5a426435e7cf499020c644e9fbcba9a0345fa7", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0be961ab1f92f2a95002926543d8b8887044442834d4fd5fe3d6eb257719daefd3f2aed28eeaee69": "0x00000000000000000000000000000000087e74e295c040927de4200c770994a314185d3ee447be3d70c79ed056fdd1ac539970b2d4d682818fe75bf20d33d350798f984ae009b8e8e127c1847461357ec8", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0c7c6da4442b90353296c9b3a6546d2319a764e00e1126215b776cb27571db2ef0392bbfbc66d45f": "0x0000000000000000000000000000000008fea1c72d488cbe5955b1eb68d746792321b1eb06616bab281f5d4838e0421c6ad4171a4d884070585e1bc36f234a9db406e6a89575ee9e5ad24605e146dc4c28", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0d9954f2f20d04e36495827bfe0b07d16c549eb10d7e45997e95788be44a3f277af6befec99fe62f": "0x00000000000000000000000000000000049af6c56d6840c84e110de42cd72b4f82d0387238d2302a937026c23940d01241", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0e032212504d7709ba57da1251d785b2d433ca687c510a82c284826b9b79859b5774a84f7000e928": "0x00000000000000000000000000000000040d92a2524d501daccb88d86720079731f9b53038e0aeddefb8828afbafa5eacf", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0e6e902c97ee9286b42bde3f29708150bd47382f10fa4eba1c27a068653cfc4e3787b7fe05fe6e7d": "0x0000000000000000000000000000000004ca44000a7a16d0e5c56d22a707e7cefdbb237b9d20de2c46a53b551ec0cf1c40", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0e7a2d3832f0ab5118c044557335d26c3a538ec7a2699ef5665cca1d17755cd6ae53d41f5bf31623": "0x000000000000000000000000000000000418c0445577a970766dfbbd43589ffdbfb1bae33e8f286969539300c6a49d0962", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0e9a3c3e586a908f8122315b758fe65626b7d0f7c8f5d0758b235f22df56cbf73610916a88520efc": "0x000000000000000000000000000000000455ce3d06cfa21735e2f8b652b7886a9a91a53c2e6ddf1bae4ee86ef2209fd0bd", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0eb83f2c7db87e68e043d8f7872cd895f8957c9179c4264816be3e649713cb3bdc523f752602cc3a": "0x0000000000000000000000000000000004a082ef6765a3eef5cce291b2507c5ac3d6ffe5e10ecec2525d1554b8d2db1440", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0f16205ef17fe25d2eeb1a6884bf369c7d1ab3f9ff75b79dd0f6c6a9792834e026a8d2f7ef049e4d": "0x0000000000000000000000000000000004acb22f070631059ce62f6e0536e561bb5d470d2bd236985b0dcf42cc3e446c68", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e0fd49b70acd3290232d4d1b0dcef676d9a72f6abf9aec55e129ef2de135ac172e19c28a9adbcad0b": "0x00000000000000000000000000000000043562230e5122411d1c436c426567ebbe517120ac76620baef8d5d78b8a2db938", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e10a8fd5f177733e23640b7b7fbbecf967f99ec9516a74f9e255efa5c8529751a383afccfe936175e": "0x00000000000000000000000000000000049653bcf18e30531092fdc1c52afe06cf61f56fb1fa5d719078cd6914d395ed0f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e11ce0c03039f6a489e4e7009937c56d267338762a60ed004293afd40e7c2081847c12cb63c76a818": "0x00000000000000000000000000000000048ad3ba81e44bd11349a8d48bb168d583decd0257d3237df7d55bba5051f5254a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e11ec48c6e9cf67fb4cf2e774e34c3603b2428a690c058d2ab826b39a2eba4e22b3aae85f9bfa7802": "0x000000000000000000000000000000000446779e4754580b4e94ac22e5da499aa39cf1aece35d5162db15003b14110f31b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e143c9b2402368042140be3ffc8865dd47a8d044916b26936a579433599bebca9d3ba1d6eb7722710": "0x00000000000000000000000000000000040a016b7d735f7a0c5e7987f99b8e46137b6668a6593c064d42d050979935793b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e148cd021e35e23e4f0673d30606ee26672707e4fd2bc8b58d3becb7aba2d5f60add64abb5fea4710": "0x000000000000000000000000000000000444d9acd86b036eae410384c8fa0d073d47e74712a5787451463fbd717770ec57", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e16ed9307fff94f1f0cc0424184702e27c49fb859c93f07d8bb0adf2a0824ada9f01db9bf76b7025f": "0x00000000000000000000000000000000083619289cb2e660dbc1c5747506a37df7a4d311aac8f29c69be8b710495e5162346b00fc11146ea6ce12405e83ec552c9f3d66dcf81ac4fd874e24db1484f4041", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e18b47e3024d66dfe628f36dddf8cdb0242104a2531e7d3efd4860a9a4633be69aaf30f63ccb25a5e": "0x0000000000000000000000000000000004ca0c59a8141101a8f9c99e3f8a85c77b0ccb57ca6121cf9edc436092e9bbd17c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e19627e3b0a1fe44f466a9934facf9723f7ecc237cf0afaca23a6e832780616e432f3eaf19d8ff949": "0x000000000000000000000000000000000426a944c20d0609837ab990ebb516c30f230f1d29be7d63f7c368c9a499be4f22", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e198703ff0791c2de1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c413": "0x000000000000000000000000000000001858ac509e6e93bcf6ac0800a070f28bd477fb9e9717ff7779d035094e361b1504d05490aa747179f2b895c2c5171e9cb10a474fd07d1a8069389678e165369e5692a8511f5619229d4e1bef8344cd9a5f85468e238fd95f843dd555b204d0f00b9a9c5706a3b70b507dcf6b013c69ef08af652b1997d6fe82d5ba6975a2581b21b4dc28082fccb1f21f1728e29c178004bde0e64385194ac7600cc222b8bb9a209a7d620473c31a9f77379b12b25920a83b43e0f5700737d9e370dbdd9738c84f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e1a0b756d13ed752dc09033af1dd99c3727bd222c35d9d34e8e4403441792399b08df0d60544fbd48": "0x000000000000000000000000000000000c8c038403fe48ee0068a652cfe2593d30d5701f508e38ef676f392fdc85f8065894ebb855993bf0568b71fbf4197fdee4cb44a39bd46fa5969bc5c372ae101367c676e6031d0f7fb3ead234afe813ecec2d6e3b47fcee702981feb2c168e2c37e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e1a61ab35fd1e09085e34b19d7230f1ea5da6d4b8fe6ede9d05c2e55b0189f75b967862c1c43d9a1f": "0x000000000000000000000000000000000882b224471e6d4cbe8d9d084d445bac45c91e88679cd3c22937d5e56da60e2bb3ae60938e514a0fc95200df7940bd0fb0f983090e91043b76f3186c6300ed7437", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e1c6684bc5e5975f29a8ead39ce1b44f37d16e98496441be79018e910d5f58c0fa1518d8fd7749550": "0x0000000000000000000000000000000008c4826569e68b7eee1b5b93406e4951fcd7ab6b40be519a7db5c6732f66da1149e07628deaa9c6fbbf2288f879396ff3566871c0dbce85c9e23764d15b810657f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e1e681645b60ebbd6a2b06daf782fa5142e365d1fea0f4a418687f53f201f185bf314c37581677b37": "0x000000000000000000000000000000000806cf58e932ba9179e8493d36dd0c02918e37649bfff2bcc24d4fc19d47492564447e00d54ea8610f6d515b7d7964b1aed5838c2971e585143807084c2a799311", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e1fda62d62fc07febbc1deacfc7e5c6e5f0373560c14fbce156ff2a0ed7e208d049ccd985dec85545": "0x000000000000000000000000000000000ceea674f13649b25e552a59b65dd203fd45055ae7f39b5a6551cafc9d4eab3776dce2db9e809d506f5bb1523baa031c25f48d3448eee538a23766c2686a7ffe2cc08d5de7a5d97bea2c7ddf516d0635bddc43f326ae2f80e2595b49d4a08c4619", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e23484ecafdeafb8d3c84767978ada6355ac3719ea8f978244b16d7e8c00552c3a189760b55eeb404": "0x00000000000000000000000000000000088c5917b51ac796f4dbb53a35008c1e0cc5a8e3aaa1300cc2e845f8e7702cd4e5149fd573a4ad8eb5dd80a1b70e89362e72f0fb2512075b4d9a52e7d23c0c776f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e2398aeb1ef43f542c44cd5285e160a2184f3f5801cdce8517ebffdb591177acb17cff2db2ffd9371": "0x0000000000000000000000000000000004209f9f598ee545bbecc4993b7dff86f89d4b3a1dfffa7dae7e31f32c4b9d2c47", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e2492dee6806c086baef6619eea08f01aef7e47d460f0730b02c075e446308892e55af56af1572168": "0x0000000000000000000000000000000004c97b296323e5b62a72504892a3ccd4fc0b1b206f4de9ba0e9764d9ed9ebdc276", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e24df16db48272ad68c085e6bde4ac25702f54f46fa3c1b0a6170bd346103c2c6339911e00306a054": "0x0000000000000000000000000000000004a9695441f301ba78bd00ce015f2f1da14eb8914531fa38695502369de72c256f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e25b20afe8011ef7d040d1324a05bb9a0b86d9eabd01245ffcf277f4611f9750dfe465761481ba053": "0x00000000000000000000000000000000044a1585474299b9deb690132a6d586e8bedfe4d8e75ec70c2dcbd2dba24269215", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e25ecccdf058700718b63cf648fa2a43a82671762a02da41dc6abbd1e62a376b3af7c2d09abf5120c": "0x0000000000000000000000000000000004866d1837675e6c261632fc872c66e779df05bca99fed82db1f5cc4c329beb520", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e26968cb24b23a08fb64a86ea0e91047a3ffbbc68c36ea9ab318ee06c8bb4a354dd3a716956c9eb55": "0x00000000000000000000000000000000042ed9b8035e0bb64685f561677349c54d0ae8806f1ea86b74c12b51dc8154bc9c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e28047368e108b3b06ef40ac7b3e092d0eca77ad072cd317683ab9d24aca4025788421d4276527d57": "0x000000000000000000000000000000000413be73ce92b712d00931d4980713bf4be8974255e1e51a7ed71ed2ea37f035dd", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e28db6c1e91cbc43002385caf9a08b92ca458a0b817a8cc303cefd5a0c6e108cb939e04242b9e007d": "0x00000000000000000000000000000000042cce76137e2e2d9bb63e081d4074cfa4688d7d9781d2888f36634f646da62561", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e2a679b6bc1ea7234ccb38aa8821510b7cc609cd55fd19c0f9c3594d49fe8db355bb2e7fb2324c948": "0x0000000000000000000000000000000004600ff061b1d97f28da91ad5b3eb7cc5dedc5431b2935a0440c02a6a82a3dd49b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e2b031c075ea343ce443c76dcde19df9387486ded7845c6d85ec2a4c17f38f8b1e7a0a14de7968d7d": "0x0000000000000000000000000000000004727dba627f34c210eba395fc7f60d28b3a58c5dbd6b63fb4f9788ee764b2702a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e304630d144e59358fe1f35d3b712d9b87e9dce926d8772267bbbaeb776e9b2a8615b29d6594c4621": "0x0000000000000000000000000000000004224963ab92b30f5a7c91256507aa6375320e32514e54eb988386ccd3654fdc84", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e31053eabded94fa87600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b44863": "0x0000000000000000000000000000000014221125c5934d75259f335bfdce9d6aab9e4c6b57724993f32f555ffc4e75d070fab574220e94c5e2a4f8fcfc9f0e7192116b24eb5df2632396d94dd43401a252ce79383a5d77f974ba22bada735faa2075716e442079b7d58ff1fd898b63251d7600c0e901b4341203f21f410f3da01ae4a45d194fd2c0693c6e0ec5980f4c21fab573fbe3296563205563eb39965933d33ea5a591c45af07f0eee2272ef6723", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e31ef141127f82186d45548e42d7f5d5aa35ffc16ff29396c99936f0c1eae84d452f1daac87c3c566": "0x00000000000000000000000000000000083e184eb35acff823bcf5199a3eec9d0a6aadcad642fe08451772a51c4215583e7061c3799bd2b1d70aa6c8014a0012ea494f4455d60e182dd1cc393d37f8604f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e32ac541eb6aa1242ac1aee6b509bdaa6aeb4718c2218bd7e78a3d6704bf886375e4c243b77a66b34": "0x00000000000000000000000000000000046e28009eb2b8b7785246c452948c27169c4e3ed258ad7a707fb64beb9442fcfa", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e361d0f16c34b17763817e559bdeb521169c4801d70a1dfefe94175d15666a1ae70719a3594a57c16": "0x000000000000000000000000000000000458a0a27aedec30fb5c0fa2dfabff0b7370f69e2a8505d714f7b2ce37a99f0d07", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e363df5d8dc0e8fe77042bfc6e75e1277fdefbea917f6b7ca8c36b3e0ad7286d66974c8f2b4cb9672": "0x0000000000000000000000000000000004bf10d082fee91854f7a6a6c56ebf8bf0d65bf914a683ce4ae1db5ccece06ad27", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e37cd5a422db43856985be267f05f586da7ab52e4430c2f6d461f396b9d6cf4f1eb5362066f7cd82f": "0x0000000000000000000000000000000004b7972e09702baf7eda528c6894408b1e9c702e5f54674bcf6de1b55b3aa16365", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e38533548d44cc8d84056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a": "0x0000000000000000000000000000000014a8e87388e083b3f1a9dfeef27977d883cf10e7c94acdf0c60f57f0a9621d4539bee56ca36a0a5393bf9bfbe5d2079e31d4359d35388df257e23793c7b195b8555e348817abb98cb962fc0780a47ebd471d9c318395fa80b4529a64cfabb2e32c982aa00fdf3835f109ab98a569a0476af2e87c92bbf3cb6c399254fd9b31c9007c8c3a92d8feb9d27f32f3ec67bcc6792f8496f7ed86d1b249c54205a39ee30c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3b8fa2e75a1b9c5bcea3dabe52b2a665b1e19bf8c6913a5d54e06d6413ca3ddbec8f9a22415ec477": "0x00000000000000000000000000000000046cf627b193bf62d66c08afc7b08095f2c12178597925fac26265bf801079ab22", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3c096cf3f561e3834026c99cba12d64d1d0e7a7a620bf54374603fcc056e1601e3713f9921671120": "0x000000000000000000000000000000000447500d616a78d59bd887bcde41d61f4ec880d0496fb4d9482f6f637f55cc1b29", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3c790f30d60af3f382ecbf12e0965d08387b8aca42993392dbe5ddd0de48393b96075c641f2c9408": "0x000000000000000000000000000000000418fab09febf634c47cc08a08a95988723b43f5ab499c4925d08793f3f701df5a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3e843a37d45e41d726171b3ad75723bf624a27485e51e4c2fe38f4b2d24ee52b86a979fb772c513b": "0x000000000000000000000000000000000420430a70d2db1bf57c424e5e81de47ade7f1f0ceae2b568b9182ecf9b025aa35", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3e9ff1da508f2a3c7ccb1907030863dd708764cc88a4b4d09dc5bb0f4c9ef5f4e73cfc0aa4bcdf3c": "0x000000000000000000000000000000000465819df33c22d72346bb95afd79e55414f35acbf0997c6bbaeaddd1d3688506a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e3edfdd48fc779cd5a80ea94af8a39eb7ba8d9afb913147e67eae84f48aad7b9ce6ee05094fe0394e": "0x0000000000000000000000000000000004f2e78c673a855ce341b8d431b3e2ce293e812236e2e42682047796fe599bb734", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e42f5d87995df46aba849437f5f8b602fc9a4210d6a9834af4adc6ce7492861bd0f5b88d11919cd7b": "0x0000000000000000000000000000000004e02374bdfa92d9969c3c6f8c313bed2e8165040d3ef604001ba1d9c838e9dc5d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4316433e1f50b4c3a66e0f4e1a121cc83fddf3096e8ec8c9e9c85989f276e39e951fb0e4a5398763": "0x0000000000000000000000000000000004ccdce2bc61518838d34314c620b7c88040c38c784e0eabe838c17192be7ed91c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e44646f06f20d51883c017930b46ab5a4413bf3153b001287ed5ff7fdbd2734cf69abc843f4ee0447": "0x000000000000000000000000000000000c14860e374c2789388379dc1cdfeceac093c9cee7a2ae8579736323c589c59e4214307eae2db6e460778426604acdb1215d1a38ae54aaa0ee1664646776557d056ca8fe9e98a7d7fb4269fe93c638a2e388c6085e74c18bc220c125fd7f0b1b68", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e45d43cb8401e3564f40cd7a2181289e32776625b9f3a193f749e33ce1bdeb76cfaabece606c7324c": "0x00000000000000000000000000000000040c789dbc85d3a4a498e13f720f71110577461e834d356ca361d49a45ef609b6b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4692967bd2332c08b22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e": "0x0000000000000000000000000000000018b05cb292c73a8d41d50181bbd829f14afa9464b6b710cf241ad1b801b0b1e654fc80cf0973d64eb59f1fb930f3107e9f8ced4aa69907717312f0c5015706f4582acc6987e6d1c5087d414d72dd8ce665458dfd16d7447ee4b0336ee869e4d0f84108a93c4704dcaa30f7b5f245de48d736164bd554743cd4bcfdf1ced6f852ab1a356596f667e9330b60d055872640198b86485ac1721c37fdfd468157a17a457e726af71a51eabcd429888bbd0e46ce1e63b3322d0683994ca825dad3d3716b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e469f989f6ca51c58f3b15e49aede08aa29d7400da8d3b4fdbd284b5bb1f1af1a53a8c47398f1f093": "0x00000000000000000000000000000000086cb7f28f67bdf8862d6ca0ca68932257d665d966222ff24f800291451121676db4fc817716823ab3322f35702e26df4fcff8f577aea26e05bce9bef8b51b6707", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e46eb4c71c2ad15c3f85bd4ec9a558cde3f05e33b0b74f9e732cc41f904894873247d4c435a3b8b63": "0x0000000000000000000000000000000004e272df04c4d1eef779341d14da26699e3832ed5a73ceda96a206ef1c4569f477", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e46f59e6d908bc0ec8488bea263878e7e16be0a8c4705f9729a5f25462bff7dc7f2d8346370c8ef65": "0x0000000000000000000000000000000004d8b5b26b1cee228c6ece5a4b44db258985abbc9f0168950d744269bee80b1852", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4825a3675ceeb1c2561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d64": "0x000000000000000000000000000000002c3091c08dc07b367c41b57585aeda74490c1850166bcfac4081ed66117f6683611234713d080856dba6865b23424e21b5fb50108669bc5762f955d207eadde13caca4f84ed6959bdee967c0bc4d289bf3fad8671f5ce7068072a7dc34964a8d0c80d57608c732427386079d29d65035cfc02b3221ff32cfe73b540d849aa0046288072cc906cf4513caf8aeb6ae323c8b7e57bf5581da1aaaa8d1363dac664266f0cab0c194935f449b3baef742e992ebb801fe38ab5c345d7a6195740399cb500af17b8dab92e7ab018e1189cf597b4e2ca38e0d00716172adb26073867ab92d783770544556ce47aae6e9e9c6cc32bb84a3df7ab11a5d30b0618e00e109d66cfa5be617ad31f9c9a41041cac3ad8ace2c550c28c73afc8e34367d64b50a6679944519212916c8838efd27a63122a176c83e9e0dc68ad20c29a1257166d7ec176eb3bf6204b55f63a2ef87543b26d158230eebb149a8b9df86555fe3f02ecb6c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e48b1dce0478b5f30daf47069cecf5c31da9a1cfde3732d2b701bf9f94c77ba7e99335d6b30ad080a": "0x0000000000000000000000000000000004daf47069cecf5c31da9a1cfde3732d2b701bf9f94c77ba7e99335d6b30ad080a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e48c106532e2fbcf5ec05f950e080aa04f8ef335280637c8c80fa6b8bf54d5a3bbfa746b9f9da5860": "0x000000000000000000000000000000000466ced89b9a76de4d3dc384b45fdf0bd2f1629f15dd3e44ea14c31ba16181a255", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e490130ac826416f286f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f": "0x0000000000000000000000000000000018dc0293434648638559e1a4cf30e829f17d2695980d5a3374af8d663bd521490524f8b3dbcb13ea214b670cb611fe7939e20a23db19647485e01206502e64ef7b6a66d0c75a897e62aa4e9cdead9f50760db6e7beae858c1bc3dcb1d1ce601e58588ab6bb059d351e9de8b2e3daa0f7dca462a8ed9ebd49ae10c3f753fe2dc84a7a33d68fb22e4ae32721ff41285cc493d664753a7d71234c77dc2eefc5782c0b60971394debc5f36af7ce9cc93a3f5cfdc400c830b8a8510d105de4364e7cb0f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e498085158358a41ed824263a2ba0b39e43b2a1fb591c68743ca504c2ce6c3c2aa96e58b6269d3115": "0x0000000000000000000000000000000004d19f8df3cdb194db075979039a6fd4d912298356bb2931c08c35db4903f53345", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e49aa36a5cacb5456d4539a7dceeeba9999b6387e9431e83c53f4b884edf5cf049623110eae570125": "0x0000000000000000000000000000000004081c5466574f932ef5e1469e984d5d39ad5946468f0ab9d06c454f74cfc2f16c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4b11703c47136f3474b0c404b20bac28ded8d662e2eae7ddc52988cd5a22d5de09259258395dc45d": "0x0000000000000000000000000000000004add1d40ef104fcb24be637eaeb9704064663df235fea0799829e270333774f3b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4dabfd58e995e46fa4a7835edb8c6b0d10b32c76ddd9560feb4894fcfb61593accd8c7451e96562e": "0x0000000000000000000000000000000008b3988a6af22247249717bd8602b7ac3e0fc63f469ae9ff8e9d022aa504d61b5e40e1ae3e3d1e6fc5dd9c3a0bdb1c0d03772a3c69ce5b4efd1d8653ece57cf539", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4e5736534181ad78b690df84dc61bb1b04bb3e5483678390a44eca9ee4a748e98f526e126c19c702": "0x0000000000000000000000000000000004114f710e9094d174ee537a86a7eb9ab2004e6405626a843d4ffea72694b9e23e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e4ed12f7f95496d053674aa73951219dbd27b3e3fc5847b806c68c1de38fd4f22f9493a461c80e903": "0x0000000000000000000000000000000004b2a9dcb35e27b71b75bdabf1cc706c567e50bbb20631e4f94d5ef6aad740fc6d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5010d8218a994822c290e73cd4a89b696210d9f712410463c89368b6fc4d22ce10207d8f31e5e739": "0x00000000000000000000000000000000049208af2fb9f1511facbd517ba7ec0296d6fc9fd010896eec0f43a415b68b3706", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e505d0ff0b2ffbc1700004bcdcc7d30d597e19c7f87652b69736066b729f7e8543231a10760f8157a": "0x000000000000000000000000000000000409e125c99b3b07749c78742584a990e78457e6424814870b165823547d3d6e29", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e512ee0fca2d67ab7d573535a40bb01903e616a383deed22b5e3ff30e552017d2395e3e75a8e78613": "0x0000000000000000000000000000000004743a504cd053c4bb4b70c29cd59bf38cc92d1f51784969c0094d010525b54145", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e54aeea67769129fb946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814": "0x00000000000000000000000000000000344cd38181e02e880a53114ccaf987a6f51a10bc1d172d509bab6f7e9d6eb2e00b2e2409b5ef509e1e584584edc945545f42fcbb3f288f3355e9194206b4ce773f484cdc76e0b6b2cb4e30850327cf37e717d91e343a62bbfaded38aa8133cfe348a64dca67c64d9361901a1415bfb3469b000d0bf7f1d439824cec71f87022159f8720c905d7ac1acab25c4f353df9eb759e0141e4732540d163ac444260f017736fd9b64e99689363368298680cb35750a594103048bffd839af770fe5536c6c5ed6f4b68a60a117a32059e96678f22fa086c505f7a8ece13c7a2e78b4788f156af358e5650b61943ba709efc5dbc501405e04d5de5798087d6c727027511a657677c2a4deb2689377319a8e830d5d9ce0ae32b95f096a7447f8f711b7f0333fa4dab34de26e570e8fb301f9c947c6f5f862dfbb27c9de5cf473675cc244213afe9d714ec9ee0f74e33282dd9e411fd0f47c1aa17553392642df99d1440df951946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814b0adcdefee88f852a85ce03afe5d4403875fcbabc350bcd5d1b94c7ce68eec02", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e55ebf22a3378f22de4bd04a7052f76425c60648c528535285bc2a23ab28db060db34f7c5e5746aa9": "0x0000000000000000000000000000000004d68d71f02028d8c8d8a76dcf0eeba7f93ad6b2a6e2f8363ccdad5fa580705211", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e56305c2c3bf8f20e465c6be30d314cf647a8fa10212bcb84318394659c46fe75d03640cebb39595e": "0x00000000000000000000000000000000082e6991a3223f09ddea0e0b1fffcffbed3f768d40231db602a030b7fba52c7d082a211b13ae9c29f805070d21d5e5e007db8ab2566e1031b6ec22733f1f3c0877", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e572aae990801cce1043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d": "0x0000000000000000000000000000000018a37a1021f6eab9a2658f2f6a5e08f5851de80230d270662dfe648c0c7bec2e463c92bc22c4934341504e8b6f0755bb76906171bcf8a55c49a78e2055ddd28802824f5bcb1f267ea5a74e1a1c444c937eb29cbaf0fc98f293eab5275aeff5dc516b05609a9079e0e03bcb50ab1676122a5fef12c48bab67b95d4d0ffe58ba7df7ed959fe3d9afc671f1b0cde07de829b2120d7da25d5f84f4e0a86e3bb940bcc1760f9c3a5299a87661dd13e267572ef052d2c2383fa8f77f45c25567a6e27f75", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5749edf76d87f942544e2e588c90a2e53e051d2f87d40e222e1f034913a30f95a9a2f39114e5be38": "0x00000000000000000000000000000000040277ce02b2ac78ceeb9ae4fa0a595005489bf3f5f77898415e32a3e9504a5314", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5a54b00d6ab21bbd58a74372b1f0a88b1df304584326ff69a68e9470d42687e12bf5dfac375d4911": "0x0000000000000000000000000000000004c235b0e23ee7b2bcceb64fd0e126b965204f7069aa3b4fcbadb8d658e2ecf86b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5ae8d02fc1cc6b946e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe154": "0x00000000000000000000000000000000100a776e233546799e6f48a26bf32c080bd40e35986f608353c5b61b3076503472b6c1880096a49c2719e0d6d8e863ccbd075aea064a47cf81c96ca5ba5d45f83e56c031a86027cfcb114d40812f06d9f462a8354171478b00dd075d9271db38720aeeb3fa38505a54f76f2a27321f9b5b875635d3b05a0f4bd92710105f377f01", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5b4c4e58d29949859a2cb674ea2f4866664769a1663fd6aa321d9cfb89b67c402c881891700c0f57": "0x0000000000000000000000000000000004640574072818008b0ffaa91a3d5febf7cf106a9285e35003fd7b55e2c1ae8b6d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5b6407bdc635903a666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07": "0x000000000000000000000000000000003ca2fafeae641e6e264d77723c00ab05f503db48ca3597cb3242c2b54d90abd01d56196c14df0a7036b943ecd01396685e799f786c0f131796c06850ec9342ff014a8de2c6b6c1690a27aaa4cb64e0168bced54ab568958965187646f06442be6dc2eea43fd0e45e0e756130e01667533bcaa001e29e0192501e7ce2186ec3554aa28942a9d2e8c8501860b847eecedc45d602e614b8b0849b959607d0dec3d071e40db41d7f07b2b867fae0d7b8ed6767d23f7b53b032710dc5b5043474bf1d11f6b2256178f0210557ddcc138e8b264204e4674fb2d73a8190faf4ac3724722f128865fced1fe2ad870d0f1ef6ac3c73c78012dbaf73ee9db06ba403cb73a5230ec3f7291f82335606f98e16f5480b38b3da95d2e7ee9489a89a8a39f9dac956e8b6a4eefeb4942bbca2bee6baee73280d49c1b7aff8d1aa7616d06bc173ad7f20857206fde63ea508a317a77bc1ca2a795c978533b71fc7bc21d352d832637c207c5841ccd565eff0f8e15ed5d3b1752749e2fc9e3f574c8434bd09d7f8f815ce3268d415f136dab575d25dc0b1932b736c7cc785a1ccc04f0474b458115f0ce23e7ebb9b8462643b8df28f53dc2dbdebb20bd0cf8fcb41d7d09db59d46a50552a63150e02f15706d9ccceabf476a79dcfae5bba86e66ece74aa031da5bce36", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5bd6a3e1e8406faa3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa59": "0x000000000000000000000000000000001c30606b4c1b89b4e562efafe76bec80154ac8b3e16e04c2e0f619bcdc0a5eef52102df685c4659f9c242ff9ac8a4ee5305770ede106db7a3cd5d3e8823e33d001468eee3d896dc822a496e712d1116e0731235c54bcec12e41eb133bf9c98cc15ba3e9b87792bcfcc237fa8181185b8883c77f3e24f45e4a92ab31d07a4703520aa41228830918cc1cf16e50df86ba154a483d77ebe3182bacfb876af4fe9ff6bba3e9b87792bcfcc237fa8181185b8883c77f3e24f45e4a92ab31d07a47035200c7fa2b79d310ce32237db73b1e3d581a979b3bbd7f19ec44ff1d37b87dd3750", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5c66629676bdc5f4766efcb5851054b4aeef694a3ad03d7bf36980a2094c07cb7b7cda28bde5e149": "0x0000000000000000000000000000000004788bb550f52a25dfdfe1db243561efb956924b8f0a76c16c62ab47b9f6d1cc53", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5d3dec38e02e37251c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea259385609": "0x00000000000000000000000000000000242ac73c24bb740376a5b0f44814e8ce8b34f23be0650e99b7ac81e1159f9c31511de154f8bc16e4a7bacf303141c913d91b1efdf4ae06c3a227f0a2877a19e90a1e7aedb71a237b95e3b805a77c031dac6a8a675441390e66bc1ddec7a41a1e54c4896d44835fe17827b4af77172094f91a1b17ec3524949c2d626ce7314a440f18cfd7be6a32e4e3ab369f7be8a880a70f42a0ef260ae11a740b1feb7dc4796937982501b1c242d5d23a353d2b44e7ef342d32adc991306632ba6f3c61d4487d6881000dfa449822280d217523794e016588e4a6c4d9c14e79161ecfc085e72f01f8b3c479e6400cdaaba7b54357ef912ee1ce5b803db86506805054070ea176dba5e754de5c965c3a904ece87b7a0304c642664457bd2159f108cddd56d781a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e5fc4a5c686ea5a40b346948ec9e4cf84b965ec17a752b3e8eff098934aaad42ec50a347dd7936583": "0x00000000000000000000000000000000042e001e3f827e6eed45a60d131d97df1a5b429ed1d0f89fdedf3eda0a16502d3a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6277dfd6b7b21ca2faf5f68fe828f5af8d69c116efd937d90f1956b0edd94e05d8b5285a8eb2a663": "0x0000000000000000000000000000000008a0209c10c7d6633de64e166a68d9b45e7f02aacd9497f5c552e577abcdb17d28487a87b4140abf956405e80acb86bb44586a8089e79b476516c6ff9b601dbc38", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e62a40c29b1fd2c93b204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d68": "0x00000000000000000000000000000000140a2178b090386d0e2645866868143abc5bf6c91af252b92c0c38174200f42904d8a03bce1c529217f76264985b1f082f154dad529677f85dcadc3c04c4c77d5948e77b8c0864277405a333a644bb283a03ade9c351473f7c167b309ba4cda308782f3f9bd84fa8b7b659bae702b90ee402c45067cbad3d97c89ada7db6e0fa67dc46b7f9c2debfe58700f30be615154d6e38f059a682ca0b5049285180675c0d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e62d8d4af4eadb392cc52156f09978540d3163b798f65a8788bd04d828f366674bf9ea1f88e96f519": "0x000000000000000000000000000000000424f7bf2054bd95b8304900a908f8b298ddf79ccc09931f514305c490d047a63e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e633914b3a4ceda021eb38b0d5178bc680c10a204f81164946a25078c6d3b5f6813cef61c3aef4843": "0x0000000000000000000000000000000004ad0992e51165d995e649d0a90b3c349ec9694d84ab1c3294e4a9c58839e7b4c3", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e657bab39f52fddf58e07d43b19d901badf3a7f57155ca84f2f835448e93a141bbbd33eac4b767d15": "0x000000000000000000000000000000000cead7c523761f8ca72780d241f11dfb4b3543c4a1e17263274d34f468001d571a768659892ca9fab8d64efd188054b2280efcc36942c84616653265d417fe966b0a3c9a0dc2a4578d4b58cce45258b3ebb0644502b355ce1241f8a38bbd1c0a72", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e668bbbac68a19cb7a02f7333e25590e4f568ae8a2ddc93a879e92e48fa3cf1666ac56e020c106d55": "0x000000000000000000000000000000000cf836649df542b24a1b63d80916ee743d4734640aa796648649685dbdd430c3628eef6710734f5d1e7d2eb303fa8f04e9bef65fb680647b24624723f95b868964a2b3963c9d349de4363ce38f5f9854fccc0636768d947108b7f219c240837855", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e66eaee046d4f02542c89cb8652eff8c73266de06baa3760534e7f37fecff971c028c2910efd6a947": "0x0000000000000000000000000000000004d0ed5a8ce0c20c3da0dade9db4969d52b6bcbe1f8914d3d9a2019526c9cb0b27", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6773244509d0e7c8d46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada5210003": "0x0000000000000000000000000000000020685f836cdb8f2749ca5a225297e1a8207fed4511b575448e09bec5a870480c6b785c76e65b2f38d3dcea220f148f8d4b42046ddd61eff8af6828d24f633a9c47021ba8ef466ccb7a06bfdefdba01817e620ada5954c34f617f6662e267dbda15bec6a380acb8489f21891545cfb9b4964bf0f3170c5deddea166cd8f87bf20787cea95ce431976642559cd8c64177ac1a51ef6c8dba625d3d021fa8807c1a137a64c092cd19a2779a2fc967ea1be4727ab3b29858a2a6f46af009daa35d84121be4c6b203c1e605511cfb8db27330ffa7abbaffcba5836a0d6f3151ee8eb993c20e1d9db00b7eaaac9d3f4a95ba206feeb6f606e16f9af3f2ac24c1c57941e2e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e682174f20abcb7fdfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e": "0x000000000000000000000000000000001000cb68a2c03e666f346a277036e8f27c912baee3c7b41c5c19123840f3a8e8fc74065a60fa33d4c2c8926d0d761d133a305f500880fa95ad86acd865f274414c9890fd3e365f6954b5bcab3c8195024da5188beaafb1b13d954c0281647ba535da0afe4e85d09d168759ffe74af6049d1001ebb6d16a0427e40a4e494a7372c3", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e68b2359cc10fae926295f0214abb5522cf3becf82504ef7c87036236e6b9afd263697a99bc5d5a30": "0x00000000000000000000000000000000047a813a8832981068f9b921dded7aafe83cf89eba4c91ac5460c65d76a61d465b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e697ead568e820ccfd2eb07f02043788e254d9e2df57be11566d241c56302b91199b4647947af3020": "0x000000000000000000000000000000000452ff057f98f0c1bed31b2fd1ccd8de4d4acf957e79b3f71eb69820bf0dc1d22d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e69e34466005457c2c48d1c4fc44dbbc10b86e40db24f95f8924efba2b31eecc6a7c32bf2b8a4481a": "0x00000000000000000000000000000000044d0887549eed4b4479973f77c05a3f40c7d182e983c3bd873789a519f5cf7ea3", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6a2d4f462a713142b45f7d4b6bd58cb550270c1ba3d9d97b6766787966b0b5c52c79b4d3b51d9a43": "0x0000000000000000000000000000000004ef7550d2801399e7f9b263d92c33ce0eef338eb5527760235e4ff5219bd44c9e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6c4d2026575763437cdc1a6a5a7f23437b6528edcdf553d0685f940a4e6e85579727ef3dc574563a": "0x0000000000000000000000000000000004e33f4520b7954cb5fee8778b44283deb0948c23c6b432058b21ee84e92085f3d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6c5088428455187bcc95d7d061fc6a655b795794b9b1614d0a240e13e81de9dce3f2b184f653da7c": "0x0000000000000000000000000000000004e05c542ad7369509f498cdea5f5c427f2fd0b3051884184b294d9ac10fe64e34", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6c7206770c39d9295a5f7eb7050fb96d8d7895d9afce428a064ce66e3b094805bcad9a8e68cb9934": "0x0000000000000000000000000000000004adcea185416af2d3e8df8c1c8ee8a634bf1c3275b3820cb6d935300d42c73b2a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6ec642500076ba25a6c5f0595d6ed85d6260bc682d4a68a4b4e605d43c67d56f2765d19698549772": "0x0000000000000000000000000000000008c3405f63dee12641abec6c12b29453b7065da04a95c09998673aca6f0c4a164e9f958e6a1f4ff8a986a4e7d76c417bcfe8affda4182e66b9952dee757d7e577d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6f73628ca952be18dad0bc6a0aadf06c56416e83bf75e865d41ccb5ffd74eabf9e81d47574b43049": "0x0000000000000000000000000000000004b6f0f10eec993f3e6806eb6cc4d2f13d5f5a90a17b855a7bf9847a87e07ee322", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e6f83ccad3981de4b7e569787b1b323854ac9a8c40914d400b6fc23a2fedd24321f814ce7db7f6563": "0x0000000000000000000000000000000004c3590205a4e4844653590740c64ec31e5d2af126cce71bc60df95bad639749ea", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e704dea62a3fb9e66a471c55caca4be7b4e60c6e94b20f9028883f8c64287d4454130c657383c3442": "0x000000000000000000000000000000000ca471c7aa909cc665212bb36003c52c5d3eeec39f96556a8242e861c5dd7dde415ecc1d4e60a92262c1bec62d034c979f42cbd3fb1c28570d5baed6e5ed20d533c83b0bba37f25f365e26efbe6c9ecfa7905dbdc0b0e3ae60b29980b42c509c6f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e71352c2eb5ded5f286484f63c9e0ae1f460dec3b53307478f5ce3ffab22a1334d34a52da7527ec64": "0x00000000000000000000000000000000046feb764cf5265d8f491f921d51c20318870ffb669b059c7a5b951d9291636b8a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e720cd28dcf99c07dac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f": "0x0000000000000000000000000000000010c0532217caad133c16b24a5e3b2da932b83aae63356a787e1594e71317df7cf00cc89d59de520e70fc4b9bb9a43b41b2b748ab0dd51ea18326e8ce755931ea0f828ad82b9738a507bf481d6c3feb4e50855378b588a653e3033f5eab788c335b08eae5dfcdcc8e1890cb16ac515d4669ed0653e98623be435327545c72f5aad7", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e72111003b96bc266a24fde6343e2bf0aefa296afcedea6f16d37c5e1c0d8b6511e7055cf7282b60c": "0x000000000000000000000000000000000422e84530cce98a0af194e12c568c8923fe6d138dcd6e19fadcece6c0a5f10e87", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e72f593a2e278eb75522e16fcd83f6d6e08fe2b44d56b5d0bdaf33527b49e8832928d003d8097ca63": "0x0000000000000000000000000000000004f09bafa226f3e27f549d4fe85723533c0f0e54e366f3a87614ca08443b06cd54", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e74782af8e47bfcfc0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d019179197576644765": "0x00000000000000000000000000000000147091f937fba948654220a41ede536b0d62cc30d20274a28005b8026564db8d25a09b87b34880c5375ecca849557dc87a00a6243938d5882017fa0d1f60193815a81b8a2a03afd92af18f0338e43afc504c6018aca6d9197c0d3a149ce65efa0ef68fafdda61f708ae4dc2e384c8012719774376e478bdc857f7191ef449ab5226011856d19723839074419b4519ab65554fac975017c6f08293f0a0ba8ec9838", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e754cb56cf6c9489ed016feaa68e25739dbc4035faf2577d17ec9d7ec2125a99a6770b5be093f6e32": "0x000000000000000000000000000000000868f26829ec470fdad2e63d97741a88df1243ea147bfb4639b97a4c816f9605fd11d3e37f3547a962068f9d46c046759e8a866b64c844b0fe7426d95fc1b599c2", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e75d112c2582d6bc3922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c": "0x00000000000000000000000000000000103ef37fce11457ebc5f00b154996471fcd30eae17efe69e5a39b12b76034dc7e44c4bf7f93d0a5ed801ef778f8e7ef58201bdd7e33e167faf42a01d439283cb43e0855069a59fa0ddf72205213ba6d7bc3bcfc44316af9684bb215f815fc0113f627922c9fc2d2f0b5707a3f0cf870fcbbc62ab06f4e4991cb04d376fa3593d6c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7629d0fa8c9ac2292c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d54": "0x00000000000000000000000000000000202357d8ee622168c14c8d3b65f311c42d67023935eeda34bfe81c8ed7791032384431708b474e888318f65c93f0049fa3043df9d7f1ec1f5f3d7d5e1493359e5891e1331ab2af4b510ca29f5e5dcc8e71d1fc6cc70ab24e2cf8513d540fa388ee51dad69a99af405193f3eec7593e9baff022b7fa55de147d1b4f9d214710388534fa4e10f24341696e46d61b982f279969608b00edd5d32298f3cab0afbb695ad8c67a57859b28434a12f1a078e2979d8c1dbb2404c0e15fe75c1c94e39b2061962f61510310bf29eb0c0170a23fcfafbabf3d0b088e69d1982b2a31b0d7de466492e3ea0e62e4e357e57c5b6732776f069e996133a08953b1c1ebcf967b647b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7642074451d24466b2e07be4d6d82f546ec91d6009ee215bb736be5b4362e66e7b466ec72d47624f": "0x000000000000000000000000000000000cf2497cdc525e2b482ddec24761aeb31826701c5a6e35919787bfcb455c62d77400831e9a6121a6d5002d53a89ce1d209d1e3359420a90620a022b22947d41140d071e04ec30e105db26f05b81646219bc57909c674c2a081e48906e604f9867d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e76d10d82508ddae096e24e9b5ab82dc275b82318a52cebed1cae3e25be096d5f288229b256359e43": "0x0000000000000000000000000000000004c2de6256e9ff0ba9b97f862290f69ec0f72b31fa0a6843e0175e9e81a0165d6b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e77300f589b9251ff6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e": "0x000000000000000000000000000000001caee72821ca00e62304e4f0d858122a65b87c8df4f0eae224ae064b951d39f61028996c52694155d7ec9082650fbf108f69da60c44a4b2565fce4e03f9bbb01780a7f29211d50461588ec3c6857c9ca25474c650c7d2048ef2283a2245ceaa8310ca0db0283dbf8d123602a2ec334ab5c3fd9e2540577e0955eaec679cefa4f0a24172a563943291c97d252def71e17abf467a1626bca358728a90a82b3de3118c4e4ff6adcb360ec9eb50d5e04ad47aec66a30055222dc13c6215b5f2db59767724e0032275bac5598878e5dee08149d11c44700c9c4626d1f339ff1be715f30", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e78a2b18d6db0a15e0bb5e12d2f6ada25c3b64171730f1c9efcf76d3bbccff01abd9f92a9aaac10a7": "0x0000000000000000000000000000000004ed6f8c70207598bc9899581a491dd8577e82f0ab65d5a78318b74bf51315841e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e78caef8fe8bb73f2a4d813e676d81d97479f9f15572d9eadcaf4503b654c0f6e7baeb49e84510e69": "0x0000000000000000000000000000000004730800477a5fb0302fa9ff4b5623662a27719a304dedb3e12eb004f48ecf6b29", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e794c7db721956af68a56b1da8dc3f4bd58630c15f5754ee634528a007ab510c86a7e1fe6e62f4166": "0x000000000000000000000000000000000494211c46d7bb07c67c2bc80e7d5ba4623f8ef0d565d266723ec60497f0375b3b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e79fa24e506fa3936321d847f8a53927fe1132754a7708c61049b2d4816ab6ce7195a8308e97c3d41": "0x0000000000000000000000000000000004d6d1d0ca917751d6148063b9e1fe8a22f74396e63a2f72e149b39e44a0e77c7f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7b1b6d2a1ef31b0a3e8c72ac1b710bbce4e7c190568bf560d89416696ac2a4700406487cde98df04": "0x000000000000000000000000000000000408104ce4b326f4b31735dfd06fdfb1ccfbad16740364d8bf0f917f32c090f362", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7ba825eccf7c1a59b66fc334c7c76cef9cc5ceac0f4b0837d845453a2e0e84703b280edf202c8f76": "0x000000000000000000000000000000000415e447e7b7a849d4489323a706823d8958db184c8c16713f1a6a49009f6da96e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7c4a65539d0e9a75fc8163c92cac3dd1d5c2c0a049c3652a8b3b8b6cb8a0867a5e494c650b4de371": "0x0000000000000000000000000000000004f5c0dc71bff8cbdce6c32ae5260549ecce90af19512e7da031f2dd02fd920689", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7c90c43e925f2226fea885b4e897d4fe908db6abeb39365ccc4689c2b6437dba675a4a0a0c0a6610": "0x000000000000000000000000000000000458cac93e1f29e4fac5351cd9879164bd90286cfb45af827fc732fbc462d2eb2b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7ea9886926039761182fe099d0c1787bb1b88de855537dcce095204028736ecfde09dd115c498f2a": "0x00000000000000000000000000000000046b973df13cf0190a75f17633f8a391020df8bac9aa9e4c50670e0dad135bf726", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7f38100bed09f866b0b000e408509bb033443af0bc700ec11894f81c090d58d7dc2ae3174c54902b": "0x0000000000000000000000000000000004fe08b40ca50585eceadf8c27c0711d8cad57d20cf68114b8f7fd6ab32534dd25", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7f6122436697b141faff1c4b5a94649e0338783122b93a469eb9e2e375bb71c92028a8fe9b6e2f46": "0x000000000000000000000000000000000c927d335e751bed3dd0da74a10e610fd2996eea79b625bfe519e8b9d2b96ec75a88ac52f4800ed8569280dd140faae0b0ed5613aa77e57a592cb9af8127dfae2a1857d6c0ec8d629533be85a017b52214c8c4954769fce002fdf6073c0b177f3c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e7f88ca6ada2372bc1a0eb7fdecee073651f1a21b9779b7bf5670493a0e35a53ab83b3cabab814a77": "0x000000000000000000000000000000000828599b35f8830b27f465e77733dab096524c56d03921532c474f06775af121fa9e447cad47afa21f342083e9ef18cf04a27d81fbd0cd742e8ec36528c4514269", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e816f363193f343a643fa61b298e82f9f207ddea327900cee26b554756c4a533f36cd875e3e7bcf06": "0x00000000000000000000000000000000043cb64a5829fe55a733bbc427b0489da973cbd6b3bbeae722ad4fa58eb8277a30", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8179afc2191e064c0ecd029fdf9259e900f08996fc9862ebfe100d49c439f19bef7084b258175a1e": "0x0000000000000000000000000000000004f4fb68640df03aeecaa19d6eefddb11516c42b586d0ac0e56f354b43b70fbc22", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e83da9cc355d0681680d8a3f4317249a895e4b49badcfa7293cfbd215d6e552d1c07024d36acfbd5d": "0x000000000000000000000000000000000456613c69103858e51c79e3525fcfbc8315d93383b9280f0acd551bdc75a91463", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e85c4e925378eb4916c42f37017f31d6c9ba5dca62626e6fb434d6edc31bfc9aa49f001a6ced27876": "0x0000000000000000000000000000000004ccbf40cc53a67fedaff6111ffcf4d618af1ef8258560609082989fe66911233c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8640e8e247a0e20f30cfdb48ff7f33b08499dfc618a8ef9699b8345fa65f0b1339eb8eec3c0e4555": "0x000000000000000000000000000000000402aa5256d804b33717f1d338eef9901e89682b80c81e3b1138a02079e0848aa0", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e87258a23c1cc74c20c618307d00b3354999ae280858c01fceddd77a25b5bc665fbd4634bf86a4178": "0x0000000000000000000000000000000004f3717672dfd677afa541355ced152c72acf081107fbecbc9e0acef5b54b51223", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e87537aeb7813f75e5efbe83a561d19b1d21126af5f1608ed28e56f4f70251cf965fe3dcb4901a26b": "0x00000000000000000000000000000000086e32fb9cce7edb56991320b049369ce553a5ba93c5d262dcbe796a9b9f3f15248595dbf64624ef80da7a916f139b607fe8ac19aed219da7c7f9990be2c214d1e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e87d2f749afa8b991984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b5413": "0x000000000000000000000000000000000c74edbae75103b891bf37c39e91cc489a6f68f7b6756b32875d5c5e28c173027208a73c9c3083971fa2ec757d38c8e7858df8076aca40ce176faef81fcbfbe2580a8a307ef15b9f928697fa09dcc72a2c19a266c1d32fa158f9916b8b804e1621", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e897931e60764d4ea8e602e63afb364ac583747b0a8bab092d5b20ee98f0495ce7562a8c992ac9f17": "0x0000000000000000000000000000000008bc81d1b8a3c50fedf5323698e1fd52fecfcda7436b8ac0ac6f663e146f4d4f5cc0a05f52c96d2af9862c7b89bd23a92c7e8345b92f1115d368b6548a58aa8f28", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8a3ab59566c3860f1ecec4f3062f61988b13e9dab318860bd0fffe5b7b37880d50a614a0a20c2502": "0x0000000000000000000000000000000008822058fa0d13ffcf079d48b96c07f71f6cfd7fc9abfadd85e205ae7a18d7bb3d3ef0a4136babea739fdcdc300f622f23d9a7fd229dd90c8f3c9e3d75fdeeaedc", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8b299234c2604004face99d3401cb9b45ee1bc0ec52f4cb35914dc5ad27806230534230eedb8413d": "0x0000000000000000000000000000000004d6b0e114db8fce63ffc070a452ffa1f47f0f7ca51f32809a624323f51c146d2d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8d47493ee3a600117269f7eab2e5f91f9efe10d0dba0e7256d9433230a8f9fdc1c4af10981853476": "0x000000000000000000000000000000000474fd218ac454949ceee42deee0ed129de80fad49f579870d7ee9d4a2d1e0e27f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e8ec37554e12de10ab08b555a5a3b2725e01ba15eb40aa32dc5b781532854b797808ed45e752b047c": "0x00000000000000000000000000000000048cda73070bddbcd243f2d1f25982dbee2a0961b277ec209756bf794c2d0f7f78", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e90f81dd1ff30118bc44ee45000531bbf1aa4c23540940eb10599e14b4fbed5267c42a0ebf5d09f66": "0x0000000000000000000000000000000004b8815e0e6280e1a3ff96f62dda149363592236eec3df9d48aafe8796c22e1d41", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e912655d634b54e9a086de7162fbfa0b91a67eee94b697646028edcf484ae78fdc0627e7eef1b2247": "0x000000000000000000000000000000000492a11c7b27f2e0db0137d0745780fe21467bfad9bb6ba3e523b8e2dced7d60ff", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e92a9b8874561dc036464f15335eee136dd7c216b994ea6ac3394eb723590e9e065fd9061e05d0035": "0x00000000000000000000000000000000083c235e80e35082b668682531b9b062fda39a46edb94f884d9122d86885fd5f1b0e2d58494df50bbe553b779921de400483c550c57a9c7b5e7ef9735958228e34", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e93d0e54cd18f21273eabb0f32cb0695fedb8d25f6299fe51f90b1e26ed858c1064aeeea0977c1e67": "0x0000000000000000000000000000000004de1894014026720b9918b1b21b488af8a0d4f15953621233830946ec0b4d7b75", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e94770065de5e75f5d0e903b51697fa10a7f8c7e5c750fb3c2f90424b749be8b6c0f0b120f5d7277c": "0x00000000000000000000000000000000048b1789281b38392a08ab0516a21dee49fba6f5e55381106ff7ae190563cc84f4", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e95e5354b81f0f460da9f7fd3d9612a68d2ead69dde53297b172b7db514d0d261e7c5be987df7f32a": "0x0000000000000000000000000000000004a65bbeb4425c55a611da4116e848b0cc39686a11f88dee6aacceac6bc5eca657", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e98d18fa62c6f4741589e41f29ab08f2d0e4e4bdf3d1c8a868162c720f9c31e22733f8d633fba901e": "0x00000000000000000000000000000000041c6ea9855f8f85002cb80858c01488a8ec5f459b1265248752b967a685eec446", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9bd6b99bd8180aace8c7ad65c15fa3ba64424a61b177382a0c5468135aecca9ca454f5e7ce4d305b": "0x0000000000000000000000000000000004888f666828e8328a33647a47bc97574a6a5671819270cc01e66c7139a1a6911a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9c21b6ab44c00eb3127a30e486492921e58f2564b36ab1ca21ff630672f0e76920edd601f8f2b89a": "0x000000000000000000000000000000000ca4c5b68728f7fdbdb4426714a385017a471d5cd22a156acd30a40277e6417b600edaa0d08e8b21d6e8f946eff381ad4be29aa63569a54a6a75c91b878b463033f6be65cc16c65708bb6a0e4b9958ffe23d1c56ee5683670a69dbbbb70c10d507", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9d430d0bdbcfdbc6f0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c": "0x000000000000000000000000000000001c94c8f2aa65dff23f542ee99d7191e88eecf45b3a61b7350dc3d48804107e393d10a767cf483ca0629c6cb5dbfd20f5f9d8468b153b90bf3c40443bfba9354a14ae34148366325c0ab46d5c086e05c87c76b58125490dababb7899e9efa41f53cba318e50a4896c8228b14dbdca63c64b9a4fe82ee967a41612c4a55909daa960223188d5f28ee27f7e9067e89bc52fca8f1da20c6a7548a21cef18d8934f820ff415f3ade9353f49fffd2f3f2ebab33ab5f1b94390ad5758fccf5a00e9441e013e5e8732b01a310abc9d0ee2173b6e7f3d00b291f1ecb2f424499c353e4ad955", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9d8014dd68872e0de21727312b2b7ce579dc0f82f129d4edecbcf00abca607d73ccf16e8352cc777": "0x0000000000000000000000000000000008b4b3a27f1b0da0e787c0863ce2307f5617f485a8c27f0b17c2d3176e788c3e6e24aa9e7b57a0e49b834fd499464cc0c83135679ac384abd9e6d7f07a8def164c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9da48123ab54b499c6477bfd57c12587b1075a80d944c7829784eed61a5c8b8255817e1d62d1070e": "0x00000000000000000000000000000000044c1bdac31e30cd50156586f5009d576c2efdc103be5ef0649d55d3b53941760e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9dcc277753735b96e04ca25cf1cbc516ed1c138492a7f2e606f60c5a9ac96cb405eaa3914fd12973": "0x000000000000000000000000000000000434bc6fb5ba6e2150087c96fd4852ec188aba74a5a383a22ef66b12c588cea00d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9ea70d098f006161264319ed6a0895c04112917fc9bdc0771f4a4773aae014a99d25bbe06fa1057a": "0x000000000000000000000000000000000878c7dc6b311bc7e44dc95793f0b8e1316ab1447073728470fe08e0b4a8dd243b005fa73637062be3fbfb972174a5bc85a2f6cc0350cb84aa9d657422796bfdf1", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37e9f053c2746e722456610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38": "0x000000000000000000000000000000000ca61fb8e0537d0f6c8d4f94d0466859215b77e5e53c44981253983062b7a46f72a160a7305cb5b47a2903f6648fbb6ba1ad24d72fd49c39ec7f9d21e184f3dcc778c505721568ecb57fe677b4c24e670079e8c342cfbc7b312c146067a2dc02a4", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea0425165102d0e25091bb84ac5b08adf128e855e1cb079ed594be42af19d09d680dae982ac209ffb": "0x0000000000000000000000000000000004640d12a59e7ac3ab24ad5c33dada639c058006c59fba147ce8caac535e801415", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea0b881b0063a363a02bf32e061073c44300056b416cd66a4fde1e6c120dbc0089bb65134f5693a3b": "0x00000000000000000000000000000000042eab66a1c3116f15f55dd2996db419e367106043a4c5491a5eeab1d33a17460b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea11a320b9a8feb01f857311106c8d7b0daf6e096db9a0d759b52403e439ab23fd6559780a8b1c803": "0x00000000000000000000000000000000043a337becdfacffca71fe67fec208733754f035958d349d36b30225fd47798f6a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea20d0b846e3d907e00555ee596210f641d2d48b9a1e2b258aead3fe8de4e973bcaf5f24674044367": "0x00000000000000000000000000000000040792d0467f5422f1617840e11eccfcc8bd24bab23b0ea04de920c1109e1e14fd", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea3f67b4c0527d154dc3aee12519c19be02628b0f808bddda9aed564027ad809cd392c13e9b924b65": "0x000000000000000000000000000000000490ed88ee1c02bcc5938985c79cd8bf1a048a9a01f6eecf8a3aec9a83aba8a20d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea6eb394e364b8f9c7682e4e399a94b0dfc4a9bc476e0bc69f25413687d2b1c29bb7139dcc8e8714a": "0x00000000000000000000000000000000044cb0f7f17953e529b8106c743f78d238e3dd6a90f421d32bc920ce120682c801", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea91237ad3fc3e223ae0d1db9082bdce75480ee80c3bf3c6496de1ef8171951de2edfe49fdbe30a67": "0x00000000000000000000000000000000048c2bae6068de838d1fc684db669d5ad1dfe26f37887ce815734145764b7e7124", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ea93c6e207f351cebc5c184f0565e2192d6aedae584ee736cef875f0e1c558ee3ede26869acd0b4d6": "0x000000000000000000000000000000000c31918cb9b9c9414a2cd4dd7f720cb98fe98cf852636fc4860845767989127e7d02e358bc31b7ccb578dcc5c36ba2908f311ac5ab2ba8c1483595268a7189fb026621dd4e5cdd0ba737c572710c13df35b316d39ecd12c1ae1320bd6db069a07a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eab7e3e98c718729f7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a": "0x0000000000000000000000000000000018508f2cb4567caff040d0a47db244d7ea791d9ec23f0d5d33928a7c6a62b3077aeaeb8cfd46b3d6a0abfdf3961d572ddf2303545b03f0b1870563d38c69de4f20d8151ecb8e8d11e6c6bd81ae49216b9ef92d2b83b3ae39702a397922f14777681e503909a89514337bf9ce931876a08003396a9def52f867e123cf1420a0f70baaff773e3f134d4e0c90ef5e5f37adb603bb591b7aadf67a2a757101a1b70302d97d35c31f6d0b75bfa93ec1eec8823651d1582368679c44f00ded1f5401b5e7", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eacdb8f7d99b9b4f82cd49434353de1d51598b44df15fcfed1e26224e055923acc9f9af881dc31d5a": "0x0000000000000000000000000000000008ecdd548c83457ab43caf7867e2bef91ef783025db9659afd89794ec1220acf29607262b83b9349efcad72b5f2a0cbc80b1fdb622aa81a861a56209014e568337", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eae60b338fc29997e986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a": "0x00000000000000000000000000000000184a45b84757c48776f4c5d887e269e8e6c3f2fc55f75adf222662f129f9fa5b40e4fc83d05b1d8ac627cc89bbc95e7379aa395cb168db459fd18c6bceb6d1523492e594db8b26bc07fd45cc783db49313f17183491f1826d417155a95d5f7d85ca459c65e21e9f36c344f9def7e0ef28e96f6e1fe02f8e3aa798a8fe9cf906453e27cf0ba46292cc95548cd67e3e29036b0eaf1ab66a4a6f5d7065408d50b9759c804d9b3aa2f285568305291efb2e0a6b70aebdd5b04ce6a5506c0a8678fe604", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb045191cd50fbf997059b7d9ad6e9f5bab40385874989cd04aabbe821094b7e45b5e4de5ecf2bf4a": "0x0000000000000000000000000000000004aa29d60ab7eeb8c8ad1e7d37f8438bb02cc86c40c28218d4f183f110067cd368", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb1580a59c1acfdc54421050207b47ba1bddef66d1e1deee5b27d27d7fc526cfd68e4be18a5b9b146": "0x00000000000000000000000000000000040e49baba2f2c359d846db58da8cb83c820aef3fbaa7b2164444d4946dc047e08", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb2867f14046b21d05a33766207d51925e4b9a2302870bf737305cddd5bb2df2dffa379963e586771": "0x0000000000000000000000000000000008388bf0fc0110c1b18dcab471725083bc6b0b52edabeab0c3e73e506a54f9e04d7883180d8cea922c0648533d6b2be8949765483e833ec49e8dfd10a0ea61a03a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb2c78530b4a796f2f8f0244b95932b7a67caffd31de91edc5cfb3aa2a13f6199f127ce51c558204a": "0x0000000000000000000000000000000004d7264854fc5645d065341b90947bd9be1564df8220073eab4043f4022e633e8f", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb49940857135462fa0db8c6cb723c474639931cae07e095e6e8d9b870c90f5b499bd8e6fdf4bd54f": "0x0000000000000000000000000000000004d6ce187276961ed56ae9a29566279cf443df42f82d9890b02de9c11e4d288e13", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb4a5da87e533f5dff58927b296a23cbf25794b7cbb8fe31c5e68f2bcd2c2483e9c9cd0712216f232": "0x0000000000000000000000000000000004bf7105cdc60a8125bc7d465c5587c26d9954572b8579bd176052bfccd2847506", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb51eff5e9260eafe64e6db572dcc9e5dc57445ff7c68ce85e42527aa74b2ed5d1e2bceefd308ed05": "0x0000000000000000000000000000000008e0512205b8cbb851e7b9d862d204b1df2d7598e03041c7e70b373ac45b1e6cfc8e6c97add8c5563d923d9b702f854b15ae59ecad39578845a04239c594046044", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb67813127799c8e920b456b7a8651f0b81f4517ffc79737cc392230cdd92a5b4bfa09ac728a0b10e": "0x00000000000000000000000000000000047c73d0b870509f5c2ce7ef8313ac58becd9dea02162a270f9913116d690f0904", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb85669beeb21dd0baa6646d5b85790bc0ab869d80385fdc10e1f4befa7f8a4bf31848f73012d2823": "0x0000000000000000000000000000000008c4bdda1c96506117589bfc216f9e5e79510c179b367f31401e01f1997b47181b66d0425af5558b202c277f282e0d55775eb9fe23e0c68b7a10cfb7f59202b402", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb8a74d4a444db6f1bcf647b00211b2d6c8cdb9e091b95ba03ac8bc6a4dd0124f1f09f8c917d1d270": "0x0000000000000000000000000000000004698654b9b352da92d00844ba8bab505a2cefffaa6269cdd2d407cc866440fb88", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eb9aa88162953b359807e371d9df95983e2b9face8efb67f962816f1a0c6681cb1e5455127ab45c09": "0x00000000000000000000000000000000088818f1b289df88876f0199aa1fd723dbec6e7bbc5b08e5eabb89edebfbe3983a2a1202907ebf57434db992641143ac78c8631a1e412d8934e5167153caed0645", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eba7663c3b3aaf51b09cdd094e9a51d26bbc6cbb71d3f7c5b8edde629402e3e5370e7f6904512fc4a": "0x000000000000000000000000000000000c47e503b630c37057023c04ea57149dc70ae19f186db24f59881c55cb61da522f1baa453966c043ca367ccfa19f450244447b9d32f4b7af2d9749e55a57ac09cc46059d2f1a61eacb55d5c4c211d0b35cf3c3f4fe1f2601cd8bf49f30ac370c49", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ebac296575a7da3090eb83479fa34dc63024ed44efa464427375a44de486e8d6007c7842b45ce817f": "0x0000000000000000000000000000000004eadae1c87f39ff2b60465c9640a1af260a815725f9ce3fdda291f92f7769e3b4", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ebc7126812bf1df493e1630f099540e76e98b9fb0002c3a5ae3f40b6ec180df68fe5cd9bd2088fa18": "0x00000000000000000000000000000000040238a0a2b0989bb426df8ac92118b4228a81b354d0c87d8acd25c8de509f2226", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ebd45ee52acd85afa825872f7d324c8d97a9d5f5c94d918eea93ef783f305767b768a76f9fede7b4a": "0x0000000000000000000000000000000008c07244af8ac9b81030b3c47c23cd5b10701d4a5490790e20d12a583e5e6068230361fd2cac02d6b4d6b0f31f3abe70104f00924a85bebed0b17267990b38c88b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec0095c67a6440edf74db9a1104a31f8b431ece5bcabbe3e508d22fe13670d32875ff6347a88d1388": "0x0000000000000000000000000000000008b4a302cab1fb0489c4211db08beae0bf7b5432416b299f57ce785b037c297a468e2499f22749aef04333796fe92b73c06cf4e358a552604ff3e550725774f924", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec029ee460555e12cb2692080bd814373a7c780dcc62922ba2e770c11a50bb1bb38fd3e69f0192a71": "0x00000000000000000000000000000000041a58ec699c897903d28984e42202dc216e2e8f7023c846926179c0c38562e4e0", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec038a43990a07bb81280a479ee3beca7af1636aca17582f30829782e2c9b1b9c72aaf8060563ab37": "0x0000000000000000000000000000000008b0ec35caca1aab56df7814b80ea0585eae79ec6f58cf03a8be0c40a5c6707711c85cbec6e7576580deab57475b75d3456c379f8c4abb617969fbf99aa4e8c076", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec07bdf560316d32b08ec72cbf62bb66f416f46f988e130585c834a381efdbb0755e30f47a2a0da5a": "0x000000000000000000000000000000000880bb3bb99df51400d9aabd8e0e6b6610d3d4f5512ae4d46e03f20ed14eb0cb3e3ab79a63ae81a8f096efbfb44d958cdd0253e97775b908d73de31a5d9cb00e44", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec17b80d313e3c78cce44b6b392394133943e063102b113e0577108fb9cb3000fe04faec3a3ad3934": "0x00000000000000000000000000000000042e544de1fc9198d35dd459c8ff8bf0a2c86eeaa4ed8ad9b32fb8d016e696ad77", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec19ae875baf61fab3e3a490c516b2a3582e6400e33f3eec42a12589958cbb86c87b23bc94710d21b": "0x00000000000000000000000000000000082c85bbe77e464b97ad4d36a49bc2b84566c38b9bf6eff49aaf005c672fafe7528a4c3a7b3f2b3cb525ce315f859de83c51410fc29ac88734be346709d0798a20", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec1e0ca80539b15c8796b851c8164a129b23282ca4b3bb694364b0bfb504e98b5d2ffc5140d58078e": "0x000000000000000000000000000000000482fdd15d55ddeeda8100a274f8872503fda6e267e345f4edd9fad26229604c0e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec237c8c9d7bd4904bc267fea33668e3515a7c01f4acca67d73d30574b600a404d2b7210aaac85569": "0x000000000000000000000000000000000444ebd2b934606a30469bfd509293c34174336f974709964a18bf40d99a0bed0d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec2a5b45c043e387bd2a0035cec74b2f90f7e72cab1fb16b6ba8317631976b138f7cced3e00668b0b": "0x00000000000000000000000000000000045485545d9937d865c9fe34b5b3723ce78729178a292681d43bcfd35076a656e4", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec3aa97983f6ecffc96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837": "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", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec562a9eed81aa2dadae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b09": "0x00000000000000000000000000000000143e1f45bd8fa191f3441574abbe1f4ef3bc6eb07bd224560f30e45909eb0c8e457ad1704a69927d8dde4807b1c67fdaf26718755a742f7994158c8f79749f3a0444e2fc205de7ec0dfc49f2e05c64555cbfc897602413c712c93967b59257e537c880ad522ee62f59ec14aea01214fb737df562d1a9bffb35d70d35bfd2c724325a482942379643a03b8eca91f12ef9ed1baf5437080664727117fd2ae6e7dc56", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec5b2faae0caa0f972c6f57e9289919d242aa985c1963f2b4040ddc57df3682d890657d130c035576": "0x0000000000000000000000000000000004f43e114e579d7503e86bc631c58415cd1cdf864d0fcf512bdd5cfae51aac062b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec78dbbfac53841cd2c0d08e42e58247b57421f3239e0e192b21edaed4bca2458028c981634bdb607": "0x000000000000000000000000000000000803bcad4ae89b033d823dd32ad149177e99e47f1c1edbfe9e5281f585bc406558fb944d7e992958540251fca02926063121bd452d21e0c20fedad450db1e5f713", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ec7b59ed3c46118b33a5e67c5be0b1a151232d17929a6479d7d7187544a40c059664c6315e94c977c": "0x0000000000000000000000000000000004a8fc72d20690562e27bb10f078d2de104192ad2d0cbfb4eec4eef42381f53739", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eca08516f7be365cf1a21174f3333c2bb416072b2c31d8f1e60f8e4ad3cf9546ab47e5b6fd060d303": "0x0000000000000000000000000000000004c203687a31c85ac0dce32725c354a515d8c027681db49edbbda4e3804e5dec63", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecbd0c872a0daf479a4848ac04c2ad298cfcbf27ade0ddebb2cc3b37b090dd933a1e988b7a3ead075": "0x00000000000000000000000000000000085607fa03519626bba53d0d71b008694a205e566c653b766c9f1c60edee39ec22320145f6b95e9a687429cab758eea7c9cf2375c09ee12b7973e85c7f8476da7e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecd624b47e3069b393e8faae4c5713c72aea65d52aa1616d3e918dee3819fbbe08cd4c76dbd754a50": "0x00000000000000000000000000000000087ef6c750071ec4ea673adf3a02c82062d042aca83eab159f599434894946423deeeaf12276eba3a08a26a606cf4c7cee9c3c0cf56a781899afa463104cdcf842", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecee83f43ea0dd41a22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed406365": "0x00000000000000000000000000000000108ae437cc2420c617f2cdec05405db6c449bada7d2b2063eadeae636a25c5ca79cd0b6229844999d1cde6c2e74ff90057d24e5875b891f645e2fb4a47ab90745ea100d0eb4c4ad076d10849f54ddfc448b83596f24f71cc49ad4c0390ac489010ad21c2f113facb0631e7145ab7f255c3e46b49904587d6aa6116c56ad615fb1c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecfa782accd3d75bebe776c10ad0e1fe7f606cfe42448e02cdb640c21214ea6c0c99df36ec0ee3d0d": "0x000000000000000000000000000000000882c35d711666a25aeef2933e8c52be35e409e288120a6555139b0c45d90c140c46351b08b39356e218524151eb16da7d6678c6066a831d6ad9b9ceea25d6df07", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecfac989e84b5ad935ee1e16ea093ea043d7f67a6f34f440c5fb921b56b54e81c177898d348685b51": "0x0000000000000000000000000000000004189ef65d1a77acbc1492c95ea3a58cb70b9ffff211190368bbfa21198c734c2d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ecfc0cc32c14f6b1b1c2a5f648afea2a94286c17f6c60d16c9ef8511fa4ae88a54ce2748b6c8fa90f": "0x00000000000000000000000000000000048e5df47c25340b48d443389c64abf88909ded6b6dd62c01548840970cc4f14a5", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed1067d55a33c02831232508adcaf57c6e78a850f9d715e3694b52000ce537832eb55c7a59f859e13": "0x0000000000000000000000000000000004078447732a649b7bf6970bbbbac8df97ce628b139a8407fd7d051f40a0258f93", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed4f4dfc6da461b20aa72c321b20bbd5b78b14f6fd800017bca47190956eb42ada2a4d8f8a8ca994d": "0x0000000000000000000000000000000008e0ca65cc737d7d170d9f7b09247f9cbc52142c62a6bcb4d8a5bbf29e6cda7e0598bb3be2e039d66d581ffe74cb449689ac74428512b67e033855de5d75b84d08", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed509c5c59195b1ec5c3739d60301126756a7510e34f9d656d4435cd4fe64bbd001f1f3473bc9c333": "0x00000000000000000000000000000000048413fca2f93b3526794f655fc3504b40e0dff0648a4999f10f8eca7c21d1c21e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed7906ae903234547463a9cd3e7cec50ccc93515557ab58221d20c67a409583428ad67caff9415107": "0x00000000000000000000000000000000044793061e5121c9561a8dd25c2e64df912f5939a096bde10bf9c5cd06f753f6a7", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed9cef13374a70e655010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f": "0x0000000000000000000000000000000028da4c4087c6c624a12ce0c066b04f71d81735ed6a252c0f63e55188be16be4f475010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f482a064f119738425180e442727eded171c8091bd90182c3071f37199d9541586e306a119e947513f180b430e3e75bc8c476a8b61e8348d1f87e490121601b5a6a4fe76ff9e27c148bf2c24e2f85fe56b4eea5bbcdc159430c18036e0f940f2782c38ac61bb075ef3c6f745af4fc8675526b69e7a66c05e777e15bf3df99302fb4c24dc7c3bc7ef831df7637143bb554db602d209f58c93c3dc2af04dc3866699442a11a7247822dfa83dd5c27ea7249cf2458e60ebf82ed760f9e6d6f99bc7bc63d29b9669894bd812dffb0a0206bfaddbf728741b3219e9ade9937bfb1874b1a9490a6fa5ca6353651e0384ff371db3aaa0d2fd20e6ba91c8733a17f581602", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ed9e0312b39961bc6726a98c27f84bf42fc842794a925418335fc9fe3badb1f535dce9c9d9efcc02d": "0x0000000000000000000000000000000008b0614de4de8cfbd7c760fba99b446a030b0ddd8f00a0dd84dfc88c7875d80c07eae07a7b7adf896a2332b5bd2e366474eab97e137c155f8741a9c6b4d30db700", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37edc6d83874526905136aff2ede1563784631d6149024982108f661b079b6b79f3d042041a9da11e2a": "0x00000000000000000000000000000000043e9520e4e74fd47da1dd509ef04dc9b14215a35e7d207fdb2c99f732ff5cac16", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37edc7d270f233cb625a6ac5af2b37a6bb6d5c9cbb7fa56748fb1c9cf9ad1ef43334efa76a431aa3d22": "0x0000000000000000000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eddd17007ceeb939fb4d78a8bb35a7b0ff8ae6a7808f9b17c83efd28b8612c2388034d0e35ce51376": "0x0000000000000000000000000000000004981d5e90031eac279276782d0d15ab97fb30898a69abc4eefaa797c572823b2c", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ede4e384e5c5bcda65ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304": "0x000000000000000000000000000000001076729e17ad31469debcb60f3ce3622f79143e442e77b58d6e2195d9ea998680dd00de863a4e1cc8c2b2050ba4be784b313caa1e51167abacf392c1f07270834ea82456d51e83aa6dbf7a473b5776454fa175d5dc9775629aa05bb09b28fe4509b054f58645b2774a05e70ab4f9b59dfa46ed60acd0668713e921324a933e2027", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37edeb3e9bfbd8d3c590cf6b6cdababf69c2af37a41a2f360820bb7dff2f61c20bb61a9503a8901ee20": "0x00000000000000000000000000000000046a6d9f13f448628beeaa0e4c8e47341163ce0eb14c612d882799b9eb4152d71b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee050fe4b1877288206c7ea7684b6aac6cd63cf88c92b0f05398bc3e13e0b0c5936c3027b8e0c7e2f": "0x0000000000000000000000000000000004c9108836cc5003906b107d31fe5c7b5d1211a4f71bee14f068d2fa04551387b2", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee18d41e2249b70ec4eb32a5fbbccb1d97d31237172fbfd92945caa6822d5f8afb558aa7b89bc5a11": "0x000000000000000000000000000000000426a81cc7f1e72380949491cb9538d125d40de48e631e0e8bc40964fddee59bcc", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee26d187c65071fe036da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb389345": "0x00000000000000000000000000000000781600e09e1d8a1324934f83d55d5f6f503e2d91bf4270eeaefd462f24e4487e29e6d97bf878b1012927ae6afb7e092c541a5abc3904656981beaefb9ebb781d1c44a1336854e44cdbfa929ad12e913e4a1870c590a6dc5e3983a6fd416b927f534877511245f8954e48858da743b9eb3544681c27ffd8802c8ea1669e961a2b6148b2cc621a25ed86391676c3686bc2cf76f06edc66a4c3c21e2452618ee1bf4e50ec868243f5ec5af29a7c679163a34978815b6f1d6e2b871f1f361cb7a1f9057c2241b8ad2176aa340dea400bd84fc389091a7511086bbc78fa98a7356e630aa06c4e59af8d86d8b552887762255c830d79b847a6648210ca6b24d0dbba0e2db64c29324eb942fab6b41cc041f0e099f35d5c7fec824bae17717c5fa68cb83e88d74924b788c1f7ec64a54c63eccaddca748f588f67c26e5595870acecd9259520aefaa9aa8f2c237f96957bc1858cce594c62126484c3cef56600e11580a7798a8cd51a12a19dd5440fde5e43cb50f9d48d95ea5c5ee3618eb0b2945f02f21be6c22b41a47d782268a2d1eecf5e623ae6b984591db92f77de07a27a447f87c92070ebf24c4c84a47db97b62d308834c3f258a9d96aafd6bd11eca52bd6ce4b9ed22cfc6877c1961ac2cdbe5536684b0761074b8ea475d0c2f173f5989be90454730499c6c53dd16d1e3f8007b64be019cc9229db22d36a12e44eff1670cf5fb4de0e0553f854c72746045b90c8e5c67d74f5d8a52d4134b259ff562e4b1409bc61f6c2ba5b42da936c12c7e5c33f6cc573988521e5350de5887b20ae9cae4906e11fd0d4df6c4765eb346aac47682cb7871da9ecfd235255f6eadb8392b20dc65de6003709aa5a6b81354c00fb13e281ac05e852cb4194c69f78566e8ac8282eef2aee654d4975535f2701af86ba6d169c2c9a1599b16635a2a5e4640db94d364c29bfbc9f06a42b5cf37ffd831e91c843cc25d8b90071546810ecf279e45838a295559d8977464fd8cdd133f8805f2388e42a6e009219247048a27d9ac06b42efa2e57a813989da4bac4551e4010ee45003fc3f360f5202a958b2b1a29918605fd1308af1ce85bab5ba3fb19b330ab7dac29e01ad501420560f44df7e0e1c9c14dbe4982ae73a084bafe1f7eea2d51f3819088f08a10eb2fd7a1343c5140b8a1ec46479fec3c43eea382d637de8f295ccb2c0b6f6fdd4c5d34a687737a601ae1595f870cc27a34374a6b819a554e242997efeb760433c6fdb4372c2f28204be2daf84705de34c1930370f53566524b08145b4d192d6cdd5a35cc71930e2406cecea2c48271687c926a72814cfccede993dad2b803ec0d546d2bafa586c11d", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee38e649e5f9f7676b4d599b32c954b0a9e554c96b248f3e66046a82f46ac914fc675938f771f8372": "0x0000000000000000000000000000000004a83a9d38e1fcd76d6e82eaf458c9b71eba96a9e6540f39213fa01366fe0fb64a", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee5018c1728c62231664513c046d4497ba05c19efac47cb0dbe498e20b089dff25aa08d1a77ec970b": "0x000000000000000000000000000000000490cbf37b94fbb758804f3f06510840b6649c0a2cacaaadda6849c9dcb766b767", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee5a27d3189e99969dad042c036fcd9897945a880458b8e7104b30617a9640eaa22b7e23e675e0a02": "0x0000000000000000000000000000000004c88bc26c3cfb3797c1b2e2c9e7fd0320d9899271ba9255a2408c4feeb33cd425", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee61549e518cc68adc8a5bf93006b7fd50ffc2abaffd57ef06c67f2171b5097070892fa1a195d920f": "0x0000000000000000000000000000000004f50556e30130b7c23f4ec520332817629963b2a69e5b024aafc29fe7bef6905b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ee7b5d2aa3f9d8295b8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d2310": "0x000000000000000000000000000000001012c8663dbe1a18335ef5b7731a7ba8c0f25c0fcc761623af5159ec6eea586b283a92d9b2a48ee9adca77ffd658b1e273434924a7b3b456693219afbc32279e107c103bb33a2f4f6ff86f2f6e11e9488d6eeaebe52bbf31291fa00e46ec26ad60d84ea2d7257eeb646fb4e0d2aeee35a3eeaea22b897d8ec95f42d5ffd2251430", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eea0e1b22a44d19352c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e": "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", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eeec11b5fca7cddef5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c": "0x0000000000000000000000000000000010e417170e6d77f90f6d7b308bddb8a414f44a87623704da628229ba777b6446473ac9ec7da0888dc010574b11d9d0dfd62446ca38a63819937aa91f40f6901d585009e192ec169788c9c1f0202fe7c2bc79405ff8b6e1d1ac78fd6152006e606dd091cf86d04141b1c17c70826c08d074cae1b00d6f82de1b8a5406ea10ce723b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef1c80fdef53d785909cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb3": "0x00000000000000000000000000000000105c5c5a4a025f3d8be84fa9ea36383c2cd168c8a018d50c88a34154afe9ecf04f09b072ba1658a3946b1f7a82a7c135c33a41ac8e6ac11407d910d4baad3e6c421aec17785fa10a655d77b8850a0b7c5ac3ce5c0389555ec7d8f303092552cea70aa18c1ff67dccbb98cbb86ea9808b63dc72582c602fb0dcd7e6716dd9ed9c75", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef3a8cb14bfca5d3d82c5c0e26848d49b32a7ae09a67f6822f2a18310b69a3ed9c31ee02144020826": "0x000000000000000000000000000000000430e9bd57ca72b2de9928df65ac7974ccc0fe678a64c2df03e2159aebb4e8a525", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef3e3959f84b063bcd6c29a7c39cee45b0e045a94081bc188ef73be2be086d66aefd850fc7eeacc45": "0x00000000000000000000000000000000044e1f1d2881471357ea697093e5e68d46712d2b0e5b650945c4ecb571ea43757b", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef5d0ba7a9e0e043b545b7958451cd22afb0367d6c99af1360190813571c47b8a94a055d575d38249": "0x000000000000000000000000000000000404db71328c96f1654885de2d1f577621c524e4515416b0f861dfce55a3f72167", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef78baea38e12315a6c7fdb8b8eaad1af9faaf918493606e1a3e8c20f9d852773ab5ebfbb93bd1948": "0x0000000000000000000000000000000004084361c7e80bd43ac0aa2917200339e51e45284349a264184ba0befe3e2cfd52", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef7f8fa46e9ed81a89ce3de1cd55ad6f4ab351ab212431d94cec798e1727176cca174fa661c8f636e": "0x0000000000000000000000000000000004f54df5a1ecdcbdc84dee4ff7821578632b9d6d884b9bfa5c52f7164c57d3fdee", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37ef98bc77ab23b03eed401f460e0251ed41d7fb32ca463b5233b620cb9569eef5327def27fbd7c7b57": "0x000000000000000000000000000000000438f4dd8e0bd0a47c6263b31add7a887956da435cceec4750540743f0235c003e", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efa4279b211bd820ab22c2075548019dd268e74f3aa69c9703b129e989d230f935797975d5ed9247d": "0x0000000000000000000000000000000004e4afcec3862a48c276628c97bec157c563a74bd8ab3c7abc9d7fae99fff38268", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efad7d2ce54667f8c1ea80b0dde0e207c8ec57ac05fbec636502cb216bb423642919679fe8f074051": "0x0000000000000000000000000000000004b0583167a388bf2ec1c4ce53d17be27a15b23abdd97265571a5c65bdeabd24a0", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efb0bc5a64f81e0ca7cbb0ed8bf228935241774290753bf282020d73e45f6724b0196c97b3bd53462": "0x0000000000000000000000000000000004c215be73d91712a74db57cf18209ec172e9a3215ce6ef5cf5b0292177d3e1140", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efc06d1b8b9ab844be64bc946c10a1f75e683f236e72a44d6d61b3bdcf72ffd8c738e488efc6e1567": "0x00000000000000000000000000000000081a7eb7be90a60ea3c4b467df2f8fd89288ef44f581426bd98cc34a0b67bb959f00f379b621bd73c45c7d155d2a1fe6a04649e3ece7c7e03b70b3a6242bc7c127", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efc6a42b3b802fc9518d54ea25ad26acd7094fba6bdb278e769f9ac350cc36b2f631da13fa92bed79": "0x0000000000000000000000000000000004149ccce9d526a65ba54fccc24f5d1dee62f9b87915d4004eb932959d468a9e62", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37efd9785f8772870809eee1e58c17ff7b037f2da5766e9bc78d5568c58d45cf363b9630ef32b2ccd79": "0x0000000000000000000000000000000004b023d129d9a0cb9490d097dbd3ca947d4830d3a6d7e0fa9975ff2789d9d97352", + "0x2aeddc77fe58c98d50bd37f1b90840f96ee5a0b09e7e9a96219dd66f0f74c37eff643fe3320aabbafcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a": "0x00000000000000000000000000000000107cbfaaf0fedba11f23780e8b1bfcac5e92a85f56835027e83bd203bab86ccb0798d7bbcdd3c7fe6e9bf7de42bc97968143fb02ce4c7f2382552237dd1398255920df777c881c5f4eed3f1c75e29c65fa681a63dc612cfabc5217f4308924e62fd66dba2833b102712151bbcfe1286506937ed28809693e730b622b3adb93e36e", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471400123d83b036c82d5c5062779d44ea2ab0469e155b8cf3e004fce71b3b3d38263cd9fa9478f12f28": "0x04010000000200000000000000000000000000000000054a61636f1644616e69656c204a61636f627573204772656566661a68747470733a2f2f6769746875622e636f6d2f6a61636f677219406a61636f67723a6d61747269782e7061726974792e696f00000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714004b6afd076a2dc82e33c5e14a53e874caa8e7c6d30bd20f6c51cda7dafaad1c465ca004fe61a63e": "0x00000000000000000000000000000000000976616c656e74756e0000154076616c656e74756e3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140069066ec36235d3c278f83039076e64ffb94cd1f3333887f8c91d99a1b979db5138c60533776b06": "0x040300000002000000000000000000000000000000000c63756a6f72616d6972657a0000001a666162696f40746865626c61636b646f75676c61732e636f6d00000c63756a6f72616d6972657a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714008f3c4dd5a156f727dad3917fef51edd3bf9c675241fcb86d296a690fc3d909a1195758b831cdf6": "0x040000000002000000000000000000000000000000000c646f746265726b656c65790000000000000d40646f746265726b656c6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714009c7552e843cd3a5ac75bc572e195144b05ded3548b218377034460f9d7506f4a36b57b837d9974": "0x000000000000000000000000000000000014506f6c6b61646f74204053585357203230323314506f6c6b61646f7420405358535720323032331968747470733a2f2f776562332e666f756e646174696f6e2f001761646d696e40776562332e666f756e646174696f6e20000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471400d8c318b5f5bd3a609438d7aa30cbded1219230de200a98951d9ecf005606eb8415f386148a4279": "0x000000000000000000000000000000000007426f6764616e194768656f7267686520426f6764616e20546f6d6f6961676100001a6768656f72676865626f6764616e74407961686f6f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140138f06b2816b46fecd06f79f6e28d47c2bcfca46173aa3a12d950f5637a8d65bda37e283c983e5d": "0x0403000000020000000000000000000000000000000005526973680852697368616e7400001672697368616e747374657240676d61696c2e636f6d000011406f6666696369616c6c795f72697368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471401443af96cf425c84c48963fc0f3c072e7a3eae4c1014e6bf7333cb7513e7bd0c2042fe86784812e": "0x040100000002000000000000000000000000000000000c41574f524b45522d30303200001a40636f6f6c6c696e656d655f676d3a6d61747269782e6f726715636f6f6c6c696e656d6540676d61696c2e636f6d0000094062696a69617969000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714014c4a8a6cb20d5f04740a3f003b7aa86a3d40f9b65c2d650035580220c2525a19f3b251c0956e40": "0x040300000002000000000000000000000000000000000d616e616d617269655f636f6d0000001c616e616d6172696a612e6265676f6e6a6140676d61696c2e636f6d00000d616e616d617269655f636f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714015b6bef29d45538bae335c017512a43fcaed23efec97d80e088bb8f7b93ee837cba5416ca51037f": "0x0400000000020000000000000000000000000000000014f09f909d2043525950544f424545532e58595a0000164063727970746f6265653a6d61747269782e6f72671e63727970746f2e6265657a7761784070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140167d7d8c6597960f482d165f7921558a0bb9b28f66ff64161ba6576f1b854fe4fcf825c00860407": "0x000000000000000000000000000000000009416c65782d646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140173de88215548e9f65f3cade8f68e8f34c6266b0d37e58a754059ca96816e964f98e17c79505073": "0x040000000002000000000000000000000000000000000b4f4c4956455220e29aa100001d406f6c697665722e74616c652d79617a64693a7061726974792e696f126f6c697665724074617374792e6c696d6f0000000767677770657a0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714018d717cb9219f862cb783d5c0ddcccd2608c83d43ee6fc19320408c24764c2f8ac164b27beaee37": "0x04000000000200000000000000000000000000000000056b6174611041647269616e20436174616e67697500124061647269616e3a7061726974792e696f1a61647269616e2e636174616e67697540676d61696c2e636f6d0000000a61636174616e6769750000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140191249b095df776704f6c600c82c4c1048f35c857e92484df9315a7e0bc298c405f808676869a7b": "0x04030000000200000000000000000000000000000000084b434d574d50520f4b6174686572696e65204d6161730000106b634077616368736d616e2e636f6d000009406d6161735f6b63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471401e66931ebe7cc802a82fb6c3dd0269f6977b022fc3abfa2f1ed9783de2d7f26672b7eebf4fa783e": "0x0000000000000000000000000000000000057072657300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140200a531a02ceab0f2f2ee56200c11091ffd9e394076723bd1e948832da89bcd746eb2e3868e8969": "0x000000000000000000000000000000000010e381a8e38282e381a1e38283e3829310546f6d6f6b6f204e616b61676177610000136d6a68707231353640676d61696c2e636f6d00000d40746f6d6f746f6d6f43454f0009746f6d6f746f6d6f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140250733e6e15b29ba4385c957aa511e5628d26e48cfaf2e46d3313011823a9272ed754019a67207f": "0x00000000000000000000000000000000000d45726d616c204b616c6563690000184065726d616c6b616c6563693a6d61747269782e6f72670000000d404b616c65636945726d616c0c65726d616c6b616c6563690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140251fe16ba336a2a1eb4f7030a34dc1c72a29f00bb174eae301af0ec88fb34557c084cac25da977f": "0x000000000000000000000000000000000008486169204c616d0b567520486169204c616d1c68747470733a2f2f6769746875622e636f6d2f56554841494c414d00146c616d76683238313240676d61696c2e636f6d00000d4048694c6d56373134373932000b6861696c616d3737333500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140264d5f165d70fd8604189f1ea74bc439b18060c58f352db2880dd4c835df7ebb26e020bf11e7969": "0x040100000002000000000000000000000000000000001b436972636c65496e7465726e657446696e616e6369616c4c4c431e436972636c6520496e7465726e65742046696e616e6369616c204c4c431b68747470733a2f2f7777772e636972636c652e636f6d2f656e2f002174726561737572792b706f6c6b617373656d626c7940636972636c652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714026cd546f7bcbf83ecfa264fd1da282eeb7b06b8c7fd5634e9f5da8eb1163c79b789d943c310ed25": "0x040000000002000000000000000000000000000000000c53757065724475706f6e740000184073757065726475706f6e743a6d61747269782e6f72671774686f6d617340626966726f73742e66696e616e63650000104054686f6d6173525f537570447570000e73757065726475706f6e74343400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471402c2da93a5b6fce008754abb6afba51a2f74f0b97bbcdb383f579a02a5e4541fee736710af562c6c": "0x04000000000300000000000000000000000000000000075061726974791d50617269747920546563686e6f6c6f676965732028554b29204c74641368747470733a2f2f7061726974792e696f2f000f696e666f407061726974792e696f00000c4070617269747974656368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471402d1c4ec984b618c46807e1b5ba42007b46e58f24fae00ade4115e1b15680337f99137a5333e0e43": "0x040000000002000000000000000000000000000000001e54686520426164676572204c61622056616c696461746f727320436f2e00000016696e666f407468656261646765726c61622e636f6d00000c406c61625f626164676572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471402df35b98c238fb36c3722bb683f6247d01da39cdc1055f07d24c1c0b5aca199ef3b0ecbfc11f414": "0x08000000000202000000020000000000000000000000000000000021f09f8cb453494c49434f4e2042454143482056414c49444154494f4ef09f8cb400001a4073625f76616c69646174696f6e3a6d61747269782e6f72671d73625f76616c69646174696f6e4070726f746f6e6d61696c2e636f6d00000e40534256616c69646174696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471402e989611aec18925220f15324663f1bb0bad6212a344c7f4deb40aa6e3f489a56db71d545507e19": "0x0400000000020000000000000000000000000000000008696c347231343100001440696c34723134313a6d61747269782e6f726712696c347231343140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471402fbd3dd4be7ed351c90e3dabd3fd0f6bc648045018f78fcee8fe24122c22d8d2a14e9905073d10f": "0x040000000002000000000000000000000000000000000b6b69616e656e69676d610d4b69616e205061696d616e691668747470733a2f2f6b69616e656e69676d612e6e6c16406b69616e656e69676d613a7061726974792e696f0f6b69616e407061726974792e696f00000c406b69616e656e69676d610b6b69616e656e69676d610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714030d3f604ca958c6a47c8ebe79ceebec1a2e5dbb3b631e5b80cfe39ac103b3fce2d1a9c8579f510e": "0x040300000002000000000000000000000000000000000a56697274756e6541421256697274756e6520414220285075626c2900001268656c6c6f4076697274756e652e636f6d00000a56697274756e654142000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714031326492a87a9c14631954522a90e4361e6b9bb3876cf6213bac251f99d456ed4703b47f289b95e": "0x08000000000201000000020000000000000000000000000000000008446f746361737400000019646f7473616d61706f646361737440676d61696c2e636f6d00000a40446f74636173745f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140321b5acf1a4323638a88c73e729a0e8a2161f95c844392baa81dc70c8e8d39f76efb0342971591a": "0x0403000000020000000000000000000000000000000007426561636f6e0000001368694077616c6c6574626561636f6e2e696f00000d57616c6c6574426561636f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714032271bc6af67408e20cb98236c8a2d833d8fb6544ce4f5809b14d5e7f5f9ad742f975f787953f61": "0x0400000000020000000000000000000000000000000011f09f918b203739616e766920f09f8d80000013403739616e76693a6d61747269782e6f7267133739616e6476696b40676d61696c2e636f6d000008403739616e7669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714032bb7554ff00e0c868f95d29b6e5290c6492e6540c3f46d900961f7c8d063dcd299cfcd97462b22": "0x0000000000000000000000000000000000194b494c54202d20506f6c6b61646f7420416c6c69616e63651968747470733a2f2f77336e2e69642f6b696c745f696e676f1068747470733a2f2f6b696c742e696f000000000e404b696c7470726f746f636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714033093647d016eaf3860c2799edfaca5866dd49f38c6180806224b1b893e77959a3cc2d4ca1602cf": "0x04000000000200000000000000000000000000000000106b6e696768746f666d616c746131330000001a677569646f2e6d616c61626f63636140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471403456c855e9a00037e878e54c1374b30df335d3a193f3e6b1f84db6c2270ee634cec769d7e33e244": "0x0401000000020000000000000000000000000000000019434f534d49432d474c4f42414c2d434f4e54524f4c4c45521c436f736d696320476c6f62616c204e6574776f726b732c204c4c431668747470733a2f2f636f736d69632e676c6f62616c1840636f736d69635f746f6e793a6d61747269782e6f726717706f6c6b61646f7440636f736d69632e676c6f62616c00000e40636f736d6963676c6f62616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140383e568f18fc74ec66041adc9730fd89001350628c4d92ce2cc734b487604cd9786622591106872": "0x04010000000200000000000000000000000000000000195175696e656e63652f4d6f6465726e46756c6c737461636b135175696e656e6365205074652e204c74642e1d68747470733a2f2f6d6f6465726e66756c6c737461636b2e636f6d2f001c636f6e74616374406d6f6465726e66756c6c737461636b2e636f6d000011406d6f6465726e66756c6c737461636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140390ba3a7443c05e4eef513781a2a7c94110928e39de53dbe50f9adc5009de3db0e2acff37f0c756": "0x00000000000000000000000000000000001157656233476f2d4d756c74692d736967001368747470733a2f2f77656233676f2e78797a0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140396382deadaa8ee485d0b693f66f1785f35ba1010d7e7528a0116ec424454f58c6e500c3c66a520": "0x0000000000000000000000000000000000144d6574617363686f6f6c204f6666696369616c0e466174696d612052697a77616e1668747470733a2f2f6d6574617363686f6f6c2e736f0015666174696d61406d6574617363686f6f6c2e736f00000e4030786d6574617363686f6f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714039ea54cb812a324847194325a12bc4f4faacb6aef973eda31658195c26b934318b960aa69050819": "0x000000000000000000000000000000000009646f746875622d3309646f746875622d33000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471403fed7fe7c184ba490bd3d091b8837f2f41c38b6e3bebd28a31ee280f82d15e687f95d798ef41c17": "0x0400000000020000000000000000000000000000000008457a696f5265640000000000000940457a696f526564000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714040dea48ab93d760f034ddb0d301f22e5084439a96ec38e7636544ac137d0514e018fde67f2b03dd": "0x0000000000000000000000000000000000074c454447455200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714040ff78a24cd58c71ebd2c29909eb603331b960308a070b839ee78e80fe12ef05e4639a176ab743e": "0x04010000000200000000000000000000000000000000074c697374656e074c697374656e1268747470733a2f2f6c697374656e2e696f16406c697374656e5f696f3a6d61747269782e6f72671173696c766572406c697374656e2e696f000010404c697374656e3136373831393338000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471404322a3587052539a23809a947f2c06542cbf2fafe17fd7d84c460d51fdd69d01f53a5ca050ee709": "0x040000000002000000000000000000000000000000000b56656761735f6c696665001668747470733a2f2f76656761736c6966652e696f2f1440636372697330323a6d61747269782e6f72671876656761736c6966656d61696e40676d61696c2e636f6d0000094063637269736c76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140451688eb2d3683ce8b53683b6ce7ef4d1c7bf913580bde6ea10b6fdc790fac42b77955c740d1301": "0x0400000000020000000000000000000000000000000013506f6c6b61646f74204e6f7720496e64696113506f6c6b61646f74204e6f7720496e6469611d68747470733a2f2f506f6c6b61646f746e6f77496e6469612e636f6d000000001040506f6c6b61646f744e6f77496e64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714045d4b9be19df388bc6c08ceb638f3fc5a0fecdfd83e909fd7ae1721794f2925ca0f5094932c3769": "0x000000000000000000000000000000000008616c6c6f6368690a416c6920416e776172000012616c6c6f63686940676d61696c2e636f6d00000008616c6c6f6368690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471404632aa45f1b73c60a6a339260fce0551ac29fd893232409f6f1182daab8e1021b3861e6a5101332": "0x00000000000000000000000000000000000a6b65697461303932380de6ada6e4ba95e5a58ee5a4aa000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471404d5e25d603189573898b6f62b50749101446132f77fa6dd77a3895674fa8dac87e6c375ea852346": "0x00000000000000000000000000000000000b4441524b464f5245535400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140501142b6fdb56404e7edd090cdd7a52eb0e50ca77b86a41835bb60755a109e421252fcb6a373624": "0x0000000000000000000000000000000000064b43435f3100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714055dfc6d34f916957640aa86730cd7fbff361db495405a4affecfeeb6581370b07ff5abb023cab06": "0x040300000002000000000000000000000000000000000a506f7765724c61627300001640706f7765726c6162733a6d61747269782e6f7267146d696e7a756b76696b40676d61696c2e636f6d00000940564d696e7a756b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471405b079eb94353bd94adf51a47b72795366d52285e329229c836ea7bbfe139dbe8fa0700c4f86fc56": "0x040100000002000000000000000000000000000000000e536861776e2054616272697a690e536861776e2054616272697a691968747470733a2f2f736861776e74616272697a692e636f6d1940736861776e74616272697a693a6d61747269782e6f726717736861776e74616272697a6940676d61696c2e636f6d00000e40736861776e74616272697a690d736861776e74616272697a690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471405d79e4283e265f4f422f57b2b12e96bfc2f8e8416bd768da1c4526f803622f7ef7536d4db29e970": "0x000000000000000000000000000000000007686f72696d6900000012686f72696d6137406e617665722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471405d8bd6067f6ae29c804531378242158a794bd06c1e9ef0e569f60bb32758597af80e5e70c07a64f": "0x040000000002000000000000000000000000000000000e43687269732d5374616b696e67001a68747470733a2f2f63687269732d7374616b696e672e636f6d1240636c616e673a6d61747269782e6f72671863687269734063687269732d7374616b696e672e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471405e989f2a5137a8f22e8d22a7fe2768c944dad8af7829d96eac8644f06643ea8ae68bc3c1e905306": "0x04000000000200000000000000000000000000000000066b6f757469000012406b6f7574693a6d61747269782e6f72670e6b6f757469406a6b76632e6465000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471405fa9b980f99404c1e8cc9421ed7548a68def07a5c4c6d205cd3b84892c4b58c0e35badbae992d6a": "0x00000000000000000000000000000000000a504f4c4b415741444508474d20436f6e671368747470733a2f2f676d636f6e672e636f6d00156576613036313230313740676d61696c2e636f6d00000d40785f636f6e675f77616465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714065d9c0c5a79e8cef73baa66d4746e8447877fe051d6dffa85811dcd14c6dceeb29e011b1514f23e": "0x0800000000020100000002000000000000000000000000000000001654484520534556454e544820434f4e54494e454e54000000113335393637353237344071712e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140666dae771739caea0f7cb4fc2c83488aa67396520178b74e13298b0cc3d89b5e7fcc0be290b406b": "0x000000000000000000000000000000000007436c6f76657207436c6f7665721768747470733a2f2f636c6f7665722e66696e616e63650014696e666f40636c6f7665722e66696e616e636500001040636c6f7665725f66696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471406829105dfef3f40a6b0e06e21e9c82af02f3aebb597d0fb4cf6470c1de0278f7a26a301680fca6e": "0x0400000000020000000000000000000000000000000009436861696e326d650000001872697461636861696e746f6d6540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714068d2dd8a39691885e09d262efefa86090446d0cc0fd6cab48b79b667e499beba1e72a0ddf16e523": "0x040000000002000000000000000000000000000000000b4161726f6e323436303100001b40696e6672617374727563747572653a6d61747269782e6f7267186161726f6e40696e6672617374727563747572652e636f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471406a3b4543b0cbdd8b609cda244e45076c572478b1b3b39636a96b7626be093cf39a222e0073cd017": "0x000000000000000000000000000000000005766976730f56697669616e612053696c657373000000000009407673696c65737300087673696c65737300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471406d7541597a81f1b6811dfa0e269a620b63ccbdb616e8e12619d504cb470324ab3ff1aeeeccbff59": "0x0403000000020000000000000000000000000000000008426974446173680000001a6d65726365646573736f72656c313040676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407063321357d092326e1f0717f99bfa5eb959816dd1bd8b79b686ca351fe16c1dfc929d55e49f247": "0x00000000000000000000000000000000000a48756f6269506f6f6c0a48756f6269506f6f6c1468747470733a2f2f7777772e6870742e636f6d001468756f6269706f6f6c4068756f62692e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714071427015841edc7844b0f0b00cfcb99ce376e5f836bac3cd801af422979f32a4bf2d32ac3e5483c": "0x040100000002000000000000000000000000000000001c43696d20546f70616c207c206d697373696e672d6c696e6b2e696f1c43696d20546f70616c207c206d697373696e672d6c696e6b2e696f1968747470733a2f2f6d697373696e672d6c696e6b2e696f2f00136869406d697373696e672d6c696e6b2e696f000011406d697373696e675f6c696e6b5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407821119981623015ef2b64a77e076b7f284c1e8c2afa826bf2ada04e58b757e2f9dfb816a250a66": "0x040300000002000000000000000000000000000000000e4a696e73652046696e616e63650000001468616f797565406a696e73652e636f6d2e636e00000e404a696e736546696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714078c7addc0fece8f18a5d639662da95bb4924c48441fb432047e77613263cf1438ce8a14fc34c432": "0x040000000002000000000000000000000000000000000d554e4956455253414c444f540000001d696e666f40756e6976657273616c646f742e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407b7c5e9987b5a061650c532ed1a8641e8922aa24ade0ff411d03edd9ed1c6b7fe42f1a801cee37c": "0x040000000002000000000000000000000000000000000d446f6b69614361706974616c001c68747470733a2f2f7374616b696e672e646f6b69612e636c6f75641440617772656c6c6c3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407badfa66414d7abc4e7d5a63d8e887932bb6dc505dd204005c3ecfb6de5f1f0d3ac0a308b2b2915": "0x040300000002000000000000000000000000000000001b436572657320426c6f636b636861696e20536f6c7574696f6e731b436572657320426c6f636b636861696e20536f6c7574696f6e730000216f6666696365406365726573626c6f636b636861696e2e736f6c7574696f6e730000106365726573626c6f636b636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407d711054306c2851292a778cf74e0573db07ff3ff3738a4f0c44ffa0f2226e821c4dc3eb7d21300": "0x0400000000020000000000000000000000000000000018f09faa9e612073206820f09fa799e2808de29982efb88f00001c40626c6f636b636861696e637572696f3a6d61747269782e6f72670b314039373130342e646500001140626c6f636b636861696e637572696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407dad820c63897d8924bccc2bf4d18656da14ad467c161370e43c2bc7ebc83d7f1e6ba4b6acd1010": "0x00000000000000000000000000000000000965746865726e616c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471407eaf323b98489af7febf816c3fee7de2f843afd83a03e4b7138c81f655ad20e31c27ec35bdbcd23": "0x0000000000000000000000000000000000104b6f746f207820466172626b696e64001f68747470733a2f2f7777772e70617472696b2d687565626e65722e636f6d001968656c6c6f4070617472696b2d687565626e65722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140802b46abd9ac8a9386a4f5a0311a2834e28c84daa299fe14414137807e201a1941e502c7a784467": "0x040300000002000000000000000000000000000000000a646861726a65657a790944616d696c617265000014646861726a65657a7940676d61696c2e636f6d00000a646861726a65657a79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140803dc9d292420d2565c14e67b353eca54a9736c1fb110f72a753c3289399674e011785af19eeb04": "0x00000000000000000000000000000000000474616400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140823dc59ec2f7a204eed7cf3f4f6560d58db4eb78bd24b655bbd1d7a5c6b454e77c8dc5e2721a54d": "0x04010000000200000000000000000000000000000000164d4f4f4e204c414d424f5320f09f8c9520f09f8f8e0c4d6f6f6e204c616d626f731768747470733a2f2f6d6f6f6e6c616d626f732e6f726717406d6f6f6e6c616d626f733a6d61747269782e6f72671976616c696461746f72406d6f6f6e6c616d626f732e6f726700000f404d6f6f6e4c616d626f734f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140874e41bb7db2c8904f9fe095c3f7e02a2ad48e58b7524cd3353a1a09097882259c1cb8b8fbc722e": "0x0000000000000000000000000000000000114672657368437265646974204c616273114672657368437265646974204c6162731968747470733a2f2f66726573686372656469742e636f6d2f001d66697261732e6b61646461684066726573686372656469742e636f6d00000d406672657368637265646974000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471408768e841e1a6e64bc9f6b302d5f299048a1d3aa10d6ea182f3db0d15fb42d0e76c086a13777dd35": "0x040300000002000000000000000000000000000000000854686520546965000000116a6672616e6b407468657469652e696f000009746865746965696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714087a5388d9e5a204ea149bdf5123e8cfade6a4541bc205d1c1bed6c92c876b21731bf4ac7984c67d": "0x04000000000200000000000000000000000000000000095468654775696c64000000197468656775696c64736f7572636540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140890dc820c706f1454824b885099cbba0103d1a671b0aac36c6b8b0e80747f3f111300d41d1cd55c": "0x000000000000000000000000000000000008426c7565446f7408426c7565446f74000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714089372171cde85a1a67f727210edec1922631f1fdd095c40c9b434c864c239968d26755cd982504e": "0x00000000000000000000000000000000000d506f6c6b61646f7453686f740000001b626f6574746765722e7468657265736140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471408a0e5fe9e4b1f842a27dd26f5f3fe4f48fc67cddb54a8cdb0f3c6e4b9c8cf751a59466771dc6144": "0x040300000002000000000000000000000000000000000f5269636861726458636176617465145269636861726420486f756c6473776f7274680000137269636861726440786361766174652e696f00000f7269636861726478636176617465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471408db713c2bbf4320a4731404eb64407b76d75dd815a3267e2dce24d8c2054f3d45d83ea11c8d707a": "0x04000000000200000000000000000000000000000000096d696368616c6973001b68747470733a2f2f6269742e6c792f6d696368616c69732d696e00176d696368616c69732e66724069636c6f75642e636f6d00000d406d696368616c69735f6672000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471408f29307d17340ac7e88d4cdb23702f9bd21d16a968463ac7e1f5272835d72b05e2224612d46222a": "0x040000000002000000000000000000000000000000000749736162656c0000000000000d40737573755f63727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471408f8525d1428358322a7a0d6570fae451f9ecf96564485fbbd451d2d1512e0c3e8b865ad4702091a": "0x0401000000020000000000000000000000000000000005496e676f0b496e676f2052756562652168747470733a2f2f7777772e6b696c742e696f2f7465616d2f696e676f2d7275000d696e676f406b696c742e696f00000b40696e676f7275656265000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140906d8a2ac7d524584a61bd5f070a257326ab2b012a19d36b9ff5b53471a44420687484ad2070828": "0x04030000000200000000000000000000000000000000084c617572656e74104c617572656e74204b6f65686c6572000017616d6972616c6b727970746f40676d61696c2e636f6d00000d616d6972616c6b727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714092e30bbc1252c51b031bd2bb49eab8e971d4734110faca76ae52998450b0f23ef46029277a1e539": "0x04000000000200000000000000000000000000000000054f544152134f746172205368616b617269736876696c690011406f7461723a6d61747269782e6f726700000011407368616b617269736876696c693237000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140932ed16a6ce31dbd08450b51426556a9e61b8e928b97c6075d95cda58b433fdfca36a2b69d9766b": "0x00000000000000000000000000000000000d43485249532043525950544f0000000000000d404348524953435259505430000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714097e95a7fbccc3c012d761ac11e70c35595d382a0c860bb0501ab0690df6c9f96ea7179b206c1d40": "0x00000000000000000000000000000000000a4669676d656e742038001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714098de700b0bd1b5ca2656a3bbbea71626facc2641a9d9f744c87c393778020354714974894b7b27a": "0x0400000000020000000000000000000000000000000012536f6e6465722056616c69646174696f6e00001d40736f6e64657276616c69646174696f6e3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140998feed74b871672c1a1173d90dfb10b0dce7544381ae4b6e7d46ec1506ec6052eb221a62d1dd18": "0x04030000000200000000000000000000000000000000074f6461696c7900000014636f6e6e6965406f6461696c792e656d61696c00000d404f6461696c794368696e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471409ba869b7efed68f24973457b12e9d08e7dc0b0f255ab508e1829c66f6d2e6c4cb94acda5a00ab5c": "0x04000000000200000000000000000000000000000000094d6f72706865757300000015696e666f40706f6c6b612d626c6f636b2e6f726700000e40636861696e616e646d6f7265000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471409cedc84fed5609d6c1c40574832dee06228c10e43537fe6b3bc4cc78cdb7d34d1586d8904d8fa7b": "0x040000000002000000000000000000000000000000000447696f1147696f76616e6e7920476f6e676f726100124067696f79696b3a7061726974792e696f0e67696f407061726974792e696f0000084067696f79696b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140a2cec7af82c6d22d22f4b3f7a9f0878a49954e7b4491ca841f68831c2e8aeb383cd79dcdc00295b": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f361042494e414e43455f5354414b455f36000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140a4cb53b517606bc609164cfbfa54bc46f2e6421980f9e50a7b21d1e2c4b8a9ecb82e08d94555190": "0x0400000000020000000000000000000000000000000007444f54696e730000000000000b40446f74496e735f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140a6e3cf2b2ed68b7f476394d38a2202be9ac84607ce7fa0a7a53981920999c231210fda7fca36041": "0x040100000002000000000000000000000000000000000a456e636f696e74657216456e636f696e746572204173736f63696174696f6e1668747470733a2f2f656e636f696e7465722e6f72670013696e666f40656e636f696e7465722e6f726700000b40656e636f696e746572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140a7e8087590f806c0ef2cc1000f878a3880a09d698b5375f20c4ab3d8b3a1b783c8150faca3da65a": "0x04030000000200000000000000000000000000000000054c756379194c75637920416e6e204265726e69636520436f756c64656e0000166c756379636f756c64656e40676d61696c2e636f6d00000d406c756379636f756c64656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140a8ec5c60a74c1b9a65626bf6bd3d70916fea48c93358cbf1e97f4f7f5ce8d5a292719e2555de66b": "0x040000000002000000000000000000000000000000000e4c6561726e506f6c6b61646f74001a68747470733a2f2f6c6561726e706f6c6b61646f742e636f6d00146c6561726e706f6c6b61646f7440706d2e6d6500000f404c6561726e506f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140ae0ef8597bfb78fd6ebcc75c7ea9a0c4459162b495e90c7ed5306e3a27f73125d6fbd2a34601323": "0x04030000000200000000000000000000000000000000064a6f7365701c4a6f736570204d20536f627265706572652050726f666974c3b373000019736f627265706572654070726f746f6e6d61696c2e636f6d0000094a6f736570746563000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140b3a777104037709f221049df41595b4296f7cdf47a38b5b7c3187f9cad55c48ad60277ec92ce869": "0x000000000000000000000000000000000009646f746875622d3409646f746875622d34000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140b5c5327ba564a7c86fc56ba95671116870c422992b82a701b9c1c877ec7f6c6adf080ca8be17d7f": "0x0000000000000000000000000000000000085365766572616e0c4ac3a16e204b6f7ac3a16b0000186a616e2e6b6f7a616b3031303740676d61696c2e636f6d00000d536576693532313535353036000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140b70260c8fbe02026c4013c3ada90b00a5c2241cec6165e96958ef1a9884c15a981f86e48b0fc102": "0x0000000000000000000000000000000000094d61787061696e6e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140ba79531536753bb707c94e3ad62ed919cf1eebeffe3381161c4daef849a306d698539931a08ce14": "0x08000000000201000000020000000000000000000000000000000011576f6c6645646765204361706974616c0000001768656c6c6f40776f6c66656467652e6361706974616c00000a406d6f68616b616772000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140bdbcf3faf64bc3f787be6b11ece98c192f5e1fa41c880db0318fe885f614eddf69ffa040b3e9031": "0x04000000000200000000000000000000000000000000044d54430000001b6d696e647468656368617274696e666f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140be961ab1f92f2a95002926543d8b8887044442834d4fd5fe3d6eb257719daefd3f2aed28eeaee69": "0x0400000000020000000000000000000000000000000009506172616d69746f00001540706172616d69746f3a6d61747269782e6f726715737570706f727440706172616d69746f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140bee7f7b3d6f8bb6dc1bc0568b4f02bc9e8105e9dd9543235232d321b4b46da86eb8f94bb4de8714": "0x040000000002000000000000000000000000000000000d4272696c6c69616e74696e65000000156461726b6d697361343340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c1cc8d36c3db95466f2c9fd9d1c3919443e6d6312f7c281d32ce1978c4a72c0dd6518ccd3cef503": "0x04030000000200000000000000000000000000000000105468696e6b57696c6443727970746f13456c697a61626574682042726f776e696e6700001c6562726f776e696e672e636f6e74656e7440676d61696c2e636f6d0000107468696e6b77696c6463727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c20ce18ec5a3b0022cd6deb3ac44803aeca3cf6543a69eaaab049069eb05231f598c324c2ef0b17": "0x000000000000000000000000000000000016506f6c6b61646f742050616c6c6574204772616e7415524d524b202d2050616c6c657473204772616e741168747470733a2f2f726d726b2e617070000c626440726d726b2e61707000000940726d726b617070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c388ae01faeb42e58be8a938b93a1a251a20a38240e235a5d62c1093c0cb9290e4567fad087606f": "0x04000000000200000000000000000000000000000000064569676572094569676572204f791268747470733a2f2f65696765722e636f2f000f68656c6c6f4065696765722e636f00000a4065696765725f636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c41e5ffb19e12ae30a11a36a48739b8fa4bee6844af919e22aa50f114f9e395a1caec59cc157102": "0x0000000000000000000000000000000000055365756e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c4559f7a17cb073568191edc1aaf4bea93b17cf53ea49ab78e2d25d83dec8581854be93d3bc9609": "0x040000000002000000000000000000000000000000000f4c6f72656e6120426c6f636b7961000000166c6661627269733139373440676d61696c2e636f6d00000a40424c4f434b59415f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c460df68c43e5ce000356a196f8dfaf9356be2697eaaf5e37f110668bb3caa503a52a223bc0ecd7": "0x00000000000000000000000000000000000c526567656e63792d3030321757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c7c6da4442b90353296c9b3a6546d2319a764e00e1126215b776cb27571db2ef0392bbfbc66d45f": "0x040000000002000000000000000000000000000000000850696f6e656572001568747470733a2f2f70696f6e6565722e6d6f652f144073616368696b303a6d61747269782e6f72671c70696f6e6565722e76616c696461746f7240676d61696c2e636f6d00000e4049686f723037303534383635000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c7d3455667b833b7e5992abc613a36e614c1d17c32342d365f9a66d57adeb96092e94a8cb7ba64a": "0x0800000000020100000002000000000000000000000000000000000b4e6f64616d61746963730f4e6f64616d6174696373204c74641768747470733a2f2f6e6f64616d61746963732e636f6d14406162633a6e6f64616d61746963732e636f6d13616263406e6f64616d61746963732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140c9893ff555d916a508e92a4d4441736fba8bf0d9ab8ab258031112be9bb9cd8e91cd11d2f806512": "0x040300000002000000000000000000000000000000000a556e636861696e65640000002173706f6e736f72736869707340756e636861696e656463727970746f2e636f6d00000a6c617572617368696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140cb42537605572168a8bc181a8b2a5e27a7c66051fe9119875f4c5718cc808aaf2258b4b2fa37832": "0x0400000000020000000000000000000000000000000005616c696e0a416c696e2044696d61001040616c696e3a7061726974792e696f0000000009616c696e64696d610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140cc8f64bbd2e71ea820050e114404eec82932c59bedbfb6c1b58981e8f85af37e5d4f26a34226960": "0x040000000002000000000000000000000000000000000d6d6173746572737061726b7900000014642e6a2e626f6f726440676d61696c2e636f6d00000940646a626f6f7264000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140ce0f91c97c65aae744be50accad162e5162a2499a897f5cfd792e0ebf9ca6ed7d13b5e404b36007": "0x040000000002000000000000000000000000000000000b536e6f7762726964676500001d40776861747265676473666f64726a6b673a6d61747269782e6f726713616964616e40736e6f77666f726b2e636f6d00000e40736e6f77666f726b5f696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140cf87334458780db58a47ac1485804eba1da4f4bad5d245535ed92c81aad8a15ce849f7474685604": "0x040300000002000000000000000000000000000000000e4361726c6f7320536177616b69214361726c6f732053c3a97267696f204d6f74612053696c7661204a756e696f720000166361726c6f736177616b6940676d61696c2e636f6d00000c6361726c6f736177616b69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140d09678fc53ebff9b6ab520cbb6fe9b6bc5433fa4193074bd1aae212f0dc969d6af584e140a08a5d": "0x00000000000000000000000000000000000d52616d70204e6574776f726b0f52616d70205377617073204c74641568747470733a2f2f72616d702e6e6574776f726b184072616d706e6574776f726b3a6d61747269782e6f726715706172746e65724072616d702e6e6574776f726b00000d4052616d704e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140d670abd53527a0c5839fa7a9242c404eaf4128cc218e3ca90ebb90c542994a19c3adcdd0bab4257": "0x040000000002000000000000000000000000000000000a4163616c61204454520000001468656c6c6f406163616c612e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140d8e58a290cc0d407460ac178015d2a7c289bb68ef9fdaac071596ab4425c276a0040aaac7055566": "0x0000000000000000000000000000000000087a6a623038303700000000000000087a6a62303830370000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140d9954f2f20d04e36495827bfe0b07d16c549eb10d7e45997e95788be44a3f277af6befec99fe62f": "0x0800000000020200000002000000000000000000000000000000001052414449554d424c4f434b2e434f4d001868747470733a2f2f72616469756d626c6f636b2e636f6d0015696e666f4072616469756d626c6f636b2e636f6d00000d4072616469756d626c6f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140dbcaadfd532d03b7a0898a186215e4295a37c12f14b3c092ac526e0d3f132112fe33983e11f7a62": "0x0000000000000000000000000000000000066b6974616900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140ded91512786b3a62ccd1ada7e7fc4068a8d69ce621b8355378b362608bdd3f65524c1e401e6433c": "0x040300000002000000000000000000000000000000000b546f6b656e67756172640b546f6b656e67756172641668747470733a2f2f746f6b656e67756172642e696f0016636f6e7461637440746f6b656e67756172642e696f00000f40546f6b656e67756172645f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e032212504d7709ba57da1251d785b2d433ca687c510a82c284826b9b79859b5774a84f7000e928": "0x040100000002000000000000000000000000000000000ef09f8fa2204d49444c2e646576001168747470733a2f2f6d69646c2e64657610406f6b703a6d61747269782e6f72670f68656c6c6f406d69646c2e64657600000a406d69646c5f646576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e08049fd14356105076e12e0065c3750fbeb83fa35368cbb09af42967eb6a473ff3a357b2b51f5d": "0x00000000000000000000000000000000000c6e616d2073616e676a696b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e21e0ca3b18ddaef4c583b1fe10e634547f909f678b4b8f5a98bea24645127b2eb9fd7b3e6c2f5d": "0x0000000000000000000000000000000000096d6f6c636861696e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e22e33a70eea1beac11e708ac83a57b6e870a4ac9e5b58bd1d247f0183810abacf548469140884e": "0x00000000000000000000000000000000000970617374614d616e164d6f6368616d6d6164204875736e692052697a616c1968747470733a2f2f6963616c31302e6769746875622e696f19406875736e6972697a616c31303a6d61747269782e6f7267156d6f63686875736e697240676d61696c2e636f6d00000d406d6875736e6972697a616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e23dcd64ffcda7f562e0d94ffb8e2492e12fa0f02bc1afa0d2cec3b3309a19337fd653ec4d81e64": "0x040000000002000000000000000000000000000000000e4e65756b696e6420546f6b796f0000001168656c6c6f406e65756b696e642e6a7000000c406e65756b696e64696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e6e902c97ee9286b42bde3f29708150bd47382f10fa4eba1c27a068653cfc4e3787b7fe05fe6e7d": "0x04000000000200000000000000000000000000000000064b495a4f53000012406b697a6f733a6d61747269782e6f7267156b697a6f734070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e7a2d3832f0ab5118c044557335d26c3a538ec7a2699ef5665cca1d17755cd6ae53d41f5bf31623": "0x040000000002000000000000000000000000000000000a5a6569746765697374001668747470733a2f2f7a65697467656973742e706d2f001361646d696e407a65697467656973742e706d00000d405a6569746765697374504d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e8195af2fbb9bd3b491f0fd140dfbae6ba14572b9b7e8bea724b9336dea4bde7f0eae9082e2682f": "0x04030000000200000000000000000000000000000000084648455741534d084648455741534d0000177465616d2e6668657761736d40676d61696c2e636f6d00000d4064616f67616e6774616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e8757f9140fa0d4f4c6e1ea78fa82de3a28d27e20c93b4b8109fd93489d864a73fe7bd4eadf2061": "0x000000000000000000000000000000000010496e73696768742046696e616e6365001368747470733a2f2f676f7374616b652e696f001577656e6a756e6438343940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140e9a3c3e586a908f8122315b758fe65626b7d0f7c8f5d0758b235f22df56cbf73610916a88520efc": "0x00000000000000000000000000000000000b43656e74726966756765001668747470733a2f2f63656e747269667567652e696f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140eb83f2c7db87e68e043d8f7872cd895f8957c9179c4264816be3e649713cb3bdc523f752602cc3a": "0x0000000000000000000000000000000000075374616b6564001268747470733a2f2f7374616b65642e7573001073616c6573407374616b65642e757300000b407374616b65645f7573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140f0643da4d7eac3d003c529dadd597907deb794cab14c863e0cfb1b47af09120efdda16fe432ca54": "0x00000000000000000000000000000000001443594420506f6c6b61646f742057616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140f16205ef17fe25d2eeb1a6884bf369c7d1ab3f9ff75b79dd0f6c6a9792834e026a8d2f7ef049e4d": "0x040000000002000000000000000000000000000000000a5354414b4550494c45001a68747470733a2f2f7777772e7374616b6570696c652e636f6d16407374616b6570696c653a6d61747269782e6f7267147374616b65407374616b6570696c652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140f5707a84539a93930e3f26094a2536e02b6879a2a92752493302d84029b80ff449eba8b9dd80d1d": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f381042494e414e43455f5354414b455f38000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140f7af1c09d518a3034d65588960a9500acf14d5d58a4bfff1a29d55e99e3079304028f13fa462a6d": "0x0403000000020000000000000000000000000000000012416c65782044696d697472696a6576696318416c656b73616e6461722044696d697472696a65766963000014636f612e64696d657340676d61696c2e636f6d00000c40616c657864696d657337000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140f848aa6535dc8a065a99d8b861ad966394cfe1fc291e7cbd3a0392b293ebaf2ed64f6bbd7294c4d": "0x000000000000000000000000000000000015506f6c6b61646f7420496e746572204d69616d6900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140fa2c1f54780ff56b08f31c5b83a67cd2b4014b513dd4cfa4ecfd32c22f0cd35a8d0d1639c3a3472": "0x0000000000000000000000000000000000154372797374616c696e202d204d6f6f6e6265616d00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140fc514eab423f9a784434de779e5fcbe6da08b123b0d1556c5ded43cccd6a9b1f6efdc9ea4942032": "0x040000000002000000000000000000000000000000000f4b75732056616c69646174696f6e00000016686579407468656b7573616d617269616e2e78797a00000f405468654b7573616d617269616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140fc7663bef7fa5771cd527641e7070529937a78c02fb4de29f1d210908ad654cfc32c1ba930c6d01": "0x000000000000000000000000000000000005636f6c64001768747470733a2f2f6172626973797374656d2e636f6d0017636f6e74616374406172626973797374656d2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047140fd49b70acd3290232d4d1b0dcef676d9a72f6abf9aec55e129ef2de135ac172e19c28a9adbcad0b": "0x0400000000020000000000000000000000000000000012506f6c6b61646f7420476f204c756e617200001a4063727970746f676f6c756e61723a6d61747269782e6f7267196e6f74696669636174696f6e7340676f6c756e61722e696f00000f4043727970746f476f4c756e6172000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410045954da3b77a48c73df5e3b5d0720799fc9d422df981bfcdb7e2daf5fda64098f433317f66481": "0x000000000000000000000000000000000010506f6c6b61646f74204d657869636f00000018646f7473616d616d657869636f40676d61696c2e636f6d00001140506f6c6b61646f744d657869636f5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714102a55fef2f92ecdaa6411ebaa64db799c310fc729b4bbfe823f8e5365370d8905db1782495e630b": "0x040100000002000000000000000000000000000000000750617472696b001468747470733a2f2f6170696c6c6f6e2e696f2f194070617472697a696f5f626e703a6d61747269782e6f726715636f6d6d756e697479406170696c6c6f6e2e696f00000e4070617472697a696f5f626e70000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714103932d4af94b6477a3da336bc10786809ad364ed466f2ac0b224e5979f428cc2d420fb2c1643c45": "0x00000000000000000000000000000000000c506f6c6b61646f7447435600000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714103c17ca46c08000ea05f87e141ce5a6f38702929411405799a18e69128fafd24e849444072e5d6d": "0x0000000000000000000000000000000000084176656e7475731c4176656e7475732050726f746f636f6c20466f756e646174696f6e1868747470733a2f2f7777772e6176656e7475732e696f2f0010696e666f406176656e7475732e696f000010404176656e7475734e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714104b7f3de11760cb22f82385aacb628dfcf268ed37fc6d846b03eb3fe766d31de012d888ae4a1265": "0x000000000000000000000000000000000015506f6c6b61646f7420706465782077616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141056f8490f45c33c4671360a95c3004648c6a4e52966ed2b097e68847bf729be9f8438f6973ade59": "0x0000000000000000000000000000000000056d62616a0b4d616369656a2042616a0016406d616369656a62616a3a6d61747269782e6f72670000000c404d616369656a5f42616a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714105cd78f2accd77f44899146a600cab633113021d077356a6c362899a4d40ee426fd3ab22d2ab301": "0x040300000002000000000000000000000000000000000777696e746f6e1b456477696e202857796e6e29204c656f2042617565722049494900001477796e6e6f7277696e40676d61696c2e636f6d00000b40426175657257796e6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714106a66f6a055b1e2d0f222915d0e0b32a9137413a0cf64a3fd7676b8b73236f73619147195ca5204": "0x040000000002000000000000000000000000000000000e416c7068612041697264726f700000000000000d40416c706841697264726f70000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410798f54edbd929bd60281dbd0933b5cbb571fc3177c5803f7b12f9b8193f83787713dfcc9f52a1f": "0x0403000000020000000000000000000000000000000007536f7261696100000016736f726169612e7273723240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410a0936c3defd2dc4a154ce100d43672e3cab61d2196621d0d69dccbf86d432595f2d0fc4eb5ee61": "0x00000000000000000000000000000000000d50656e64756c756d416c65780000000000000e4050656e64756c756d416c6578000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410a8fd5f177733e23640b7b7fbbecf967f99ec9516a74f9e255efa5c8529751a383afccfe936175e": "0x04010000000200000000000000000000000000000000114d61737465726e6f64653234f09f94b10d4d61737465726e6f6465323418687474703a2f2f6d61737465726e6f646532342e64652f1540616c65786b6964643a6d61747269782e6f726719706f6c6b61646f74406d61737465726e6f646532342e646500000e406d61737465726e6f64653234000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410ab4532df9af262e83e7463783cc45e410d91594a73c2ab7daf49c3cc7886c7df454bd948d1f158": "0x0000000000000000000000000000000000076a75616e363200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410baf040e7f1de1d5a2a286ee3c24f270564b3dfee5bcc553022e4affe2694c62101f00773a7d25d": "0x00000000000000000000000000000000000a73696b616d6564696100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410bb1f59d0b43521b2dc691fc657bb1b8a732fb6887984ebde8885f652ef6df372b564ea30e4c07f": "0x00000000000000000000000000000000000d4361726c6f7320476f6d657a0d4361726c6f7320476f6d657a0000166361726c6f73406361706974616c782e6d65646961000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471410fbb58c9784f416deca8beea42c6361e77eb489db4e951bb1c63f0eb85afa7827075962fa46537b": "0x0403000000020000000000000000000000000000000015546f6d61732053656e6f76696c6c6120506f6c6f15546f6d61732053656e6f76696c6c6120506f6c6f0000127473707363677340676d61696c2e636f6d0000001e68747470733a2f2f6769746875622e636f6d2f7473656e6f76696c6c6109746f6d6d7939375f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141108a7f2fbcca12cfc9fd7446ec46d27262587240fe98dbc5855bd390714f3713ef561729052154b": "0x040000000002000000000000000000000000000000000b414a204153544552494f00000016616a2e706f6c6b61646f744070726f746f6e2e6d6500000c40616a5f6173746572696f000a616a2e726563616e6100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714118564695738fc77fc3f5a249cbc860ba90c0b7322c615b0b47e360e376d85cf366ce6d7f8d9bc75": "0x000000000000000000000000000000000006504f4c4b4100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471411ce0c03039f6a489e4e7009937c56d267338762a60ed004293afd40e7c2081847c12cb63c76a818": "0x040000000002000000000000000000000000000000000744725733524b00000016726164686140776562332e666f756e646174696f6e0000084044725733524b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471411e075ceba8e3f4524112dbb17e6f83bb832ee26149c8b00cefac96a1a668ccf0645898c3c271d04": "0x00000000000000000000000000000000000c54696d204a616e7373656e0c54696d204a616e7373656e19687474703a2f2f74696d6a616e7373656e2e63727970746f00177468776a616e7373656e383940676d61696c2e636f6d00000e407468776a616e7373656e3839000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471411ec48c6e9cf67fb4cf2e774e34c3603b2428a690c058d2ab826b39a2eba4e22b3aae85f9bfa7802": "0x040100000002000000000000000000000000000000000a414354494e4f4c49580a414354494e4f4c49581668747470733a2f2f616374696e6f6c69782e636f6d1640616374696e6f6c69783a6d61747269782e6f726719626c6f636b636861696e40616374696e6f6c69782e636f6d00000b40616374696e6f6c6978000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471411f19977cb6420ff7852bd4de2d3d4207ca8bb3fd9954cfe3c6ca91e1acba438e8a70df5fbbdd91e": "0x00000000000000000000000000000000000c597572694e6f6e6475616c0000000000000d405975726970657475736b6f000c797572696e6f6e6475616c00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471411f91d41b705cb0e442758c71011edc49ef5f9297c81f905dc3e847acdee4edb87b3bda628a02044": "0x000000000000000000000000000000000012456e67656e686569726f2043726970746f0a4775696c6865726d65000020636f6e7461746f2e736f75656e67656e686569726f40676d61696c2e636f6d00000a406762746332303038000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471412060f617a53b90efa99c57636163b80492e7748882c27e82074cc76ae723804e0c8f222aa1c9879": "0x04000000000200000000000000000000000000000000144b726f6d626f70756c6f73204d69636861656c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141211d1890e7a3711586fd1cdd673dec2a5c3dea4f1f2efab11c15c6008698c3adb139a876bc0354e": "0x040300000002000000000000000000000000000000000d404f6e6c79446546694775790e416e64726577204c6966666579000017616e647265776c696666657940676d61696c2e636f6d00000d404f6e6c7944654669477579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471412255c95905b3078f2681118b778f641d6064047cb36d943cbe0761bca515f07d762768bc0205405": "0x0000000000000000000000000000000000044a6564044a6564000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141241731d14d7e2624e438b5a8c79cf1f158bae626b3fcbae0d60e4fe0a783a92a51c7a06c81c1a07": "0x00000000000000000000000000000000000b446f74456e72697175650e456e726971756520527562696f000021656e72697175652e727562696f2e646576656c6f70657240676d61696c2e636f000009406b696b65727562000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141249720e20450dc46645e03be465e70990610e0d6c978da1866dbd9c9828f6e19ef1f0e3b1d02f11": "0x040300000002000000000000000000000000000000000b7969616e6e6973626f7410496f616e6e697320507361727261730000147969616e6e69734070726f62656c61622e696f00000b7969616e6e6973626f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141257e95afd3f3529fabfc151a66d7cbd2cfebbdea1954d13fa4721a568a8086386f445c2cefa261c": "0x04000000000200000000000000000000000000000000114c696768746e696e6720426c6f636b7300001c406c696768746e696e67626c6f636b733a6d61747269782e6f72671b636f6e74616374406c696768746e696e67626c6f636b732e696f000011404c696768746e696e67426c6f636b73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141263f06b8f0929949c665073980c9bdbd5620ef9a860b9f1efbeda8f10e13ef7431f6970d765a257": "0x040100000002000000000000000000000000000000000f526f636b585f506f6c6b61646f7406526f636b581668747470733a2f2f7777772e726f636b782e636f6d0012737570706f727440726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471412d4691f7bf1f08098650252aba2203808fa1dca1f57dce2e9927b88d66f193bab53f4910b9e1c59": "0x040300000002000000000000000000000000000000001038426a4c55443366376144473766781457696c6c69616d2043726f6973657474696572000019694d723338675a3754637537786f40676d61696c2e636f6d0000114057696c6c69616d3533363436363531000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714137178bb7584275bc64c6a15649acd3f96cf450ca06d53059b6888d67456f8e7ec31c8504eb3125d": "0x040300000002000000000000000000000000000000000e477520496e73616c75627265730f4775737461766f2050726174657300001a6775737461766f2e7072617465736d40676d61696c2e636f6d00000e696e73616c7562726573627463000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471413c8717f740994a86aa8cd24ade14ce3debcf13ff5d3ce5fcecbfb2acc1c0c9c0c7b25d79d902d22": "0x00000000000000000000000000000000000567686530001268747470733a2f2f6768656f2e746563680000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471413fba91067ee782aaefd2727ec65732fec6ebfc4a824345adb093436abfd5f53e0fe421c6f5cdb0b": "0x0400000000020000000000000000000000000000000006445053544b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714140fdd346d273b4bce5395a6819c6edb4a8679a1f1b9c809de142dd5b84805e4d0a2ad428476d606": "0x040300000002000000000000000000000000000000000868616b6d61726b0d4d6172656b2048616b616c6100001768616b616c612e6d6172656b40676d61696c2e636f6d00000968616b6d61726b5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714143c9b2402368042140be3ffc8865dd47a8d044916b26936a579433599bebca9d3ba1d6eb7722710": "0x00000000000000000000000000000000000b4441524b464f5245535400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471414754c6ae34414e51eec92559de5be4295be18caa79400d49466b8b06a4c819e766a7b79ad3b846d": "0x040000000002000000000000000000000000000000000b526f73732042756c61740000000f726f7373407061726974792e696f00000b40726f737362756c6174000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714148446d6e27ad179566511e3d396022cf986a5a86d09bf77db45af3ddbae12a8bd78948072505f4a": "0x0403000000020000000000000000000000000000000009546172656b6b4d410b546172656b2041746961000013746172656b6b6d6140676d61696c2e636f6d00000a546172656b6b4d4131000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714148771da2618d248c4962b64a7f16b6af320177d041e2229ede9d4efad694b74d02be3f1cbbfdd74": "0x04030000000200000000000000000000000000000000084f6e6c79444f5400000019646f74696679746865776f726c6440676d61696c2e636f6d00000c404f6e6c79446f744e6f77000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714148cd021e35e23e4f0673d30606ee26672707e4fd2bc8b58d3becb7aba2d5f60add64abb5fea4710": "0x04000000000200000000000000000000000000000000044761761544722e20476176696e204a616d657320576f6f641568747470733a2f2f676176776f6f642e636f6d2f0010676176696e407061726974792e696f00000b406761766f66796f726b0a6761766f66796f726b0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471414b9317a39b5587ca81adb32eb83fa9f6853129997532384eb874facafcf0f717c8eb952df30491a": "0x04030000000200000000000000000000000000000000164d75466920506f6c6b61646f74204163636f756e740a4d75466920496e632e0000117370656e636572406d7566692e61707000000e406d7573696366696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471414df282ca6fd7e90be66c34c519a045956620b6c6962fa9440e79b96ee839b93b4a188d961693401": "0x00000000000000000000000000000000000653574b696d00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471414f4cb7e8e1dd98fa423f953c39a707184067af6963efe1143a155f57aa003299c45b9be12f02642": "0x0401000000020000000000000000000000000000000006417266616e1c4d6f68616d6d616420417266616e20417367686172204973686171000012417266616e6d6940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714152bf2356a6365ea3ce185c80846549d014ef1b12ab7ce5ad8931c7913208ae3fe5b206cb8d5480b": "0x000000000000000000000000000000000005444d523500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714152cd44728673f349e7c73972c8cf09884b6647f957d945a8c9109ccd4e742e843e89b343a43651c": "0x040300000002000000000000000000000000000000001456656c6f63697479204c616273e29aa1efb88f1156656c6f63697479204c6162732041471e68747470733a2f2f7777772e76656c6f636974796c6162732e6f72672f00196e69636f6c61734076656c6f636974796c6162732e6f726700000840765f6c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714153e9a548981fe578ce2fb4076ef92d3a5cac7689f4bf9c589296b99d5aa899511aff9e2be5c7a40": "0x040300000002000000000000000000000000000000000653616c61640d5361726168204c657374657200001573656c6573746572313240676d61696c2e636f6d00000f74727565736172616873616c6164000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714155306eb29d41fe65cc0cc69582f48b38baa0c7acb297580c4facad35056691f999bf3c53ae08a44": "0x0400000000020000000000000000000000000000000012736e6620646f742076616c696461746f72001c68747470733a2f2f696e666f7365632d636f6e73756c742e636f6d001d69687562616e6f7640696e666f7365632d636f6e73756c742e636f6d00000a40736e696666736b69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141596b645522e66dd2c4f99c0f8272e38f7169e264234dc13a4da815517564a538382e5828f61fc28": "0x000000000000000000000000000000000009706172616c6c656c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471415b4508e0114da171f449a820b2c7718597a61ee2aa3928e53404e89779f8d97f7a3fb341ea68ff1": "0x00000000000000000000000000000000001f506f6c6b61646f7440436f696e6465736b436f6e73656e737573323032331f506f6c6b61646f7440436f696e6465736b436f6e73656e737573323032331968747470733a2f2f776562332e666f756e646174696f6e2f001761646d696e40776562332e666f756e646174696f6e20000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471415d31b7bc7b1054023f71995b4441f187fa21b4020e925b820950705c5e4a602a16c57baf551b3d9": "0x040100000002000000000000000000000000000000001541697264726f702e636f6d206d756c74697369670c41495244524f502e434f4d0000166d61726b6574696e674061697264726f702e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471415dd65723b63fdc2f6d19b31316879ce7470aafdcb908d04dfc5c156f8de974bdd582086d0ff6030": "0x04030000000200000000000000000000000000000000075458536865700d42656e20536865707061726400001962656e736865707061726478797a40676d61696c2e636f6d00000854785f73686570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471415eee78443792d00346ebc3380be6816f828d1d1df372c51fbe99c95a321d7510403bb98f067695e": "0x040000000002000000000000000000000000000000001c50726f6d6f5465616d207c205765623320557a62656b697374616e0000001c706f6c6b61646f7470726f6d6f7465616d40676d61696c2e636f6d00000d4050726f6d6f5465616d5044000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471415f1d58f2dffcd5d7a23f1a7ce3801006e4c449d66fa97c61b6f45fff10e365e08710c0432930c39": "0x040300000002000000000000000000000000000000000653706963790000001d4d6973686f2e6b616e617269614070726f746f6e6d61696c2e636f6d00000d4d6973686f4b616e61726961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714161735619834be83b8be96d986897797d117987e4368640ffdf32bc967ba7467d012136c22dca33c": "0x0403000000020000000000000000000000000000000005636c307700001140636c30773a6d61747269782e6f72670b76406c6572792e64657600000740636c307735000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416214d11e8d53abe10f8035fd1cf87ae493a030edb707fef7c92df6a343489d06c0e242dfe43b35d": "0x040000000002000000000000000000000000000000001b4a4b5242207c20506963636164696c6c7920f09f87acf09f87a7000000196a6f656c406a6b7262696e766573746d656e74732e636f6d00000a404a6f656c4a4b5242000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141627a7ca07c7aef778dc106e241524180b2594b639d2f0eca4d41b1eb7f9e973c253402a7cd2ed4f": "0x0000000000000000000000000000000000076d6179616b610c5a696c69616e67204368650000156368657a696c69616e6740676d61696c2e636f6d00000a4030786d6179616b61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714164c857f81c668cfbc27ad8fa6f2ea276c5657bdd2c6e1c810c96975dabcdc0e4a48fe1b7c6f9900": "0x00000000000000000000000000000000001155736f206465206d756c746973696e671853657267696f205261756c204d6172636865736f74746900001473657267696f4061646c69626e65742e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416632ac54302ab493a06ba1dcdd93d70630fc8cdb68ac3e69505c4570d43ef1f110c82e0af756678": "0x00000000000000000000000000000000000631574542351757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141666dc35836cd0a48e41df7864847ec31fc0168967dd5b7912c21f4a597438c697f7f4c1a29c4d57": "0x0400000000020000000000000000000000000000000010526f636b585f506f6c6b61646f743406526f636b581268747470733a2f2f726f636b782e636f6d0012737570706f727440726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714166a46eb86ae1a6b0f1ae3ffead748e1f440e6d1a76ec495f2f9e1670fd15e737ddc2ab913b8a149": "0x04000000000200000000000000000000000000000000084c4f47414e5447000014406c6f67616e74673a6d61747269782e6f72671a6372697374616c2e726f737369383840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416709400d558465ddc20836f2e4b88c1858d1e3f918e7358043b4a8abcd2874e74d91d26c52eca2a": "0x040300000002000000000000000000000000000000000547616265184761627269656c20466163636f2064652041727275646100194061727275646167617465733a6d6f7a696c6c612e6f7267186761627269656c40696e76617263682e6e6574776f726b018550a42403112eb7e49d90abe036e1980b988ef01768747470733a2f2f6962622e636f2f66595a5a7959310c4054696e6b6572476162650c61727275646167617465730b74696e6b65726761626500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714169763ff321610ad14fd4519281e3bfda326702a0f55da78d8cff3213553f65d7bdceeff8bb136a1": "0x0400000000020000000000000000000000000000000009434f4c4f53535553001a68747470733a2f2f636f6c6f737375732e6469676974616c2f1d40636f6c6f737375732e6469676974616c3a6d61747269782e6f726716696e666f40636f6c6f737375732e6469676974616c00000f40436f6c6f737375734974616c79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714169ece2ddc0ce13e205addba4075b267f6ab1c5f8308743fe060d0aed47e018bcfbefd0f197ab52d": "0x00000000000000000000000000000000000b4c756d6f73204c616273164d75736875204d65646961205076742e204c74642e1a68747470733a2f2f7777772e6c756d6f736c6162732e636f2f00146b6161767961406c756d6f736c6162732e636f00000b404c6162734c756d6f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416c2d8d550a452fb203795f6b0bc5cf58ee69bc38f4d82278d7ae40d5c7b7ee7b6d2e8e04e2b4952": "0x04030000000200000000000000000000000000000000047377620d53657268616e20426168617200124073657268616e3a7061726974792e696f1173657268616e407061726974792e696f00000e4073657268616e776261686172000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416c32812353e2b741090ed109e1c7cdb689467b8b9a48daeb19d21473918cc6fc5632f11a261d80b": "0x04000000000200000000000000000000000000000000054475636b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416d1d6d8171d77ca767806fa170bbfc9eb86c0b65bb265c85f86e5e0bfb82525c1149a38fc6d613f": "0x0000000000000000000000000000000000054a4f4d490000000000000c406a6f73656d6d6d323337000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416ed9307fff94f1f0cc0424184702e27c49fb859c93f07d8bb0adf2a0824ada9f01db9bf76b7025f": "0x0400000000020000000000000000000000000000000015f09f8d8120486967682f5374616b6520f09fa5a9184e6578757320496e666f726d6174696b204475727265721768747470733a2f2f686967687374616b652e746563681640686967687374616b653a6d61747269782e6f72671e686967687374616b65406e657875732d696e666f726d6174696b2e6368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471416f70b3f811d00f5f08cce486eece7d4a7a3d614b7cd85586d657893f2be9df6e8e3c4f7b181bd52": "0x04030000000200000000000000000000000000000000114d696368696b6f20576174616e616265114d696368696b6f20576174616e61626500001b6d696368696b6f34706f6c6b61646f744070726f746f6e2e6d650000104d696368696b6f506f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714173972b961cdea90c49a03d9a47482fda70a5879e99da5159670949018884c6a239ec04c89f9a160": "0x00000000000000000000000000000000001244616e736f6e205477657369676f6d77651244616e736f6e205477657369676f6d776500001764616e74776573696779653440676d61696c2e636f6d00001040706f6c6b61646f74417275736861000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141774ee3fbd2aa269e0cbc3810429380ad335eb242f47acb1f4b609001af240dcbae281594d4ba522": "0x040300000002000000000000000000000000000000000f756269717569746f7573446174610f756269717569746f75734461746100001c756269717569746f7573446174612e636140676d61696c2e636f6d00001140756269717569746f7573446174615f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471417a3c17fe29895d0b4074510d7de2fe2dc843dd1f2eacc53b0c5a54b876e27af0b4eaebae9bc340d": "0x0801000000020300000002000000000000000000000000000000000947656465416e74611c4920476564652050757475205261686d616e2044657379616e7461000015616e7461406d616e64616c61636861696e2e696f00000a40616e74616b657061000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471417ca96d717d13d8f86409335c78332d6a06f712f4d3ded1e7849cb75ec083ee71f23e5477630420c": "0x00000000000000000000000000000000000b537461626c654e6f646510537461626c654e6f6465205074652e1c68747470733a2f2f7777772e737461626c656e6f64652e78797a2f0014696e666f40737461626c656e6f64652e78797a00000c40537461626c654e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471417dfa67fb23d9e4d093472713dd6fbe16b514cf07d445644396f2881d8237acb70d92055a1aaed77": "0x040000000002000000000000000000000000000000000c56616c69644f72616e6765001c68747470733a2f2f7777772e76616c69646f72616e67652e6e6574184076616c69646f72616e67653a6d61747269782e6f726715696e666f4076616c69646f72616e67652e6e65740000104056616c69644f72616e6765444f54000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471417ea45d57a104fc3f41c1aa075742a552affbe40871e68e62aec936ffae12b497e7b38d32d3eb70d": "0x04030000000200000000000000000000000000000000135a6f6543727970746f4769726c73436c75620e5a6f652046616972636c6f746800000c7a6f65406367632e78797a00000e5a6f65436174686572696e6546000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471417f2428f049676136029b5b2d1d0ff3a0a4aed8721f480386c8c866d79d86386e5780a6454cd7f24": "0x040300000002000000000000000000000000000000000a5f65636172646f356f0a5f65636172646f356f00001a65636172646f356f406b7573616d69676f732e6f6e6c696e6500000a4065636172646f356f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714181900f50b9dad51f855f52621dad2bef24b708644e05d48391ba124f93bb81149ac7f2faac64138": "0x0403000000020000000000000000000000000000000007566963746f72000000136d657461766974694070726f746f6e2e6d6500000a40566974697265756d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714188e91cee61b2febd6f3fc13608eaccd3e3c75789225fbc23963888890d5e7f806b0ccaaf90caf79": "0x040300000002000000000000000000000000000000000b4178656c4265636b65720000001963727970746f6265636b6572313740676d61696c2e636f6d00000e406178656c6265636b65726f6b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471418b47e3024d66dfe628f36dddf8cdb0242104a2531e7d3efd4860a9a4633be69aaf30f63ccb25a5e": "0x040000000002000000000000000000000000000000000b537769737320426f6e640000001c7377697373626f6e64706f6c6b61646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471418d26b3f2b895c6dc448b1c0c946fe680dc9d237c6ba6bbcda519c42dfbea7ef74b0b73f7972a666": "0x04000000000200000000000000000000000000000000095f7061636865636b000000176272756e6f2e757073697a6540676d61696c2e636f6d00000e406272756e6f70616368656373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471418e9b69f585d7a7d3c10da0654ed968b149f27cf9db0203337c79b6d86f6741f156598fb7699ab78": "0x04000000000200000000000000000000000000000000074c6179657258000013406c61796572783a6d61747269782e6f726714696e666f406c61796572782e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471418f0062e466404f0976ce4203c844a11164d1b3f8342ad16a4cc5d99ac8eaae5cd74f4b1cc68c764": "0x04010000000200000000000000000000000000000000085355425343414e085355425343414e1868747470733a2f2f7777772e7375627363616e2e696f2f14407375627363616e3a6d61747269782e6f72671168656c6c6f407375627363616e2e696f00000c407375627363616e5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141908028815102f077027fd39de5dece15c83271c7bed94615b69d3b170a8518b056ec951ef51da46": "0x040300000002000000000000000000000000000000000c446546695f5374616b65720000001d66616b656d61696c666f727370616d6d657240676d61696c2e636f6d00000c446546695f5374616b6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141909140e98d4fcdfd880b45154006c09eb568c69f1febc0dadccaa59723dcd058cdae45c9c13ae68": "0x00000000000000000000000000000000000a4669676d656e742033001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471419522f0465b284216cb2a6e7b4c6451a1a1fcf05a4545dfbda0215f15ad77851be9f7f7e94171e6c": "0x04030000000200000000000000000000000000000000104775737461766f204a6f707065727400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141954fe85b0e70adcff2ce23cb974ce041c73878aaf0d84454faee2b798569727d81703996c370fc7": "0x040000000002000000000000000000000000000000002057656220332e3020546563686e6f6c6f6769657320466f756e646174696f6e2057656220332e3020546563686e6f6c6f6769657320466f756e646174696f6e1968747470733a2f2f776562332e666f756e646174696f6e2f001661646d696e40776562332e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714195552a14ebe4e24a6fabeb7a687bcc4705cd5d8cc3ac91adb6460d20d4d65b90ec3ce20be966554": "0x040000000002000000000000000000000000000000000659616f7169000018406a696179616f71696a69613a6d61747269782e6f72670f7940616c747265736561722e636800000a406a696179616f7169000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471419627e3b0a1fe44f466a9934facf9723f7ecc237cf0afaca23a6e832780616e432f3eaf19d8ff949": "0x040000000002000000000000000000000000000000000b5354414b45204c494e4b0b5354414b45204c494e4b1668747470733a2f2f7374616b656c696e6b2e696f2f16407374616b656c696e6b3a6d61747269782e6f7267116f7073407374616b656c696e6b2e696f00000d407374616b656c696e6b5644000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714198703ff0791c2de1e30aa51ad68b8918d2c46e914986818c111bee03582610cbc9fb73fe0e4c413": "0x04010000000200000000000000000000000000000000094741544f544543480d4741544f54454348204c54441468747470733a2f2f6761746f746563682e756b15406761746f746563683a6d61747269782e6f726711696e666f406761746f746563682e756b00000d406761746f746563685f756b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141998ecfe5c3f796158c941d90f219cf41ce169f540c96936193fbfee601c0e9ae6e415c75a8f80d8": "0x040000000002000000000000000000000000000000000f426c6f636b7365656b65722e696f001768747470733a2f2f626c6f636b7365656b65722e696f1b40626c6f636b7365656b65722e696f3a6d61747269782e6f726718706f6c6b61646f7440626c6f636b7365656b65722e696f00001040626c6f636b7365656b65725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141a0b756d13ed752dc09033af1dd99c3727bd222c35d9d34e8e4403441792399b08df0d60544fbd48": "0x040000000002000000000000000000000000000000000f4c75636b794672696461792e696f000018406c75636b796672696461793a6d61747269782e6f726714696e666f406c75636b796672696461792e696f000011404c75636b794672696461794c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141a2ca5d095126893b82dc797d2ab47107b7b50397e46dfeb1d962737c349863f8682a86e1fd2630b": "0x00000000000000000000000000000000000e53616c616820506c6b61646f740000001273616c6168313540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141a61ab35fd1e09085e34b19d7230f1ea5da6d4b8fe6ede9d05c2e55b0189f75b967862c1c43d9a1f": "0x040000000002000000000000000000000000000000000b554c5452414e4f44455300001740756c7472616e6f6465733a6d61747269782e6f72671976616c696461746f7240756c7472616e6f6465732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141a870c80f78975df4411ac181d7ec3d63ac2c53bbcc41d8721f9f99f6090c51f463cf91b74eefe57": "0x00000000000000000000000000000000000d79757669616d656e646f7a6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141aa91021c24f2547e098dc986d4fd3a45b360314403a0baadce5da87c260eb1422da793fe623b16a": "0x0000000000000000000000000000000000174665726e616e646f206375717569206d61727175657a00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141acc24036266de3356937386a873382cb01abd0d0b223ae40790ebe0e97d8a06b7236640c865b730": "0x040300000002000000000000000000000000000000000e4372757374204e6574776f726b0e4372757374204e6574776f726b1768747470733a2f2f63727573742e6e6574776f726b2f0016627269616e77754063727573742e6e6574776f726b00000e4043727573744e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141b08960e386dd5cbd55ec415b6703ddf7bec9d5c02a0b642f1f5bd068c6b3c50c2145544046f1491": "0x040300000002000000000000000000000000000000000652304755450d523047554520494f204c54441268747470733a2f2f72306775652e696f2f000000000940676f7230677565000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141b0d7ea318c4d6a0223599480908ad0aa988a0b81a5799a32d32b2e81c79cea35ad07f78397d7b17": "0x00000000000000000000000000000000000b646f746163636f756e7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141b324457916228d02f944a1d1c5688dd06bc0335fb0bb058fa7fb2805a4247047dbbbc6c15121bc9": "0x040000000002000000000000000000000000000000000c506f6c6b616c79746963730000001d746f6d6d692e656e656e6b656c40706f6c6b616c79746963732e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141b4a951e7e2e12e5120f229aaff8334243bbf1867e7ac4f3d7e016ca3af627bd551380f3dd756456": "0x040300000002000000000000000000000000000000000a426974736b77656c6100000014626974736b77656c6140676d61696c2e636f6d00001e68747470733a2f2f747769747465722e636f6d2f626974736b77656c61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141b6b2384d0a5895de2978ce4a089bab55731feb84c485c99b42362de314df66dd9afce844283432e": "0x00000000000000000000000000000000000e504f4c4b41444f5420504c4159000000166e69636b40706f6c6b61646f74706c61792e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141c24b3930fc8ca702a93f3f741525a17c26c491b229fac443dc2f185f69923b19d3041955c311056": "0x040300000002000000000000000000000000000000001344656e69732053756b686f7665726b686f761344656e69732053756b686f7665726b686f7600001d64656e69732e73756b686f7665726b686f7640676d61696c2e636f6d0000000007636b636e696b00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141c6684bc5e5975f29a8ead39ce1b44f37d16e98496441be79018e910d5f58c0fa1518d8fd7749550": "0x04010000000200000000000000000000000000000000135354414b494e4720464143494c4954494553185374616b696e6720466163696c697469657320476d62481f68747470733a2f2f7374616b696e67666163696c69746965732e636f6d2f001b696e666f407374616b696e67666163696c69746965732e636f6d00000c405374616b696e67466163000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141cb765d78beead8b7682d70550e153859a2f48dbaac25db251799fcaa8fa084eed3ab73c0ce5273b": "0x000000000000000000000000000000000013444f54205374616b696e672077616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141cca28a5e0eadb1e008bf964db02d6018d0f97514170c4418103da670129723ca8547f5e4afa6536": "0x040300000002000000000000000000000000000000000e63727970746f766171756974610b766963656e74206d617300001863727970746f7661717569746140676d61696c2e636f6d00000f4063727970746f76617175697461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141cd490d2ce0d345b5ec41f11b9d98e7422174148cd748dbc7c5eaffb239b0946de4c1bf43db72f23": "0x040100000002000000000000000000000000000000000c61646173747265616d65720f457567656e65204b68617368696e00001b657567656e654063727970746f70726f63657373696e672e696f00000f40657567656e656b68617368696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d035207463779a168272c6f3753f3c797d830406e26815ed5c71ab453d6312d92e53651cf8d2c11": "0x040000000002000000000000000000000000000000000854726162616a6f00000000000011404e6f74696369617354726164696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d1cefdb9f26986204d7b7a1ea1cca728d31978c3822f4ddb7b2deb804107e7e709d6ee451c11633": "0x040300000002000000000000000000000000000000000447756b124765766f7267204e6172696d616e79616e00001e6765766f72672e6e6172696d616e79616e393040676d61696c2e636f6d00000e406e6172696d616e79616e3930000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d3399c309aa965a62bac995e1409297460e9ba42a01bba4c01e2740fcaea01950402ee0a51f8022": "0x00000000000000000000000000000000000b426c6f636b6368617365000f626c6f636b63686173652e636f6d000000000c40626c6f636b6368617365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d458f26330fbe568079c5a78a4d63fea543b4c9feece4cc9fcd4aaa2b94ac5761807ea945bd2d05": "0x00000000000000000000000000000000000d53696d706c652053617261680653617261680000186a61636f62736172616836323640676d61696c2e636f6d000010404a61636f6253617261686a61636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d4a91a318b45894505a23b381677c7a05a7fe603b023c341b955e2ad03a1398dfd9b85f3c3ef855": "0x0400000000020000000000000000000000000000000009526f73616c696e6400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d7bc19ef441935b0e03cbf394247c7def2b4020688ed95a6eb61c538eefd92963c448e06a50671b": "0x0401000000020000000000000000000000000000000009434f5645524c4554001468747470733a2f2f636f7665726c65742e636313406164653030373a6d61747269782e6f7267136c756369616e40636f7665726c65742e6363000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d8084584a6038ad15a31019bfea7696aa19e004843f73dfd52cd68e9c26a3e29861e55adb900af3": "0x040000000002000000000000000000000000000000001d536f6369616c204d6564696120456469746f7269616c20426f617264001d68747470733a2f2f7777772e706f6c6b61646f742e6e6574776f726b000000000a40706f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d81ee99b6c993e4ca88fe90d5326a97bf01b05083be12b10bd75699ac4107e65c1de1744d209679": "0x04030000000200000000000000000000000000000000155068696c69707065202d205461704e6174696f6e135068696c69707065204c656e6f726d616e640000217068696c697070652e6c656e6f726d616e64407461702d6e6174696f6e2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141d8662dbe62ffc1aae145910fae8147b2d325cdbf3a537a12be32f3874815d076d4820bfe97fc63f": "0x0403000000020000000000000000000000000000000006546f6d6d7900000012746f6d6d7940626173656461662e646576000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141db941c89bca443c40ff75e9f6e5eea6579fd37a8296c58b0ff0f0940ea873e5d26b701163b1b325": "0x0400000000020000000000000000000000000000000017536e6f776272696467652042656e656669636961727900001d40776861747265676473666f64726a6b673a6d61747269782e6f726713616964616e40736e6f77666f726b2e636f6d00000e40736e6f77666f726b5f696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141dd4b5b7695b46cd6cd1ffb6ec4677378b3f276ccd6d84e9eb156dc4105eb7e997d9a3604b75420d": "0x040000000002000000000000000000000000000000001259756c696120f09f91a9e2808df09f92bb0000001973746172747365762e79756c696140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141de25a6a6996407006e496c8f09c262953449758d1ac4299ab148c657d2b41eebe82a3c89b576b20": "0x0000000000000000000000000000000000104142524148414d204d554749534841084d55474953484100001c6162726168616d6d75676973686134303140676d61696c2e636f6d000008404162757a7441000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141e1b6c66b87b23257061ec410d336d832362341e983a7e48d0a68898840cf5e94e08aab0fed41010": "0x040000000002000000000000000000000000000000000e4d4f5449462e4e4554574f524b000019406d6f7469666e6574776f726b3a6d61747269782e6f7267124e494b404d4f5449462e4e4554574f524b00000a406172746e61756b61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141e681645b60ebbd6a2b06daf782fa5142e365d1fea0f4a418687f53f201f185bf314c37581677b37": "0x040300000002000000000000000000000000000000000b436967636f6c61496e63074a756261204b0000126472696e6b40636967636f6c612e636f6d00000c40636967636f6c61696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141e7f051b9f457ae97cd5336d50ec2652a90f89edaa708f0952cc7b4e95f16d3e632f4488a4e42423": "0x040300000002000000000000000000000000000000001154686520576869746520526162626974054d696b65000018746f7272652e6d696368656c6540676d61696c2e636f6d0000114074686577686974657261626269744d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141e9ee92c6f734ec81a6c1bbf22454cf45f27a51e603ca304242ddac6f1013af1c9611a01a3910115": "0x00000000000000000000000000000000000b446f742077616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141ea22a62585a79397e2880bf2b632d5832327b8237a447ed48dca728c2afa80fca610b3477c35abd": "0x0400000000020000000000000000000000000000000013506f6c696d656320466f756e646174696f6e13506f6c696d656320466f756e646174696f6e1968747470733a2f2f7777772e706f6c696d65632e6f72672f0011696e666f40706f6c696d65632e6f726700001140506f6c696d656350726f746f636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141f09c884077a085e9277a4f83997f9675c5554349860c719769f71b634a9ecd0bf63dae7cff0ad69": "0x0000000000000000000000000000000000027700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141f111b5054813a93cca76bb38fecfc6a03024af5ae8c655763f9eab8fff50719ac43ff0c59b0db5a": "0x04000000000200000000000000000000000000000000116c696768746e696e672d737472696b6500001440736d6f6b6532363a6d61747269782e6f72671c616c6578616e6465722e6672656562736440676d61696c2e636f6d000011406c6962657274617269616e313937330012616c6578616e64657273686174756e6f7600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141f4321336da7ceadf4d95d4c5c0131969148d3a16b3d95ab3d051771d971a1955d7e745b0a3a4f16": "0x040000000002000000000000000000000000000000000e5044505f56616c696461746f7200001440706176656c64703a6d61747269782e6f726718706176656c2e627574656e6b6f407961686f6f2e636f6d00000b405061756c4241636944000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141fda62d62fc07febbc1deacfc7e5c6e5f0373560c14fbce156ff2a0ed7e208d049ccd985dec85545": "0x040100000002000000000000000000000000000000000d47656e6572616c2d4265636b0444656e1b68747470733a2f2f63727970746f2d6d61747269782e696e666f194047656e6572616c2d4265636b3a6d61747269782e6f72671767656e6572616c2e6265636b40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047141ff990588b6880e4ea9f463588e498f46933a45b834e10273cfbcee3d2e44c8d15072052b669b143": "0x040000000002000000000000000000000000000000000e4a6f656c20f09f87acf09f87a70b4a6f656c204b656e6e791c68747470733a2f2f6a6b7262696e766573746d656e74732e636f6d00196a6f656c406a6b7262696e766573746d656e74732e636f6d00000a404a6f656c4a4b5242000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714203ca9c500dfca7c383d052b70007f5382342d61205c50e75336c57eda16b84db766278420ada25a": "0x00000000000000000000000000000000001144617669642053202d204c6f67696f6e000017406461767363686d69747a3a6d61747269782e6f7267156461766964406c6f67696f6e2e6e6574776f726b0000094062655f64617363000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142057c2e1894e9a819e92823bda563f6821bc3b7af00917608d454dfa89de101414ee0b51ac3ab57f": "0x040000000002000000000000000000000000000000001054755072696d6572426974636f696e0000001a676572617264706c616e656c6c657340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714205f8d2645ea3f1a78dae380bd96b96f6218851036432b300b0fbd65763f51278903922ed7163844": "0x00000000000000000000000000000000001777697a61726420616d69676f73206d756c746973696700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142067c893ca23078d2899477496b6c390ee6a83d1e533d860d1ed9d3093e9f74103185879c65de25b": "0x000000000000000000000000000000000007726f694c656f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142074c595e55b069dda0feab49605a4b3cc1344b4d926d20852341d1796566a524d83781bb3111053": "0x040300000002000000000000000000000000000000000a526f62696e486f646c0000001e726f62696e686f646c36393432304070726f746f6e6d61696c2e636f6d00000c726f62696e686f646c3639000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714208f193ba8c59a98eca90d099f8bbfc41261759f0474d3f613d1d83f0a6cb910e15abe2f95cbab4f": "0x040000000002000000000000000000000000000000000844465f5465616d0000001464617070666f72636540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471420a737060c3110efd67d1cbe5bda2d5975130656f1f799398b018fd40a09a5c86b2026f69fdacb56": "0x040300000002000000000000000000000000000000001043687269732040204772616e746564114368726973746f7068657220576172641668747470733a2f2f6765746772616e7465642e696f00146368726973406765746772616e7465642e696f0000094063616c6d726174000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714210b26b3351f6a65f06a37a8628769bafba50c0ecd085dd7fe574949e013ee737c9d6671e59b8513": "0x04010000000200000000000000000000000000000000084b726177696563000015406b7261776965632e3a6d61747269782e6f72671c6b7261776965632e76616c696461746f7240676d61696c2e636f6d00000f404b7261776965635f7374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142132d2b9d69b1260a8300f53d9cda28b136491a9b18b937eae584f7f08fbb6aac29e0ea38e38f864": "0x04000000000200000000000000000000000000000000104c65747261734372697074696361730000001a6c657472617363726970746963617340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142162588dd88d3a33aa48a9775be7af0521acefce054dc7e9e461814dc167a5cabf52aef8534d8249": "0x04030000000200000000000000000000000000000000194c6520436f6d7465206465204d6f6e74652d43727970746f000000126d6e746372707440676d61696c2e636f6d00000c40506f6c6b614d61726f63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471421a2450da5997cedda95b7b5c463b7d00700c34294c283a21235f8d31377620dcd1a56bf60f3e320": "0x040300000002000000000000000000000000000000000853494d2d444f540000001873696d6f6e6a6f73656c6c40686f746d61696c2e636f6d00000a4073696d6f6e787065000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471421c356d070c125b4b4c0a3bbd567cf9fe5e5ad607debd6e89fb31a294288f94ab2490aebd03ed306": "0x00000000000000000000000000000000000750617265746f0750617265746f1368747470733a2f2f6a6564736164612e696f00157265616c70617265746f40676d61696c2e636f6d00000c407265616c70617265746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471421f2e65cb5d0a0be1c95e1f32ddc271b9161da11a343f31619b38dc9f3d966d2624376549ae1da18": "0x040300000002000000000000000000000000000000000b4f5253454e5f5345414e0d5365616e204f5265696c6c79000012736f7265696c6c79406f7273656e2e636800000a5365616e4f5253454e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714222fa12fb4681a4d0e47ff458bb2f80c4bc89a6a7bd022a555e9c1bc719726f475f8a1841428832f": "0x0000000000000000000000000000000000097261676e61726f6b0f4e6568656d6961204b72616d65721668747470733a2f2f706f6c6b617269636f2e636f6d1e406e6568656d69615f736f72616d697473753a6d61747269782e6f7267186b72616d65726e6568656d696140676d61696c2e636f6d00000f404b72616d65724e6568656d6961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142230ad1e2bae6213b218a07558705ee2b86d4f2988e708454452b7d2efc237b95e139630e04f6116": "0x0400000000020000000000000000000000000000000009437269735f5061700000000000000b40437269735f50617038000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142231d8f9634359403e2a0c8a13611c5eb6921612ecd1a2d7d6c1525a3723956c1c6193e3e2901f3e": "0x0000000000000000000000000000000000134b657672657620506f6c6b61646f742e4a5300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142237e0f9b0ff0758161378b7c016bd381841b01d1f20e66cc5ba9ead421638045c5ba754dbd5a10c": "0x0403000000020000000000000000000000000000000009636865746861636b1143686574616e7920426861726477616a00001263686574616e7940736974612e6661726d000009425255484457414a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714225b1e95c870e114d86cce0d391087696b6123aae807e8da8ae365eeeebd43f857c6b5c4eee76975": "0x040300000002000000000000000000000000000000001c536c38746520506c6174666f726d2028546f6b656e5472617878290f416c6578616e646572204d6f737300000f616c657840736c3874652e78797a00000c40546f6b656e5472617878000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142264b5df53ebf1f498f37af89509e846463f6874745b6f8c4e02a941d2c9a83b7d60d90ad5b81863": "0x00000000000000000000000000000000000d706570656172617563616e6f0d4a6f73652042656c6f7373690000166a6f736562656c6f73736940676d61696c2e636f6d00000e40706570656172617563616e6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142265233f75ee737e4dcb5e6cb19c4034a66e1f5e10be70f0ac356e9beff459e1b334ce7351a229cf": "0x04000000000200000000000000000000000000000000086c75636173766f104c7563617320566f67656c73616e67000000000009406c75636173766f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471422b354403ceb2cc3ceeefbffd1cab85b87e1469bf23bbd35b83fd508cd41e17b0fd3a81b8ffe4467": "0x04030000000200000000000000000000000000000000105468655375737365785472616465720e5374657665204875626261726400001a74686573757373657874726164657240676d61696c2e636f6d000010746865737573736578747261646572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471422c52d6bb34054bfa8fc69f4bcc2ee09a91d633b59b82ca325027ea9567b1b47fa5912c4edeb9d6a": "0x040300000002000000000000000000000000000000000963617274616769610000001463617274616769613040676d61696c2e636f6d00000a436172746167696130000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471422f8d0d571261afe14d6965cd9bcce81dfe785bd7642bbaf4caa8f203de34459ad12d7a9e501bb6e": "0x040300000002000000000000000000000000000000000c50726f666974206c696e6b0000001b67617263696170726f6475636572393140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471422fa92e09f76627f5a2160296c65f838252b9da9f51b9691950ece465e1a71b444d286d91316dd24": "0x040300000002000000000000000000000000000000000b526f6d616e204d2e4b2e10526f6d616e204d2e204b656d7065721868747470733a2f2f6a6f696e7765627a65726f2e636f6d174072656b746f726d6f6f6e3a6d61747269782e6f726713726b406a6f696e7765627a65726f2e636f6d00000c4072656b746f726d6f6f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471423484ecafdeafb8d3c84767978ada6355ac3719ea8f978244b16d7e8c00552c3a189760b55eeb404": "0x040100000002000000000000000000000000000000000a4d616e74726144414f0a4d616e74726144414f1b68747470733a2f2f7777772e6d616e74726164616f2e636f6d2f0016636f6e74616374406d616e74726164616f2e636f6d00000b404d414e54524144414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714235333782a45d3df229f2896c2bd6f30162c9cc0f5899432515f2cffed36a4dc6b42d48bd2b2910d": "0x00000000000000000000000000000000001044454144424c41434b434c4f56455200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142383a648795d6d96f093fdd7214faca57e8f0a10e8ea4c03c4602af97676242b933a757824ca8335": "0x04010000000200000000000000000000000000000000054e4f56590000000e7374616b65406e6f76792e707700000f406c6f73745f696e636861696e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142398aeb1ef43f542c44cd5285e160a2184f3f5801cdce8517ebffdb591177acb17cff2db2ffd9371": "0x040000000002000000000000000000000000000000000a4541524e5354415348001a68747470733a2f2f7777772e6561726e73746173682e636f6d16406561726e73746173683a6d61747269782e6f7267146561726e737461736840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471423bd63bc18ca71967478e4ccf706567c80242c11e0c11312b7b8ed3db3af63eebd94167aba9ac1a6": "0x000000000000000000000000000000000010504f4c4b41444f542042524153494c19506f6c6b61646f742042726173696c20f09f87a7f09f87b71e68747470733a2f2f6269742e6c792f706f6c6b61646f7462726173696c000000001140706f6c6b61646f745f62726173696c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471423d0615e8f4e163856b5a7ba509762854581e36acc727a27983e3005731931bc31be21c1df4b401f": "0x0403000000020000000000000000000000000000000010504241205347502057414859554449096f576168797564690000136361726e65677a73407961686f6f2e636f6d0000096361726e65677a73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471423d5be68d79bf6613417721ef067cbae6a29f3ddd4d5df9659d5f007e23152b96c2e5b939af7fc68": "0x04030000000200000000000000000000000000000000094f6e65426c6f636b00000018796178756e6368656e3139393540676d61696c2e636f6d00000b404f6e65426c6f636b5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471423eae731efa0ee7a3aa151f9bdc2bb6f8e27d492446ace702955f1eed20efa5ee31a59dafdf3354e": "0x040300000002000000000000000000000000000000000e686f6676656e736368696f6c640000001c6a6f616368696d2e7269747466656c647440676d61696c2e636f6d00000e686f6676656e736368696f6c64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142411ce5d2c7e203b500427a67b8b8dbf1b569c99d1d0a3662359b5aeaa4cbead3d603857271a3670": "0x040300000002000000000000000000000000000000000841754167656e740000001574775f70726f665f6e654070726f746f6e2e6d65000011404d6134363134333938323637383737000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471424883d27e305ffe5f89d4c543e6cd62e62136614f7b98a423cedb9fd863584a2f4ff887259432437": "0x00000000000000000000000000000000000963796265726e657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142492dee6806c086baef6619eea08f01aef7e47d460f0730b02c075e446308892e55af56af1572168": "0x040100000002000000000000000000000000000000000b696e74656772697465650e696e74656772697465652041471b68747470733a2f2f696e74656772697465652e6e6574776f726b0018696e666f40696e74656772697465652e6e6574776f726b00000f40696e74656772695f745f655f65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471424ab767106e162e17a9749cfb7256e7e48edca7a6911018861ec6e26d9eb2c81bbf037628fefcf04": "0x040100000002000000000000000000000000000000000e527562792d4e6f6465f09f928e00001240746174616e3a6d61747269782e6f726719527562792d4e6f64654070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471424c51cd1777082130630cade4d018323ce09989df4f43749469506631ec446b3322c5b029283ef03": "0x040300000002000000000000000000000000000000000e43727970746f2042616e7465720e43727970746f2042616e74657200001a706f6c6b61646f744063727970746f62616e7465722e636f6d00000f4063727970746f5f62616e746572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471424ddab62ae2ee0f5da1bdcd2db52642b3be2dd7d474a865c85ef5db7b76d6732b132c80de1750d28": "0x040300000002000000000000000000000000000000000f42726176655f4f6666696369616c0f4361726c6f73204163657665646f00001e69742d736572766963652d706f6c6b61646f744062726176652e636f6d00001040417474656e74696f6e546f6b656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471424df16db48272ad68c085e6bde4ac25702f54f46fa3c1b0a6170bd346103c2c6339911e00306a054": "0x040000000002000000000000000000000000000000000b56414c49444154484f520000001576616c69646174686f7240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142506f1a04a86e00ea2793a1de617bc5ff2e0fc73334fb1792f1e6849352ceeab2cfe0a4f43b77608": "0x00000000000000000000000000000000000b4c75636163727970746f0000000000000e404e4654736172656d796a616d000b6c75636163727970746f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714251429e29e5bdc418aff8f8e6f78afd4fd4d5c59242373cc0e5ecbd5595578ad042e6cf97d53ea1e": "0x0400000000020000000000000000000000000000000018506f6c6b61646f742045636f20526573656172636865720d506f6c6b61646f742e455249002140706f6c6b61646f742e72657365617263686572733a6d61747269782e6f726715706f6c6b61646f745f657269403136332e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142522dbe7f104bee21ccdf130995bda0c195a1c383532e4704f289b31d3923c18f76ff0ef6626f21c": "0x04000000000200000000000000000000000000000000084d616368616c610000001c6a6f736875617a696f6e666f7274756e6540676d61696c2e636f6d00000e405468654a6f73687561736f6e00096d61636368616c6100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714252e878992d864fb960d75eab8e58bffcedf1fa51d85e2acb37d107e9bd7009a3473d3809122493c": "0x040000000002000000000000000000000000000000000957444d41535445520000154077646d61737465723a6d61747269782e6f7267136d6f6c7465732e6740676d61696c2e636f6d00000d404d414b53494d3738383736000b6d616b73696d3133343900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714255d8383c400c461dcc1b944a156b60b0adaa4a2a59dd97804c1ec4fca4751a3efb6bc0434ddf051": "0x040300000002000000000000000000000000000000000e4265616d737761705f5465616d00000011696e666f406265616d737761702e696f00000b4265616d73776170696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471425b20afe8011ef7d040d1324a05bb9a0b86d9eabd01245ffcf277f4611f9750dfe465761481ba053": "0x0400000000020000000000000000000000000000000011416c6979756e2d76616c696461746f7200000012746f6e7473696e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471425d12cd63f2c7151f66dcadc693afcce9876c486304d77941b2084677b0e9b7804935da272dd3625": "0x00000000000000000000000000000000001342617262656ee280997320536c617368203200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471425d728fd5c84d7cd8c5671a38e6cc4175311cdb5280fc86d2ad25d197c14682153a30b406a029e75": "0x040300000002000000000000000000000000000000000c6b616b6f6f7a617669616e0f4b616b6f6f7a61205669616e65790000166b616b737669616e65793140676d61696c2e636f6d000010406b616b6f6f7a617669616e323536000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471425ecccdf058700718b63cf648fa2a43a82671762a02da41dc6abbd1e62a376b3af7c2d09abf5120c": "0x040100000002000000000000000000000000000000000a436861696e5361666517436861696e536166652053797374656d7320496e632e1568747470733a2f2f636861696e736166652e696f0012696e666f40636861696e736166652e696f00000d40636861696e736166657468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714261d16493407cc0ac587192891bca929ce36a9004a6b1beca795e27a0dbf10b14d68cdaa962f15a0": "0x00000000000000000000000000000000001c506f6c6b61646f74204d65786963616e20436f6c6c6563746976650000001163646f746d7840676d61696c2e636f6d00001140506f6c6b61646f744d657869636f5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142622a69ca095df152e33a240cb3adb22310f77b1d8f6e105e325077f4b35ffd8bf35780221fcc1ef": "0x0403000000020000000000000000000000000000000005566c6164001868747470733a2f2f6769746875622e636f6d2f72636e79114072636e793a6d61747269782e6f72670a6d654072636e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471426237f16f577beb4108750788ae77403993574ef05638bfe9cff80729c2ca6ba310f6aa65dd0b901": "0x00000000000000000000000000000000001450617261636861696e732041756374696f6e73114d69636861656c204c6120466c6575720000196d69636861656c406c61666c657572686f6d65732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714264c10224bdb241eee938b6b034193875fa93d617a9543084ef41f40790898fa1eb4118e6361e950": "0x040000000002000000000000000000000000000000000946726f67f09f90b8001968747470733a2f2f66726f677374616b696e672e636f6d2f184066726f677374616b696e673a6d61747269782e6f726715696e666f4066726f677374616b696e672e636f6d00000d4046726f675374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142650651beda2cb6ffc644cc7758af1bf8dd4974d1e920fde4e1cc71b5297571368559b48f180917e": "0x00000000000000000000000000000000000c733066746d616368696e6500001840736f66746d616368696e653a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471426968cb24b23a08fb64a86ea0e91047a3ffbbc68c36ea9ab318ee06c8bb4a354dd3a716956c9eb55": "0x040000000002000000000000000000000000000000000f4155524f5241205354414b494e47000018407374616b656175726f72613a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471426a2abbc21cd770cd88a4b558274e57737ffd3fc9741848596199a29d77fe511804d20810cb76050": "0x040000000002000000000000000000000000000000000d5374616b65506f6f6c323437000019407374616b65706f6f6c3234373a6d61747269782e6f726716696e666f407374616b65706f6f6c3234372e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471426e7f4ebcd01d4dae6dd0a94c6dc8091d357cf0092af2f8e108daf432d02d27dcb7ffd019d98a509": "0x0403000000020000000000000000000000000000000007496e64696b6f00000019696e64696b6f6a6f68616e73656e40676d61696c2e636f6d00001040496e64696b6f4a6f68616e73656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471426f6a2ed87b420011ad2ce70e114cbd2d3611571bb2c5b15b2186460de419ca0c774305b62f5cc33": "0x0000000000000000000000000000000000076461696167690f42617275636820466973686d616e00001164616961676940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714271fca71d49496c2ccab328611b1ace9fc6fa0e67bab07922427c5cf6f0291c5b5235e6868f9f310": "0x0800000000020100000002000000000000000000000000000000000d4c4f43414c43525950544f53164c6f63616c457468657265756d20507479204c74641968747470733a2f2f6c6f63616c63727970746f732e636f6d0019636f6e74616374406c6f63616c63727970746f732e636f6d000010406c6f63616c63727970746f73656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142730809323ff3aebc29ac3c17a8bb1145487c9f80bc86e6982b95bfb522b6e191ab95ad8f248f07c": "0x000000000000000000000000000000000005486f6f6e09486f6f6e204b696d0000106d61696c40686f6f6e6b696d2e6d6500000b40686f6f6e737562696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142777a559c125897fb8897a746ceaa53376946a3da353c1c987df8c0caa4395ac0eaf0e6c74874054": "0x00000000000000000000000000000000000b4a656c6c6965644f776c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471427c5cc778df57308e8bfaeea37b4d2f39cafa194a0758805af9a1b9253dc27dc2b7880d06f312d32": "0x00000000000000000000000000000000000f4b696d7320436172204e6f74657300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471427ce23d8a102db2306e6e94eaa021535d3632154bb1c00bbc511d692a33bd5816d518367421932f0": "0x00000000000000000000000000000000000c526567656e63792d3030381757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471427d82cb3e937516ba0aa6672877b1924e7a86c9ec99bf1cb93797123b14ec80c0effe2a8685e1002": "0x0403000000020000000000000000000000000000000009444f54414d494e4100000016646f74616d696e6134323040676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471428047368e108b3b06ef40ac7b3e092d0eca77ad072cd317683ab9d24aca4025788421d4276527d57": "0x040000000002000000000000000000000000000000001ff09f90b05f2e2de3809020435259505449445320e380912d2e5ff09f90b00000154063727970746964733a6d61747269782e6f72671468656c6c6f4063727970746964732e6c69666500000b40637279707469647338000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714285588f89e26dc6c2ab6a0d5885b1debcb5f089ce73d3abe16792cd01d63d788609f8d859fc1fe01": "0x000000000000000000000000000000000017f09f8cb74b494e4420535452414e47455220f09f8cb700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142895ffb6b45282d85a093ae9a82c3b93551017c2f3e6eb796a3cc532da826a9f30cc51d28cc8a601": "0x040300000002000000000000000000000000000000000a476572616c726f636b1f4765726172646f2052616661656c20c3816c766172657a2052616d61796f00001c6765726172646f2e616c766172657a313840676d61696c2e636f6d00000b40676572616c726f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714289ca7552a5b54db20af269d7bab673454a2f802bff3917cb7e693fb9857affc0be384560cd5a2b1": "0x04000000000200000000000000000000000000000000085a65726f44414f0000000f6c6565406d656c6f646f742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471428a876cad533fcb536677e8e5d84c1a25bdac951e9055abff3df4c7a656abd841197a8726ff29a3f": "0x04000000000200000000000000000000000000000000094c656e677569746f0000001530786c656e677569746f40676d61696c2e636f6d0000094030786c656e676f000c4c656e676f37233236363400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471428cc3c2610e32eb246d9719d59eedbef886f837bc68f5afe35eb594ed7546c9507c5d55992c9f035": "0x000000000000000000000000000000000009506f6c6b61726f620e526f62657274204d2048656964000013726865696430373740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471428d20381664d55c37099f4d19d4f37dea1e2ad9be9f4948f837fc391cf9e9af0b458e960dd102a76": "0x00000000000000000000000000000000000762616e6b343513416c656b73616e6472204e6967616d616576000016636f746d6f744070726f746f6e6d61696c2e636f6d0000084041524e5f3838000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471428db6c1e91cbc43002385caf9a08b92ca458a0b817a8cc303cefd5a0c6e108cb939e04242b9e007d": "0x0400000000020000000000000000000000000000000014537562517565727920436f6e74726f6c6c65720000001d6a616d65732e6261796c794073756271756572792e6e6574776f726b0000114053756251756572794e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714293cf013489f4e2d9afa0d65d7fa0d1b9240ed167102fe95be2b87c6d585917f6c4ee40e45cb6e5a": "0x000000000000000000000000000000000009477265617468697400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142959c4bc29b0128ea4496cb0c04854a6634444b262642d22f70b361cf9e45842bae6e92b42294d19": "0x040300000002000000000000000000000000000000000a43757272656e63797800000014656574696365706f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714298645876ad18694bee606a879569e5675d379121f832a04d3e378618ee6d12244646d2d00bdf420": "0x040300000002000000000000000000000000000000000a6a6f69655f70696e6b044a6f790000146a6f792e6f7369766540676d61696c2e636f6d00000c405465616d5f46656f6f68000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714298ad014cd66be3404aec61601a366f706a5dda2bdb5987555ebea5347bf32080bdfde6f33849d05": "0x0400000000020000000000000000000000000000000009726f636b6e6f646500001540726f636b6e6f64653a6d61747269782e6f726715726f636b6e6f6465687140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471429a96dcb25143c65cef75691f5bc9f7552778942bc996e7dc0796a3b431d6894e4ee36c168168222": "0x040000000002000000000000000000000000000000000a736f72616d697473750000001974616b656d69796140736f72616d697473752e636f2e6a70000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142a251205d65518b0e6b912626c9dfa3cd9e65b4412b19eb9d123edb1aa22d492a58a88091c483a7a": "0x04000000000200000000000000000000000000000000034d4b0000001b6d69636861656c40636f6c6f7266756c6e6f74696f6e2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142a3ffa5c696e8f33fc5bf1b734c6224841177fb6111b9fc879c86cabd506a7c5b5f84bd66bf1d37a": "0x04000000000200000000000000000000000000000000115468652043656e7465722050617274790000001974686563656e74657270617274794070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142a65c9799fef41adec3d304da58d77a4384fced1c59dd3cbc9618dd1ec92e6feb64293147272a21d": "0x0403000000020000000000000000000000000000000009526f636f536170650f526f636f202f20446f7463617374000017726f636f63727970746f343140676d61696c2e636f6d00000a40526f636f736170650009726f636f7361706500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142a679b6bc1ea7234ccb38aa8821510b7cc609cd55fd19c0f9c3594d49fe8db355bb2e7fb2324c948": "0x04010000000200000000000000000000000000000000096c7578382e6e65740d496e66696e697465204c75781168747470733a2f2f6c7578382e6e65741540616d6133313333373a6d61747269782e6f72670e696e666f406c7578382e6e6574000009406c7578386e6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142a6803733e06edd5682740b90bc8be47e739a0b66b3bd84eac0962a708078b238c8c08945fb2024b": "0x0000000000000000000000000000000000044d2d4f094b656e6e79204e670000146e6f7665783839303840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142aa976bb8726f15e2e5157fa386365bb2a60fc6f415bf070acdae47078be1396e3dc47ccb837d459": "0x040300000002000000000000000000000000000000001d4e696b6f6c61204d616e646963207c204d565020576f726b73686f700e4e696b6f6c61204d616e64696300001d6e696b6f6c612e6d616e646963406d7670776f726b73686f702e636f00000a6d616e5f6461613231000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142ab0d54695f8d579c6515b55efbd99301b103862a649266e6f4a08ed9f2f9e653faa4629710dd6d2": "0x00000000000000000000000000000000000d746f646f646563726970746f0d746f646f646563726970746f00000000000e40746f646f646563726970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b031c075ea343ce443c76dcde19df9387486ded7845c6d85ec2a4c17f38f8b1e7a0a14de7968d7d": "0x04000000000200000000000000000000000000000000064b414d454c0d6b616d656c7374616b696e671968747470733a2f2f6b616d656c7374616b696e672e636f6d19406b616d656c7374616b696e673a6d61747269782e6f726719636f6e74616374406b616d656c7374616b696e672e636f6d00000e406b616d656c7374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b2d37123329b9ba08bf2f84a9f268c10adb63f3446fa65d680c7574d794c4115b605ad40d26cc42": "0x040100000002000000000000000000000000000000000e4252494748544c595354414b45001b68747470733a2f2f6272696768746c797374616b652e636f6d2f1a406272696768746c797374616b653a6d61747269782e6f72671a636f6e74616374406272696768746c797374616b652e636f6d00000f406272696768746c797374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b2d468ee1c0d6cf28ee86c98db79e06b3e25509ad654b002720aad45713da761bae4f0ae813387d": "0x04030000000200000000000000000000000000000000054761626f000000216761627269656c6e69636f6c6173676f6e7a616c657a40676d61696c2e636f6d00000f4063616d62615f6761627269656c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b2f2f9bc8a6dc303020182b284d6ac805b1382502a771eb140c80303e128cfefa992a62160a7728": "0x000000000000000000000000000000000008426173696c696f0f4d617474686577204261726e65730000186f6e656e6174696f6e3134393140676d61696c2e636f6d00000d40436174616c797374557365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b53fe0d3b6de98ab40270f026c5a4841078cc77a050c780f88e5dee8436e569972c93fa56d9a020": "0x00000000000000000000000000000000002077616c6c657420706f6c6b61646f7420706172612070617261636861696e730a66646e74732e646f74000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142b6e818ad6aaf2194425333101d35f55eccfe16b28f0e65007a0076ca42eecb050405f6e0ac4737e": "0x040000000002000000000000000000000000000000000455414900000018616e6172636879636861696e734070726f746f6e2e6d6500000f40616e6172636879636861696e73000f40616e6172636879636861696e7300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142bac4814c142df16f89d49e97071dfd7f8971ed816c0fc60a34aa6a8d0b1af8f7c6922659dfbd789": "0x00000000000000000000000000000000000d63796265726e6574776f726b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c08340921a3d8d9981e0c8001f0d80ef450c0c0561f9e4b22337af479023b9d79851381ffbe0348": "0x0000000000000000000000000000000000083130313538313400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c09493faa9e924efc5d04e7ff3965c8285a2c23aa573117deeed886bbe5e3be0974f1cf0a2ff216": "0x00000000000000000000000000000000000b536861776e2059616e670b536861776e2059616e671e68747470733a2f2f6769746875622e636f6d2f526f6d65726f59616e670015736861776e40706f6c6b6177616c6c65742e696f00000c40536861776e5859616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c3ee724586db259eaab0cb55c147ffaf184a4c00513e85f6d5bb6416994fbdd0dd168f3c59a291b": "0x040000000002000000000000000000000000000000000c437970686572204c6162730000001d6379706865726c6162732e636f6e7461637440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c4d0f13e5d38cd42a813834d9532d047dcc1c87a3abde12724abfa8b681edaf89d59dc4d69d3e60": "0x040100000002000000000000000000000000000000000c686f6e65796261646765721144616e69656c2042616572697377796c00002064616e69656c2e62616572697377796c4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c5adc2eb80036fe5e217ee74a4735c3e66dff90cc3ec8dd2185411ded94590173ec8cd773cd1071": "0x0000000000000000000000000000000000114a616661725f436f6d706f7361626c6500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c85c1028c0265f1d0ee5462aa1f69fbb13d1bbba3fe774167ce82a5cd36da733f2f2db0e7e4ad4d": "0x040000000002000000000000000000000000000000000d5542494b204341504954414c00000015636f6e74616374407562696b2e6361706974616c00000d407562696b6361706974616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c9114f608ac39a9a45d1c3020272172fdb2238d4b68c1f8d6178dfbf4a80404dcd01da024dac33d": "0x0400000000020000000000000000000000000000000009476162654b6f696e0000001c6761627269656c5f626f6e75676c6940686f746d61696c2e636f6d00000a40676162656b6f696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142c953664c84e500ad4d71d52cefd70e1668f6b908e3196d664e2fd5e541905966c514ab660b86966": "0x040300000002000000000000000000000000000000000757616c7669730000001277616c7669733740676d61696c2e636f6d00000877616c76697337000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142d1be0f377b4cffe7c1207030eebbff1aa8d1d3fb13ef4a44251f81480ff627240d45a0e4547c639": "0x040000000002000000000000000000000000000000000b5354414b4543524146540b5354414b4543524146541768747470733a2f2f7374616b6563726166742e636f6d15406e3174726f67336e3a6d61747269782e6f726717737570706f7274407374616b6563726166742e636f6d00000c407374616b656372616674000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142d51e6ba205c01881e8f1a5238c8472f9059d189db0d25ae5bfd6380b2ec5325d302689d96bfb479": "0x040300000002000000000000000000000000000000000e4e6573746f722043616d706f731e4ec3a973746f72204e69636f6cc3a1732043616d706f7320526f6a61730000196e2e63616d706f732e726f6a617340676d61696c2e636f6d00000b6e65735f63616d706f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142d5da20efbc496e3401ddfae657e8222bce22c9787be36b1ae9906840546c992fa4b4b9201be1776": "0x00000000000000000000000000000000000d496e73616e654272612e696e05416c79781568747470733a2f2f696e73616e656272612e696e0012616c797840696e73616e656272612e696e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142d6a11aa67106d2d8ae51d44bfb6e10f175e6e86e829e1013589f4f1049b3a98f648cd1a9d8d3007": "0x040300000002000000000000000000000000000000000b416e67656c696e6138380f416e67656c61204b616b69697a61000019616e67656c612e6b616b69697a6140676d61696c2e636f6d000009616e67656c615f6b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142d70dfa84c8df520b8b3f33a5d67eaa3bd04013795e3f6ab9fa3d6851ab3005ba7cacdde440eb053": "0x0000000000000000000000000000000000066a657375730d6a657375732067617263696100001c6a6573757367617263696167756169646f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142da517d91ffe519dea08e3af45c5a91e4f22bf4e5e6491e5927538296954e4fbb450bd5db3ec543e": "0x000000000000000000000000000000000015486174656d207c20446f7442656c3361726162790000000000000e40446f7442656c336172616279000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142de8d0b38098bb8dde607c18f59d4b90b26ee90bb1e7fe10d4ad22c871ea17414ddc9a9d355c255d": "0x00000000000000000000000000000000000a42615f73733335383800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142de96dce1f9cc98a04aae2b4b67be2cfee31d6cdc0f777f4b8e6ba330f93978f9d1aefe9af61374f": "0x00000000000000000000000000000000001d5374617368204163636f756e742031202d206e6f6e206c656467657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142dfcf93c305276e4327f10a5aa41f8e64ca4dc6cb07bf883e19354851979be53c77d1d65a66fa765": "0x040300000002000000000000000000000000000000000f78696e7869616e6764657369676e0978696e7869616e67000013646f6e677831313140676d61696c2e636f6d00000e78696e7869616e675f6d657461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142e0a85ddf8e6a3e3d24f805ca7bafb11cfdb0ace585a9d0e6edf83878dc7b42946c33c2378211464": "0x0401000000020000000000000000000000000000000007414e414d495807414e414d49581468747470733a2f2f616e616d69782e746f702f1440646270617474793a6d61747269782e6f726714616e616d697840706f6c6b61646f742e70726f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142e346820d7be398158598801d9659099c1437f879e3003c0461affdcb378e9462824a1b7e5cd4c65": "0x040000000002000000000000000000000000000000000661626761720000124061626761723a6d61747269782e6f726716616267617262617273656740676d61696c2e636f6d00001040416476697a6f7254727573746564000a676172696b3537313500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142e764a24050b5fa2022be0daf8bcff3056f4e4e1c4296d436184ec10c21a4f9bedc57d2778674e7c": "0x040000000002000000000000000000000000000000000852686f6d6275730000001a72686f6d627573706f6c6b61646f744070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142e7e56460089fc7a54c473bf199d05b878ab34e9a37d17d0a8bf70498edb5c759672e984fa38b432": "0x040000000002000000000000000000000000000000000f4170706c6965644243204c61627300001a406170706c69656462636c6162733a6d61747269782e6f7267186170706c69656462636c616273407961686f6f2e636f6d00000f406170706c69656462636c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142e8429dbeda5cc3f2042cbe5632c5f2d92c0f91144fb9f02541d75f721881337e5ba8d5f13691506": "0x040300000002000000000000000000000000000000000f5472656173757279204775696c640f5472656173757279204775696c6400001874726561737572796775696c6440676d61696c2e636f6d00000f40436174616c797374537761726d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142eb239de2237ff4464c92fbc08d8d3594de7a9eeae4ef24891cf7e8330faf07ed804cd0045e49e6d": "0x040000000002000000000000000000000000000000000a53686f7274795f33350000000000000a407273686f7274656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142eb8e564ba3255aa8ed07ac253ff90568509ab1e98620aab2d27739c088425500b1555c200fc5a6d": "0x0000000000000000000000000000000000085765625a65726f001d68747470733a2f2f7777772e6a6f696e7765627a65726f2e636f6d2f000000000d406a6f696e7765627a65726f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142ec71cb46d9dac8c4061fa23b882bde2f44bbbf50b167a0540bd1f34cdfa015199e099ff610e9a54": "0x04010000000200000000000000000000000000000000094f4e454352595054094f4e4543525950540015406f6e6563727970743a6d61747269782e6f726711726f6f74406f6e6563727970742e696f00000b406f6e65637279707432000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142ef8fef75807c63dc8d6404482643a279bc4a12ccb233ae1be9cc911b65313415ae1f6e99ea6351d": "0x040000000002000000000000000000000000000000000950726f706f736572000012406a6465746f3a6d61747269782e6f72671a6a6f7365706840636f6d706f7361626c652e66696e616e6365000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142f05080e250453cc88609d041e06db09ff8a0bea7122bceb122630591856f71285ff8215cdcaa95c": "0x040300000002000000000000000000000000000000000c45737562616c657720412e0f45737562616c657720416d656e7500001b65737562616c6577627573696e65737340676d61696c2e636f6d00000a65737562616c657761000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142f3b5813e65122054cbd158ed5b37e237e8a790a020d9a67032b56318dd7f674de1e5a002f8b5a52": "0x000000000000000000000000000000000004446f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142f4bb305762822d5d4f47497fa575d0be94b1dc8833b9ffee17058bdcb32e4aaaf5f7d846afdbc11": "0x00000000000000000000000000000000000e4c6972616e50656e64756c756d001b68747470733a2f2f70656e64756c756d636861696e2e6f72672f00146c6972616e407361746f7368697061792e696f000009404c6972616e416c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142fb53ad11aed254b52582c7985dc8002e718841421ee5059a92ed9a4e38c0c33365ee196c96d5e0a": "0x040000000002000000000000000000000000000000000a4972696e615f56455200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142fbc5fa5095a463cfa9fb4eccab4919417e2a6072c77e55b7d1b69a9682629a09953ce699260b564": "0x00000000000000000000000000000000000a4669676d656e742035001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047142fccfd4d73aaadfef8c309d6472fab1a89e619867d57934db759e5d76d63b9e67968e36f02787335": "0x04030000000200000000000000000000000000000000084d72457863656c134672616e636973636f20416c626f726e6f7a0000176672612e616c626f726e6f7a40676d61696c2e636f6d00000f406d6973746572657863656c7733000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714304630d144e59358fe1f35d3b712d9b87e9dce926d8772267bbbaeb776e9b2a8615b29d6594c4621": "0x04000000000200000000000000000000000000000000076b734d6f6f6e000013406b736d6f6f6e3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143046396b7c34c0b3eec4bd650a277342ebba0954ac786df2623bd6a9d6d3e69b484482336c549f79": "0x040000000002000000000000000000000000000000000664617678790f4461766964652047616c617373691468747470733a2f2f64617461776f6b2e6e6574124064617678793a6d61747269782e6f72671264617678794064617461776f6b2e6e6574019484ae9c0de026adf6a15a538f550699515c84cb00000664617678790000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471430731e299628f086987179a4c458ad0333ddf074031278a4e40cbf3d07c3c93bdaf1d4e720e25b70": "0x0400000000020000000000000000000000000000000016506f6c6b61646f74204e657773204368616e6e656c000014406d6172796c65653a6d61747269782e6f7267156d6172796c6565626f7840676d61696c2e636f6d00000e40706f6c6b61646f746e657773000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143081f00d680b8e9f7824673613d28fd0e00381e7a257a670c9fe3caf566f5ea3b4eae0190c3fd06a": "0x040000000002000000000000000000000000000000000a7374616b657468617400001640616e647265697369643a6d61747269782e6f7267167374616b6574686174687140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471430a9041ab751137e14b3cf31ec26dcd596285c2afbdd19579b3634a78bc987dad71d91ecf436847b": "0x04030000000200000000000000000000000000000000114a617669657220456c69205265796573194a617669657220456c6920526579657320436162726572610000176a6176697265796573636d3540676d61696c2e636f6d00000d404a617669426c616b654352000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471430abe05ab6e2104d2e84d8f02b52516e31d4e588ef866a26f721896ea42fb351a63d58a418cf9d42": "0x00000000000000000000000000000000000d43727970746f64696e676f3200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471430d3bc09d2bfcfb50c7f10142a81fedec753f7c556f5b93a400c280805e7fcdff668719637b13434": "0x040000000002000000000000000000000000000000000a47656f7267695f5053000000126a69673737303940676d61696c2e636f6d00000b406a696763727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471430ef5160a1f04948b2e8980baff3a96bacc15e3f314bdfa64112a67afc736beee37f5d2e1b907462": "0x000000000000000000000000000000000006576574657a0014687474703a2f2f7777772e776574657a2e696f0d576574657a2077616c6c657400000006576574657a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471431053eabded94fa87600c0c74304812e4928a503408a68c782c69a6af2fca55fcd9e48e095b44863": "0x040000000002000000000000000000000000000000000ff09f90a0205354414b4546495348000013406d34646269373a6d61747269782e6f72670e6869407374616b652e6669736800000b407374616b6566697368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143118317c1a74f34820a72747f8fa2e88160c65260e1dd461e775a75e05fd60c0ee07c929411bf611": "0x0000000000000000000000000000000000094b6574757432353600000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143185ee0b1cadbcee56ca8c23e3988aaddd0fe5deac26eef5661547ce8ae71c4fbe07014b7052e71a": "0x04030000000200000000000000000000000000000000064d6174656f0f4d6174656f20436861756368657400001863686175636865746d6174656f40676d61696c2e636f6d000009404a5a656974616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714318ee29c136c23ba24d6d7cd9a0500be768efc7b5508e7861cbde7cfc06819e4dfd9120b97d46d3e": "0x000000000000000000000000000000000012537562736f6369616c204e6574776f726b001a68747470733a2f2f737562736f6369616c2e6e6574776f726b000000001040537562736f6369616c436861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471431c949d064ba830cfc60f1dfd95340dfe375e3e49d846e35283e3fdfcce5a83aa09c8a4718d64f7d": "0x040000000002000000000000000000000000000000000b4a6f657267537475647900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471431ef141127f82186d45548e42d7f5d5aa35ffc16ff29396c99936f0c1eae84d452f1daac87c3c566": "0x040300000002000000000000000000000000000000000c446973747261637469766510446973747261637469766520496e630000156e6174654064697374726163746976652e78797a00001040646973747261637469766578797a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471431fa432a48d8271ecc17542453f0d5e9caa6e8351612ecd3fe895c023eb93cbccf0ab0457728b87c": "0x0000000000000000000000000000000000074d75727068790e476572617264204d757270687900001567736d2e6d757270687940676d61696c2e636f6d00000d4064657370657261646f676d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143203618ac806a5094866c7c5c93a0984394d5279fbbecb07c1e48368b042566ebb632c2055698b02": "0x04000000000200000000000000000000000000000000084e6f646561737900001540637261626265616e3a6d61747269782e6f72671577656e7a686968616f406269746f7069612e636e000009404e6f6465617379000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714320eb468db7ea3c7aeb9fc068a3340edead118ac3cf3decc6743724cd5fb11edebaa98b540a08f07": "0x040300000002000000000000000000000000000000000a59756e6720426565660000001a79756e67626565666269676261677340676d61696c2e636f6d0000104043727970746f436f77626f794f47000c79756e6762656566342e3200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143229ab61e8335194fcbc52e3cdfb14d85daa469993d85fd39f8f52fd8c89c53afc067e327fd2da5a": "0x040000000002000000000000000000000000000000000f6c6f67696f6e206e6574776f726b000000147465616d406c6f67696f6e2e6e6574776f726b000010406c6f67696f6e5f6e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714324c8ff3d7043f733a47ca4e579b94d1edbf9a82eaf0e5b1d018ef37f84d85bd96e415147378e048": "0x00000000000000000000000000000000000e57616c6c65742048697473636800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471432566a7e7c573a80b2cb9187546fcaa8c721b02805a6ed72fc162c0cba916e4af26e95b624668d47": "0x040000000002000000000000000000000000000000000970756e6b726f636b0000154070756e6b726f636b3a6d61747269782e6f726715706f6c6b61646f744070756e6b726f636b2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714327fdfd66e528b9662d8c4e1c6fbab57ba4df15b8120db4cec5c150371d0755d8ee5312382f47f09": "0x040000000002000000000000000000000000000000000b437269734e677579656e00001740637269736e677579656e3a6d61747269782e6f72671e7472756f6e676e677579656e3139373139393940676d61696c2e636f6d00000e40637269736e677579656e3939000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714329deba10a6ffdb9f64d8174827dde573fbc8bd2d0b184a7e38fae4957d1ba577e98522de9bd8e52": "0x040000000002000000000000000000000000000000000b4d61746a617a20e2a793000014406d61746a617a733a6d61747269782e6f7267126d61746a617a406170696c6c6f6e2e696f000009406d61746a617a73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471432ac541eb6aa1242ac1aee6b509bdaa6aeb4718c2218bd7e78a3d6704bf886375e4c243b77a66b34": "0x040000000002000000000000000000000000000000000d45786f746963205374616b65001968747470733a2f2f65786f7469637374616b652e636f6d2f184065786f7469637374616b653a6d61747269782e6f726718636f6e746163744065786f7469637374616b652e636f6d00000d4045786f7469635374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471432e1c9cc0499e7e2dbcd8d24233cad535726ee1613bc044d6c376af651779deee9721338d12d0458": "0x04000000000200000000000000000000000000000000125350414e49534820424f554e54592056320000001a626f756e7479656e657370616e6f6c40676d61696c2e636f6d00001140426f756e7479656e657370616e6f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714333ed71ba3fea8299a248664937e01d8e4856eb89c980637b2d88c705fb69307d7925ccc61022b53": "0x04030000000200000000000000000000000000000000074a45455045520000001378636a65657065724070726f746f6e2e6d6500000a4078636a6565706572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143351d9da302db1e80e86d53dbd64cb20f18ca85d0e78ea35331f734bedeeafa0166bf06c7224d100": "0x04000000000200000000000000000000000000000000124b6f67617261736869204e6574776f726b00001a406173685f77686974655f6861743a6d61747269782e6f726711696e666f40696e766572732e74656368000011404b6f6761726173686943727970746f000c417368576869746568617400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471433c674ddb7d7206854d7aa0bba9a5dbb1bb77973f344625df346f6a65840b8534ee22e93fbad767a": "0x040000000002000000000000000000000000000000001af09f95b5efb88fe2808de29982efb88f70676f6c6f766b696e0000164070676f6c6f766b696e3a6d61747269782e6f726714706176656c406e6f766177616c6c65742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471433c7d151629670075e7fb7c001173521bcbfdca5b2087290de094c04f9e1ce7491b836cd408c125a": "0x040000000002000000000000000000000000000000000e4c61626164616261646170746100001b406c6162615f6461626164617074613a6d61747269782e6f7267186c61626164616261646170746140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471433e2754f2553aa4e5068e605e8d0653954d518d7b9025d374b2e374731bbe800cfa6ca89743f7053": "0x040000000002000000000000000000000000000000000865736b696d6f72000000000000000865736b696d6f720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471434089e43cd4989a9dbc5fe127aa5c0a6df694aa2a9dc6c68a1acd76e61f8f238bc8e71fc8d311636": "0x0000000000000000000000000000000000117363616c6577656233202d206a726d7200000000000008406a726d723932000f5363616c6557656233233731323300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714342d10fd36c3ac43cec9484c231e2d686bc8932300191a43fa515f95c02ceebda09ad8d8f5fc5305": "0x000000000000000000000000000000000015496e7641726368205465616d204163636f756e740000000000001040496e76417263684e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143458891c8e3214bfc070c3303fb82d487442202f6a3270f8a19af8691f9b6bb5b23dcf1745f02d1a": "0x040300000002000000000000000000000000000000000e53616368696e204775726a61720e53616368696e204775726a617200001773616368696e686c6f32333240676d61696c2e636f6d00000f73616368696e6775726a61725f34000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143461fb0d1f2c29fe9088b991261091d43c92ce790d4c8fb007b7e8d19c9c619a7d722c6fbdb55f04": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31331142494e414e43455f5354414b455f3133000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143494187c44a6e4fb8efd9cd4b3a223ff29da836fd6f01ce2fecadafaba8fa460c360239f2b084eb9": "0x0000000000000000000000000000000000124445442054656368204d756c74697369671b446563656e74726174696f6e20547275737420436f6d70616e791968747470733a2f2f646563656e74726174696f6e2e6f72670000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471434c90aef7cd6c087500774a5e6eb480dcabecc949e4c2508d7329ea62a1e68aebf76b819da6b864e": "0x040000000002000000000000000000000000000000001c616d6974726f76696368207c20556e69717565204e6574776f726b14416c6578616e646572204d6974726f76696368000012616d40756e697175652e6e6574776f726b00001140416c656b73616e64614d6974726f31000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143510bca3b55859f7b8296995e76034c70f1f703618da7493b946e24b590c53cd7bf5ab0c4cadd35f": "0x00000000000000000000000000000000000d746865626c61636b6861776b074948204b494d000014736f6172696e677373406e617665722e636f6d00000b40736f6172696e677373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714355270ed8e9758bf26283680a763407ce7914d1a67d460d0d1f44d51097783ad17f161678218062f": "0x040300000002000000000000000000000000000000000c436f6e6f7244616c7932320b436f6e6f722044616c79000014636f6e6f7240636f6e6f7264616c792e6e657400000c436f6e6f7244616c793232000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471435668a15706f1b1bb42eda141e4c2c67af7180747b776be512c3fd83e5c359e7ca4cb3fc2d3a545b": "0x000000000000000000000000000000000011506f6c6b61646f74204163636f756e740c4a6573736520426c61636b0000176a657373626c61636b36343440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714357accb7976ec983aa479bfcbf35b48d8e5755c7a34bb367ce63261b6a0a51f24de1978c711f813a": "0x00000000000000000000000000000000000c526f79616c6167656e63790000001e636f6c61626f726163696f6e657340726f79616c6167656e63792e6573000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714359ba2c3f9bfa49015d7109f79f5bbf8a34fe2b2c9e68f0076f2bb900fb3cadff0e3e0239d804a70": "0x000000000000000000000000000000000014426c6f636b636861696e2052696f203230323400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714361d0f16c34b17763817e559bdeb521169c4801d70a1dfefe94175d15666a1ae70719a3594a57c16": "0x000000000000000000000000000000000014736f7665726569676e6e61747572652e636f6d00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714363df5d8dc0e8fe77042bfc6e75e1277fdefbea917f6b7ca8c36b3e0ad7286d66974c8f2b4cb9672": "0x040000000002000000000000000000000000000000000d414c474f207c205354414b45000016407368616465776f6c663a6d61747269782e6f726713696e666f40616c676f7374616b652e6e657400000b40416c676f5374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471436614a3e28f4b5c8ca7c4d5563b5f38c3a5d1e7d348ea2dbe06332f55f17dd0150d606bcb8777258": "0x040300000002000000000000000000000000000000000a4e6d61727368616c6c124e6963686f6c6173204d61727368616c6c00001d6e6963686f6c61736d61727368616c6c31406c6976652e636f2e756b00001047616d696e675f6f6e5f436861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471436623b12ed037a52fcbe4bd03bed7dd7ad734f50e0c283d9af0a129e71e78ea6128021f9cbf5af05": "0x00000000000000000000000000000000001e506f6c6b61646f74204272616e6420426f756e74792043757261746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471436d8007439bfb5ce4aa76d977ed253365d18637af3d4159ca3ef710933143d8db9b99faaa48a5a52": "0x00000000000000000000000000000000000e466c6176696f20e29895efb88f0000000000000e40466c6176696f5f6c654d6563000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471436e262e10cb9b3db9f96f2a47d349d32da9e47f6206196b6869fce0e614fdb0fc46bc95fbbb60ecd": "0x000000000000000000000000000000000018506f6c6b61646f7440546f6b656e323034395f3230323318506f6c6b61646f7440546f6b656e323034395f323032331968747470733a2f2f776562332e666f756e646174696f6e2f001761646d696e40776562332e666f756e646174696f6e20000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143721f074825b67fc14e5b21d2eee0865adfb8783ac900540d67f0a89eb6881e77dda91d509398809": "0x040000000002000000000000000000000000000000000b476f6e74616a6f6e657300001740676f6e74616a6f6e65733a6d61747269782e6f7267176172747572676f6e74696a6f40676d61696c2e636f6d00000e406172747572676f6e74696a6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471437626cdc63a152498a0e3784748694717e84559e00e0876f456fa206db3ab70327d512a24730ec37": "0x040000000002000000000000000000000000000000000577696c6c00001d406d6574616b6f736d69613a6d61747269782e7061726974792e696f00000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471437a32ce68f563a4a0a820dd53c6ea693d41a8d11910443a34fdc13a3d54cd111682b39d90ef57c38": "0x040100000002000000000000000000000000000000000e7374616b652d706f6f6c2e6575001a68747470733a2f2f7777772e7374616b652d706f6f6c2e65750013696e666f407374616b652d706f6f6c2e6575000009405374616b654555000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471437cd5a422db43856985be267f05f586da7ab52e4430c2f6d461f396b9d6cf4f1eb5362066f7cd82f": "0x040000000002000000000000000000000000000000000b5350494359205441434f0000164073706963797461636f3a6d61747269782e6f72671a73706963797461636f70657070657240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471437fb611aa391843a0617c14e4ba86d011c84b8a2a5b3f18758bf40915608a130518fa89b0a47e169": "0x040000000002000000000000000000000000000000000e436861696e20736572766963650000001564656e7665727437383440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143831c8a7af466e1a968ed5a157452dab7ddc6950d423e78edc9780da648cf7c009982b6bce956e7a": "0x040300000002000000000000000000000000000000000e43727970746f566972616c6c790000001868656c6c6f4063727970746f766972616c6c792e636f6d00000b4e61737461476c656e6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143844e5cda0e40f06f4f08248be088e83f0fd179f3b32d48c4540adaa119630979292e8b24b12144f": "0x04000000000200000000000000000000000000000000144a6f726d756e67616e64204c616273f09f908d000015406d6f7274677261793a6d61747269782e6f726700000010404a6f726d756e67616e644c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471438533548d44cc8d84056f76b206c306712a75e10ece4cffe091b1a49b0ba4c505f2ae4ee673c576a": "0x00000000000000000000000000000000000c5a4b56616c696461746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471438713841aa089048252a69cb3b782cfc3696fed0fe67bd0c92ca21f2767482af41a902e5a8281145": "0x0400000000020000000000000000000000000000000008566978656c6c6f00001440766978656c6c6f3a6d61747269782e6f72671268656c6c6f40766978656c6c6f2e636f6d00000b403078766978656c6c6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714388926241aaeef7a34dc4d6e6c7520791be90da8875a9a40653b4845ca03811c317cdcb034ce9e3c": "0x040000000002000000000000000000000000000000000d44696f6e79737573f09f8d87001968747470733a2f2f64696f6e797375732e6e6574776f726b1f4064696f6e797375732e76616c696461746f723a6d61747269782e6f72671468694064696f6e797375732e6e6574776f726b00000f4044696f6e7973757356616c6964000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143890df58c23c48913a04ac816fac137bf9ea324fbe8aae47b1169761f94c9dc943ed2e4b80620f4f": "0x040300000002000000000000000000000000000000000c52616a2052616f72616e650000001872616a72616f72616e6535373640676d61696c2e636f6d00000d4072616f72616e655f72616a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471438e49f900e62691ecaafae0aaa6333fcf4dc193146945fe8e4da74aa6c16d481eef0ca35b8279d73": "0x0401000000020000000000000000000000000000000005616b727500001240616b2d72753a6d61747269782e6f72670d6d61696c40616b72752e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714390c74f4052dd71642a8f4af92bc51e83093eeecb73f2aab526a11c41735ff54d9fc7de54ace5c6d": "0x040000000002000000000000000000000000000000000d50617261636861696e626f790000001e6a6f686e72686f64656c626172746f6c6f6d6540676d61696c2e636f6d00000e4070617261636861696e626f7900106a6f686e72686f64656c233831363200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471439335e2f28a7aaec85a72cf77774526be03a8e0759b18af9c2ca15954050ce4098d48996a8e716cc": "0x0403000000020000000000000000000000000000000013506f6c6b61646f742e456475636174696f6e0000001b636f6e7461637440706f6c6b61646f742e656475636174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714397f26eed6dc09cdae3abb16e30166db6c77a2f24b6e19cc63bd95fc08529bcb05bc71273a762b29": "0x00000000000000000000000000000000000e746d64765f706f6c6b61646f740f546563686d65646576207361726c1568747470733a2f2f746563686d656465762e65750012696e666f40746563686d656465762e6575000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143984bb08caa099b70cdbc545f7f5439e9eeebcf2ba592a87fe0da381d75a0bc8abf9f3b8ade4884a": "0x04000000000200000000000000000000000000000000044a4a4200000000000008404a4263727970000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714398ac470c132d05746cba586963ce742f0f17d705174df4317e773788ebdd7244df0a0ddedcc645c": "0x0000000000000000000000000000000000144379706861646f63f09f91a8e2808df09f92bb10416264756c617a697a204b616d696c0018406162756a756c61696269623a6d61747269782e6f7267136379706861646f6340676d61696c2e636f6d00000a406379706861646f6300096379706861646f6300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471439ae776eda0085e120f67bb36605f9ed8f7718d0b1c2ae212a5de9560662ba0814ae8ddd3bc9be57": "0x04030000000200000000000000000000000000000000045465301154656f646f72204b72617374616e6f7600001474656f4073637974616c652e6469676974616c00000e4074656f6b72617374616e6f76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471439c5f2d53febd2c2f8c56648d781e59233b49323a09ee6a8b0410a4049d62549d27240f691893872": "0x04030000000200000000000000000000000000000000135468696261756c742050657272c3a9617264135468696261756c742050657272c3a9617264000018742e70657272656172644070657272656172642e636f6d00000840546974693150000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471439fc7b224a1750e8dcbad707002e3836a201fee988a917a528e2eb37ed99c74cb8a98819a9330406": "0x040300000002000000000000000000000000000000000c57696e7465725374616d70124c656f6e6172646f20437573746f64696f0000156c656f6e6172646f40637573746f64696f2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a0f07f5bfdc2f192a45a8d99f3141ae7e1c9c636bead309c3bf3ee50d72a948acdd3d0104bb5608": "0x00000000000000000000000000000000001a446f742d437270746f666f6c6c6f776572202d20537461736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a183e641b31567800859d2281b19e6650fd9bcc6dee02254ea1590ce4b8b831617dd79336ba4d36": "0x000000000000000000000000000000000007436872696e6300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a2a13c271740b976af2f79717e1a5b28437221e8b526ec3a23d9b83c45baeba67ae76812ea07636": "0x040300000002000000000000000000000000000000000a4d616e64616c696f6e0c41647269616e204b65657400001c61647269616e2e6b656574406c696768746174776f726b2e6f726700000f4061647269616e6b656574333630000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a47757951924bf938236315632f2c74a59daeaeb84b2f349771ed1dd9018b421a8ed32f69d0750a": "0x040000000002000000000000000000000000000000001050727565626120506f6c6b61646f7400000013646965676f4070726f746f666972652e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a4998c1a7d8244c6819b9b3dab3439825f9b076ff1be1f248fe246f6be57b131d7d10e38b08fd00": "0x040300000002000000000000000000000000000000000b4761746f724b6f727073115374c3a97068616e6520466972696f6e0000176669725f70697261746540686f746d61696c2e636f6d00000a40676b31385f646f67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143a5db923b142979614acd07ac36ad489a295216ed144b8b0ed0c46a5f8a74c44b1948793f015297a": "0x04030000000200000000000000000000000000000000084d61745061756c000000146d61747061756c303340676d61696c2e636f6d00000b406d61747061756c3033000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ab053dc6b6a71e1b4f7f03bebc56ebe96bc52ea5ed3159d45a0ce3a8d7f082983c33ef133274747": "0x040100000002000000000000000000000000000000000f41757265766f69725861766965720b586176696572204c61752168747470733a2f2f6c696e6b74722e65652f61757265766f69727861766965721b4061757265766f69727861766965723a6d61747269782e6f72671078617669657240696e762e636166650000104041757265766f6972586176696572000f41757265766f697258617669657200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ae48fb4d4a27b38063f5eee28e6df57ff122966e99dc82b479be3be5be9d627c10c5ea4db744d53": "0x0403000000020000000000000000000000000000000008446176696443431144617669642044616c6c2741676c696f00000c63656f4065766f782e676700000b4461766964456e656144000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143afb6326da17f7c2b27005300822ca95d14188dd385d93db13a6f76c4fc434c192ed476d353fc9df": "0x000000000000000000000000000000000008696e6b2168756200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143b04e47e14f8c9afcc472f8aa3afdab9a0f1abb66088817448690426bacc0af6f509241ae452a65c": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31351142494e414e43455f5354414b455f3135000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143b1767a9bb0967a7c6b17325907642f63b7e30a9636cb7db2ed22aec146ccad2e0a8991b5568607d": "0x000000000000000000000000000000000005426f7661000000166368656e62616f4063727573742e6e6574776f726b000009406170706f697070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143b484b0dc727b45354825d8d050d0ac046e52f333e820999ac3dacb75f29306eb8233c0caf8ef012": "0x00000000000000000000000000000000000c446f742e616c6572742829001e68747470733a2f2f646f742d616c6572742e676974626f6f6b2e696f2f000000000b40646f745f616c657274000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143b4dd5f6332fce89f835522ecf3341305a26c938e8ad09fdf91dca4b9a98b8b0daafccd68ac4a505": "0x040000000002000000000000000000000000000000000ff09f95b454555845444ff09f95b400001a407475785f696e5f74757865646f3a6d61747269782e6f72671774757865646f2d77686974654070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143b8fa2e75a1b9c5bcea3dabe52b2a665b1e19bf8c6913a5d54e06d6413ca3ddbec8f9a22415ec477": "0x040000000002000000000000000000000000000000000644617669640000174064617669643a776562332e666f756e646174696f6e0000000c4064617669646861776967000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ba0d8c6411833131ac5e7c54f557fcef02102186c742fce89cdda3c1073bb3271d8e91557877c70": "0x000000000000000000000000000000000009627261796f323536124168696d6269736962776520427269616e00001d6168696d62697369627765627269616e393640676d61696c2e636f6d00000e4062726963727970746f323536000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143bba269358278e21860054009a10c600b2d7cb347d672e1b27906a15e26955cc014fe868317a497b": "0x040100000002000000000000000000000000000000000e4669676d656e74204c6561726e0e4669676d656e74204c6561726e1468747470733a2f2f6669676d656e742e696f2f001379616e6e69636b406669676d656e742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143c0955c5290aa69b8b1cf3b7ea2354781b6355660bd1481fe2e68d5a7a9c7692b54eed3c278e5b73": "0x040100000002000000000000000000000000000000001443727970746f50726f63657373696e672e696f2143727970746f50726f63657373696e672e696fe284a2204f4f4d2e41472049451c68747470733a2f2f63727970746f70726f63657373696e672e696f0019696e666f4063727970746f70726f63657373696e672e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143c096cf3f561e3834026c99cba12d64d1d0e7a7a620bf54374603fcc056e1601e3713f9921671120": "0x04000000000200000000000000000000000000000000114c45505245434841554ee29898efb88f00001c40706f6c6b616c65707265636861756e3a6d61747269782e6f72671b69726973686c65707265636861756e4079616e6465782e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143c29f0e466429f37964df9daa6cae8b790469f83dd63d0650bfc76ae16a67c4cabefdcf25d8d172c": "0x0000000000000000000000000000000000074e6f74696669095061756c204b696d1868747470733a2f2f6e6f746966692e6e6574776f726b2f174070696b616e6f746966693a6d61747269782e6f7267187061756c2e6b696d406e6f746966692e6e6574776f726b00000f404e6f746966694e6574776f726b00174070696b616e6f746966693a6d61747269782e6f726700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143c790f30d60af3f382ecbf12e0965d08387b8aca42993392dbe5ddd0de48393b96075c641f2c9408": "0x040000000002000000000000000000000000000000000647335251300000124067337271303a6d61747269782e6f726719673372713076616c696461746f7240676d61696c2e636f6d000007404733525130000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ca7f22618c737cbdedcb9123b5751a728ba18380f2c53b9cfb307cda0a6afdd85a30a3e9205385b": "0x00000000000000000000000000000000000b50617261636861696e7300000018736b6174655f62636e393540686f746d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143cc9562cc3c280496e92f87f2434cffb3afa90a740ede218ffd94189a9a5f216b89de7c74609f047": "0x000000000000000000000000000000000005536f74610e536f746120576174616e6162651768747470733a2f2f61737461722e6e6574776f726b2f0013736f74614061737461722e6e6574776f726b00000e40576174616e616265536f7461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143cca7e3b1fdfe91c74d294ca861109c5f994b079460265f593e736010dff119e1449a2c1519c6186": "0x0000000000000000000000000000000000174d65657475707320426f756e74792043757261746f72001d68747470733a2f2f74696e7975726c2e636f6d2f6b3376366338626d001568656c6c6f40646f746d6565747570732e78797a000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d38025ab9dda7b272e03b44235444cf15cd1c6f4b028ef714605714a5eb4be2a4013c649bc5c97d": "0x04030000000200000000000000000000000000000000194672657175656e63794e6574776f726b50726f706f73616c0000001d7068696c6970406175746f6e6f6d6f757370726f6a656374732e636f00000e6f6e655f6672657175656e6379000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d4a76d67fff41d458ea543dfaedae9fe811b7c8cef72335ac41180e0c13d2d9e0bb89c506d44049": "0x00000000000000000000000000000000001061736f6c696d616e2028426f64612914416264656c7261686d616e20536f6c696d616e00174061736f6c696d616e39323a6d61747269782e6f7267000000000b61736f6c696d616e39320000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d50c330808d23bc48bb96e509af35ac3308a94a3ac2db6e47f0197cae378cd4ca86430bc5dbce8d": "0x00000000000000000000000000000000000631325745421757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d606081b82ba5aa0851213d7b0d4ef3edf4f62f7b0d3dc92edaad32daddb3c51b4ec205ec9c7779": "0x0000000000000000000000000000000000084f55544b415354001d68747470733a2f2f6c696e6b74722e65652f6f75746b6173746e667400166f75746b617374736e667440676d61696c2e636f6d00000d404f75746b6173744e465473000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d6510d934b941c5feba71d41f307c6b4c59481cfb3a5d732175f7766aca821e98b1ffa8ea9f355b": "0x00000000000000000000000000000000000a4669676d656e742037001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143d7b57c9bab601df742f10a2b57e5ec3247c0ae6da2a2fdb4a731324dc7a2edfe0f4fc761e1a4d3f": "0x04000000000200000000000000000000000000000000094d696368656c6c65000016406d696368656c6c65783a6d61747269782e6f726700000000001336303833373436343939373331313330313400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143da7764530213aeaace846bae7cfbaa4ddb3d59d4bbaccd5d0b23bc3fc2cdf2194600bdab81b2972": "0x0000000000000000000000000000000000056e6f776100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143dc70605572f3709b8db36235621ae2f05e3e35e61a8101af409113d06b17417db649dab460c5c2e": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2035001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143e0a61ef993a58f6b099640796b5d19532ac152deb098b161a0b0d23c6b95c5a72f0ea27e696db3c": "0x040300000002000000000000000000000000000000000d4564676172506572616e746f1d45646761722044616e69656c2053616c696e6173204c656465736d6100001865646f67612e73616c696e617340676d61696c2e636f6d00000e67656e746c655f68756d616e6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143e843a37d45e41d726171b3ad75723bf624a27485e51e4c2fe38f4b2d24ee52b86a979fb772c513b": "0x0800000000020100000002000000000000000000000000000000000843686576646f720e57696c6672696564204b6f70701868747470733a2f2f7777772e63686576646f722e636f6d144063686576646f723a6d61747269782e6f72671263686576646f7240676d61696c2e636f6d0000094063686576646f72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143e9ff1da508f2a3c7ccb1907030863dd708764cc88a4b4d09dc5bb0f4c9ef5f4e73cfc0aa4bcdf3c": "0x04010000000200000000000000000000000000000000054572696305457269630014406433636b6172643a6d61747269782e6f72670d6572316340747574612e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ed5ac38541b55b1cf68aca8c6afda0f57323e21f3aee8bc2630736c2a85c6213c79160b4d711283": "0x00000000000000000000000000000000000e414a554e41204e4554574f524b1c426c6f476120546563682041472028537769747a65726c616e64291268747470733a2f2f616a756e612e696f2f162040726f786f6e746f783a6d61747269782e6f72670f68656c6c6f40616a756e612e696f00000f2040416a756e614e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143edfdd48fc779cd5a80ea94af8a39eb7ba8d9afb913147e67eae84f48aad7b9ce6ee05094fe0394e": "0x0400000000020000000000000000000000000000000005416c6b6f00001340616c6b6f38393a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ee48405c88be7992aa791b10dcfbe7ee482dfc6700da33db52b3ac81fc8822dee527f8aabcad613": "0x040300000002000000000000000000000000000000000b536972576f6c636f74740e506574657220576f6c636f747400001a736972776f6c636f74744070726f746f6e6d61696c2e636f6d00000b736972776f6c636f7474000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143ef4b38f8ce032ce06b8e579e2c0a3a3b87f1070181254ea66f8e083c00220215b111d117565334a": "0x040300000002000000000000000000000000000000000d446f74204c696e6520446f74164a61696d65204665726e616e64657a205065c3b16116687474703a2f2f646f746c696e65646f742e78797a001a646f746c696e65646f742e706f6f6c40676d61696c2e636f6d00001140446f744c696e65446f745f706f6f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143f340ae0b8ad2cdc2017a0afa42b831ea0c10e34b8b208eeccfe324169a8d6776921510cb42a897c": "0x040000000002000000000000000000000000000000000e4173746172204e6574776f726b000016406173746172323030363a6d61747269782e6f726713696e666f4061737461722e6e6574776f726b00000e4041737461724e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143f4e772ad45522ecaea3ca653928298cd4d1d64cf916aacf72e4e2ca435453941a73327a8dd0a00b": "0x040000000002000000000000000000000000000000001056696b6b202d20476f7620f09f8f9b0000164076696b746f722e762e3a6d61747269782e6f72672176696b746f722e616d6261737361646f724070726f746f6e6d61696c2e636f6d00000b40786356696b746f725f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143f542ae0e8a4948cf48ad80b7cac41b7805a33923cd8357e7d179c16db083494bddab65845707b6f": "0x00000000000000000000000000000000001b444f54204a445020506f6c6b61646f742e6a732057616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143f632b1c99a04492568b83865c932b2538214e98c5b8e4fc4779b9f0dd63788c8911d933b3b53f63": "0x00000000000000000000000000000000000b566963206375656e746100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143f6dc540984e16754c1383fd768ee83c1cd53eee57d10f21bb61eb6d37360fd34565ce35e5c5241f": "0x000000000000000000000000000000000008427574614d4d5300000018736f6d6564617967726f77757040676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143fa0b657ef7bbd841e5db30d360532b3bb6a9c0eb447f439bd16fa7be3002bdac10d2a6ce6e03567": "0x00000000000000000000000000000000001141726a756e207c2050656e64756c756d001b68747470733a2f2f70656e64756c756d636861696e2e6f72672f000000000a4050656e41726a756e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143fb71bbdb75b9a868cd54ac24629880ed1f3e6c8d5858ea08b5a7fbaa2c210c79e04223f3f05f35a": "0x040000000002000000000000000000000000000000000a526f62696e686f6f6400001740726f62696e2e686f6f643a6d61747269782e6f72671f726f62696e2e686f6f642e76616c696461746f7240676d61696c2e636f6d000000000c726f62696e2e686f6f6f6400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047143fd48a75c1748c9c8e1ad9a11d5366e823c79dfb0b4416853734464245fb93d9ba62e818cbffe516": "0x040300000002000000000000000000000000000000001143726970746f204578706c6f736976611c46656c69706520416c62757175657271756520646120526f63686100001e6d657461766572736f64617363726970746f7340676d61696c2e636f6d00000f66656c697065726f636861747631000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471440211a7f8ab7a9a03c757ba7f937e877ce2171c04b729b5fcdf7bb4d9f11c46dfc50212664e5cd08": "0x040100000002000000000000000000000000000000000f5a6869786920496e7465726c61790c5a68697869205a68616e670000127a6869786940696e7465726c61792e696f00000e406e696b6b695f73756e73657400175a68697869f09f8f96496e7465726c6179233730333500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471440935ff2a98db16d44cb8281a79f264f66e42069baa12cb82c312afc38e4c09258b246cfc5752f4f": "0x00000000000000000000000000000000000a44616d6a616e444f541344616d6a616e204b727a69736e696b204d2e00001a64616d6a616e2e6b727a69736e696b40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471440a080abf9c0d1738465abd5a02f5b42b23e323b73e52416514460b9a3e7c34c94ed8d9f986c3d6e": "0x00000000000000000000000000000000000c536b616c6d616ef09f90a200001440736b616c6d616e3a6d61747269782e6f726713736b616c6d616e407269736575702e6e65740000000a6472736b616c6d616e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471440b2bd2f7def6a3b80be87a5561edbd79c1ac4606901d84d1b4e185c26ac139cfc4ac12413d26d6c": "0x00000000000000000000000000000000002042494e444d494e543a20616e792d77616c6c657420616e792d62696e646572000016406e6f7474696573746f3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714410472dcbca97371353b66bebdd4061939ffb1a79127e46d4c262bb8548e4a052f2087706cd4cc62": "0x00000000000000000000000000000000000c436f6c6c61746f7273696f0c436f6c6c61746f7273696f1568747470733a2f2f636f6c6c61746f72732e696f0015636f6e7461637440636f6c6c61746f72732e696f00000d40436f6c6c61746f7273696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144137b87771b2fd4e981bc48f19eab52de7f8c981822cc15f26990d5e90faba03e15894c0daf39759": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2034001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714415c4423d7d007052511a0306373926c509df110cda6e83fe525b6cc5564a9cf397ecefeeb57413e": "0x00000000000000000000000000000000000c526567656e63792d3031301757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714417aa25e24e3a895b46b21246e25a4882615af17b38863ad0b757ec4242f7fa58ce70462c0c4b246": "0x00000000000000000000000000000000000e4d7920444f542077616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471441c47496ae1126564a8646cd9813bde9f62216e463129227292ac57963a50e3f4184220ef8163052": "0x040300000002000000000000000000000000000000000b506f6c6b614d6172696f104d6172696f2053636872616570656e0000136d6172696f4073636872616570656e2e657500000f6d6172696f73636872616570656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471441e29c1629f394e1e4a77c09a5e7cca4340cd6ce8dd3cf6dfffacadaab7bd6581b7ca50959834271": "0x040300000002000000000000000000000000000000001553696d6f6e2040204b65792050696374757265730e53696d6f6e204869706b696e7300001673696d6f6e406b657970696374757265732e6f726700000d404b65795069637475726573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471442322010c0d1a89d36f6612bdd0a99e13fc4b24f30fb4522c13e2c2dfc3cd3fdcb44a2eb8d94c972": "0x040300000002000000000000000000000000000000000a4d722043727970746f0743727970746f00001969736161636d636d616e7573313040676d61696c2e636f6d00001140497361616363727970743433393534000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471442817abe7768122ad62aa3f00ef7f4e99f6dc2b160ed54d22142d890e4589effd93159596db40a5d": "0x0403000000020000000000000000000000000000000005416e6e610d416e6e61205275626c6f76610000167a756576612e616e6e6e6e40676d61696c2e636f6d000011406d6f6f6e7072696e63657373616e6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471442e8554be4de706545f4c317ada07d49eba49a3c0efaaa1e59283fbb081aca1c62b1826031ab68b8": "0x00000000000000000000000000000000000e42616e642050726f746f636f6c17576f726c64204461746120436f72706f726174696f6e1e68747470733a2f2f7777772e62616e6470726f746f636f6c2e636f6d2f001462644062616e6470726f746f636f6c2e636f6d00000e4042616e6450726f746f636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471442f5d87995df46aba849437f5f8b602fc9a4210d6a9834af4adc6ce7492861bd0f5b88d11919cd7b": "0x040100000002000000000000000000000000000000000d43525950544f20504c415a410d43525950544f20504c415a411868747470733a2f2f63727970746f706c617a612e65732f00177374616b696e674063727970746f706c617a612e65730000104063727970746f706c617a615f6573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144316433e1f50b4c3a66e0f4e1a121cc83fddf3096e8ec8c9e9c85989f276e39e951fb0e4a5398763": "0x00000000000000000000000000000000000a67696c6573636f70650b47696c657320436f70651968747470733a2f2f67696c6573636f70652e6e696e6a612f000000000b4067696c6573636f70650a67696c6573636f70650000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714431c4c64db68d8bc2211d6fce26d7140904357fce2aca5d1e63b362f1789bb6d7dbd848d3df79c65": "0x04000000000200000000000000000000000000000000084d6172636f526f000000196d6172636f726f6d616e6f77656240676d61696c2e636f6d000009404d61726330526f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714431d3bd5ffac15fd908006776baddcbd6ee1037b124dce04923c13176eca8a467612a1bfe471184c": "0x000000000000000000000000000000000006757262616e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144346ad63c2bfe5464174ed6a137e6df4c9dbbc1ef6fd102a67295edb937fe7446b0a38930927bf16": "0x0000000000000000000000000000000000084d75726977616900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471443496d81af6ed7735855f6f9634a68990a917f22cda160e53f14a0bab251926d946650b4df53412f": "0x04000000000200000000000000000000000000000000217370617a636f696e5f4368616f7344414f5f496e74724b696e745661756c7473000000137370617a636f696e40676d61696c2e636f6d000008407370617a7674000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714434ad746326c40551646bd1c80f91d01409be58ff6e426f857aff02f544540e2b5c7b54c6d4a3e16": "0x040300000002000000000000000000000000000000000753756d6565740c53756d656574204e61696b00001568656c6c6f4073756d6565746e61696b2e636f6d00000a73756d656574776562000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714439f39607719f9fb7026f145d6eb23143d729bc300e35203a831fb08b315235032e2527a659f6c29": "0x00000000000000000000000000000000001a506f6c6b61646f7420526567697374726172233120546573740000001d63686576646f722b72656774657374646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471443c450490ea5a0dfaa1e41806e32999e0754be06b02cf2cd7397d7449111cd16757b6a846b9cdc54": "0x00000000000000000000000000000000000e636f696e766572736174696f6e057061756c19687474703a2f2f636f696e766572736174696f6e2e696f2f000000001040436f696e766572736174696f6e5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471443d4cb05677396f618812f78e7c7d0769e2050a07e54d7d26ef922f2ab3e45d66f0289d5dd1deb08": "0x040300000002000000000000000000000000000000000754696767616800000014746967676168406d6f6f6e73616d612e636f6d00000f407469676765727363727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471444000dd1889b03b1be415da93670251b3c219aff9d1069ef99d27a453620c20d9b4dde4739caa55d": "0x0400000000020000000000000000000000000000000009706965726f20672e000000000000000a706966726167696c650000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714444f277f5dcf70d79848dbbf16e1a48ac57884a4d2a3d64ed6784969927e04129066877ad098a009": "0x0400000000020000000000000000000000000000000015526f737320616e64204a6f656c207c204a4b5242001068747470733a2f2f6a6b72622e696f0010636f6e74616374406a6b72622e696f000009406a6b72625f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471444646f06f20d51883c017930b46ab5a4413bf3153b001287ed5ff7fdbd2734cf69abc843f4ee0447": "0x0400000000020000000000000000000000000000000017f09f909f59656c6c6f7746696e2054756e61f09f909f00001940626c756566696e5f74756e613a6d61747269782e6f726713616e74756e40747574616e6f74612e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144473d1741e91e5149a137cacb7c5e216b12fda7a62c853c15ff93d8f0bd0c8b19520c3ec689df366": "0x04000000000200000000000000000000000000000000084d696c647a73750000000e6d696c647a737540706d2e6d6500000000084d696c647a737500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714447e1613a9d973af08d48a00b01356b80f40e50f281c2cda9e858f45a1bc8e989b3eedfb27dfe044": "0x04010000000200000000000000000000000000000000094252415f31362d4400000016637074636f7272656f6f6640676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471444807460d777b1493446e1bf0c0eb4682d4b7269c0b0459685dd3cdb024467ec4f01f6e878df113a": "0x0401000000020000000000000000000000000000000013546f626961732041697264726f702e636f6d0e546f62696173204b75737465721568747470733a2f2f61697264726f702e636f6d2f1440746f626961736b3a6961627369732e636f6d15746f626961732e6b4061697264726f702e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144497480ac18f14a6cc267824fecaa355e8b540102fc0386dc902d068e1099f5d64f9bdfad8e6b936": "0x00000000000000000000000000000000000b53756775616e677275690000001773756e62696e674070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144499fd1a049d4b87923e75ccccb33e471161db9558583ef4668de361bdf471e674256e8fe0748706": "0x040000000002000000000000000000000000000000001d50726f6d6f5465616d207c20416374697661746f72207c2052756279000000166f70656e676f7662726f7340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471444ae3a94bfb51fab3e5ec4b057a0f4b697e048bb02918c5c07998f08ade9e7b6a31ca6ddf3956442": "0x040300000002000000000000000000000000000000000b416974696a696127657200000019616974696a696165722e696e666f40676d61696c2e636f6d00000b40616974696a69616572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144567817f570fd2a7d4780b9e5750a1a1772e61c81d02fb63c88815de6c2f5e1123a2915a4dfa1143": "0x00000000000000000000000000000000000873616e6368657a0e46617a65656c2055736d616e6900001966617a65656c75736d616e69313840676d61696c2e636f6d00000e4066617a65656c75736d616e69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471445710aad85286ba2f61e1319acc0189207ad27455845c7d7b60ded1be7c50279c04cea4d89835759": "0x040300000002000000000000000000000000000000000d4976616e206f6e2054656368104976616e204c696c6a6571766973740000126976616e40696c686f6c64696e672e736500000b6976616e6f6e74656368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471445a26c6e9f4fbc9e1a93333836f4c417e6a25d826a06d994d688a791f31a2ffe77eb6f0b11074575": "0x00000000000000000000000000000000000c57616e677368692e65746807e78e8be58d8100001677616e677368692e65746840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471445b8ad3d042acdd1361d8fe50e87561a6623c67f9ad530973749b54f8015c29ce0b234de9f942e45": "0x00000000000000000000000000000000001044617669642059696c696e67204c691877656368617440446176696474686550616e6777616572000014646176696440666f757269657270722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471445d43cb8401e3564f40cd7a2181289e32776625b9f3a193f749e33ce1bdeb76cfaabece606c7324c": "0x040000000002000000000000000000000000000000001768656c69787374726565742e666f756e646174696f6e00001b4068656c69787374726565742e696f3a6d61747269782e6f726711744068656c69787374726565742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471445ec95bcb8dd897248d5f568124b09fefe504a22bbce2ccee0fcae9262c639b6b2ebaf95b5c8fe77": "0x04000000000200000000000000000000000000000000175368616e6b6172207c2045646765776172652044414f0f5368616e6b617220576172616e67001a407368616e6b6172776172616e673a6d61747269782e6f72671b7368616e6b61724065646765776172652e636f6d6d756e69747900000f40576172616e675368616e6b6172000a7368616e6b61722e7700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714464cfe5f5087e90778875e66122277dc5609bad6a10ec246d89c1bd30c549ef3d839d2bc2f78af1a": "0x0000000000000000000000000000000000094a6179506f6c6b6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714465cbd752cabb7fa409b7555f513abf3af9740d09b7a47d7c2ce84dd3b146a791dfd28d8e0abae75": "0x000000000000000000000000000000000010706f6c6b61646f742e676976696e67001868747470733a2f2f706f6c6b61646f742e676976696e670015696e666f40706f6c6b61646f742e676976696e67000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714466588a6e1073ed4aaa806fd8ff8e363c4f3139c07bd115f3879de52f9961fd61f58eb1610ef6836": "0x0000000000000000000000000000000000074c5020444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446720693a520effa96f8ff6a5803682aa883aebdb426940851c7de4cc302e540a4822d63e1216c71": "0x000000000000000000000000000000000014476d656973746572207c2045646765776172650e432e20476167616e2042616275000019676167616e4065646765776172652e636f6d6d756e69747900000e40687573746c65346c69666537000a676d6569737465723700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144672db3439b14d041e5d733c17f21e33af639896e0e959ed44cdd05f44d67f60e8311022dc90d51a": "0x040100000002000000000000000000000000000000000f51494e57454e2e3136384e6f6465001468747470733a2f2f3136386e6f64652e636f6d001771696e77656e40776562332e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144692967bd2332c08b22f88d05ca6fdb70235b599b99c69f927ed71163c2ebc11c9649d678a8ba84e": "0x04010000000200000000000000000000000000000000094c6974656e747279094c6974656e747279000012696e666f406c6974656e7472792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446955dc79999f928ddd3e0632b74f5e8d57de6814a16b6451366eb903a7943ed00051e7cca5d24d2": "0x040300000002000000000000000000000000000000001050617269747920536563757269747910506172697479205365637572697479000014627567626f756e7479407061726974792e696f00000f706172697479746563685f736563000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714469f989f6ca51c58f3b15e49aede08aa29d7400da8d3b4fdbd284b5bb1f1af1a53a8c47398f1f093": "0x040000000002000000000000000000000000000000000b424545465920f09f90820000134062756c726f673a6d61747269782e6f72671f73766562697261642e7072697469736b6f76696340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446a18621916cf2627efce294aceebeb808ff4ab99930030a5182be918fff1261ca5c5b41acbf6f11": "0x00000000000000000000000000000000000c526567656e63792d3030331757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446a8b45a25e83bcdea16fb2015c85c938d41f946c5fcf6c310872e30ec541c81fd2108e7d1b89813": "0x040300000002000000000000000000000000000000000f4d65726b6c6520536369656e636521537461636b7365657220546563686e6f6c6f67696573205074652e204c74642e0000196e69726d616c406d65726b6c65736369656e63652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446b9cd597eba686fe4a48b16cd6a6c6c44e4c9542e923726dc861077b6a4ff3df1969b13a6868b2f": "0x040300000002000000000000000000000000000000000d5061756c6b61646f74746572000013407061756c6b613a6d61747269782e6f7267177061756c6b61646f747465724070726f746f6e2e6d6500000e407061756c6b61646f74746572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446cfb8d6f019ac35a002a7d2c93a1e4c5f3ed5e95b06862f91cc8f914c64ba3fe844b35ce36ce151": "0x00000000000000000000000000000000000c4369746164656c2e6f6e65104369746164656c2e4f6e65204c54441568747470733a2f2f6369746164656c2e6f6e652f0014737570706f7274406369746164656c2e6f6e6500000c404369746164656c44414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446d4ef367550b68d2a0783588d2ec76c02517d1465e08cc3e5964ae9b3b3215bb598489989f62119": "0x04030000000200000000000000000000000000000000075a454e495448195072616e6176204368616e6472616b616e742050617761720000197072616e6176637061776172406f75746c6f6f6b2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446da05f48ba08b97e60b065719963027baac7cb4d68145539a0b428aa74048ec1c32b6b255530646": "0x04000000000200000000000000000000000000000000084e45574445414c000015407061726964655f663a6d61747269782e6f72671c6e65776465616c2e76616c696461746f7240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446eb4c71c2ad15c3f85bd4ec9a558cde3f05e33b0b74f9e732cc41f904894873247d4c435a3b8b63": "0x040000000002000000000000000000000000000000001d4d4554415350414e2028616c736f2074727920504f4f4c20233138290d6d6574617370616e206c74641568747470733a2f2f6d6574617370616e2e636f6d000000000d406d6574617370616e5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446f3d1d0510badd5763735fed6d0ce2b2909c3365eccafaeb1ffcc2a10af6060a637b1dacff01616": "0x04010000000200000000000000000000000000000000184c697361277320506f6c6b61646f74206163636f756e740000000f6c697361407061726974792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446f59e6d908bc0ec8488bea263878e7e16be0a8c4705f9729a5f25462bff7dc7f2d8346370c8ef65": "0x040100000002000000000000000000000000000000000e53504143455f494e564144455200001a4073706163655f696e76616465723a6d61747269782e6f72671b7370616365696e76616465722e646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471446fca39721ec26e31ee933d8dc66947b2826fa57de49b62e7d9201326cd9cc01abcd8bc06c35c02b": "0x04030000000200000000000000000000000000000000084269744c696f6e000000196269746c696f6e32314070726f746f6e6d61696c2e636f6d00000a404269744c696f6e33000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144702815fa4f5b7fd02251a6e0194f2ee97f988a8f2e779a06a73b2ee3e1a54f413a3b9f6f8d04f6c": "0x040100000002000000000000000000000000000000000e6d75737465726d6569737a657217467265646572696b2047617274656e6d6569737465722168747470733a2f2f6769746875622e636f6d2f6d75737465726d6569737a65721a406d75737465726d6569737a65723a6d61747269782e6f7267186d75737465726d6569737a657240706f7374656f2e6465000010406d75737465726d6569737a657232000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714470f8592fcae215df03039aaa27dbd35081f359f8a6aa39ab5dc098c19937617389dd8cd05e4dc3a": "0x00000000000000000000000000000000000b6b736d7365616e6e657700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144719a17064a7613bb9f26de7808ffcf087492fc04a2c00178c3bf9ae512d1fc817f8430f60093801": "0x0401000000020000000000000000000000000000000008434f534d4f4f4e00001540677265676f7273743a6d61747269782e6f726715636f736d6f6f6e40677265676f7273742e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471447207f7f4037875fca91a41c974862cae390d507621b3cd9d96c2d8624fde2481d518a61c6b4cf3b": "0x040000000002000000000000000000000000000000000b53796e61707469636f6e0000174073796e61707469636f6e3a6d61747269782e6f72671a73796e61707469636f6e4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714472c11c45d19e722cfc5e71e4781885c9ee4420c55496b1a1b2d95b5cc0eeeaf4459c4ebc5bb8fe9": "0x00000000000000000000000000000000000c526567656e63792d3031331757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714472da44c2d8c63974ebdc7b636074ac97be407593236b00bd410c19fe56ab1b6d1c5db782f0bc17e": "0x0000000000000000000000000000000000044b6f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714476ed96b663d19f9d20ee72ee9744e1669971043d3ff9fe7a7223fc3334c87de6b1c6c0b36555c4e": "0x04030000000200000000000000000000000000000000084d6573736172690b4a6f686e2050757264790000106a61636b406d6573736172692e696f000009406a707572643137000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144822d22761cb98521237b750e00e3d48fe0b1629f2a4cf0630971cbf489dfca33e75235347196474": "0x0403000000020000000000000000000000000000000008476b697269746f08476b697269746f00001467756a6b697269746f40676d61696c2e636f6d00000a4047756b697269746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144825a3675ceeb1c2561077519794c195b22f5058bd1195f6847aa6b5a749053d44468ba5db872d64": "0x040100000002000000000000000000000000000000000f506f6c79636861696e204c616273001e68747470733a2f2f7777772e706f6c79636861696e6c6162732e636f6d001664657640706f6c79636861696e6c6162732e636f6d00000f40706f6c79636861696e6c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714484069a0f1cb9062b8d71afc98c6256dfcb316ff7ef0665270537c85ff081db98255159abb5fe017": "0x04000000000200000000000000000000000000000000124e65774f6d65676156616c696461746f720000154063656c726973656e3a6d61747269782e6f72671363656c726973656e40676d61696c2e636f6d00000e40506c61794e65774f6d656761000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144874818619a271dd4725fa85860f87917edff507310721c0cb930595fe16c829f536fb1289e4a852": "0x040100000002000000000000000000000000000000001177656233726479206d756c746973696700001440776562337264793a6d61747269782e6f7267136d6973636137303240676d61696c2e636f6d00000a406d69736361373635000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714487b7409ae4dd68d8e706d0bd734b0cf21ccbfc5ca90cd9dc03ef4d0be9b932bd23727869445105d": "0x000000000000000000000000000000000004414a4d00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714488adbd6698f281d1eeb54e0e7e13080dc9dfeb2cf5de7170fc7c84f4fb70cf5c2ca0a5c93b25735": "0x00000000000000000000000000000000000c7433726e2d6576656e74730d7433726e204c696d697465641568747470733a2f2f7777772e7433726e2e696f2f000c6f7073407433726e2e696f000009407433726e5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714489667186afa0e91ca5bc1915da74aba3aadd7ce7b809045d5eb5b73559259755fdcd85a40a5dc6e": "0x00000000000000000000000000000000000f4a414d20e298a0efb88ff09f908d000013406a616d31306f3a6d61747269782e6f72671768656c6c6f4073686f6b756e696e2e6e6574776f726b000008404a616d31306f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714489b5689523a93fdf4f5911143092b1788c3a91f96d192b35e4fb201f05658f47b677e7dc9a1fd5d": "0x00000000000000000000000000000000000c52484545207c20415041431053414e472d4859554e2c2052484545001140726865653a6d61747269782e6f72671472686565756e696f6e40676d61696c2e636f6d00000840786352484545000a72686565756e696f6e00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471448b1dce0478b5f30daf47069cecf5c31da9a1cfde3732d2b701bf9f94c77ba7e99335d6b30ad080a": "0x040000000002000000000000000000000000000000001856462056616c6964696572756e6720f09f87a9f09f87aa001b68747470733a2f2f7777772e76616c6964696572756e672e63630017636f6e746163744076616c6964696572756e672e6363000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471448c106532e2fbcf5ec05f950e080aa04f8ef335280637c8c80fa6b8bf54d5a3bbfa746b9f9da5860": "0x0400000000020000000000000000000000000000000006506c7573560000000f706c75737640706c7573762e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471448cdedeb02681e28ac891d5a6e2f56c923dcff8c05d0a535c6695a118bf3de7ed3bab92ff7db641f": "0x0000000000000000000000000000000000144a6f6e617468616e202854616c69736d616e29000016406a6f6e7064756e6e653a6d61747269782e6f7267166a6f6e617468616e4074616c69736d616e2e78797a00000b404a6f6e5044756e6e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471448fd29f3f7e12961b4ddcbdb50b550740253810978125ded4acafacccfdbf9e2cb3bd031c9291388": "0x000000000000000000000000000000000013636f736d6f76657273656d756c746973696715636f6d706f7361626c6566696e616e63656c74641f68747470733a2f2f7777772e636f6d706f7361626c652e66696e616e63650018696e666f40636f6d706f7361626c652e66696e616e636500000f40636f6d706f7361626c6566696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714490130ac826416f286f68361d0a346a62be267558e72dfb9e3b5a04adcc2c9e46fb7b9482f7c876f": "0x04010000000200000000000000000000000000000000094b6565704e6f6465001968747470733a2f2f7777772e6b6565706e6f64652e78797a11404472756e3a6d61747269782e6f7267156472756e2e6d6167696340676d61696c2e636f6d00000a404b6565704e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714496b2311f8412ae280a4a5a4e8e8c8ce6b19bd926a83efa02d70a6137d9896c627eea987e10d3655": "0x0400000000020000000000000000000000000000000007444f546f6d6900000019617374696b61696e656e746f6d6940676d61696c2e636f6d00001040546f6d69417374696b61696e656e0014546f6d69417374696b61696e656e233632343900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714498085158358a41ed824263a2ba0b39e43b2a1fb591c68743ca504c2ce6c3c2aa96e58b6269d3115": "0x0400000000020000000000000000000000000000000016f09f9a82205a756769616e204475636b20f09fa68600001840726f626572743a776562332e666f756e646174696f6e17726f6265727440776562332e666f756e646174696f6e00001140526f626572745f48616d62726f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144980dd5ac2100210047e68bf811eb225dae8c88461df5edfc581c80c460a31672c36d53ca0164b0b": "0x000000000000000000000000000000000008617234766f6c6b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471449834f6d0d98c2caf4f7e8c9dcf45daa322fa14585d8f14a37aceca839106ed3414bb04778696145": "0x0400000000020000000000000000000000000000000009636c616e67656e6200001240636c616e673a6d61747269782e6f72670000000009636c616e67656e620000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714498684a38db4f62054c56b5010033b3c17a5677cd9bc45b2d6c5d24b7590b7681bceac60b0f3833f": "0x0403000000020000000000000000000000000000000019546578617320426c6f636b636861696e20436f756e63696c19546578617320426c6f636b636861696e20436f756e63696c00001f6c6565407465786173626c6f636b636861696e636f756e63696c2e6f726700000e7478626c6f636b636861696e5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471449891bd977a475d4fa150742c53997a227cb5648c21029d8a6a087ea1c27c502903aa60ef7701823": "0x040000000002000000000000000000000000000000000d45524e2056454e54555245530000001c65726e63727970746f76656e747572657340676d61696c2e636f6d00000d4065726e76656e7475726573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144990ff033d5343d5a85e37331d7b706f90745bd7e4ad7ae82a83beacf5a585f69fb4afd10704a71d": "0x0000000000000000000000000000000000085261626173736f0f4a6f73652046205261626173736f0000146a667261626173736f40676d61696c2e636f6d000009407261626173736f00156a6f73655f67656e65726963636861696e2e696f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471449aa36a5cacb5456d4539a7dceeeba9999b6387e9431e83c53f4b884edf5cf049623110eae570125": "0x040000000002000000000000000000000000000000001f45617420507261792056616c696461746520f09f8db4f09f998ff09f96a5000013407978313178793a6d61747269782e6f72670c4f5456406570762e6c6f6c000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a3ab523f50a954b22d05d25884419493436b157e4f7ca725b885d6e328f7c09849c7c12395aec50": "0x040000000002000000000000000000000000000000000650524956490000144070726976695f6a3a6d61747269782e6f7267186a756c69616e40707269766970726f746f636f6c2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a46ea11348a56200a66532a23c418cca12183fee5f6afece770a0bb8725f459d7d1b1b598f91c49": "0x00000000000000000000000000000000000d44617277696e69612044657600000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a4e353d6c92b4f6fc5f90e8fb39b1656b5a018d5fa169f80a4ab3fcd03b3d46e2acdb3ae3fc8174": "0x00000000000000000000000000000000000f4a65676f72207c2050617269747900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a69dd5ac19d5ad6743037278f95ee81a2cf5a59518d3dd440611989cf8dd826811accf784a9ff2e": "0x0000000000000000000000000000000000044a7572001068747470733a2f2f6a75722e696f2f000d68656c6c6f406a75722e696f00000c406a757270726f6a656374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a7360f6b774d3fda84ef8c0efdd519e001cb3f5b6351725178283edf1b122a464f0a0f425699759": "0x00000000000000000000000000000000000b4c75636b79205465616d0000000000000b404c75636b7944617070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a7a8224146595f932ab6289334629c2011e3bbcd7742c9aaa5501d440a5ab5d76b42704ff2baf6f": "0x0000000000000000000000000000000000074d6175726969114d6175726963696f20417274696761731768747470733a2f2f7777772e6d61757269692e636f6d0010696e666f406d61757269692e636f6d00000b404c6c634d6175726969000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144a894c423d88cda06cc6b537b36e5f7347ad0daaebd9f5fa22be1e4b8bc68a58c8ee57d43b4d2e70": "0x04030000000200000000000000000000000000000000116d6968616a6c6f5f7061766c6f766963114d6968616a6c6f205061766c6f76696300001c6d6968616a6c6f7061766c6f766963343040676d61696c2e636f6d000009404d70636f6e6e30000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144af14bc1b4b0280418d30040a8245c5ff17afc9a8169d7d0771fe7ab4135a64a022c254117340720": "0x040300000002000000000000000000000000000000000c456477617264204d61636b0c456477617264204d61636b0000126564406564776172646d61636b2e636f6d00000f406564776172646a6d61636b6a72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144afaabe16b988c8244f1bc09ae85c878c320783337f5991e4a172d3daded474eaf772069ac48b811": "0x000000000000000000000000000000000013414d4920426f756e74792043757261746f72001b68747470733a2f2f6772696c6c6170702e6e65742f3132313731000000000d40616d69706f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144b0852ee2d8116607454e2120a4f7b4eddc39c681fea50a8366b39c176e7393913bbfaca5649a450": "0x0400000000020000000000000000000000000000000016506f6c6b61646f742041504920446576205465616d0000001c706f6c6b61646f742d6170694070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144b11703c47136f3474b0c404b20bac28ded8d662e2eae7ddc52988cd5a22d5de09259258395dc45d": "0x00000000000000000000000000000000000b4441524b464f5245535400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144b33ce1e975a619404d3773ac89f099d5cd7257a72a53b7877935fe84065dff6ae95c0ed1ce17e63": "0x04030000000200000000000000000000000000000000104845524f49435f6f6666696369616c0a4865726f696320415300000f68617267406865726f69632e67670000096865726f69636767000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144b688debd0defa3c60c02d8df757b0af6de882ebc51bf2bba0cdeb949e6ad76331628768fccbd743": "0x00000000000000000000000000000000000b506f6c6b61646f74203200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144b6b6385bf015c077a31de6245e807c4398025994cefc7ceb4bdbe252c4590e732c99698691b666f": "0x00000000000000000000000000000000000f426c61636b626561726420444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144bc239eae76c6ad1fe5cd339cdd38f39283d20c2352716e68153deb3267c7a5d543c394814e88e04": "0x04030000000200000000000000000000000000000000044a61790a4a617920506f70617400001b636f6e746163742e6a6179706f70617440676d61696c2e636f6d00000b406a6179706f70617430000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144bd6e2ebc6fe2e047b72f47f4a630d6a3c03d7499a70092a183cd5a2541afc72ab8301ba640f4821": "0x040000000002000000000000000000000000000000000645617379410a4561737941204c74641268747470733a2f2f65617379612e696f2f000f68656c6c6f4065617379612e696f00000b4065617379615f617070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144bed375fad94bd6b2ccc353342d8ed955553be5ae666a0b2f05db798bb6a213ded13f25b7af7bf54": "0x0000000000000000000000000000000000054841534800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ca0ff14934456cd32cd9b54bb73288503c7969f219ab74a83cb5b8bc2672ef472b7b7c43d866533": "0x0000000000000000000000000000000000124f6e2d636861696e204964656e74697479064a45524144000017627573696e6573736a33383640676d61696c2e636f6d00000e40627573696e6573736a333836000b4a65726164233130363500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d2dafa5e265f20094ecf114c292f2a24ff6dbc3dbf8311be37ef53f7e78c9d1a59d0c5762cac672": "0x040000000002000000000000000000000000000000000a66696e616c6269747300001240617269666b3a6d61747269782e6f726717696e666f4066696e616c626974732e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d35c327c115f99b08745476e8a2fb16504c77a75b2dd20b6f56cfb71c87125f1707a702753af24e": "0x00000000000000000000000000000000000642726561640000001762726574746b6f6c6f646e7940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d466d1a5e9c13dfc483215a3e72d171dd71c55d3885dfa73a40385682f9fe4ced1e811320265714": "0x0800000000020100000002000000000000000000000000000000000c56616c696461747269756d0c56616c696461747269756d00001656616c696461747269756d40676d61696c2e636f6d00000d4076616c696461747269756d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d4d81d0048d154f680529ad3b92e92ee8955e6a50109c5f12c1b50be62fa4eb82f66ef62400ccd9": "0x040300000002000000000000000000000000000000000f547261636520416c6c69616e6365002168747470733a2f2f616c6c69616e63652e6f726967696e747261696c2e696f2f001a616c6c69616e6365406f726967696e2d747261696c2e636f6d0000104074726163655f616c6c69616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d51d2cbac595fa87056ac3306e0fca5ef9784e7d34b1f72af8e2650a29f0b3ce50f86df501ce858": "0x040000000002000000000000000000000000000000000c7777772e6973672e64657619496e666f726d2053797374656d732047726f7570204c4c431d68747470733a2f2f7777772e6973672e6465762f706f6c6b61646f74144069676e617465763a6d61747269782e6f72670d696e666f406973672e64657600000d40696e6673797367726f7570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144d538289bdc31db0d05099da3d810eceb0001840b3ebbeac4b8b8b230ecbc4988a5b2f131aef4835": "0x0000000000000000000000000000000000135354414d207c2054454143484d454445464900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144dabfd58e995e46fa4a7835edb8c6b0d10b32c76ddd9560feb4894fcfb61593accd8c7451e96562e": "0x0800000000020100000002000000000000000000000000000000000c45726e7374204b696e74730c45726e7374204b696e7473000012706c61736d616a61636b406d652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144dd03705d9d21ba9efbb245a877c2ee64cf822cf8ce58907ceec0d4481746da50d533a386a8c4cde": "0x00000000000000000000000000000000000c526567656e63792d3030391757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144df55d839183b50360b5acfd88341f7df867518c44929c114775a3457f3496d29dd231cca9499143": "0x00000000000000000000000000000000000f43727970746f2e536865696e69780000001963727970746f2e736865696e697840676d61696c2e636f6d00000940736865696e6978000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144dfaf303c80f7947c618838a7cda0fba033eac4b3df3e2b31e1b304765bf98004eb72690fc117f09": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31341142494e414e43455f5354414b455f3134000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e4f1bf6b4d19f047a3f515334d24cd37b65d4b1c5838cc7c34951a67f3ae2da041a6e2385d8da05": "0x040300000002000000000000000000000000000000000d427261766542726f7773657213427261766520536f66747761726520496e6300002069742d736572766963652d706f6c6b61646f742d334062726176652e636f6d000007406272617665000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e5666c0de8b6c84ac2752e0009c6ffc103fd1a723726affbd91d6b8e65ddabbeff28fe14a93b678": "0x0400000000020000000000000000000000000000000012646563656e74657265642e6a656f7269630000001a6a656f2e72696340646563656e74657265642e73747564696f00000000086a656f2e72696300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e5736534181ad78b690df84dc61bb1b04bb3e5483678390a44eca9ee4a748e98f526e126c19c702": "0x04000000000200000000000000000000000000000000064c65676f73000012406c65676f733a6d61747269782e6f726711706f6c6b616c65676f7340706d2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e5ef662a865543dea9196cd611c7e79bbca036076b2ffd2f684421ba82134c29e84a1e40479b309": "0x0000000000000000000000000000000000146e6963686f6c6173207c20646f7420706c61790000001c6e6963686f6c61732e646f757a696e617340676d61696c2e636f6d00000a406e69636b646f757a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e6885d639fed568e0d1e848ba9cf7ec704b12a0f1e2381e42c8a4a4d55f40625de6d60c39ebc032": "0x040000000002000000000000000000000000000000000978634b7265736e61000013407368613838383a6d61747269782e6f7267196b7265736e61737563616e64726140676d61696c2e636f6d00000b406b735f736861383838000c4b7265736e61233333333300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144e883ef525616aa09096cbeb77c7810fd11cdaf9e53f64d20e43e41a437ecf8db2c5a7ad98c89c24": "0x040000000002000000000000000000000000000000000e546563686e6f4172746f726961000000186172746f7269616d617374657240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ebb87c523e02c41a87f7dc3c8fd5d0b2d229e4fcb9aacda9427025218f69627ba1a2b82a07bb451": "0x04010000000200000000000000000000000000000000104f6d61646f7965204162726168616d104f6d61646f7965204162726168616d0000196f6d61646f79656162726168616d40676d61696c2e636f6d000010406f6d61646f79656162726168616d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ebc48c63a5dc09fa4ac69b3ea42acebe4f70767ee894eeef5eef1f011f0dca45097a2e6c40c5366": "0x04000000000200000000000000000000000000000000036635000017406b7573616d61323233333a6d61747269782e6f72671e6b7573616d616b6f736d6f73696c613232333340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ec6dcb09516ac9cae463a6613cae63a77d1c391bb1e00a974ccd178ebd91e00268608f3a570f84f": "0x040100000002000000000000000000000000000000000d5061736861426f7563686572000000177061736861626f756368657240676d61696c2e636f6d00000e407061736861626f7563686572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ed12f7f95496d053674aa73951219dbd27b3e3fc5847b806c68c1de38fd4f22f9493a461c80e903": "0x040000000002000000000000000000000000000000000b472d444f542e54454348001368747470733a2f2f672d646f742e746563681740672d646f742e746563683a6d61747269782e6f72671467646f742d746563684070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144f50c6bb1b68e3b5944f4742584f6194f1ca08a3dd92d00d059439abb46629f6ea6bc0f6202dbb58": "0x040300000002000000000000000000000000000000000e44616d69616e20416d616d6f6f0e44616d69616e20416d616d6f6f00001464616d69616e40646f78642e6361706974616c00000e4044616d69616e416d616d6f6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144fcc35394dbbfdb0eac8ab5909257a63ef3726ca5824a68902205beb1e58d578ceaba30ab3dfed65": "0x00000000000000000000000000000000000a464c5546464833414400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047144ff1355416158dcf7c4e85307ba0bb29b098e2f405c673f39b76d77fb012ed5f5c61fc68e1cbff80": "0x040000000002000000000000000000000000000000000f466f726b6c6573734e6174696f6e0000001868656c6c6f40666f726b6c6573736e6174696f6e2e696f00001040466f726b6c6573734e6174696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145010d8218a994822c290e73cd4a89b696210d9f712410463c89368b6fc4d22ce10207d8f31e5e739": "0x0000000000000000000000000000000000054c58333800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714503214bf4f8e7195eec846c98971c15deb2504433f2946dfa0c01f310d1e7b777b79fe0a1a279054": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2036001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714504497b5432c58213aa53e50cea84e455aaf2f9172db100c8068658ee1234f9bcbde84e5bfe52e54": "0x0403000000020000000000000000000000000000000007446f6c70686100000013636f6e7461637440646f6c7068612e636f6d00000a546865446f6c706861000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471450532746b82002af1ecfb64d5f40dbe9c02df58a8570cd2335acd41a107fe5fce9b3fb4f8d537d58": "0x00000000000000000000000000000000000773757975656500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471450541acb5b3adfcb783677be3528d7c562df11a31317f6138279cd39ef96abba3dd1f38e9896a37f": "0x0000000000000000000000000000000000127733662d7374616b696e672d6d696e657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714505d0ff0b2ffbc1700004bcdcc7d30d597e19c7f87652b69736066b729f7e8543231a10760f8157a": "0x040000000002000000000000000000000000000000000a5354414b452d4f5053000011406876616c3a6d61747269782e6f7267147374616b65726f707340676d61696c2e636f6d00000a407374616b656f7073000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714505e4ce25c0327113230fd173f1cbd58c493f4f6488a8bd7d8594e167a45052ce8eb51f697e9e914": "0x00000000000000000000000000000000000b4d617961204163616c6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714506b81d74d617d923ce9d3e9979b7600344c225b00d470e268d6c38616bafea38027a373ae3c3f3c": "0x040300000002000000000000000000000000000000000b61644c49425f4d5f4d531353657267696f204d6172636865736f7474690000146d6172696e614061646c69626e65742e636f6d000011406d6172696e616d6172636865736f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471450848286e4980cc86ef58fbe5043add10a359ead21248eb5575bd560ec489382cea3a7e360aecb71": "0x000000000000000000000000000000000005482d4d4100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471450aff8b6edbd559bf2529946850f8dd66c794a795a6b01a911f25df007e4cf5f97f38a037380f250": "0x040100000002000000000000000000000000000000000d446563656e74726174696f6e1b446563656e74726174696f6e20547275737420436f6d70616e791968747470733a2f2f646563656e74726174696f6e2e6f7267001872616d73657940646563656e74726174696f6e2e6f726700000f40646563656e74726174696f6e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471450e0223a7f06f4edee2804a63951212e1342a2c01ea12f20153f27b6a5a649ef2e6c7b20d7859f68": "0x0403000000020000000000000000000000000000000015696b68616c65643238207c205761674d6564696100000014696b68616c6564323840676d61696c2e636f6d00000b40696b68616c65643238000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145126d11d32941450dc41188d0dcd6722402508e1eb7601ac5d225c923114ff63aa085f20756fc371": "0x040000000002000000000000000000000000000000000f566c61647950726f6d6f5465616d00001740766c6164796c696d65733a6d61747269782e6f726715766c6164796c696d657340676d61696c2e636f6d00000c40766c6164796c696d6573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714512ee0fca2d67ab7d573535a40bb01903e616a383deed22b5e3ff30e552017d2395e3e75a8e78613": "0x0401000000020000000000000000000000000000000010f09fa49620506f6c6b6153746174730b506f6c6b6153746174731668747470733a2f2f706f6c6b6173746174732e696f16406d6172696f70696e6f3a6d61747269782e6f72671a706f6c6b6173746174734070726f746f6e6d61696c2e636f6d00000c40506f6c6b615374617473000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471451affb7adda940b6380329063444b0d709fe60a6bd0ee966c85ee1da8d62faf0bf33c58d8a15f93a": "0x0403000000020000000000000000000000000000000005544f4e491c4a75616e20416e746f6e696f20496e66616e74652043617361646f00001d746f6e692e696e66616e746563617361646f40676d61696c2e636f6d00000e40546f6e695f426974636f696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471451b04076756292749ea8a333af594a76a48fd053a4ac0c48a87cdc5908f5099cdfb053d05cbddc3e": "0x04030000000200000000000000000000000000000000104a61636b2048616c646f7273736f6e104a61636b2048616c646f7273736f6e0000176a61636b406c756e617273747261746567792e636f6d00000f6a61636b68616c646f7273736f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471451b7261dd3a3db7140d9be44e5bbd9bb656741d05142d47c08ffbfd1f0157b5e79626dd51fc5270b": "0x0400000000020000000000000000000000000000000010416c6f6861426c6f636b636861696e00001c40616c6f6861626c6f636b636861696e3a6d61747269782e6f72671a616c6f6861626c6f636b636861696e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471451dd6eaed401198dc44209e13e42fd156130e708866c28b0ac7cbd5b650011411b8979e5670f3a7a": "0x0000000000000000000000000000000000074b534d204c5700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471451fe2259dc584cad041148d9102c91506d9e3e75297536084c9e3c3259ff78e4651ef4c464a04377": "0x04000000000200000000000000000000000000000000064e6f646c650000000000000e404e6f646c654e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714522288fcb9f80cd6c81b22d9b1c398a968215a07a4d62af23b6db994b0c6d6e7b8cf8bdd8c57e82a": "0x000000000000000000000000000000000004444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145268dc052973ededba3ecfd7483cdcdad1132af7d1e8067816009cbd77fc0bc30eafe8d2218a1971": "0x04030000000200000000000000000000000000000000066e696b6f73124e696b6f6c616f73204b6f6e74616b697300164077697265646e6b6f643a6d61747269782e6f72671477697265646e6b6f6440676d61696c2e636f6d00000b4077697265646e6b6f640a77697265646e6b6f640000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714527efcd187a9fe40aa71da79c896004229d1592df63c4091b31356787a87c960e7a58ade7021cd77": "0x040300000002000000000000000000000000000000000a437574655f576973700d43686f726f6e67204a616e670000187377656174706f7461746f313340676d61696c2e636f6d00000b40437574655f57697370000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471452c8ca65b329df6b02f87ce6d066323c92f56d284faaa856ce083f9ba81635464f04fabec453c822": "0x040000000002000000000000000000000000000000001a4368616f7344414f5f4e6f6d696e6174696f6e5f506f6f6c730000000000000a404368616f7344414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714531481d95ba52af5b2a75e17655fc2753328a8fe1ae22a20c8bb0ae8b7a7c809e8d84289571bcd1e": "0x00000000000000000000000000000000000b4a6f68616e44726f69641a4a6f68616e20416c6578697320447571756520436164656e611768747470733a2f2f6a6f68616e64726f69642e636f6d17406a6f68616e64726f69643a6d61747269782e6f7267000000000b6a6f68616e64726f69640000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145322942d92e4b0ac628524da485cdb93551dab991b7569b96ec32ea8dfab885c0ff21d76f781cf7a": "0x00000000000000000000000000000000000b44415955e88a82e782b9054441595510687474703a2f2f646f7465722e696f14406a6f69656375693a6d61747269782e6f72670d6a6f6965634071712e636f6d00000a40646f7465725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471453839e0f2882afca84b58d6f589a104d2f4bdd8b76317d55c1576464e22dda803dd94162ba40c398": "0x00000000000000000000000000000000000f4c414f53464f554e444154494f4e164c414f5320436861696e20466f756e646174696f6e1e68747470733a2f2f7777772e6c616f73666f756e646174696f6e2e696f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471453a80b1cc8a5fa031212f18a064433a237a56022beffd0ca0f0baef317b34c7f6f12b19968f10233": "0x040000000002000000000000000000000000000000000a7464696d6974726f760000154074737665746f6d69723a7061726974792e696f000000000a7464696d6974726f760000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471453c13c992a5e1d2c9a201b14e4207ebacf5b729ff166ffa224bb4b5cfca02bdf9f3823a0e2979064": "0x04000000000200000000000000000000000000000000114c656168404f414b204e6574776f726b0000000e6c656168406f616b2e74656368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471453ea4f8fb6ccab21e6f540b5dd5f15bf2d3f0eabd392a35bfe76c58cbb36227fb4c29785714e085b": "0x040300000002000000000000000000000000000000000e466c6f7269646157454253454f0d486f706520476f6f646d616e000015486f70652e436c61727940676d61696c2e636f6d00000a486f7065436c617279000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714541213aceb4fb60c1859cdd686b9d08a9fb3bc6b4c20b794339e028aa7300454deaaff5b5860200f": "0x0000000000000000000000000000000000084b4a646f74343400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471454259ba3fa998087a0d16c9a998cb8884bb937cc6192b7e962151cc0c19529d7aac7491f0617457c": "0x040000000002000000000000000000000000000000000a53746173526f766572000016406b61346f6b313333313a6d61747269782e6f72671873746173726f7665723133333140676d61696c2e636f6d000000001373746173726f76657231333331233632363300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145482a19c5b8df37d1e727755b4af4ed6b10e91b550ed5e30bfcd1d3eedec76e159e137ddf5fe9223": "0x040000000002000000000000000000000000000000000e42616d42616d2057616c6c65740000001662626d6f6e65796261677340676d61696c2e636f6d0000114042616d42616d527567677942616773001542616d42616d4d6f6e657942616773233738303300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471454a7cd8dd3cde7aa5ef0603406fea5cef09155727ee3f76c528d688ea48a5f0183bfb06bce5f7b20": "0x00000000000000000000000000000000000a636861696e796f646100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471454aeea67769129fb946d9ac73a5f11a32e8c8709d631304d2db1ebbbca156fc86b9f438286363814": "0x00000000000000000000000000000000000c426c6f636b6461656d6f6e001868747470733a2f2f626c6f636b6461656d6f6e2e636f6d0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471454d7e633409fc98ca61cffec64bd3d89d7195fd423998178d8a4e6a0593ea5ced602f43d2e5ca346": "0x0403000000020000000000000000000000000000000009437361696e74303200000014637361696e746e303240676d61696c2e636f6d000009637361696e743032000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471455484e82afa6b522260092c95b675be8db8490bc0f55d7357a1cbb066f5198fcb7aa2d7f05377331": "0x00000000000000000000000000000000000c526567656e63792d3030341757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471455538dd590c80f13507c2d0784ffc68240a395784f16cd29f99f974a58876fa9e948fe4ffcb70334": "0x0403000000020000000000000000000000000000000021f09f8d80204c75636b7920467269646179202d204f70656e476f7620f09f8d80001868747470733a2f2f6c75636b796672696461792e696f2f00147279616e406c75636b796672696461792e696f000011404c75636b794672696461794c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145557cf88d37091a7a256aad87b40568d82450352060cb44fd4f22d491cda208f2f7da5b23ff23d01": "0x00000000000000000000000000000000000944594f5244594f52001c68747470733a2f2f6769746875622e636f6d2f64796f7264796f72154064796f7264796f723a6d61747269782e6f72670000000d4064796f7264796f72636f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714558060fa90d1941f87d108bb4f19a365b10f0ce5a87be412bfc89c359c4e6a34d9ab83532622e949": "0x00000000000000000000000000000000000c526567656e63792d3031321757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471455cbcfc5ff45de9288befc38a0a30b69022eac9e133fb589defc7a8c6b7f0dc601ded9804bd7e114": "0x040300000002000000000000000000000000000000000b4d656c612061644c49420c4d656c612061644c4942210000126d656c614061646c69626e65742e636f6d00000a406d656c6131303030000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471455ebf22a3378f22de4bd04a7052f76425c60648c528535285bc2a23ab28db060db34f7c5e5746aa9": "0x040000000002000000000000000000000000000000000954616c69736d616e0000000000000f40776561726574616c69736d616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714561df2dc51ef7baf3e89f959d4ae263361a6d7d0b87f1be73ad01356f5b982189f19c3be93fbe554": "0x00000000000000000000000000000000000d4f616b205365637572697479124f616b20536563757269747920476d62481c68747470733a2f2f7777772e6f616b73656375726974792e696f2f0014696e666f406f616b73656375726974792e696f00000d4053656375726974794f616b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471456305c2c3bf8f20e465c6be30d314cf647a8fa10212bcb84318394659c46fe75d03640cebb39595e": "0x040100000002000000000000000000000000000000000d416c7a796d6f6c6f6769737410416c7a796d6f6c6f67697374204f791a68747470733a2f2f7777772e7a796d6f6c6f6769612e66692f0015636f6e74616374407a796d6f6c6f6769612e6669000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714563affe7df4a40c094c7373d1e335e281b2a80565b3370c5de9d6b2d87fdf0cddac5641377a24b50": "0x0401000000020000000000000000000000000000000010526f636b585f506f6c6b61646f743306526f636b581668747470733a2f2f7777772e726f636b782e636f6d0012737570706f727440726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714564cb6671f34ac580c30d360adcf621ab5e8754a9481cc15c1827574958fdd9fd15c5d4d526c7909": "0x04030000000200000000000000000000000000000000104179657662656f7361204979616d75104179657662656f7361204979616d750000166179657662656f73612e6a40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145680c43f6b36d90ffecaf47bf20372df1eab92aa6781caef84c728ef14a18ebc4c39e35789f8a23b": "0x0000000000000000000000000000000000044a6179044a617900000000000e406a6a65647361646131393937000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471456ae9d419c0660f83235f7d984058bb410c163fc1d7a90e5475c0917aad77deb241093a50b4f683f": "0x0000000000000000000000000000000000064272756e6f0e4272756e6f20c5a06b766f72631768747470733a2f2f6272756e6f2e6574682e6c696d6f0020747261702d706f6c6b61646f746964656e7469747940736b766f72632e6d6500000a4062697466616c6c73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471456b5cfba8996c0c084671f7cec13e5359aad22bffb62ca545c385e1fd68f0f3de08b74c15e58c25f": "0x0000000000000000000000000000000000025000000018676d2e736f646572626572676840676d61696c2e636f6d00000f4042616c6c616e74696e65733837000f62616c6c616e74696e65735f706d00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471456e0891e915252b140975dcdfcd7ecc14eb7f986e0dac66349e19973a66dfa6be7b61cd3fbbe143a": "0x00000000000000000000000000000000000e43494b6f6e746865626c6f636b001f68747470733a2f2f7777772e63696b6f6e746865626c6f636b2e636f6d2f00177465616d4063696b6f6e746865626c6f636b2e636f6d00000f4043494b6f6e746865426c6f636b00084a53233638373600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457130fa04591b33060283de9f5beb93ac69b24ca8c62f60f39b8c80758d807aa244532c66b67bc3c": "0x0403000000020000000000000000000000000000000012706f6c6b61646f745f636f6c6f6d6269610000001b706f6c6b61646f74636f6c6f6d62696140676d61696c2e636f6d00000c706f6c6b61646f74636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145721ebba28d18ffd9c84f75e0b1b92f6b003bde6212a8b2c9b776f3720f942b33fed8709f103a268": "0x000000000000000000000000000000000006616e6472650d416e6472c3a92053696c7661001740616e64726573696c76613a6d61747269782e6f7267000000000b616e64726573696c76610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714572aae990801cce1043393e76c137dfdc403a6fd9a2d6129d470d51c5a67bd40517378030c87170d": "0x040000000003000000000000000000000000000000000d506172614e6f6465732e696f001568747470733a2f2f506172614e6f6465732e696f164070617261646f7878783a6d61747269782e6f726715737570706f727440706172616e6f6465732e696f00000b40506172614e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145749edf76d87f942544e2e588c90a2e53e051d2f87d40e222e1f034913a30f95a9a2f39114e5be38": "0x040000000002000000000000000000000000000000001c436861696e487562202620546578617320426c6f636b636861696e00001440737269766973683a6d61747269782e6f7267186d654073726972616d7669736877616e6174682e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457707f9d1b18edb4729324ff6798093939a73546e0f3d53a9cd7d4e938d238145c9422ce9f0beb07": "0x0000000000000000000000000000000000205374616b65444f54732e636f6d202d206279204269736f6e20547261696c7300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457903c6184bae82f5a090c88f0438b46b451026597cee760a7bac9d396c9c7b529b68fb78aec5f43": "0x040100000002000000000000000000000000000000000d5365756e204c616e6c656765000018407365756e616c6e6c6567653a6d61747269782e6f7267197365756e40706f6c79746f70652e746563686e6f6c6f677900000d407365756e6c616e6c656765000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457a5cae663c515ca00ecaacb451648a3660fe122ccc2c32cfd9459ca6dac9f10cbf7a0ab60c61318": "0x040000000002000000000000000000000000000000000d4a616d65735f4167656e6461000019406a616d65735f6167656e64613a6d61747269782e6f7267176a616d657340686f6c64706f6c6b61646f742e636f6d00000e406a616d65735f6167656e6461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457f0c0a9a6359c3474e4867b46b4d8ca428315963427c002b2e78d0faf10f6f7ce28a3d963cbc65d": "0x00000000000000000000000000000000000a626c756570616e646100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471457fba32d45d674cc3a8ec57f1e3455033d4e4a4d92afbafedade5b15bd8a9569eb77157b8163af4a": "0x00000000000000000000000000000000000577696969000000196a65756468666a74794070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714581f77b10468b1425440f21f8078b780afad2b1f6604939ee2d3d4cdfc2ed48eb1422e76a54e291b": "0x040000000002000000000000000000000000000000000d506572666563742d6e6f646500001940706572666563742d6e6f64653a6d61747269782e6f7267146b6174656b7261737640676d61696c2e636f6d00000f40706572666563745f6e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145833bff9f455466ed63a7eba107bb1e70778603a7c1a10288284b5acf296c15f0b616c19df2b8641": "0x00000000000000000000000000000000001352616d61207c20456467657761726544414f1152616d61205368616e6b6172204a68611568747470733a2f2f72616d61766174732e646576154066726f676d616e783a6d61747269782e6f72671872616d614065646765776172652e636f6d6d756e69747900000b4072616d615f76617473000972616d617661747300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471458397d7e3fd835eec870531deb0be32ec5f13db615776a199622cf2b2a8d5061be0a30d560ac5413": "0x040000000002000000000000000000000000000000000a4162696c657820414700000011722e7a6f6e69406162696c65782e6368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145839ea98689b2889bc6e12d7ab70abea4c08db7055e84f16bab817b5fb359088ad5190422df9dd1d": "0x040000000002000000000000000000000000000000000e416c657850726f6d6f5465616d00001340616c65782d6d3a6d61747269782e6f72670000001040416c65785f50726f6d6f5465616d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145874725d77d3161042fe55f037d3acfd9073a0110f9a241c7c0b484ee39ebcd77e7952582be5463e": "0x040300000002000000000000000000000000000000000f48656e202d2053706561726269740000001368656e72794073706561726269742e636f6d00000d40537065617262697444414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714587f0b18f53b18b02aa10e36f0d84091e5850da2564bf99d14d5b9837c1ee2fa8bc068c995994379": "0x040000000002000000000000000000000000000000000a4578747261436f696e0000104079726e3a6d61747269782e6f7267187961726f6e736b694070726f746f6e6d61696c2e636f6d00000c404578747261436f696e5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145901a7d03ac32e8c460411e07f93dc4bc2b3a6cb67dad89ca26e8a54054d13916f74c982595c2e0e": "0x000000000000000000000000000000000006436c61726111436c6172612076616e2053746164656e00000000000f436c61726156616e53746164656e0f636c61726176616e73746164656e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145955584d4460250b9d00cdd9010cddfdc119c7ce69b4e122261ee68848e50daaaed117df2a7b6f7b": "0x0000000000000000000000000000000000174f6e72616d7020426f756e74792043757261746f7273002168747470733a2f2f74696e7975726c2e636f6d2f444f542d426f756e74792d320000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714599af3f3a616204088116da7569ffa5b8634742c63b9eaff0d5334e8f68588bef54e28e6ba64d04b": "0x04030000000200000000000000000000000000000000066b617665680000001d6b61766568746865626c61636b736d69746840676d61696c2e636f6d00000d6b6176656874656872616e69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a0dda79fdf58ba93657cdadd375b91ff01e797249907eeaa2d28e7f882f4176d43140767162111f": "0x000000000000000000000000000000000009627962742e6f726709627962742e6f72671168747470733a2f2f627962742e6f72670011737570706f727440627962742e6f726700000a40627962745f6f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a322d41358015c5820e859e96c107c3dc5e0b110d8e5a7fd2bf312b511b00a5a45e59eeec47d741": "0x0403000000020000000000000000000000000000000009436872697342636b00000017646f706579706875636b40686f746d61696c2e636f6d00000a4042636b4368726973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a53642bcce8d5192055808c210d863dfc372ec85beafa8fd3a8ff497f8eaee401ef05bf27d3065b": "0x04000000000200000000000000000000000000000000214a696d6d7954756465736b69202d20506f6c6b61646f74205265736964656e74000016407374616b656e6f64653a6d61747269782e6f72671b6a696d6d7974756465736b69407374616b656e6f64652e64657600000f407374616b656e6f64655f646576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a54b00d6ab21bbd58a74372b1f0a88b1df304584326ff69a68e9470d42687e12bf5dfac375d4911": "0x040000000002000000000000000000000000000000000c53454b4f5941204c4142530000154073746577617274763a6d61747269782e6f726713746f6d4073656b6f79616c6162732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a7e0322bf0bc3b7eec3f748ce7ebbe4bd41e991a04eb92b050d5e80667e60938c6a5224d66cd464": "0x0403000000020000000000000000000000000000000011546865204772656174204573636170650000000f676d40706c61797467652e636f6d00000940706c6179544745000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145a9ac6c6fb60e3add06b046f9929cd9ec3494f87b7ba1b533f8313c8132896639b110063c81a605b": "0x0403000000020000000000000000000000000000000011506f6c6b61646f7420496e736964657211506f6c6b61646f7420496e736964657200001b706f6c6b61646f742e696e736964657240676d61696c2e636f6d00001140506f6c6b61646f74496e7369646572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ae3d02694d32b74b4154f12cdef88338edfa85cbdd64b61c410187e4f7971057aef32cdafdfb702": "0x0400000000020000000000000000000000000000000016f09f9bb8205a6f6f70657220436f727020f09f9bb8001868747470733a2f2f636f72702e7a6f6f7065722e6f726717406a6f686e756f70696e693a6d61747269782e6f726710636f7270407a6f6f7065722e6f726700000c407a6f6f706572636f7270000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ae5cf79085c900374799c49548c591db342eb29f486980d7e28e687f9f88f9f602f050e8e106c64": "0x040000000002000000000000000000000000000000000e544f425553494e4553534c41570000001b746f627573696e6573736c6177406a6b6c65696d616e2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ae8d02fc1cc6b946e53696350731ed439f8c353b0b69b40b324fcdcb435ba225fbc22a33c9fe154": "0x0000000000000000000000000000000000074f6e656d6169001368747470733a2f2f6f6e656d61692e6e6574000000000c406f6e656d61695f66646e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145af116176166f3dcdc891490870515c71014938641e9b09cfbfadeb502b16d67d2cff9145aaa9a75": "0x0403000000020000000000000000000000000000000009426c6f636b41544c09426c6f636b41544c1a68747470733a2f2f7777772e626c6f636b61746c2e636f6d2f0015636f6e7461637440626c6f636b61746c2e636f6d00000b40426c6f636b5f41544c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145af59607ad06416224714636e0203b3a39bdf5a84df455ee05f6449e2df03fbbc7ed49be08182d7b": "0x0800000000020100000002000000000000000000000000000000001a6e2d667573652056616c696461746f722023312053746173680c6e2d6675736520476d62481668747470733a2f2f7777772e6e2d667573652e636f154076616e74686f6d653a6d61747269782e6f72671563727970746f2d6f7073406e2d667573652e636f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b1cb8848fc74ed707b738ebac4b30c502415704c8a06c9194c3df1f2529855f959b1dbd43377554": "0x00000000000000000000000000000000000631335745421757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b301c74acab4e7e12ccb53338ac0da571d3697548346fb5f0b637ac9412f8abbf6d13588be75632": "0x0800000000020100000003000000000000000000000000000000000d5265676973747261722023310d5265676973747261722023311868747470733a2f2f7777772e63686576646f722e636f6d144063686576646f723a6d61747269782e6f72672063686576646f722b706f6c6b61646f745f7265673140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b37a7061f92e1981e7c14ac9433d4637fecd8b61cfe017b31145aeba9742370c8ac715fe009ff41": "0x00000000000000000000000000000000000b6469707379764d41494e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b4baec7933bf780a85e51387dd437dd83dc7f9c2a7e59bf0590e9dd48758b6abbc463b3e26e5163": "0x040100000002000000000000000000000000000000000c4a6f6e6e792052696e676f124a6f6e204b6f64792057696c6c69616d731f68747470733a2f2f6c696e6b6564696e2e636f6d2f696e2f6a6f6e37313100156a6f6e6e794064616f61636164656d792e6e657400000f406a6f6e6e7972696e676f373131000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b4c4e58d29949859a2cb674ea2f4866664769a1663fd6aa321d9cfb89b67c402c881891700c0f57": "0x04000000000200000000000000000000000000000000084c6962657274790000001c6d657461706172616469676d4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b6407bdc635903a666c474e2f859bb39716a333ad449122df3605cf2d272ab876171d0a61cbdd07": "0x0401000000020000000000000000000000000000000008706f732e646f67001068747470733a2f2f706f732e646f6712406d616f79753a6d61747269782e6f726711706f6c6b61646f7440706f732e646f67000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145b98628a4ffdb492fc5c731996ade530d0289dd11a6ccf4e246ea5054119d2fe15a2da5c2ef01062": "0x0000000000000000000000000000000000000000000000000012416964656570616b6368617564686172790000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145bab10ce7448709e7c6781a204088ce17d88592c07355af5a72a81a33011ca9c0b8f79329050ee0d": "0x00000000000000000000000000000000000a67696761686965727a0c4c656e6120486965727a690000166c656e61686965727a6940686f746d61696c2e646500000b4047696761486965727a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145bbcb49931f6e14912ec4426bd4c3d506b2322b8817ff42bc670792fd1aa4cfa662548fdb0e60b15": "0x00000000000000000000000000000000001047616c6163746963436f756e63696c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145bd6a3e1e8406faa3c82ab06b794c99f14a161973be7aa6012568b1c491d45ec969ed7420bcfaa59": "0x04000000000200000000000000000000000000000000044a6f650e4a6f6520506574726f77736b6900000f6a6f6540706574726f772e736b690000000d6a6f65706574726f77736b690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145be461a0929fc6dc1da1e4d7d2a6a1e28f8778ca2d924672d83abcb6c5a2240b8186d4aa5cce2569": "0x00000000000000000000000000000000001c546563682041636164656d7920436f6469676f204272617a75636100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c2c88f13736061bb6ca4dd8f15039b1550849ac495b65fe2e1e93daf4be62c4c4adf440ae155d68": "0x040000000002000000000000000000000000000000000a57696e6b727970746f00001540736c797577696e6b3a6d61747269782e6f726713626f626f4077696e6b727970746f2e636f6d00000b4077696e6b727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c66629676bdc5f4766efcb5851054b4aeef694a3ad03d7bf36980a2094c07cb7b7cda28bde5e149": "0x0400000000020000000000000000000000000000000018454c444f5241444f2d544543484e4f4c4f47592e6e6574002068747470733a2f2f656c646f7261646f2d746563686e6f6c6f67792e6e657415407061756c2d6769653a6d61747269782e6f72671d7061756c40656c646f7261646f2d746563686e6f6c6f67792e6e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c6942d78c3e288a0842fe19dee2029fe63ae78b250fb0ed99ebcc6a72b36e7f56160150c230f237": "0x0400000000020000000000000000000000000000000008636d616c697a6500001640636d616c697a6530313a6d61747269782e6f7267166d616c697a65636872697340676d61696c2e636f6d00000e4063687269736d616c697a6533000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c6b1c34b6431f3840b9259dde4ecf577907b60e73ac636e896ac881e1f44c1bab1062fce8edef10": "0x00000000000000000000000000000000000e42414a554e204e4554574f524b1c426c6f476120546563682041472028537769747a65726c616e64291268747470733a2f2f616a756e612e696f2f1540726f786f6e746f783a6d61747269782e6f72670f68656c6c6f40616a756e612e696f00000e40416a756e614e6574776f726b000d6461726b667269656e64373700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c74ede8dfd9a44fd833a6cfefacabd9675f88e02953e4341badc949471b18f4e54b07e7383d6fbe": "0x00000000000000000000000000000000000d4f4720436f7265205465616d001768747470733a2f2f6f70656e6775696c642e7774662f00186f70656e6775696c647465616d40676d61696c2e636f6d00000e406f70656e6775696c64777466000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145c9b7dbdbf5f8eeb76446963a70e86cdaccc02ab22bf59bca9b5eb5fdb0353b144fbbddcff8a3a69": "0x04010000000200000000000000000000000000000000124465657020496e6b2056656e7475726573174465657020496e6b2056656e747572657320476d62481a68747470733a2f2f646565702d696e6b2e76656e7475726573174067656e6573697364616f3a6d61747269782e6f72671861646d696e40646565702d696e6b2e76656e74757265730000104047656e6573697344414f5f6f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145cf461f932bdcdbafcfd589d8df6da23f65a51de867fac9490ead3ffbb36ce8d1946cec1789a9a46": "0x040000000002000000000000000000000000000000000d43727970746f4c61622030310000144079616f6873696e3a6d61747269782e6f72671779616f6873696e4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145d2b112c788bfa92d474d9a6e955d7813d04f0fe2b5d35f0986837b7943975699d13ce159067082f": "0x00000000000000000000000000000000001648696e646920456475636174696f6e2047726f75701648696e646920456475636174696f6e2047726f7570002140616d69745f68696e64695f656475636174696f6e5f67726f75703a6d61747219616d6974736861726d616c65616440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145d3dec38e02e37251c6d8b40be9990c19e993d238e6e3613cfc6cbc51979d5fa61dd6ea259385609": "0x0400000000020000000000000000000000000000000007416d666f72630a416d666f72632041471368747470733a2f2f616d666f72632e636f6d00137374616b696e6740616d666f72632e636f6d00000a40616d666f72636167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145d6b2bca719d97c7ee2019dd45affea8eafaa263f346c25b477cef6858bd732898994e464cb57211": "0x00000000000000000000000000000000000c484f544249545354414b4510484f544249542045786368616e67651668747470733a2f2f7777772e686f746269742e696f0012737570706f727440686f746269742e696f00000d40486f746269745f6e657773000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145da2ed96282667842cf42c1d5eca2e17a00edde3c54ce01a2c1e0c070ebaa11ad9eb85083263b877": "0x000000000000000000000000000000000007444f542e6a7300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145dfe5da7f34068cb40668c14ac6f4e09373373ed8cc2fc6c7e092b10769b571af5c02bf4765ecd53": "0x0403000000020000000000000000000000000000000008416c626572746f0e416c626572746f205061686c65000018616c626572746f2e7061686c6540676d61696c2e636f6d00001140484552435f48414d4d4552444f574e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145e30111214665710be033afa19dd93fa4303e4c72b00b2c4102ff8c9b2fd75292774b56ba44de566": "0x00000000000000000000000000000000000d56726b3364735f537461736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145e47309d56ee80fcfc1af31cb4678204d2f643f29290d127fc9fc4ad0f148e258ceb48764763e062": "0x0000000000000000000000000000000000044e614e0013687474703a2f2f7777772e6e616e2e78797a000d6c756b65406e616e2e78797a00000a406e616e5f78797a5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145e680ae5b0223aa782a9563f0050686a13dc52d6a266b9cf19325ce9375f6cf13ae4712688011d52": "0x040300000002000000000000000000000000000000001070726f746f636f6c776869737065720b4368726973204d61746100001770726f746f636f6c2e65746840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145e68d454836a65b5902795e8d37421da1234a1a8f330fa910581ef0bfa3204d5bda6840890c6d23c": "0x04030000000200000000000000000000000000000000086c6964616d616f086c6964616d616f0000146c6964616d616f406c6964616d616f2e636f6d00000c426573744c6964616d616f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145e9f43767f234e4e0eb07d0fb791114259b3ae2ff2c186ffeb9f3c0cf05b5008a31994553b544c46": "0x00000000000000000000000000000000000558696e6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ead34c4d42568f9c0880e0e0918866661f9918d66b53287c95269d24e99121ee80618ca5f253666": "0x040100000002000000000000000000000000000000000c686173687761726c6f636b074a6f736875611868747470733a2f2f686173687761726c6f636b2e6465761840686173687761726c6f636b3a6d61747269782e6f72671a686173687761726c6f636b407068616c612e6e6574776f726b00000d40686173687761726c6f636b000c686173687761726c6f636b00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145eb695b4e8f904c91c2dd1f8db4faa532a9904dcfedc1c53eedf6307b54cbabe0b5b96c52d886c6f": "0x04030000000200000000000000000000000000000000115469676572204d6f6465204d656469610f41647269616e20526f6269736f6e00001a61647269616e4074696765726d6f64656d656469612e636f6d0000104074696765726d6f64656d65646961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145eb9bc0505da44278aa29a2af6e85eb0bb2d2f00a6894ce0e83ebca01e2830da7678516cb7e84416": "0x00000000000000000000000000000000000b546f6d42726f7468657200000012746f6d676162724079616e6465782e7275000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ed1cc4a4cfee745c427dd8b136f4c7463ab9a5761b8b4d7b1280e0d14ef070958db8641cb41b417": "0x00000000000000000000000000000000000a574152414f4348414e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ed4004f0c9e60f942aa0cf9b476762d4948072578e972faa9462a11b5ba17b1db8fcd8cc1d0420c": "0x00000000000000000000000000000000000c4235382046696e616e63650e423538204c61627320496e632e1468747470733a2f2f6235382e66696e616e63650014636f6e74616374406235382e66696e616e636500000c4042353846696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145ee8405cff42241194339db8b404ea216d60433f00ed67b0cdcd9e29d21355615d967161db0cb04c": "0x040000000002000000000000000000000000000000001f5354414b454e4f4445207c2056414c494441544f5220414c4c49414e4345000016407374616b656e6f64653a6d61747269782e6f72670000000c407374616b656e6f64655f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145eeade208c2c3d2213aa0eae4c9244da2b6bb58f13febd792db76c932b3bc64d0035df4735c8db02": "0x00000000000000000000000000000000000c526567656e63792d3031371757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145f3b96e8f7e196621cfbfde369c6f58b4df770cc3ba47d6583c0e9603007338779cbad7426767578": "0x00000000000000000000000000000000000b4d5843504f53504f4f4c001468747470733a2f2f7777772e6d78632e61692f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145f8f8fbe3a4a3e1256ae9b2d74ab4bb07306faf10549792549c52d4d092169530151a2aaeab28a0f": "0x040100000002000000000000000000000000000000000f446f745363616e6e65722e636f6d0f446f745363616e6e65722e636f6d1768747470733a2f2f646f747363616e6e65722e636f6d001561646d696e40646f747363616e6e65722e636f6d00000f40546865446f745363616e6e6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145fc4a5c686ea5a40b346948ec9e4cf84b965ec17a752b3e8eff098934aaad42ec50a347dd7936583": "0x0401000000020000000000000000000000000000000006716472766d0a51756164727669756d1168747470733a2f2f716472766d2e696f14406b616d696c73613a6d61747269782e6f72670b6b40716472766d2e696f00000a40716472766d5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047145fcf6e3e8fa7f7d4544eefa255546c84bf702f6d81c6828033cc49f7043e62043a3e83add44c6209": "0x040300000002000000000000000000000000000000000662727a64730d42726164204472657966757300001462727a64736f6e747640676d61696c2e636f6d00000962727a64735f4744000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714601c869e08b51af7b04b58ffedd058a81a625819d437d7a35485c63cfac9fc9f0907c16b3e3e9d6c": "0x0000000000000000000000000000000000074b68656f707300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146028af9a7bc6edd8d4c9b5341b6040e6f218c5476e5bb87a26fd80e03a0ac65b92d4d3eb917c8f22": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f351042494e414e43455f5354414b455f35000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471460c30e5ee0f16de5405a662b1e68b18eca577e175d2bb0b12a71d7c46bdb9ad0a546ab81686b245a": "0x0000000000000000000000000000000000056a73647700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471460e96a9630dce3d89c7e01287164e51a07f34b17c26c5eff66e1954d347310da015ac23e895a4150": "0x0403000000020000000000000000000000000000000014456c6973615f4576656e74735f426f756e74790d424f544c61627320476d624800000e656c697361406b696c742e696f000010656c69736166726f6d6265726c696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714613c4c21e4ca890ad2e5f1942410cb763e8418f7c2c9afe20141d6ac4f780c4d1ce3dd2205426865": "0x040300000002000000000000000000000000000000000964616e6963756b690e44616e69656c2043756b69657200001364616e6963756b6940676d61696c2e636f6d00000964616e6963756b69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714617869f5844780e5f84795f2f68a2c43453b25ab4814c460f257d9bb05d04596499fd3211821076a": "0x04030000000200000000000000000000000000000000084d616861766972164d6168617669722047616e617061746920446173680000176d6168617669722e732e647240676d61696c2e636f6d00000a32374d616861766972000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714617ca8c9a7bf519bdc156e868d00cf92479a2417ebcdafbf0ce336f4cf3a818be068c49ee0562e79": "0x000000000000000000000000000000000008436c656d656e741e436c656d656e74204f6c69766965722044656e6973204a756d656c696e000018636a756d656c696e4070726f746f6e6d61696c2e636f6d000000000972756d656c696e6500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714617f389a0cb0d26a8659ed6f5a98bf0e1718fcc89e8e55a550e220da0f5de46f356297ea2af72c4f": "0x040100000002000000000000000000000000000000000f426f756e7479204d616e616765721467616c616e6970726f6a6563747320476d62481a68747470733a2f2f67616c616e6970726f6a656374732e6465001a626f756e74794067616c616e6970726f6a656374732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714618fd93a58f35389e2680e2c991a18cf7ba4710a51ba147b6856879a3047a03f8c647c69b953d630": "0x040100000002000000000000000000000000000000000751696e57656e0751696e57656e1a687474703a2f2f7777772e71696e77656e77616e672e636f6d184071696e77656e3a776562332e666f756e646174696f6e1771696e77656e40776562332e666f756e646174696f6e00000d4071696e77656e5f77616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146191809a9acac4bb8c529de435a764457d6247ef93b5cc72fd73b922e4903834dfb43dbf64013365": "0x0800000000020100000002000000000000000000000000000000001243525950544f4c41422e4e4554574f524b001f68747470733a2f2f7777772e63727970746f6c61622e6e6574776f726b2f154074616e69735f33373a6d61747269782e6f72671b74616e69732e737461636b4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471461d35c4872d484b694c860705264b96854acc3cb307365132bd131524ef83a7c014378ed79373723": "0x0000000000000000000000000000000000164d65786963616e20436f6c6c65637469766520484100000018646f7473616d616d657869636f40676d61696c2e636f6d00001140506f6c6b61646f744d657869636f5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471461e96b98dbac9ae8cebcf37135a013069cdbafff3cc1074943f5ce992bfa90c58dec50c1440dad12": "0x000000000000000000000000000000000013506865656220506f6c6b61646f7420352e31132f722f506f6c6b61646f745f4d61726b6574000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462075dba595e3a2898a570ec356d2f77d890fb7643ffbf7a92c442af3f45dbd87a5ca8f17ff5b679": "0x00000000000000000000000000000000000f44657672696d50656e64756c756d0d44657672696d20436574696e1b68747470733a2f2f70656e64756c756d636861696e2e6f72672f001964657672696d4070656e64756c756d636861696e2e6f726700000a4064657672696d6277000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714625e8e7181f526d87a202a62e71ca9d711e66c2e8587d830388f723563b782611849824b42608542": "0x000000000000000000000000000000000009504f4c4b41444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146277dfd6b7b21ca2faf5f68fe828f5af8d69c116efd937d90f1956b0edd94e05d8b5285a8eb2a663": "0x04010000000200000000000000000000000000000000115374616b696e6734416c6c20f09fa5a9001d68747470733a2f2f7777772e7374616b696e6734616c6c2e6f72672f18407374616b696e6734616c6c3a6d61747269782e6f7267167374616b696e6734616c6c40676d61696c2e636f6d00000d407374616b696e6734616c6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146279b764d4a4ad2eaebfc0f0232c4a23c29dba65a33f7611db55e924e4b0a65950694b857e33764b": "0x0400000000020000000000000000000000000000000008636179626163680000000000000d405469656e43797072657373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714627f8fe7f248c866bc19869b7dc67efaa0923dd74b337c57baaedf41a1d002534f70cf4520b9b642": "0x040100000002000000000000000000000000000000000549505345001668747470733a2f2f697066737365617263682e696f000b686940697073652e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146281ccf16900ef3cac00a2740247063b6f890eea8309fa99d0fedeeb27602925e1de7e58b0ec6f6a": "0x00000000000000000000000000000000000d50617261636861696e333538134b415a554e415249e3808049574154414e4900001d776f726c642e6f6e652e696e766573746f7240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146282c39a18dfcab98e5d5f02fdd82b7c0ab38bd6093d17261f4c862f22caededb3a808c12a7904f4": "0x0000000000000000000000000000000000096770657374616e61001568747470733a2f2f6770657374616e612e636f6d000000000a406770657374616e61096770657374616e610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146293ae906f82830db8a2ad752a280c8f9d461025191b195f8c1f60ea080604c24c1aebe1ebf6415a": "0x0000000000000000000000000000000000075279616e486f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462a40c29b1fd2c93b204051d55c2c80cdf6e0d3346944e921fc97f0b86a4cc5eb5547982fc475d68": "0x040000000002000000000000000000000000000000000b5374616b6520506c7573000016407374616b65706c75733a6d61747269782e6f726713636f6e74616374407374616b652e706c7573000011405374616b65506c757343727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462b931cf40e0dd8a4278dc8473c1319b51e5e326374b22f4b290bbf716f1d5a6e6bec98e2ac42c03": "0x00000000000000000000000000000000000967616d613238333000000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462d6ffba2553d09e31e11c530aee0dc228f734335dba8e77607b187c46b1c7c5827df020f94b0400": "0x0403000000020000000000000000000000000000000016446563656e7472616c697a6174696f6e5f6d6178691b416c7661726f204d616e75656c20476f6d657a205a756e69676100001461676f6d657a34323340676d61696c2e636f6d00000c40416c7661726f5f5f677a000b616c7661726f6734323300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462d8d4af4eadb392cc52156f09978540d3163b798f65a8788bd04d828f366674bf9ea1f88e96f519": "0x040100000002000000000000000000000000000000000b48595045525350454544000012406c6f6b616c3a6d61747269782e6f7267146c6f6b616c40687970657273706565642e6175000009406c6f6b616c7070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462e3e6769daa8cb66aaa8240cb6f2f8c0a86cf27c3f39f980074e7ec3d000bc0248978936bb9a83c": "0x000000000000000000000000000000000020524146207c20506f6c6b61646f7420416d62207c2050424120416c756d6e690c4a656f6e67536f596f756e1c68747470733a2f2f6769746875622e636f6d2f636f636f796f6f6e184070726f6f666f66796f6f6e3a6d61747269782e6f726714636f696e796f6f6e4069636c6f75642e636f6d00000d4070726f6f666f66796f6f6e000e436f436f596f6f6e233631313100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471462e49551b36f932cd8d4e647a65738b7ec76c4e59af4b40d167270e55d008acabc172759d51e0e7b": "0x040300000002000000000000000000000000000000000c5468616e6720582e2056750c5468616e6720582e2056751268747470733a2f2f7468616e67782e7675134073696e7a69693a6d61747269782e6f72670d6869407468616e67782e767500000c407265616c73696e7a6969000773696e7a696900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714631b52e3f40c72ed64a020cd2e215de928d7f9defcd9380a7e2415b8c3e22444ed2219cf95fa2e1c": "0x00000000000000000000000000000000001141204b616e65204d792057616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146332adb00a8dc85a427150f6dee04d6e06f06a62a3509ba0b0cfa0ac01a69558616402b7498f1247": "0x00000000000000000000000000000000000d536f7461207c20506c61736d0e536f746120576174616e616265000011736f7461407374616b652e636f2e6a7000000e40576174616e616265536f7461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714633914b3a4ceda021eb38b0d5178bc680c10a204f81164946a25078c6d3b5f6813cef61c3aef4843": "0x040000000002000000000000000000000000000000000e416c69636520756e6420426f6200001a40616c6963655f756e645f626f623a6d61747269782e6f72670000000f40616c6963655f756e645f626f62000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714634b6c2676d6ffce12751adf007e19834923db0f540c0f255901febc74640782cff748e94c65c72d": "0x0000000000000000000000000000000000096461746170756e6b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714637afeda6c31f8ce54857fcb60606080a3ad974ef8d8673f899b3e1983f1c512f2f671c79f2b4a55": "0x0400000000020000000000000000000000000000000006416c696e6100001940616c696e656865727a6d616e3a6d61747269782e6f726714616c696e6140616e74697363616d2e7465616d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471463b1d194ccf414dfa4e5f5b5bfc485119954be727698c6eeb542b909a2d40014822d9dd0ebf91a1f": "0x0000000000000000000000000000000000084d617175655f3100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471463cb40b01c7b706af03a9fd09c8d3f8b134a20a873380efc542f5b85606cf62ffaa7fa302d7e0e23": "0x040300000002000000000000000000000000000000000c456c656374726f636f696e0c456c656374726f636f696e000014696e666f40656c656374726f636f696e2e657500000e456c656374726f636f696e4555000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146419f57ea3f84915121b12be1a2b918b9d01ff05c3d2fe5a28769cb747ff9fd7ecafc320dd5f810b": "0x00000000000000000000000000000000000f446f744c65617020456469746f72001f68747470733a2f2f6e6577736c65747465722e646f746c6561702e636f6d0013656469746f7240646f746c6561702e636f6d00000940646f746c656170000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714647269eb11608c5734a12ea862a1818defeb3fcde0962c89b7e71184e08ebbfddca97b9954b43144": "0x040300000002000000000000000000000000000000000944616e69656c20431344616e69656c2043686d69656c6577736b69000017636f6e74616374406463736f6674776172652e78797a00000964636f6d706f7a65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714647a84ffd21ef58f323e0ef6182a1c24b15bad084d75a03ba5aa787e7af723327287f6df292e6f76": "0x040300000002000000000000000000000000000000000e546865205765616b2048616e64000000197468657765616b68616e64646f7440676d61696c2e636f6d00000f405468655f5765616b5f48616e64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471464c511948fee226142c119baba24ac08d19b6f23bd0752b81f5169c331d39481519795bee26dc350": "0x0403000000020000000000000000000000000000000004536f770d4d6177657961746120536f77000014776579617461736f77407961686f6f2e636f6d00000b40536f774d6177657961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471464eea8ed6e0c669be2baaa3eda02d880fa4ed98b9de89e16e2a064d649231f53c00c27403fc6ea7c": "0x0401000000020000000000000000000000000000000011546967657250726f204361706974616c001c68747470733a2f2f746967657270726f6361706974616c2e636f6d1540746967657270726f3a6d61747269782e6f72671c636f6e7461637440746967657270726f6361706974616c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714651097b4998394e146d1b7fd733a68d1c3e53d6bfd7134a5803fe5a4033c2dc9eba2e31dc21c4a65": "0x0000000000000000000000000000000000076272656e7a69000013406272656e7a693a6d61747269782e6f726700000009406272656e7a6935076272656e7a690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471465326f57f6604b32cca044696fc5f11711266f7da0da4d0b94e34420cdcaa9f3e9e06939e551d27d": "0x00000000000000000000000000000000000b646772656174616e64610b416e6461204461766964000015646772656174616e646140676d61696c2e636f6d00000c40646772656174616e6461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714653768733bf980751cb8badbed1198dcece2e14047133b22e64bd06a9cf74ec5c8f94f668d1f2720": "0x04000000000200000000000000000000000000000000164b656e6e7920284d616e7461204e6574776f726b29094b656e6e79204c690000146b656e6e79406d616e74612e6e6574776f726b000011407375706572616e6f6e796d6f75736b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714657bab39f52fddf58e07d43b19d901badf3a7f57155ca84f2f835448e93a141bbbd33eac4b767d15": "0x040100000002000000000000000000000000000000002163727970746f7374616b652e636f6d20f09f87a8f09f87adf09f87baf09f87a60c43727970746f7374616b651868747470733a2f2f63727970746f7374616b652e636f6d001661646d696e4063727970746f7374616b652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714657f579f3442148eea0ab1b08b58a3708b50ba9928c4e25ad71d68efcbb868a2f75b987d0e8e4108": "0x040300000002000000000000000000000000000000001063617473776974686f75746861747300000016736869746c62674070726f746f6e6d61696c2e636800001063617473776974686f757468617473000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471465b47ab9f3aec5ec06e3ed1e088da56a1e7ea6b57a856a0ead9e03bfbbd1ec74b33153e35015f10a": "0x0400000000020000000000000000000000000000000008546f6d69747a7500001440746f6d69747a753a6d61747269782e6f726712746f6d69747a754070726f746f6e2e6d6500000940546f6d69747a750008746f6d69747a7500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471465ce07032d38638e0453c20a8f8f0b374ec6d08c489e06e74686a2233bcf6422f345dfaab11fda26": "0x040300000002000000000000000000000000000000000b54656e7462616b657273001768747470733a2f2f74656e7462616b6572732e636f6d0017636f6e746163744074656e7462616b6572732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714660e4d7cfca9e1ef4263436c1c3bd22e1a1e09401982bb2df2e6e6c449417a5ad157d07ab2319243": "0x0000000000000000000000000000000000074a61766965720d4a61766965722056696f6c611868747470733a2f2f6a617669657276696f6c612e636f6d12406a61766965723a7061726974792e696f000000000a7065706f76696f6c610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146619f3097120b33a1bbdfb8e2904d640a26915c57200ac20ee110d6490d5e5129271b09d2ebf2c36": "0x040000000002000000000000000000000000000000000a446f6d694e6f646573001568747470733a2f2f646f6d696e6f6465732e696f001368656c6c6f40646f6d696e6f6465732e696f00000b40646f6d696e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714661f86092c2992fefa8bd5aca42a81a5b5e5d82a75204214606e67517458dfb94363da5cebc42c15": "0x040300000002000000000000000000000000000000000a526563726166746572000000157265637261667465727840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466331c5b2aefc4da60e469433111edea77c7b0075788c8ce009ad00aeed8529b9c26f26552e81948": "0x0403000000020000000000000000000000000000000007e8b5b5e4ba9107e8b5b5e4ba9100001873746f6e65737461723139383640676d61696c2e636f6d00000f4073746f6e657374617231393836000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466334165bb2310561082b1a911dd8e9d01ebec53598da502cf118af543db458ce6d0e60b43a5af66": "0x040000000002000000000000000000000000000000000c546974616e204e6f64657300001740746974616e6e6f6465733a6d61747269782e6f726714696e666f40746974616e6e6f6465732e6e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714665d1a1f97f0cb0ebec5d127b5bc86b320b802f368a9cf427b3682d973b9fe41a9e6f5bff108432b": "0x000000000000000000000000000000000011426c6f636b636861696e20506564726f12506564726f204c75697320526976657261001c40626c6f636b636861696e706564726f3a6d61747269782e6f72671a426c6f636b636861696e706564726f40676d61696c2e636f6d00001140626c6f636b636861696e706564726f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714665d24a2e48cf277dc50817f1905a0dbf31de7065eb1891100f8bb18005786b68082ea625d6f6325": "0x04030000000200000000000000000000000000000000096568696c64656e620000001f657665726574742e68696c64656e6272616e647440676d61696c2e636f6d0000084072765f696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714667070096dd1a56f92db463a407b5818299a44b9db0727c16e9cd6b64dde2db70a592421be9f9b29": "0x04030000000200000000000000000000000000000000084d6f72616c6973084d6f72616c697300001168656c6c6f406d6f72616c69732e696f00000c4d6f72616c697357656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714668bbbac68a19cb7a02f7333e25590e4f568ae8a2ddc93a879e92e48fa3cf1666ac56e020c106d55": "0x040000000002000000000000000000000000000000000b436f696e73747564696f0000001a636f696e73747564696f4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466a0ec80cc3122c082bf733f44a840f0a5c1935a002d4e541d81298fad6d1da8124073485983860e": "0x040000000002000000000000000000000000000000000b53616d20456c616d696e0000164073616d656c616d696e3a6d61747269782e6f72671273616d40696d6275652e6e6574776f726b00000b4073616d656c616d696e0a73616d656c616d696e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466ab20bec2c8842b5c7a60ff74811eee72747ef1f1ae376eda2d3c8aab129f6c2cc76abaf59fb87c": "0x040000000002000000000000000000000000000000000a486563746f723c423e00001840686563746f7265737430363a6d61747269782e6f7267156862756c676172696e6940676d61696c2e636f6d00000d40686563746f726573743036000d486563746f7242233936313500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466eaee046d4f02542c89cb8652eff8c73266de06baa3760534e7f37fecff971c028c2910efd6a947": "0x040100000002000000000000000000000000000000000a4c6567696f6a757665000000146c6567696f6a75766540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466ee39ba0cc8fa55f4e0ed785c7c3f9f3efd38a15ac1498383070f1d7154c2ed5769652045609d75": "0x0403000000020000000000000000000000000000000013506f6c696d656320466f756e646174696f6e14506f6c696d656320466f756e646174696f6e2e000011696e666f40706f6c696d65632e6f726700001140706f6c696d656370726f746f636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471466f191e02c9f27205e13ed8ae098f9a3cedd297c6a019aff1cd744b56546dec7884c5ddac1090e20": "0x0000000000000000000000000000000000064167796c65000000136167796c654074616c69736d616e2e78797a00000c407374696c6c6167796c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471467065dcde6578a8344eb828e27b43fd3e8cefd90f96aa467bd629dac03603b8355ffe434b865c50c": "0x0000000000000000000000000000000000134b415445207c7c204e4f544946494741544f001b68747470733a2f2f5757572e4e4f544946494741544f2e434f4d15406b6174656761746f3a6d61747269782e6f7267156e6f746966696761746f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146724d23e0f578016d7e81893f6494f953ddc28c0565d5d82c7f57426b59f35a779cef72804b37086": "0x040000000002000000000000000000000000000000000d4f70656e5a4c20436f6d6d2e000000156f70656e7a6c406d616e74612e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714675a4d3970c551d5acd87357aaf3bc58b5499d10d6c03092ef4fa89ac4a9c2fe7a80f6a6cdd7b060": "0x04010000000200000000000000000000000000000000094d494e5477617265174c65726e656e206d697420646572205a756b756e66741468747470733a2f2f6d696e74776172652e63680011696e666f406d696e74776172652e6368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146773244509d0e7c8d46cd0ae6eeab8ef19bf289712c9f2ae4272c663bfe0786d7c10d4ada5210003": "0x040000000002000000000000000000000000000000000c4859504552535048455245000011406876616c3a6d61747269782e6f72672076616c696461746f72734068797065727370686572652e76656e747572657300000e4068797065727370686572655f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146773f65a3ce78ec9f673019128278eb8e7483c1c8b16506a89d140ad1dedaee28b6589306e98b28a": "0x040100000002000000000000000000000000000000000963656c616461726917436861726c65732d45646f75617264204c41444152491568747470733a2f2f63656c61646172692e636f6d0021636c2e6b79632e646f742e717439386c4073696d706c656c6f67696e2e636f6d00000e4063656c61646172695f646576000963656c616461726900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471467f3ca507a532ccb2e1884c53071526483b14004e894415f02b55fc2e2aef8e1df8ccf7ce5bd5570": "0x00000000000000000000000000000000000970657079616b696e00087065702e777466000000000a4070657079616b696e0970657079616b696e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714682174f20abcb7fdfa5e6f955d973efaca30897c4a3e4fbec88186ae72b8b331408804d73dfc275e": "0x04010000000200000000000000000000000000000000174245535456414c494441544f52207c205a55524943480e4265737476616c696461746f721a68747470733a2f2f6265737476616c696461746f722e636f6d14406d6f736f6e79693a6d61747269782e6f72671868656c6c6f406265737476616c696461746f722e636f6d000010406d6f736f6e79695f7a6f6c74616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146850837ac8d1be3236b8df7482c47933d4409ae2aea62f412be6f2af44173bb32d49e9abf3858445": "0x0400000000020000000000000000000000000000000007676c692e616c00001240676c69616c3a6d61747269782e6f726710706f6c6b61646f7440676c692e616c00000a40676c696f63797465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146857f90ade375e178c1860117351602843d192a9b4eb3b3641da38ab14c7974398761e7b7f3f3a14": "0x04030000000200000000000000000000000000000000054c75646f124c75646f76696320446f6d696e6775657300001e6c75646f7669632e646f6d696e67756573393640676d61696c2e636f6d0000084b726179743738084b7261797437380000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714687ec1d74f1c4464947c43d52db657492fed9368dc326e667d9c7bbf8df33c50974df47d2941ec42": "0x040300000002000000000000000000000000000000000e3078436f70706572736d69746811546962657269752043617a616e67697500000e6f776e61626c6540706d2e6d6500000e3078436f70706572736d697468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714688f2c242370997680f9384b92e09042571a9e5cd43d9656d62acfeb0324ff44698bb2cfe422b36b": "0x00000000000000000000000000000000000e506f6c6b61646f74204c6976650e506f6c6b61646f74204c6976650000106940706f6c6b61646f742e6c69766500000b405a65616c6f745f3078000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714688fa9c16c2592d347051c516138c028eb5de9449fcd8fc9b657540f7592f822359f26b29092029a": "0x040300000002000000000000000000000000000000000a43727970646f756768000000117a6163684067697665706163742e696f0000114063727970646f756768646f74657468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471468b2359cc10fae926295f0214abb5522cf3becf82504ef7c87036236e6b9afd263697a99bc5d5a30": "0x0400000000020000000000000000000000000000000014f09f91a8e2808df09f9a8073706163656d616e0000184073706163656d616e3131363a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714693a853cf5be87fcd81bf7c20643158bc6957827b344bde86cd260676dffa382afe24896634aa16b": "0x00000000000000000000000000000000000844656661756c7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714694ea541e2c22fadd6b8ec23dc68f20b5d315007d9c1a6706f9bd5c883319181129e76a89e978155": "0x040300000002000000000000000000000000000000000f446f7420506c617920416e6769650e416e67656c612044616c746f6e000020616e67656c61407369676e756d67726f77746861647669736f72732e636f6d00000a4064616c746f6e616e000d616e67656c6164616c746f6e00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471469576573c28ce38722e2d9f05aef8aa9965e0798d0789cb16f21ae1610b5695d20340a0e61bb4fad": "0x04030000000200000000000000000000000000000000125761674d65646961206d756c746973696700000017746861746d6564696177616740676d61696c2e636f6d00000e40746861744d65646961576167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714697ead568e820ccfd2eb07f02043788e254d9e2df57be11566d241c56302b91199b4647947af3020": "0x040000000002000000000000000000000000000000000846415241444159001968747470733a2f2f666172616461796e6f6465732e636f6d1940666172616461796e6f6465733a6d61747269782e6f72671768656c6c6f40666172616461796e6f6465732e636f6d00000e40466172616461794e6f646573000d666172616461796e6f64657300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146988e63c3f5238944c1391e430e3bff9da68fb549a8c47881bd0fc7ed745031f57fa02495cbdbc7a": "0x040300000002000000000000000000000000000000000672616661630772616661656c00001672616661636162696c6c6140676d61696c2e636f6d00000f4072616661656c636162696c6c61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146996157961e3bb9397722aac08a16eefd9a6d17b5d69874b7d84ae30eb523c09054f677e976cc8c5": "0x000000000000000000000000000000000014496e746572204643207c20506f6c6b61646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146997b214126ecad17e45841538166aa927c3e1c2bdaa3c0d1aa1938b1ea21710eb3a2c9e6431b93b": "0x0403000000020000000000000000000000000000000017526f636b585f506f6c6b61646f745f4469616d6f6e6406526f636b581668747470733a2f2f7777772e726f636b782e636f6d0012737570706f727440726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471469a5e82dfb57babbb40b08703caaacd889ed6521b6cd76db8c017652dda03f7239484e10e49ebd1d": "0x040000000002000000000000000000000000000000001d4a4b5242207c20546f7765722042726964676520f09f87acf09f87a7000000196a6f656c406a6b7262696e766573746d656e74732e636f6d00000a404a6f656c4a4b5242000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471469c81f40482c7fe2ac561538f2f61fdee2e15d44a6df7b310fcb0428da93ea0d5373a4ba14408d52": "0x040100000005000000000000000000000000000000000f4e696e6f202d204170696c6c6f6e001368747470733a2f2f6170696c6c6f6e2e696f00106e696e6f406170696c6c6f6e2e696f00000940676f7375313238000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471469d27efc78020c0bb2e2af76c0926af438cb5c3a2c0f534da4c25ab3bed006df4eca319ad3bf8874": "0x00000000000000000000000000000000000d576562332d446f7446616e7300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471469e34466005457c2c48d1c4fc44dbbc10b86e40db24f95f8924efba2b31eecc6a7c32bf2b8a4481a": "0x04000000000200000000000000000000000000000000064c65776973145368696e672059696e204c65776973204c41550000156c657769736c737940686f746d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146a205861e5fd90b2ae3a9e0c24a161ca065e6af741e35dcfa1cb3c0c00d820f9445e1dcd1b36ef09": "0x00000000000000000000000000000000000450345500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146a2d4f462a713142b45f7d4b6bd58cb550270c1ba3d9d97b6766787966b0b5c52c79b4d3b51d9a43": "0x0403000000020000000000000000000000000000000017f09fa681204c454f5354414b452e434f4d20f09fa6810000001974656368737570706f7274406c656f7374616b652e636f6d00000c6c656f7374616b65636f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146a4f96f9cd70bd9472e7ccd983b92c5ae60481a636eab0fe42269c9f43c302a74f9dc65e0fbe202b": "0x04000000000200000000000000000000000000000000175375627371756964204c616273204f6666696369616c135375627371756964204c61627320476d62481568747470733a2f2f73756273717569642e696f2f0013736f6369616c4073756273717569642e696f00000a407375627371756964000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146a6c65861cbfd4f690ebd94a58a07211dcf05c4164ebab8c3abaca45f16f793fbe34072ae7b9ba08": "0x040000000002000000000000000000000000000000000a4d61726b205279616e0a4d61726b205279616e0017406d61726b2e656d6265723a6d61747269782e6f726700000011406d61726b5f656d6265725f7279616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146a89e104b2a237cd50192a1801fb73df626b690ff6e92a6f502ab5289437d799927cf486cef84319": "0x040300000002000000000000000000000000000000000b4245454659204d454d450000001377656e626565667940676d61696c2e636f6d00000f4062656566796d656d65636f696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146aa8b880a0c4b9171275627409e1eca0f9aa7e08fe1f1a26988cb462283067fdd30c13fcd7981424": "0x0000000000000000000000000000000000134d44726f75676874202d205374616b696e67000000166d64726f75676874406d64726f756768742e64726f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146b14621db5a14421ee995f41ea8d34445ee36e73b1f44437ea7f758bbb1f1e89c9894066b013ca3d": "0x00000000000000000000000000000000000761736c696e6b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146b1f8277766d740bc622132c1da0a0c45d91cb970fb5332e5c592a45f6c7e223767fd8c7fb849c58": "0x04030000000200000000000000000000000000000000125348412d74776f666966747963687269730b436872697320436f63611868747470733a2f2f7777772e646f7469736465642e696f001a6368726973746f70686572636f636140676d61696c2e636f6d00000b406263315f6368726973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146b9baafd26f9d78929f107a6abccb303dcdd5d05569389f87a411d192e8463829a9c84a95a5b3ed1": "0x040300000002000000000000000000000000000000000c4d69737465725f436f6c650000001e6d6973746572636f6f6f6f6f6f6f6f6f6f6c6540676d61696c2e636f6d00000c4031393238333734367a71000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146ba30fff03a1847c98acccca7675aa832373fa4dfee14c0c237c1e547ae91981b63b4a0a9810d270": "0x040300000002000000000000000000000000000000000b5265616c566973696f6e175265616c20566973696f6e2047726f75702053455a431c68747470733a2f2f7777772e7265616c766973696f6e2e636f6d2f00186163636f756e7473407265616c766973696f6e2e636f6d00000c405265616c566973696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146bf602d4ccb0664d3c235e80e35082b668682531b9b062fda39a46edb94f884d9122d86885fd5f1b": "0x00000000000000000000000000000000000000000000000000097270686d656965720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146c4d2026575763437cdc1a6a5a7f23437b6528edcdf553d0685f940a4e6e85579727ef3dc574563a": "0x04000000000200000000000000000000000000000000114365727448756d204d61785374616b65000018406365727468756d2d6a696d3a6d61747269782e6f726715706f6c6b61646f74406365727468756d2e636f6d000009404365727448756d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146c5088428455187bcc95d7d061fc6a655b795794b9b1614d0a240e13e81de9dce3f2b184f653da7c": "0x04000000000200000000000000000000000000000000097279616e686967730000000000000a407279616e68696773000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146c617259271d955c48b2a90dced600b59871b53ba285b33b16ad830ea6877ffea3ea7469a996b054": "0x04000000000200000000000000000000000000000000074655545552450000124031667574753a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146c7206770c39d9295a5f7eb7050fb96d8d7895d9afce428a064ce66e3b094805bcad9a8e68cb9934": "0x0401000000020000000000000000000000000000000013426966726f737420466f756e646174696f6e13424946524f535420464f554e444154494f4e1868747470733a2f2f626966726f73742e66696e616e6365001668656c6c6f40626966726f73742e66696e616e636500001040426966726f737446696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146cbe0677de752662eebc7887720ec1ce8b759629cb425df5f15011f0d455bfe1a22ad4cfb36d1a3b": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31321142494e414e43455f5354414b455f3132000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146d1925fb53c401a7aa926dd1d0ac5fd7a08808a687e8ab73137ea8355c32c397b4b8b1c2db7cd752": "0x00000000000000000000000000000000000a4a61736f6e20547365064a61736f6e00001576616c76656368696e6140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146d2ec78ce0df90db282babe83a600ea252085b952e5df448a09e3b859d510d21900a77549f39b66c": "0x000000000000000000000000000000000008656b697463686f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146d3350ee036daad1f21779c6e9e861c7af89d8edf7077a73c54d16ee419d8080e3539937bf565e4f": "0x0000000000000000000000000000000000114d79436f696e7461696e65722e636f6d001968747470733a2f2f6d79636f696e7461696e65722e636f6d001761646d696e406d79636f696e7461696e65722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146d34ca1ecaaeb6174471abb5438fa95f8c85b8d5a417df0a6a38b4372874f27f30f20645f3263830": "0x040000000002000000000000000000000000000000000b5975647573204c6162730000154064757979756475733a6d61747269782e6f72671579756475732e6c61627340676d61696c2e636f6d00000c4079756475735f6c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146d5ba05b78a2e080daa4917008c6339bc42960ff491ffb03c3a6ddfc2b2b045d1c24112383398252": "0x000000000000000000000000000000000007686f646c337200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146dc100623401ea343e7064033033db59b89b05afc0408800e1c6a900e5ef4465f6493d50e5070031": "0x00000000000000000000000000000000000f4b65697461204d6f726979616d6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146dc2070d9c7fd08ed88e71e550f7c318065fe4ce9c7d58430af17fa534f87d27195dd93cce667719": "0x00000000000000000000000000000000000a4669676d656e742034001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146ddcb34ad887603a8283bf2db7f36e834b16ce3b301f978609b2eefd855f01f6c7f16209c0a9147e": "0x00000000000000000000000000000000000d4d6973636861277320446f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146dfdc0beae27efb8ee5b5133284a68de459de2373129497bf4bad758619ebc6b0b6bc77fb1ee2862": "0x0000000000000000000000000000000000085052585920434f001368747470733a2f2f70727879636f2e636f6d0012636f6e6e6f724070727879636f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146e0bda57536f0f7afe8ed746b2f0fafda336e27346a75f2f03db0f73a3e73e1ca6deb3676e14d139": "0x00000000000000000000000000000000000a4d61747453616e746f124d61746961732053616e74616f6c61796100001b6d617469617373616e74616f6c61796140676d61696c2e636f6d00000c406d61747473616e746f5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146e282abb12705aa32837c15322c7d358dc07ee65dd3ab42a3d70b6c4577a015b2479100bbeacda51": "0x0000000000000000000000000000000000064368696c6c000000166d6f6c6c79646f7430353640676d61696c2e636f6d0000094055534348696c6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146e4e14c3138d789d92f2999a6efaa86285a96c5d0ba78f11ec72b33c6973ec6fd5afb7b8b0e4fb45": "0x04010000000200000000000000000000000000000000085a656e6c696e6b115a656e6c696e6b2050726f746f636f6c1468747470733a2f2f7a656e6c696e6b2e70726f13406c656f67756f3a6d61747269782e6f7267106c656f407a656e6c696e6b2e70726f00000c405a656e6c696e6b50726f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146e586fa9f032427be49ad2f6a7346dca526a39aeea90aa0231717c77eaf257b0733faed3e1953f19": "0x040100000002000000000000000000000000000000000e414a554e41204e4554574f524b1c426c6f476120546563682041472028537769747a65726c616e64291268747470733a2f2f616a756e612e696f2f1540726f786f6e746f783a6d61747269782e6f72670f68656c6c6f40616a756e612e696f00000e40416a756e614e6574776f726b000d6461726b667269656e64373700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146ec642500076ba25a6c5f0595d6ed85d6260bc682d4a68a4b4e605d43c67d56f2765d19698549772": "0x040000000002000000000000000000000000000000000b5374616b656c792e696f0000124069696363313a6d61747269782e6f72671161646d696e407374616b656c792e696f00000c405374616b656c795f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f4309182c6e307ed4e8bfb1c924dd64e33ecfbb35d90061bb83b2dde667e58588780068f9fc1471": "0x00000000000000000000000000000000000b506f6c6b616469726b730f43687269737469616e204469726b00001843687269737469616e2e6469726b406d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f47cd4490d5c355aeb3b1fa02364f2a474a149c1ce5b80c177857c0cde909e140d8d88036dde539": "0x00000000000000000000000000000000000844414f4e676f6b001868747470733a2f2f646f7261666163746f72792e6f72670016737465766540646f7261666163746f72792e6f72670000094044414f4e676f6b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f73628ca952be18dad0bc6a0aadf06c56416e83bf75e865d41ccb5ffd74eabf9e81d47574b43049": "0x040300000002000000000000000000000000000000000b43756c74757265446f740b43756c74757265446f740000146a7562616b4063756c74757265646f742e696f00000d4063756c74757265646f7431000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f74c55a2ace0819606aa47c4cbf48834774de4e02bed163e76c54e50415f5a0cb103e6a47511c0b": "0x0000000000000000000000000000000000054c616e6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f75ffac66bf6b9f1028da734244eb60a38d63f97c96f89f4f9630bb98376631a4d24c2baf1ccf6f": "0x04000000000200000000000000000000000000000000064d61727461114d61727461204d6f72616e64757a7a6f1968747470733a2f2f776562332e666f756e646174696f6e2f17406d617274613a776562332e666f756e646174696f6e166d6172746140776562332e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f83ccad3981de4b7e569787b1b323854ac9a8c40914d400b6fc23a2fedd24321f814ce7db7f6563": "0x040000000002000000000000000000000000000000001452656b7420537472656574204361706974616c0000174072656b747374726565743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047146f9c17a3ac4a6c898a3b9446cadec292c5064f0572e8752007bd8db06cc58feccaf23dea69da58cb": "0x04000000000200000000000000000000000000000000076765726d616e001468747470733a2f2f6e696b6f6c6973682e696e000000000c40736b796d616e5f6f6e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471470391fe33aca6dcaf6a7abb3dd0e36f9f77e31e10462ea14b10c909f37cc0db83ee8349dc531d840": "0x00000000000000000000000000000000000b4461636164652e6f726711556e697420552b3234363720476d62481a68747470733a2f2f756e6974382e617065756e69742e636f6d0012753234363740617065756e69742e636f6d00000b406461636164654f72670009656d696c2e61706500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147049f2f99a873c94c00f86f5f5421e98f7ba345ccd996c53412f39308ea854053fe650ca7bf44f75": "0x00000000000000000000000000000000001242726967687420496e76656e74696f6e73001d68747470733a2f2f627269676874696e76656e74696f6e732e706c2f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714704dea62a3fb9e66a471c55caca4be7b4e60c6e94b20f9028883f8c64287d4454130c657383c3442": "0x0400000000020000000000000000000000000000000018f09fa78a2049636562657267204e6f64657320f09fa78a00001940696365626572676e6f6465733a6d61747269782e6f726716696e666f40696365626572676e6f6465732e636f6d00000e40496365626572674e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471470d495db70840cac599742dc389cf9dbb6a67d8cbd22170dabce386c06df1ab4ad8c8285f351f2af": "0x040100000002000000000000000000000000000000000b476c617a657363617065001768747470733a2f2f676c617a6573636170652e636f6d001568656c6c6f40676c617a6573636170652e636f6d00000d40476c617a6573636170655f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471470ea89be94fe51a442cc5215992b80128fbe79ab6b9e9ef599e18a9fd3aabb62973d80e66cb40d0a": "0x040000000002000000000000000000000000000000000667626163690000124067626163693a6d61747269782e6f72671d67696c626572742e73746f7279637261667440676d61696c2e636f6d00000840676261636958000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714710936ab2f44516c185002001ae350c3815b9414a1113f6a6eaefa51a52ad3bfa09183c197c23f6b": "0x00000000000000000000000000000000000c6861727279646f3339373912446f205068616d205472756e67204861750000166861727279646f3339373940676d61696c2e636f6d0000104068617272796265617574795f6f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714712aaca2b02746086883c9953ae0dea90b0b1db721a34e5ab73f948f428c403ca23bfca0f514594d": "0x040300000002000000000000000000000000000000001cf09fa6bef09fa4962049766f72794e6f646520f09fa496f09fa6be0000001769766f72792e626c616e63614070726f746f6e2e6d6500000e4049426c616e63613439353736000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471352c2eb5ded5f286484f63c9e0ae1f460dec3b53307478f5ce3ffab22a1334d34a52da7527ec64": "0x04000000000200000000000000000000000000000000084d656c616e67650000001a6d656c616e67652e7374616b696e6740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714713faaeb6b134411e9d6e3adda6c3383cb1f5e92d6908f7d792fc1b4a80958341e05f53fee624836": "0x0000000000000000000000000000000000154272617a696c2042697a44657620426f756e747900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471570c7baf07c52daca9b971305af399221a92e1bf8c58307fb1057f0c8f6c3d226cf7402897b837": "0x00000000000000000000000000000000001048656c656e61202d205075626c69630748656c656e6100001668656c656e616a77616e67407961686f6f2e636f6d00000d4068656c656e616a77616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147164fea0aaf340daa6075a9968b174ce67edaab5fbdb011bd625e2b4728f953e6444386a36b8722a": "0x040100000002000000000000000000000000000000000b54504b4c2e45617274680c546f6b656e506f636b65741d68747470733a2f2f7777772e746f6b656e706f636b65742e70726f2f1c40746f6b656e706f636b65742e70726f3a6d61747269782e6f726713626440746f6b656e706f636b65742e70726f00001040546f6b656e506f636b65745f5450000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471807145847ce7520a9e6fb48b9423ae5939f07fe1d7f41a6c1ebe3d2135e94af94b7fd717a47418": "0x04000000000200000000000000000000000000000000094d6161726d617061000015406d6161726d6170613a6d61747269782e6f7267106d6172696f40626f796b6f742e636c00000a406d6161726d617061000e4d6161726d617061233830343800", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147180d79828e0ec897e6a7945c3108fbc35ee60d6f338f4472d4658249d96493086994e02e7dd3a11": "0x04010000000200000000000000000000000000000000055855414e055855414e0013407875616e39333a6d61747269782e6f72671b79616e676a696e677875616e6d61696c40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147181755808f2aabbc83e489ed94fbe1d1b6a71e8393d59583910463dc95bfd00a93ce47cb1465928": "0x0403000000020000000000000000000000000000000014f09f8fb5efb88f20464c4f5745525354414b45001768747470733a2f2f666c6f7765727374616b652e696f1840666c6f7765727374616b653a6d61747269782e6f72671b666c6f7765727374616b654070726f746f6e6d61696c2e636f6d00000f404265466c6f7765725374616b65000c666c6f7765727374616b6500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471bd36a7be01ed70461b8eab2552590c5860de5271e7dc81fbf3fde9c772509fc4fdf67fcdedef61": "0x040000000002000000000000000000000000000000000c747275737465646e6f6465001768747470733a2f2f747275737465646e6f64652e696f0014696e666f40747275737465646e6f64652e696f00000d40547275737465646e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471c3ea80d7b0dfb82a60c7682b7a16f3e6502873a523a3c55703f5df93d297fca9c5fd8779d05a28": "0x0000000000000000000000000000000000086a6572657a5f5100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471471c705b1381272e69efc992685aa35aba0942285fefffe37246b1fc16ee417ce28d1be8ca4e20030": "0x000000000000000000000000000000000006737461736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714720cd28dcf99c07dac133ebfde441672c055b79ca9a6059850984eead1ae036f48ca1230e7f0556f": "0x04000000000200000000000000000000000000000000094d696c65f09f8c8d000016406d61746865726365673a6d61747269782e6f7267176d6865726365674070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471472111003b96bc266a24fde6343e2bf0aefa296afcedea6f16d37c5e1c0d8b6511e7055cf7282b60c": "0x040000000002000000000000000000000000000000001053756c74616e4f665374616b696e67002168747470733a2f2f7777772e73756c74616e6f667374616b696e672e636f6d2f204073756c74616e6f667374616b696e672e636f6d3a6d61747269782e6f72671f73756c74616e6f667374616b696e674070726f746f6e6d61696c2e636f6d0000114053756c74616e4f665374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471472491867cdbdb72a5071733a41703f6cf3fe43daa2814861b512205451a2f33a60a8b3d739eab20e": "0x04000000000200000000000000000000000000000000084c554935444f540000144077696c64646f743a6d61747269782e6f7267000000084031784c554935001a4c5549352f57696c64446f744170706561726564233230303900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471472695126ff943f9e38d442452b078203a37f178906e67650b19128ad687051f1aaca4c0c428b3c04": "0x0000000000000000000000000000000000086d75686172656d00000000000000086d75686172656d0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714726da8e64fe5cc017269960f17b619f90d534da2bfb1506b14ee66307459a066289218d2bbcd2414": "0x040000000002000000000000000000000000000000000a4554205075626c6963000000000000094065743930323636000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714728227c4dd30620ff826273e80a776cf79c96ef33dbde5ae91a843fc3f36401c6f878447f6aa6315": "0x0000000000000000000000000000000000104b4a4320383320446563203230323100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471472f593a2e278eb75522e16fcd83f6d6e08fe2b44d56b5d0bdaf33527b49e8832928d003d8097ca63": "0x04010000000200000000000000000000000000000000094e4f5354524f4d4f11446f6d696e69717565204ac3a4676769000014696e666f4073756e646f776e65722e6165726f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714731ba4e11a7d5feb8c77062e797e4a1bd08a3d9ca4feaa8917d02315dd3ecee23f3649246e7ea84d": "0x04010000000200000000000000000000000000000000054449434f054449434f1068747470733a2f2f6469636f2e696f000b6869406469636f2e696f00000e404449434f3033323739373034000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147331c534ba659f84f47f6c77a0720b820074d7f48abb22ef868ba2ec24159bc850e1423dfa1bd43a": "0x04010000000200000000000000000000000000000000094b534d4348414f53000000136b736d6368616f7340676d61696c2e636f6d00000a406b736d6368616f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471473364b7f8cfc00b812c039004da5e1e846aae808277098c719cef1f4985aed00161a42ac4f0e002f": "0x040000000002000000000000000000000000000000000874696d777532300000144074696d777532303a6d61747269782e6f7267000000000874696d777532300000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714735f4b854a56e790d063d0325df758d4e35a9ba4c07526410fbba664c0b61fe163c4405f5b38dc66": "0x040000000002000000000000000000000000000000001950617269747920546563686e6f6c6f6769657320476d62481950617269747920546563686e6f6c6f6769657320476d62481768747470733a2f2f7777772e7061726974792e696f2f001470726f706f73616c73407061726974792e696f00000c4050617269747954656368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471473b93bc1a743680630ddff6cf0557f5ec5929f4ba1ae54279c028f94251e4f4cce45d72c5a9c58ca": "0x00000000000000000000000000000000000c526567656e63792d3030371757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471473c1f960c73bd4b5a40ccb73fa01d3dff2ed46e235fb2fe8eedac1b4e3dea68c76ac2deecf942022": "0x04030000000200000000000000000000000000000000086d5f73686565700b48616f79616e67204c690000166974616c792e313834323940676d61696c2e636f6d00000d404d61676963533836363433000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471473c700cacfaf7b1e7cc47cd222c6c30c2856e545ff74e6b31ed1725334b0e31cd43a52730e9ad66e": "0x0403000000020000000000000000000000000000000011546865577269676874537563636573730e4173686c6579205772696768741e68747470733a2f2f746865777269676874737563636573732e636f6d2f001a696e666f40746865777269676874737563636573732e636f6d000010407772696768745f73756363657373001674686577726967687473756363657373233531383700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471473fe9dfb9a1dc2c1c41be0c2c5e5ad66d0d3a1ed02ca8ccf056d3b92a84df2429dc1e957eeb1152a": "0x040000000002000000000000000000000000000000000830786e3030627a0000144030786e3030627a3a6d61747269782e6f72670e30786e3030627a40706d2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714741edd192a56853bd2413cac426040b67e93948afbd069b37ca700049a2f170d05b16418ff8da032": "0x0400000000020000000000000000000000000000000014536d6f6c646f7420646576656c6f706d656e7400001540746f6d616b6131373a6d61747269782e6f72671d7069657272652e6b7269656765723137303840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474782af8e47bfcfc0a4a3233cb4870d9f20b5c55e77f839ce96a26f0fd773d019179197576644765": "0x040000000002000000000000000000000000000000000b45584e4553532e434f4d0000001576616c696461746f724065786e6573732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714748c854ac41713f81ae3a39de384cc366c0c0693e82a9b38397a35b201ffc33e383469df052e4227": "0x040000000002000000000000000000000000000000000c556e6f205374616b696e6700001740756e6f7374616b696e673a6d61747269782e6f7267186f70657261746f7240756e6f7374616b696e672e636f6d00000c40556e6f5374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714748e26e4416abae0ccd87fa65729f7bdaa8305581a7a499aa24c118e83f5714152c0e22617c6fc63": "0x0400000000020000000000000000000000000000000005416c6578000000000000000661746865690000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147499a373d4b2f70f8419a4ac409fa4e7bec032c696c526fac10ff9114d928df56ca0bf9e9ae29149": "0x04000000000200000000000000000000000000000000104d41415254454e207c204153544152000013406669657865723a6d61747269782e6f7267166d61617274656e4061737461722e6e6574776f726b00000b4068656e736b656e736d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474b0c239e26aca84a6c70805946002d87f9a6a2c5ec0900cd31ae4e27fd375e71dd6d75c0c264b68": "0x040300000002000000000000000000000000000000000864656669677579084775737461766f00001461737461726465666940676d61696c2e636f6d00000b40646566696775793232000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474c3ae49c1416014a0afbe96d21f06c21f01a6e501750fe36c0e4697b8431fab6f94a558541b6446": "0x0403000000020000000000000000000000000000000005323037350000000e6d6172636f407a65726f2e696f00000a6d6172636f6261686e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474c5981ba60102c7e82d3b7fbff7f5ff1010b279435012e0ce3b68dc387eb2827fc2e9d5001ada7c": "0x00000000000000000000000000000000001062696e616e63655f7374616b655f321062696e616e63655f7374616b655f32000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474d6aadd494e266842a510b82f5075233945c7d705a187bdd4d36745a3ca90f36b860f8b3247a27d": "0x04030000000200000000000000000000000000000000084b6c617374657200000011696e666f40706f6c79636f64652e736800000b6b6c61737465725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474f1e1edd85aece4106a53bc7d39e4116f4bac46cac7c172269fe76e7757be1094c32d1243ab920a": "0x0403000000020000000000000000000000000000000009436872616c7439380000001b636872616c742e646576656c6f70657240676d61696c2e636f6d00000a40436872616c743938000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471474fcea92fd9411873eaf71e6279d9b9666930f468b7204050c448bfe4593762f44e5f04ffc00f968": "0x04030000000200000000000000000000000000000000184d61727320456e7465727461696e6d656e74204c4c432e0c53696b646572205161697300001d6d617273656e7465727461696e6d656e747840676d61696c2e636f6d00000c4053696b64657251616973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714750f6a824e75e9801a1bae27765f9be012e6d1a2307afac2b32c82dde3027c9d2b4978029f0c5171": "0x000000000000000000000000000000000007417679446f741541726368616e612056616964656573776172616e00001761726368616e61763139323940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714753931c0b2ecf25f803166343a21e65218ead92135f73df970ed63e5aa18b329d9542b47ba9fa219": "0x040000000002000000000000000000000000000000000747757374617600000013677573746176406477656c6c69722e636f6d00000c406775737461766e697065000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714754cb56cf6c9489ed016feaa68e25739dbc4035faf2577d17ec9d7ec2125a99a6770b5be093f6e32": "0x0400000000020000000000000000000000000000000009446f74536b756c6c00001540646f74736b756c6c3a6d61747269782e6f72671268656c7040646f74736b756c6c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714754cdcbcd79de061288197fe1d9f6b12ee7f9656663791366fd5ea4ec01999d7a7f8b84e22a0591b": "0x00000000000000000000000000000000001062696e616e63655f7374616b655f311062696e616e63655f7374616b655f31000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714754f0164b9ddbc7048a94c9ca2c21cb5f258f5873bbb5beceb4c64df4662d43c3c289b4d67a56f06": "0x00000000000000000000000000000000000531304b4100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714757a8da264c88695a6b1c75426a3170fdd0b13bd2ba35e0f80cf2d1010973a8cea518ea78995bb54": "0x00000000000000000000000000000000000c444f54203120284578742900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475846ad69bb139bac2828538511e926bcfe09150d03638cff3f4243d1d74b9fe0cc150567802b45e": "0x040100000002000000000000000000000000000000000a4254434d494e455253084c7563696c6c611668747470733a2f2f6274636d696e6572732e66722f001a6274636d696e6572735f70617269734070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475867a568daa1785baedf2e50d3732045c8b24d42ad3167b994e318707f4ae4cabb7ef212f5e3860": "0x00000000000000000000000000000000000f547269706c4569676874f09f8dba0e44656e697320506973617265761e68747470733a2f2f6769746875622e636f6d2f747269706c65696768741a4064656e69735f703a6d61747269782e7061726974792e696f1e7069736172657664656e2b706f6c6b61646f7440676d61696c2e636f6d00001e68747470733a2f2f747769747465722e636f6d2f44656e69735f507374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475aaed01d33aff0f6a276c8c59606dbc8515f3bbde2bbf30956ae793689cf5c003d7e595d1ecee64": "0x040100000002000000000000000000000000000000000c506f6c6b6177616c6c65740c506f6c6b6177616c6c65741768747470733a2f2f706f6c6b6177616c6c65742e696f184030787468726565626f64793a6d61747269782e6f72671568656c6c6f40706f6c6b6177616c6c65742e696f00000d40706f6c6b6177616c6c6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475bc7afdeb88fc9d0aa041bf62d5b52adee07e7cbc0687ace86e77308a982c07db871ef2dab63901": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f371042494e414e43455f5354414b455f37000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475ccfb98243b897452cadfbd70405e7a8fe22235a0d0eeaf7cffc9644b3a3ccd8b5177cbb56c3c57": "0x0400000000020000000000000000000000000000000009616e64657273656e00001940616e64657273656e303730373a6d61747269782e6f726718616e647265693037303730313140676d61696c2e636f6d00001040416e6472656930333334333837380010416e6472656930373037233131353900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475d112c2582d6bc3922bc16cff1acfc4a08cb5bfcebadaa9eb182cd47a51b8b047a0202ae9624a1c": "0x04000000000300000000000000000000000000000000045733461e576562203320546563686e6f6c6f6769657320466f756e646174696f6e1868747470733a2f2f776562332e666f756e646174696f6e0015696e666f40776562332e666f756e646174696f6e0000104077656233666f756e646174696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471475fe22e7da8bab122ee58d589be14b8d4fdf4dea986983733c837b6af4b99a8a550da9fbb1aefc77": "0x0000000000000000000000000000000000054e31626f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147601c8c0075205c282f81b71f17b13f87e58ca1444fc00604907342aed7dbfc828872a8db645032a": "0x0000000000000000000000000000000000063231446f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714760aecf664bf053f863ba022a0315ac70e6881db2f4906ca51d2864c43800cc5601acddc05b0d903": "0x0400000000020000000000000000000000000000000005426c617316426c617320526f6472696775657a204972697a617200000000000b40626c6173726f647269000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147629d0fa8c9ac2292c81fc1faa024d3d1a727d953187860b45bcb185d046631ab98261eb6f2b8d54": "0x00000000000000000000000000000000000e41626c652057616e646572657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147642074451d24466b2e07be4d6d82f546ec91d6009ee215bb736be5b4362e66e7b466ec72d47624f": "0x040100000002000000000000000000000000000000000a534158454d42455247001768747470733a2f2f736178656d626572672e636f6d2f1840735f736178656d626572673a6d61747269782e6f72671468656c6c6f40736178656d626572672e636f6d00000b40736178656d62657267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471476593933a2785b22f0cd49d0588323d08bdcb1c1e4b71539b8998471df15f41584f98cb9f5008c23": "0x0000000000000000000000000000000000074a617273656e074a617273656e0000126a617273656e406a617273656e2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714768c2c58b90681dfce28672fa749577e198bfe03ec3972b22b47dbbfa9996dca0be76ff05851012c": "0x04030000000200000000000000000000000000000000104d69786f5f5374656c6c6153776170000000136d6562407374656c6c61737761702e636f6d00000b5374656c6c6153776170000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147691ee6d858f48473eb7ee31abeb77dc61aac4a18390bfbe97131da7426583e9df30b3b4e5f5ed71": "0x04000000000200000000000000000000000000000000086d6172316465760000000f68656c6c6f406d6172312e64657600000000086d61723164657600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471476c0068d9d7b7dea7081fe1fe013c00fbe52543ccd437d45fc26b0d49b7df5c117de02c4193c7d12": "0x040000000002000000000000000000000000000000000b6672616e6b7977696c64000017406672616e6b7977696c643a6d61747269782e6f726700000000000b6672616e6b7977696c6400", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471476d10d82508ddae096e24e9b5ab82dc275b82318a52cebed1cae3e25be096d5f288229b256359e43": "0x040000000002000000000000000000000000000000000b537769737320506f6f6c0000000000000c4073776973735f706f6f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471476f5243ff4ce86095604806a738c7e4d516625d47db7a4ac3197142b84203c1495b6689b066d9d44": "0x0000000000000000000000000000000000094772697a7a3337350000000000000a404772697a7a333735000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147724a5ea734f20f7bad6db470dcfd5ee86f6e3abc0e5351fa654cbb5528f4daf2f0d393f4a46b421": "0x00000000000000000000000000000000000749555244414f0749555244414f0000176975722e70726f4070726f746f6e6d61696c2e636f6d0000084049555244414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471477300f589b9251ff6c695c4e546c6889ca591b582eee8b49ba68d8485a3732e08d232b2f28f2342e": "0x040100000002000000000000000000000000000000000852796162696e61001468747470733a2f2f72796162696e612e696f2f144072796162696e613a6d61747269782e6f726710696e666f4072796162696e612e696f00000b4072796162696e61696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471477364a8cd584fbff7ed6682224da03023f194d53bbd806050575d0794e73f6cf8b99be9ae1bbb230": "0x0403000000020000000000000000000000000000000007696c617269610e496c6172696120456e616368651b68747470733a2f2f6769746875622e636f6d2f696c61726961650017656e61636865696c6172696140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714777b3c12eea4a22494b1ee887c35565f8d72777b3e5d8a7ccfda76b370dcdaa105df7bd6e49b8841": "0x0403000000020000000000000000000000000000000007536572686969115365726869692050726f736b7572696e00001a706f6c736b612e7374726f6e6b406f75746c6f6f6b2e636f6d00000b6d6f6d735f6d696e6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714779e501e142783af7caa3fa184254cc0cd46a0a4fc1be30b87afc70d2b290b9545dd4f7af46dd70e": "0x04030000000200000000000000000000000000000000087765623364657608574542334445560000176163636f756e7473407733642e636f6d6d756e697479000009776562336465765f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471477a0350acc7abcb9f66311b1720ee0da02af2b95c703f1db4e2db091296b598b466ae15c9ea29344": "0x0401000000020000000000000000000000000000000009536e6f776361706500001540736e6f77636170653a6d61747269782e6f726716736e6f77636170652e696f40676d61696c2e636f6d00000c40736e6f7763617065696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471477a8f518e90d0d2cbe1c8831d018fed582688b5e75be3c9983ac1761fb24a916451c6999c0c66f5e": "0x000000000000000000000000000000000009646f746875622d3209646f746875622d32000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471477c114f494effd6f109914286fe2fa65a85cfcdbcd4562010745b1fa12e9f02b62795b740000e541": "0x04000000000200000000000000000000000000000000057074716100000011676f6431373540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714780625038e82798d9410c1acc9de3fc8a2c36e5b1116f435b745ce96335ce5d2e133dc3d27268152": "0x0400000000020000000000000000000000000000000011456173794120476f7665726e616e63650000000f68656c6c6f4065617379612e696f00000b4065617379615f617070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714783efdad4741c0a9a1e99029c8d8deca2c762dc353047586d9a46e523bdf3b4ddbd9fed1ceef71fd": "0x0401000000020000000000000000000000000000000011475241424249545920e29ca8f09f9087001568747470733a2f2f67726162626974792e6e6574154067726162626974793a6d61747269782e6f72671368656c6c6f4067726162626974792e6e657400000d4067726162626974796e6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147854d7d5ed8a10ef807561257b836e4a4367cd5fb433621781f882de92a97eb03977e092f64af57c": "0x040100000002000000000000000000000000000000000c50444d204361706974616c1c506f6c6b61646f74204d6178696d616c697374204361706974616c00001370646d6361706974616c403136332e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478a2b18d6db0a15e0bb5e12d2f6ada25c3b64171730f1c9efcf76d3bbccff01abd9f92a9aaac10a7": "0x0400000000020000000000000000000000000000000004474d5a00000012676d7a40636f6465616666656e2e6f726700000940676d7a61626f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478a4b4280c25b8bdee540d3a73580cf5e0ae2d80ac9d98dc27847f5518d62b652a6561d46c16b553": "0x040100000002000000000000000000000000000000000af09f838f205368616400001340736861646f763a6d61747269782e6f726715736861646f767365726740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478acd82014dac4867a24e507ab6be3b521af33bebbece8f57f9b8c20ae23a87986ec0518c1ac1d2d": "0x04030000000200000000000000000000000000000000104869726f50726f7461676f6e697374001868747470733a2f2f6c696e6b74722e65652f74796d61741440616564696769783a6d61747269782e6f72670e74796d617440707269732e696d00000840636861307465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478caef8fe8bb73f2a4d813e676d81d97479f9f15572d9eadcaf4503b654c0f6e7baeb49e84510e69": "0x0400000000020000000000000000000000000000000011566972657320696e204e756d657269730000194076697265736e756d657269733a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478db440095822ae679ad7966c6eafe858c375d0ec2d0717c59c973ccd7c7c82131d48a76dbc22d85": "0x0000000000000000000000000000000000076775706e696b0d4e696b68696c2047757074610012406775706e696b3a7061726974792e696f00000000076775706e696b0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478e05e6ced85f9d7180364775e32443f308fc34a8917ec40227726c736c2817ae56c5b982a17165a": "0x0000000000000000000000000000000000086d6364616e393310416e64726577204d6344616e69656c0000126d6463616e393340676d61696c2e636f6d000009406d6364616e3933000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471478fa03421f9ba61e726ef17b500f436cf596935acac782c71a423d35a959f3e6831f13c34db9d71d": "0x040300000002000000000000000000000000000000000a58594c4f44524f4e450000001978796c6f64726f6e654070726f746f6e6d61696c2e636f6d00000a58796c6f44726f6e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714790543fc3e74b681e0f527663883fadc99963738cc81dd244d866241b296cb6d54596c296170534b": "0x00000000000000000000000000000000000f4573706163696f2043726970746f0f4573706163696f2043726970746f00000000000f406573706163696f63726970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714794c7db721956af68a56b1da8dc3f4bd58630c15f5754ee634528a007ab510c86a7e1fe6e62f4166": "0x040000000002000000000000000000000000000000000a414c46415354414b4500000010616c66617374616b6540706d2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471479f659a7c9788777c4181e01fbb27d6e4792397efe9becf4a3e4c535be6112f60b5ece445a76552e": "0x0000000000000000000000000000000000157061726974792d7374616b696e672d6d696e657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471479fa24e506fa3936321d847f8a53927fe1132754a7708c61049b2d4816ab6ce7195a8308e97c3d41": "0x0400000000020000000000000000000000000000000015f09f8d8041524953544f5048414e4553f09f8d80135079746861676f726173204361706974616c1f68747470733a2f2f7079746861676f7261732d6361706974616c2e6e65741b407079746861676f7261732e632e693a6d61747269782e6f7267207079746861676f7261732e6361706974616c40747574616e6f74612e636f6d00000e405079746861676f7261734349000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a03e16a44321a127421cac8b6fb5e37a318f997074319584b2be9ca7f9ded1f7c999e27f7eeef02": "0x00000000000000000000000000000000000753504143455f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a246b025078730ed4fa8184e7ea69dbb3cbee71cfd7490803d457140d5d57d0e53a49a887bc4a06": "0x00000000000000000000000000000000000c6578706563746368616f730000001a65787063746368616f734070726f746f6e6d61696c2e636f6d00000c4065787063746368616f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a2939f6c5b0bc2542a463a7a8813a1272eb8605af0c83660ce65b57d3d5f85ffa5eeff31793ad21": "0x0400000000020000000000000000000000000000000013416374697661746f72207c2053657262696100001a40616374697661746f726e6f64653a6d61747269782e6f726718416374697661746f726e6f646540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a390aecbef66d7830ef2d9cf069b213123b970d5b3f1cbba939a6a5f4af7424e0672751b8a2ae1f": "0x00000000000000000000000000000000000f73696c69636f6e7072616972696500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a4ea65f46c7d37580919233b08e12a121b170ef3622bd400ca60df99cd7a4cac5eae6f06025380b": "0x00000000000000000000000000000000000d6f6e64617869616f2d646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a8b32f16affc46690c0525e98b52472f3330771f76feda69ddd01aeec5995085b96df4a0d6abce5": "0x0400000000020000000000000000000000000000000012424420426f756e74792043757261746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a92dffceaab6643ede4ad3403c21a44fff398a158e058f9212e92444bdcbc699ef01962578ba4f5": "0x00000000000000000000000000000000000750414e4b414a1150414e4b414a2043484155444841525900001d70616e6b616a63686175646861727931373240676d61696c2e636f6d0000000b506f6c6b6176657273650000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a98c3963c233c3248d3348d85e6e65def6ce7fdf16f9a8e7c7e3290ee2fe99ffb568a1ad86e1676": "0x040000000002000000000000000000000000000000000553696465000000177376657a3038334070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147a9fdf3a1eeb5b7d52fad643426e11575fa0a9069bf4d383b04fd311150ad974af8f5d4b3a6e5b1f": "0x000000000000000000000000000000000010537461726c61792046696e616e6365001968747470733a2f2f737461726c61792e66696e616e63652f000000000c40737461726c61795f6669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147abb02eb1d54cf5dd5b89078eed9b9dfec5c7d8413bac0b720bad3bd4078c4d8c894325713192502": "0x000000000000000000000000000000000008427261646c657914427261646c657920416c6c656e204f6c736f6e000019627261642e6f6c736f6e2e35383740676d61696c2e636f6d00000c4062726f6c736f6e3130310f427261646c65794f6c736f6e36340000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147abc5f242c0220a7ec9579e168a1b2200cc3447f5e3c29f74883683ab134cac6372f378dee048745": "0x040300000002000000000000000000000000000000000b4561676c6520f09fa6850c4b656c6c7920496c6d6572000017636f6e74616374406561676c652d6e6f64652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147b1b6d2a1ef31b0a3e8c72ac1b710bbce4e7c190568bf560d89416696ac2a4700406487cde98df04": "0x040000000002000000000000000000000000000000000a4d454e47204c4f4e47000000176c6c6835393132323138323440676d61696c2e636f6d00000e40444f545f6d656e676c6f6e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147b232746110617a52cbc67180b8230618e420c16395099c9f44fb825b8c3c649d670e6aa409f5539": "0x00000000000000000000000000000000000d4a616d657320576f2044464700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147b5162449d2d3491bc5db9edb63d7b17fabfab232318e1b087066c0f23b06553f9080fb61a523616": "0x04030000000200000000000000000000000000000000104144494f532041205455204a45464518486563746f72204a6573757320536f736120476f6d657a000016686563746f72736f73616740676d61696c2e636f6d00000c686563746f72736f736167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147ba825eccf7c1a59b66fc334c7c76cef9cc5ceac0f4b0837d845453a2e0e84703b280edf202c8f76": "0x04000000000200000000000000000000000000000000055554584f00001340766f6a7463683a6d61747269782e6f72671b766f6a74613135392e73747564656e7940676d61696c2e636f6d00000a403078566f6a746368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147bbbfadb8086c23baeb6173b1b6d5933c79992954d1469e845a89a5c754f91a9cb2f7589d78b9970": "0x04030000000200000000000000000000000000000000084d61785f4849430a4d6178205265626f6c00001a6d617840686172626f7572696e647573747269616c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147c44d632272a194b12b8bb5de35aa1722e1996065bb42a0fca24449625d4f72cdc483e682b22832c": "0x0403000000020000000000000000000000000000000005444f544117444f54417c444f543230206f6e20506f6c6b61646f7400001367656e697573756e40636861696e2e70726f00000b646f7432305f646f7461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147c4a65539d0e9a75fc8163c92cac3dd1d5c2c0a049c3652a8b3b8b6cb8a0867a5e494c650b4de371": "0x040000000002000000000000000000000000000000000d504f5354434841494e2e494f00000011646f7440706f7374636861696e2e696f00001040706f7374636861696e646f74696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147c90c43e925f2226fea885b4e897d4fe908db6abeb39365ccc4689c2b6437dba675a4a0a0c0a6610": "0x04010000000200000000000000000000000000000000073330383072611f33303830205265736561726368202620416e616c7974696373204c74642e1468747470733a2f2f3330383072612e6c74642f13403330383072613a6d61747269782e6f7267107465616d403330383072612e6c7464000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d28858f34005cc8b6761e35250c1155f4bd6eef565b7d28f7ccca539fd8f678ec0563427c9d9d46": "0x000000000000000000000000000000000009534147494954415200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d2e715ea1e6005feacf33e37aff83d33c7472ff69683a322ab320d9de25586311e75b6ac8270f5c": "0x040300000002000000000000000000000000000000000b4361726c6f2053616c61124361726c6f2053616c612047616e63686f0016406361726c6f73616c613a6d61747269782e6f72671a6361726c6f73616c61674070726f746f6e6d61696c2e636f6d00000d406361726c6f73616c613232000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d37f03ec99fdcbb1caf1e15eeb0d3a899f1c3e1aa7d5178d4b3e4f29c89667e7c4560172371660f": "0x000000000000000000000000000000000009506f6c6b61646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d3c2944c766ee6eaa328d54b650d207564ecb9d0267e1bc52c18e22abe6366af6014ca53d06cb33": "0x000000000000000000000000000000000009706f6c6b6164616e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d652feaf863f69f94546ff56643b8c0fed386347d7a8cd0b995383125a0fc0f0e45f0e33a6c5827": "0x04010000000200000000000000000000000000000000196365647269632e414141f09fa68a7c20616a756e612e696f001268747470733a2f2f616a756e612e696f2f1540726f786f6e746f783a6d61747269782e6f72671063656472696340616a756e612e696f00000a40526f784f6e546f78000d6461726b667269656e64373700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147d6d64049c8aa12d29cf01efa70d0f6f4758a5b5374469b0b4d1cd239ce2e5ee2d38fb4b70efdd1b": "0x00000000000000000000000000000000001847696f74746f20427261696e20476f7665726e616e636500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147da0ec7e951876bb62b8fd03e30e4f98b0da0e2a99caa7efff8b951990ead650ae3bb9ae36982651": "0x040300000002000000000000000000000000000000000756614b614e6f0d41726c6579204c6f7a616e6f00001661726c65796c6f7a616e6f40676d61696c2e636f6d00001e68747470733a2f2f747769747465722e636f6d2f56614b614e6f425443000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147da931f7536ac4ab484d62a228121a1800e26e8b0139995703309a81ca4467308d734b4678da3d40": "0x00000000000000000000000000000000000a4669676d656e742032001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147e5babdd52e35979dc308c3ff0d8cecba66c3198e955d6986b577f2778da300964daa5c05f31310d": "0x040000000002000000000000000000000000000000000a56616c6c65746563680d56616c6c65746563682041421568747470733a2f2f76616c6c65746563682e65750012696e666f4076616c6c65746563682e6575000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147e8c7a3ed6096e376c38ee38bd0943c66fbec7b8222ce117c0feeccdb9c5cd9ccddaafe82bab4c40": "0x000000000000000000000000000000000009506f6c6b61646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147e954ecfd56b24afeea0ee586e9b430c8b3f0fb625bd8ef5f9f6447e72d8c7e84a24c1a34abe9753": "0x00000000000000000000000000000000000c5375706572636f6c6f6e79125355504552434f4c4f4e5920434f52502e1968747470733a2f2f7375706572636f6c6f6e792e6e65742f17407468656d61726b69616e3a6d61747269782e6f7267186d61726b69616e407375706572636f6c6f6e792e6e6574000011407375706572636f6c6f6e795f6e6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147ea9886926039761182fe099d0c1787bb1b88de855537dcce095204028736ecfde09dd115c498f2a": "0x040000000002000000000000000000000000000000000c503250205354414b494e47001868747470733a2f2f7032707374616b696e672e6f72672f001a7032707374616b696e674070726f746f6e6d61696c2e636f6d00000c405032705374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147eaf54d33fb6eaa0e45255703a954986602a77b7103cd062576f33811e5b5b853de2ec1d120ea609": "0x000000000000000000000000000000000009616e64793230343609416e647950656e67000017616e647970656e673230313540676d61696c2e636f6d0000000009616e64793230343600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147ed96b7d3f8a3e92083857fb5e068b7253110088fdc0431964252a7d2f46622d6b3cfc66be587c30": "0x0000000000000000000000000000000000087361746f73686900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f1f1924b3cbcec77a2b3317472cfc9a20318bf0054952052ef8df169438af1b188eeaedb2bc030e": "0x04030000000200000000000000000000000000000000084145436861696e0b4164616d204576616e7300001b6164616d2e6576616e7340636861696e616c797369732e636f6d00000a406164616d65766e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f38100bed09f866b0b000e408509bb033443af0bc700ec11894f81c090d58d7dc2ae3174c54902b": "0x04000000000200000000000000000000000000000000074c4547454e4400001a406c6567656e64373334313231363a6d61747269782e6f7267156b7572746f736973407961686c6f6d692e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f6122436697b141faff1c4b5a94649e0338783122b93a469eb9e2e375bb71c92028a8fe9b6e2f46": "0x08000000000201000000020000000000000000000000000000000016546f74656d204c697665204163636f756e74696e6711546f74656d204163636f756e74696e671c68747470733a2f2f746f74656d6163636f756e74696e672e636f6d0019696e666f40746f74656d6163636f756e74696e672e636f6d00000d40546f74656d5f4c6976655f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f659dc8b63c4bfa16bf09f62054218ff31e36e042d5c0e56aea26366bfd8c75cff2835ced5afb41": "0x000000000000000000000000000000000012f09f9890207c20f09faaac2067686f7374000016407265706c67686f73743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f746099fc9e6cff3cba3cb96173c2dfff3f2bb0cf5e3c70784cffadbf02b1b2be4fcdd1f78e4374": "0x040000000002000000000000000000000000000000000c42697420436174f09f90b1000013406e69756e69753a6d61747269782e6f7267186269746361743336352e636f6d40676d61696c2e636f6d00000b40426974436174333635000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f88ca6ada2372bc1a0eb7fdecee073651f1a21b9779b7bf5670493a0e35a53ab83b3cabab814a77": "0x0400000000020000000000000000000000000000000008316b766e6f6465000013406461766534343a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147f9e55d7623ce6876ae93e7162785a77d3a2c0413a9ee04af1b948ba5df9ac191552b72e1dd49b71": "0x04000000000200000000000000000000000000000000064372616e65000000000000094030786372616e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147fa9548e769cc523a237fa87e569e6b5aed61aefe41eacafe0fd7000ca90f888e8517e77be1f3c78": "0x040100000002000000000000000000000000000000000c457175696c69627269756d001b68747470733a2f2f7777772e657175696c69627269756d2e696f001568656c6c6f40657175696c69627269756d2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147fc4f80a616861525e9ec2d24e959cb9053751ac65b19ef3bc380ed2c24fa23a6bfa44c36b58d928": "0x040000000002000000000000000000000000000000000d4c4155524f20e298aeefb88f000000156c6175726f677269706140676d61696c2e636f6d00000c406c6175726f6772697061000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147fd837e50e26922d265013803cbe5f9f3ef7b38ad278b6d097d3be3ed79248030f460ba93d164a60": "0x040000000002000000000000000000000000000000000b5354414b452e5a4f4e45000016407374616b657a6f6e653a6d61747269782e6f726710696e666f407374616b652e7a6f6e65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047147fe9c3b575119fc9bea849c82dc0da19b799de164e15d83352559a2a6ca5fee6bf3f35056a997a21": "0x040000000002000000000000000000000000000000000f506f6c6b61646f7420496e64696100001540616d69742e776f773a6d61747269782e6f726717616d697440706f6c6b61646f74696e6469612e6f7267000010405f506f6c6b61646f74496e646961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148015f9c9dfb7b49a281a723802b50fb25a874e19d4f643168f4016aa759bad298940eb455cc87249": "0x040300000002000000000000000000000000000000000e506f6c6b6157617272696f72730f53616e6720486f6e67205472616e00001868656c6c6f40706f6c6b6177617272696f72732e636f6d00001040506f6c6b6157617272696f72735f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714801d924a92a5fc1918bd4fb6b90f5088bdc825c3d674bd72e705c6f1163e86f960eeb7969ab4833a": "0x040000000002000000000000000000000000000000000857315a53505233000016407265706c67686f73743a6d61747269782e6f72670000000b407265706c67686f7374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148031c0fb42aa475ed26298f9adfd81b0194a572bd49c0a8469acdcb585586dfc22bd1deef8a8e705": "0x00000000000000000000000000000000001b496e7465726c6179204c7464204576656e747320426f756e747900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714803d5aecf59783b17628a5be63c4d3c8dbb96c2904b1a9682e02831a1af836c7efc808020b92fa63": "0x0400000000020000000000000000000000000000000006626b63687200001140626b6368723a7061726974792e696f0000000740626b63687206626b6368720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714804e9334b8d21cf9c26ccc67ae0f9051eb2f2b1795b8f166f46536a29b6651fe7f6bb1f8b550047f": "0x040000000002000000000000000000000000000000000c5368616b7572686172756e000000167368616b7572686172756e40676d61696c2e636f6d00000e40416761736869486172756e6100115368616b7572486172756e233837393000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148078a26b9e8719c946e2508c379dc61858e00b9fbf1424b12b64d5120d2f16c525822f94acc0f435": "0x040000000002000000000000000000000000000000000a4d61676963205461620000001679736e61796e6e3230303240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471480815510d147d8979a0b9cef028c95b4635cd22fefd9001a544d17eae85fbaf1857fda4d9f4ba75f": "0x040000000002000000000000000000000000000000000c6d616c697a652066726564000017406d616c697a65667265643a6d61747269782e6f72671663667265646d616c697a6540676d61696c2e636f6d00000e4066726564636872697374757300106d616c697a6566726564233234373200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471480903a9113fc7d1e24be4391bcf17d95b0ccf03c2c1374f0e20c7a886eccfb3a77b373f3ff97166d": "0x040300000002000000000000000000000000000000000d44697667756e2053696e67681344697667756e2053696e676820536574686900001764697667756e2e736574686940676d61696c2e636f6d00000874656b76797979000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471481032745bb8fa3a2ae2d99c29e603ff76a9705ac23371d47b7245bc3bf953ca7906347b952390d78": "0x040300000002000000000000000000000000000000000b416c657820486f75647a0000000f616c657840686f75647a2e636f6d00000b40686f75647a5f6b656b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714810532057fdf6829669618142822c01d88debd960eaa1d3dbfcb243ad965b8a5ded1c7b7c15b2226": "0x040300000002000000000000000000000000000000000c504241202d206d72617374134d69636861656c205261737461646d6568720000196d69636861656c2e72617374616440676d61696c2e636f6d00000a404d72617374313131000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714816c2a63e3c205f4981c728cb2461814ec4e6cb50906eded0e4f51e5513018e28753337cfb971d70": "0x0401000000050000000000000000000000000000000006546164656a00000011746164656a406170696c6c6f6e2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714816f363193f343a643fa61b298e82f9f207ddea327900cee26b554756c4a533f36cd875e3e7bcf06": "0x04010000000200000000000000000000000000000000114163616c6120466f756e646174696f6e001668747470733a2f2f6163616c612e6e6574776f726b001468656c6c6f406163616c612e6e6574776f726b00000e404163616c614e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148179afc2191e064c0ecd029fdf9259e900f08996fc9862ebfe100d49c439f19bef7084b258175a1e": "0x040000000002000000000000000000000000000000000f507265737362757267204c6162730f507265737362757267204c6162731a68747470733a2f2f7072657373627572676c6162732e636f6d001d7072657373627572676c6162734070726f746f6e6d61696c2e636f6d00000f405072657373627572674c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471481bac95793d75f5ac6d1e9633ce74e1a09f9ca37470de256f8d1cd977ba4e4eb994258dc078f4429": "0x040000000002000000000000000000000000000000000e4265696e67205361746f73686900000017616e616e74406265696e677361746f7368692e636f6d00000e404265696e675361746f736869000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471482a2945d18dc6de7685dc052a755ac3cecc0b0bd0d1405ade433d8463a3cabc1e5b7eedb13c08871": "0x040300000002000000000000000000000000000000000552656d791752c3a96d79204269656e2042616f20506572657474690000126c65696d69303640676d61696c2e636f6d00000a40736578796465666900086c65696d69303600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471482b81636ee5910ca452de33977b421766e2191acd0b79dd6760fb5e56aee0b00a02422df3f35b26b": "0x0400000000020000000000000000000000000000000010466f7274756e654e6f6465732e696f000015406769736c656d6f6e3a6d61747269782e6f72671668656c6c6f40666f7274756e656e6f6465732e696f00000f40466f7274756e655f4e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471482b8bce0892920f9ca3d904d81a1b1ba11bd6e391daa897b907ff89c5c5aebfe6f2da23292b8500f": "0x040300000002000000000000000000000000000000000d5765796c616e645f46756e640000001a79616e6777616f406d6574617072696d652e6e6574776f726b0000086b6f6461646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471482d187c7f127ad6e6c49e0b3f2b674374ad5d80a75f1e60cdd012e6e8e3739a10cdae9cb76ef857c": "0x00000000000000000000000000000000000c453230205374616b696e6700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471483253a02c1f77c53a0c4d9864d312099740db16ed243615447e5ca42aa689fee0109c195c65fa91e": "0x040300000002000000000000000000000000000000000a43687269737469616e1143687269737469616e20436173696e6900001e63687269737469616e636173696e693139393340676d61696c2e636f6d00000c4043687269735f4e696674000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148328836b7b67fa4fdab8f87f6dfc47a03ebf8901b36039ebfce8707a2c5d3f4ff099d788ca6a02fe": "0x040000000002000000000000000000000000000000000555545341000018406c65736e696b5f757473613a6d61747269782e6f7267176c65736e696b3133757473614079616e6465782e727500000e406c65736e696b313375747361000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148348313aaefc25eca801051533332369ef5a24d9d7d13709896d3e170297851c63123b26a4034137": "0x040300000002000000000000000000000000000000000d53657262616e20496f7267611253657262616e2d496f616e20496f72676100001473657262616e33303040676d61696c2e636f6d00000a73657262616e333030000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714839f1a74e283a0e1b26cea7b8424d659bd6ee2dc3176d96dc7d646ebff25fa7004c88c68770d584f": "0x040000000002000000000000000000000000000000001b50617472696365202d2054656e64616e6365732043727970746f0000001a74656e64616e63657363727970746f40676d61696c2e636f6d0000114054656e64616e63657343727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471483c5f86634d0a9e146190509288f1d1dabe6de4917e2a5765eda06bbaa156d19d55e2b7f813dd416": "0x040000000002000000000000000000000000000000000c4d697373426974636f696e00000014646f74406d697373626974636f696e2e636f6d000011406d697373626974636f696e5f6d6169000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471483ce59511097e6b62add0af948eba3b1fcd5cacde1f6fcc70f11ef75056f88ca4d11dcc5b080220e": "0x0400000000020000000000000000000000000000000017416c62657274202d2049204c6f76652043726970746f00001840696c6f766563726970746f3a6d61747269782e6f72671e616c62657274706f6c6b61646f74737061696e40676d61696c2e636f6d00000f40495f4c6f76655f43726970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471483da9cc355d0681680d8a3f4317249a895e4b49badcfa7293cfbd215d6e552d1c07024d36acfbd5d": "0x0800000000020100000002000000000000000000000000000000000f53696d706c79205374616b696e67000000197374616b696e674073696d706c792d76632e636f6d2e6d7400000b4053696d706c795f5643000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471483dcba70a0b190a2a2d23b8643531f6e7ae2dd88ff990de4edec8ec0c655002caca002756d1b2704": "0x00000000000000000000000000000000000d4461766964204172636865720d4461766964204172636865720000156461726368657237383640676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148407ca5b0d3d9daf59a32cbcf20e6fd03a2044525bf4b0676c4d0f1fa5f6f15699c607aa705f1fec": "0x04000000000200000000000000000000000000000000056c616461000000136c6164612d6b6d764079616e6465782e7275000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714842f41c0d4632e2e769ab3ef0ff669144d7046a0d9f11b76ec2efa8aa76bdbb0fedb69e8126b897b": "0x0400000000020000000000000000000000000000000019f09f939c20486f6c7920436f6e73656e73757320f09f939c000015406d6f67696f6d616e3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148461b8e5b35b37172450c3f4fb88d8cf3e0a4f044b4ad1d327ecd3e6b1d7dfbb999713f04ee1e87d": "0x0400000000020000000000000000000000000000000011e5a4a7e59684206461697a656e2e696f000013406461697a656e3a6d61747269782e6f72670f696e666f406461697a656e2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714846cf02493758816a4cd4dd151f0106d8157bdf02bfac75f9abe8e635ecc6498b8a8f6acc1f5e674": "0x0401000000020000000000000000000000000000000014f09f908b696d546f6b656e205374616b696e67001168747470733a2f2f746f6b656e2e696d000c626440746f6b656e2e696d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471484738c96361adf35624b8f2e5a08aa4e0dc556fa9745a1509c91a8c17dae991bcfdf89133ffc5b00": "0x0403000000020000000000000000000000000000000012506f6c6b61646f7420536176616e6e6168002068747470733a2f2f6c696e6b74722e65652f776562335f736176616e6e61680015696e666f4077656233736176616e6e61682e696f00000f40776562335f736176616e6e6168000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471484d3812801bbbf15b1725c0de514e0df808b19dbfca26672019ea5f9e2eb69c0055c7f1d01b4f18a": "0x0400000000020000000000000000000000000000000021416e74692d5363616d20426f756e74792047656e6572616c2043757261746f720000001a616e74697363616d40706f6c6b61646f742e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148510852a75250a28040a61ca8223dcb3c203b27167fdee611801375fff6c6f25c71c3e3ca86cea65": "0x040300000002000000000000000000000000000000000d566963746f72204f6c6976611456c3ad63746f72204f6c69766120566964616c000012762e6f6c6976614070726f746f6e2e6d6500000a40766f6c6976615f76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148532f472372d0e04e83a05a23704fc96cae39473196633a53d1820656f8b81f7bf30637ce41bd965": "0x0403000000020000000000000000000000000000000004414a501b41697a61204a6f7963652050726164617320536865707061726400001661697a6131376a6f79636540676d61696c2e636f6d00000a40616a637073686570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148549b7fd2bfcfdd9bc0525c374a8198f3288a0733918321dfc26532e253d94da3a6a27a4c3e31760": "0x040000000002000000000000000000000000000000000b506f6c6b612048617573001c68747470733a2f2f7777772e706f6c6b61686175732e636c75622f0014696e666f40706f6c6b61686175732e636c756200000b40706f6c6b6168617573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714854f02c37bb0a17d4653f0d351f8bca69b7be83c41b90fcee17c7ac2b285bb01a95b3755a6101a3c": "0x040100000002000000000000000000000000000000000b52616469616e63655f3905416c657800124061636964783a6d61747269782e6f72672172616469616e6365395f7374616b696e674070726f746f6e6d61696c2e636f6d00000c4052616469616e63655f39000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471485776350491a535bcea1d92de6550af9c490706f76cb9e12458c4632ad594cd66784630ad2e1ef34": "0x040300000002000000000000000000000000000000000a54686520424c4f4b431254686520426c6f636b6c61627320496e630000127465616d40746865626c6f6b632e636f6d00000f40746865626c6f6b6367726f7570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714858c0d6078e97ec2863010a4400694804bb594ed57a7d55e6149ce2e8abe2657b601fe2a7fabed00": "0x04000000000200000000000000000000000000000000145061766c61207c205061726974792044617461000011407061766c613a7061726974792e696f0000000a406461656d69613130000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471485a31ae8c4d5be8eea99c22436f5014c366a3e94a05c3410b997e436a414f7697af3f8206fa87e5a": "0x04010000000200000000000000000000000000000000114175726f726120506f70707973656564114175726f726120506f707079736565640000196175726f72612e6d616b6f76616340676d61696c2e636f6d00000e40706f70707973656564446576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471485a3d2fc56fa42403616337a83344f0849510571f384a48a55563b6618304e4da6162c4b7cc48e53": "0x0000000000000000000000000000000000186f7869786f20706f6c6b61646f74204e585f424c41434b00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471485c4e925378eb4916c42f37017f31d6c9ba5dca62626e6fb434d6edc31bfc9aa49f001a6ced27876": "0x040000000002000000000000000000000000000000001df09f8fa2204d696e6973747279204f6620426c6f636b7320f09f8fa20000001778406d696e69737472796f66626c6f636b732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148613e243ad5accda52a6c52dc82940a36fefd1474cc0778517bb1a56b7bda0e308b6c19152dd7510": "0x040000000002000000000000000000000000000000000b4f70656e537175617265001f68747470733a2f2f7777772e6f70656e7371756172652e6e6574776f726b1840776c69796f6e6766656e673a6d61747269782e6f7267166869406f70656e7371756172652e6e6574776f726b00000d404f70656e7371756172654e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148621671899b86161726ac63a0a6a700ad7e1178fef89a87620bbc152a19f74708defc7f08bbc6556": "0x040000000002000000000000000000000000000000000a426c6f636b4374726c00000019626c6f636b6374726c4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148640e8e247a0e20f30cfdb48ff7f33b08499dfc618a8ef9699b8345fa65f0b1339eb8eec3c0e4555": "0x08000000000201000000020000000000000000000000000000000018f09f949273746174656c6573735f6d6f6e6579f09f9492001d68747470733a2f2f7777772e73746174656c6573732e6d6f6e65792f19406161726f6e7363687761727a3a6d61747269782e6f7267194161726f6e2e416e746f6e6f706f756c6f7340706d2e6d65000010404d6f6e657953746174656c657373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714864262e04bb1d055588b5b3b691acdcdcbbc78158f60b97398185efb643eed0bba3e8ad6ac24b545": "0x040300000002000000000000000000000000000000000f4c756e6172205374726174656779134c756e6172205374726174656779204c444100001a696e766f696365406c756e617273747261746567792e636f6d00000f404c756e61725374726174656779000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148665682395484a7f5e5e31bfd996593554b54016676af00cc0ac2015b12c8824e5a50315f1bfe05a": "0x000000000000000000000000000000000012426c6f636b737061636544657672656c730000194073616368612d6c616e736b793a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471486a03b31f22c207f6607dc83a7fc1f33c13e978ee3527fdb2c908ae6b5c0d2dee81bf30a01808263": "0x040000000002000000000000000000000000000000000c426f747469636577736b69001968747470733a2f2f626f747469636577736b692e6172742f001b626f747469636577736b694070726f746f6e6d61696c2e636f6d00000d40626f747469636577736b69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471486e69567b2fc7d85a44fe0211e518d4a7e0d647cb66979cafcf322d3427972abf875d29c7c76d501": "0x000000000000000000000000000000000013776f73732d303031407375627374726174650f44616e69656c204d6172696369631068747470733a2f2f776f73732e696f1140776f73733a6d61747269782e6f72670f64616e69656c40776f73732e696f00000940776f73735f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714870976f0672085c5f8ff75032359f0de13264a134c3e88089cf6a2a31e5cf3cdfe405a4e272f0508": "0x040000000002000000000000000000000000000000000d547963686f204d61736975730000000000000e40547963686f5f4d6173697573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714870de10fb6114007fed7d1cc37fe7a63ac7e5882194d3684e12a17df4d2848a4f4b7e5abefed92c9": "0x04000000000200000000000000000000000000000000125969656c64426179205472656173757279000019406e6967687477696e672d79623a6d61747269782e6f7267166e6967687477696e67407969656c646261792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487116eaed0a9a16e7e29f9518827a1bfb2e3b6a8a153cb136f9405f68c728f9c8a38c7971897b77b": "0x040000000002000000000000000000000000000000000f434f494e205245464552454e43451b4a75616e204d616e75656c2053616e63686f20506974617263681968747470733a2f2f636f696e7265666572656e63652e6d6516406a6d636f696e7265663a6d61747269782e6f7267166a6d66696e616e6765737440676d61696c2e636f6d00000c40436f696e5265665f636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487149495530dd8d3f81550f147455d286246994dbf4bfa37961d235b96ed8d1189b7445c18680f50": "0x000000000000000000000000000000000006646f796c6500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714871588d7f6c0fdd3002f931bb0cf405212de02243756d8ff665710af7fb234bfb1a50bb78ae1327b": "0x040300000002000000000000000000000000000000000b52617669204b756d61720b52617669204b756d6172000015697473796f757261766940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714871c07918bd122cae4a15453d67f7353ee3d4eca8f465b2337e675b5efdebebe8209b6179af0bb43": "0x00000000000000000000000000000000000f5a6565205072696d65204c6162730f5a6565205072696d65204c6162731368747470733a2f2f7a706c6162732e696f2f0012636f6e74616374407a706c6162732e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487258a23c1cc74c20c618307d00b3354999ae280858c01fceddd77a25b5bc665fbd4634bf86a4178": "0x04030000000200000000000000000000000000000000057469656e115469656e204e677579656e204b6861631268747470733a2f2f7469656e2e7a6f6e6513407469656e6e6b3a6d61747269782e6f72671b7469656e2e6e677579656e6b6861634069636c6f75642e636f6d00000d405469656e4e677579656e4b00087469656e2e6e6b00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487537aeb7813f75e5efbe83a561d19b1d21126af5f1608ed28e56f4f70251cf965fe3dcb4901a26b": "0x04000000000200000000000000000000000000000000084b686173746f72000014406b686173746f723a6d61747269782e6f7267127374616b65406b686173746f722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148756caab39a157be040f4dbfe9b3333f7faf9304bf2ba9af0b4f850bab4e716759e0ebc8c4703c8c": "0x040100000002000000000000000000000000000000000a434f534d4f54524f4e00001740636f736d6f74726f6e763a6d61747269782e6f72671d636f736d6f74726f6e76616c696461746f7240676d61696c2e636f6d00000c40436f736d6f74726f6e56000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714878042bdd9d96dd3f07260abfd43d442e54357c409f75680478b2e97f348126e199537eaf964b342": "0x0403000000020000000000000000000000000000000007536f757261760e536f75726176204d6973687261000016736f757261762e6d2e627440676d61696c2e636f6d00000a3078736f757261766d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148795674870556252585e982d74da4f4290d20a73800cfd705cf59e1f5880aaee5506b5eaaf544f49": "0x040000000002000000000000000000000000000000000c446f6f7264617368636f6e0000000000002068747470733a2f2f747769747465722e636f6d2f446f6f7264617368636f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487ac7128ed93fd445e50e6e8499b921414360c3da7de7ca78544e38412bb6dc313383aaceb7c2068": "0x040100000002000000000000000000000000000000000a5072656d6975726c790e5072656d6975726c79204fc39c1668747470733a2f2f7072656d6975726c792e696e2f0015636f6e74616374407072656d6975726c792e696e00000b407072656d6975726c79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487b8d0a4f87b32a47c3f190f0abecf2b39643a21a67df302a024487d84128d5bc68fcc445ac23a06": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31301142494e414e43455f5354414b455f3130000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487c09bd19ab0b74df0802c5c92cc72abd8e7b849f32513f21d05bea7f60ec3f92a20854def08f247": "0x040300000002000000000000000000000000000000000b43727970746f5769736500000015636f696e6765656b323240676d61696c2e636f6d0000104063727970746f7769736567757973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487c5eb005741995b4a729cc2bb0da0787bfa545a498c261969623c3042b3099ffe331c5728f94125": "0x04030000000200000000000000000000000000000000084261727265746f0f4d617274696e204261727265746f0000166d746e2e6261727265746f40676d61696c2e636f6d00000b6d746e4261727265746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471487d2f749afa8b991984e16482c99cfad1436111e321a86d87d0fac203bf64538f888e45d793b5413": "0x0402000000030000000000000000000000000000000004576569095765692054616e671268747470733a2f2f7061636e612e6f7267000e776569407061636e612e6f726701bfa78a598c9343be661a1ee6e175faa5093a30680000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148827ff7e5656ef4ab1dca1726b672e75cdbdf56f990fc4170e44d460821e91a89d846f2359b45fb3": "0x0400000000020000000000000000000000000000000010467265736843726564697420496e6310467265736843726564697420496e631868747470733a2f2f66726573686372656469742e636f6d001e6465766f6e2e73686967616b694066726573686372656469742e636f6d00000d406672657368637265646974000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714885fb110161cbc6f4227279d29a93cb842f44a0bc9c29f4041d903011031bf155e7cb64814e37a6c": "0x00000000000000000000000000000000001f436f72706f7261746520506f6c6b617373656d626c79204163636f756e74001e68747470733a2f2f7777772e70656e64756c756d636861696e2e6f7267001c636f6d6d756e6974794070656e64756c756d636861696e2e6f72670000104070656e64756c756d5f636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714886cf5449f57c7b92488bc636ae2d90c355a53620f8c6dc36c8f30837f805ea399710bc2a43d6d18": "0x000000000000000000000000000000000006535441534800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148873265c60b23b3ce47c0672b1389c3456de496556d40ad8f2923595d54eb1f69b617febb8292501": "0x0000000000000000000000000000000000094b6f6c6b61646f74000000156b6f6c6b61646f74383640676d61696c2e636f6d00000e6b6f6c6b61646f745f6d656d65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471488a1a127cd77d12b806fc8e477a0cab0bd93e76f7e9f73fdee31ffe7dcd7d052037c39554f212e04": "0x000000000000000000000000000000000006532d646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471488ffc163fa9907f076f9c831b885b8f1a216a27064fa793733b162ee06afb502a8cdbc2ccd6cc536": "0x0400000000020000000000000000000000000000000009594a52656e6175640000001c796f76616e6e7972656e6175643634363140676d61696c2e636f6d00000e4052656e617564466562726573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714894c10549d53016ad8290537d6e31fe1ff165eaa62b63f6f3556dcc720b0d3a6d7eab96275617304": "0x040300000002000000000000000000000000000000000a4a616e2042756a616b0a4a616e2042756a616b1a68747470733a2f2f6769746875622e636f6d2f6b6f7574652f0f406a616e3a7061726974792e696f0e6a616e407061726974792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148954d9b6c7704b5c0a912cf4f0c7894598d81d26f2c24f6e5c2541f312462bb576593e9dc549146d": "0x040000000002000000000000000000000000000000001051757069642076616c696461746f7200001b40717570696476616c696461746f723a6d61747269782e6f726719717570696476616c696461746f7240676d61696c2e636f6d00001040717570696476616c696461746f72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714895c460a54a2e543ea803ae6f4cabebc87af9678cfecfa3c302244b138e0d691947bdae74b4a8c6e": "0x00000000000000000000000000000000000c50696e6b446f6c7068696e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714897931e60764d4ea8e602e63afb364ac583747b0a8bab092d5b20ee98f0495ce7562a8c992ac9f17": "0x040000000002000000000000000000000000000000001070617468726f636b6e6574776f726b0000154070617468726f636b3a6d61747269782e6f72671f70617468726f636b6e6574776f726b4070726f746f6e6d61696c2e636f6d00000b4070617468726f636b32000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148980acab3e7bb9bb1035801fd00144e10a3933ed859f8236bbffb93a7ac515bab9f1ca53cbb3f776": "0x040100000002000000000000000000000000000000000b4a7573745f4c75757575000000166c75752e6b6f6461646f7440676d61696c2e636f6d00000c404a7573745f4c75757575000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471489b10dfbde827732504ee3d36525d0ab821bef5161d7dc32eab7015fcf6f9c913d8b7178f9a5d261": "0x040000000002000000000000000000000000000000000b57617465726d656c6f6e00001b4077617465726d656c6f6e6e6f64653a6d61747269782e6f72671a77617465726d656c6f6e2e6e6f646540676d61696c2e636f6d0000104057617465726d656c6f6e4e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471489b9a5bd12ebd0af56220569726127d988e0eb1dd10defd87548de2579edcb6490af1214e568232d": "0x00000000000000000000000000000000000f4d65726b6c6520536369656e636521537461636b7365657220546563686e6f6c6f67696573205074652e204c74642e1f68747470733a2f2f7777772e6d65726b6c65736369656e63652e636f6d2f00196e69726d616c406d65726b6c65736369656e63652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471489d14e177f11397c9b62bcf47bb081dc8ecdf2d205b84d7c37261d3b5713b8e303b43537ca3a18ac": "0x04000000000200000000000000000000000000000000194d61726b6574696e6720426f756e74792043757261746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471489f6ea03f6581d565675d0d624354179fa260c34540ac9284cded48d4c2951ff17265c4517a2a747": "0x000000000000000000000000000000000009426974677265656e1c426974677265656e20537769747a65726c616e642056657265696e1f68747470733a2f2f7777772e626974677265656e73776973732e6f72672f0017696e666f40626974677265656e73776973732e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148a0b7cb67b16efc758ca37c5cd96fe3b250d9cdbabf28b891a93fd9ae9296e0e66732bfb57206918": "0x04030000000200000000000000000000000000000000084c696d696e616c0000001e6d696c65736272656e74706174746572736f6e4070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148a3ab59566c3860f1ecec4f3062f61988b13e9dab318860bd0fffe5b7b37880d50a614a0a20c2502": "0x040000000002000000000000000000000000000000000a2a2a2a2a2a202a2a2a000000196c756e61722e706f6c6b61646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148a452b72d725a7f78a676bf14fbdb4da5cd987dde8b7bfada8064a24aba2775bb573c20e5479e06b": "0x00000000000000000000000000000000000a4344524156454e523200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148a8347ca23548ddc8afa8cba08ebd8a15eec2017ee6c73292be36384ac5666d4a6680ac0bf53e97e": "0x04030000000200000000000000000000000000000000094d61726b65646f7400000015636f6e74616374406d61726b65646f742e636f6d00000b406d61726b65646f7474000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b0889a31b9f57b3e287c7494655d636a846f5c3347ad2cb3c462a8d46e0832be70fcc0ab54ee62d": "0x0400000000020000000000000000000000000000000008736b756e6572741153656261737469616e204b756e65727400154073656261737469616e3a7061726974792e696f12736b756e6572744070726f746f6e2e6d6500000008736b756e6572740000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b204d64b79dca3e8a449fac4875a24774175651ffcacc851939eff231fcd2e270e1e29429902059": "0x000000000000000000000000000000000012436f696e46756e642f47726173736665640000000000000d40636f696e66756e645f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b299234c2604004face99d3401cb9b45ee1bc0ec52f4cb35914dc5ad27806230534230eedb8413d": "0x040000000002000000000000000000000000000000000542494c4c0000164062696c6c3a776562332e666f756e646174696f6e0000000c4042696c6c4c61626f6f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b5245b925036264bf6429fc1003a7db6b560bcd9a9a5942e05c0d2193190d5739c17eabbf6b61c9": "0x04030000000200000000000000000000000000000000184a5553542042657465696c6967756e67656e20476d6248184a5553542042657465696c6967756e67656e20476d624800154061726e6f6c645f623a6d61747269782e6f72671861646d696e406a7573746f70656e736f757263652e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b64e7386b807a4c244a3fafb7a625ae311e31f2f83f470228a573ae21e011031a8c0721f86fe844": "0x0403000000020000000000000000000000000000000015f09f90bc50616e646157617272696f72f09f90bc00001a4070616e64615f77617272696f723a6d61747269782e6f72671970616e64612e77617272696f72444070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b6d998b612fe91d80c622c5213c9ff2cc3ffc7872409b6678e1dae72f63405698e8acfa2db2f06c": "0x040300000002000000000000000000000000000000000c6e69636f5f63616c63696f0c4e69636f6c6f205a696e690000166e69636f2e7a696e69313440676d61696c2e636f6d0000095a696e694e69636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b886522779ff3151d426e21be4fd135a6d4a02d9c0adbc43b24a428738c2bad59d722ea6f3e2f11": "0x04000000000200000000000000000000000000000000075a6f6e6461780a5a6f6e6461782041471268747470733a2f2f7a6f6e6461782e636813407a6f6e6461783a6d61747269782e6f72671068656c6c6f407a6f6e6461782e636800000a405f7a6f6e6461785f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b93860429ecf0c99c1d315cb41447f88f1da0f976f9ebca8970536df07af241ace21b5757383c6c": "0x040300000002000000000000000000000000000000001149204c6f76652043726970746f2042440000001e616c62657274627572676f7340706f6c6b61646f74737061696e2e6573000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148b9d575479a1dea6000e1c0ffb6a29c80083a8b1c4dc4d70fb2fbbd9c1319b8e9c0173aaafbd2963": "0x040300000002000000000000000000000000000000000767616e676f760f4b616c6f79616e2047616e676f7600001267616e676f763140676d61696c2e636f6d0000076767657a7472000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ba29f0652612f2cc4494455e738c0a47b5690708ab81dc9264395046089cd8aa613bae176c4880d": "0x040000000002000000000000000000000000000000000f44535347202865782d44414f5f290000114064616f5f3a6d61747269782e6f72671964616f7465726d696e616c636f6d40676d61696c2e636f6d00000d4064616f5465726d696e616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148bd90fa5b38a5d2d74340c22162ba8ddd49d836d01b693aa4cdc07eced946b0701173e0cd6bc7d69": "0x0000000000000000000000000000000000134e6f6e46756e6769626c654a6f75726e6579134f73636172204672616e6b6c696e2054616e2168747470733a2f2f7777772e6c696e6b6564696e2e636f6d2f696e2f6f736361001c6f736361726672616e6b6c696e2e74616e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148bdc67657419bbeb22ce51e9b096db10638d2889c4a847781e0360f6fd3adffa6280107ef7260f62": "0x0400000000020000000000000000000000000000000018506f6c6b61646f742048756220696e205370616e69736800000016706f6c6b61646f7468756240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148bed542ce020de9fd40d213230a9218267b54e293b86a4c6954d4e89ad60f9553ef9a63ac45dbaaf": "0x0000000000000000000000000000000000094d6f6f6e6265616d001a68747470733a2f2f6d6f6f6e6265616d2e6e6574776f726b2f0000000011404d6f6f6e6265616d4e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148bf84080a1ebdf7ca6f56e262666adfbbd80486024bb3255e8a5e31cf474ba64ea31a7c698833461": "0x0000000000000000000000000000000000084765726dc3a16e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148c508a69b80c90ec54b3e6a7a51343d32931c6f6820a84d8c0a8231906c4171d03e1dba0f0b50746": "0x04030000000200000000000000000000000000000000184d43207c204d43536572766963652e696f207cf09f92a50c4d61726b204372696e636500001a6d63626f7577656e7365727669636540676d61696c2e636f6d00000c404372696e63654d61726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148c56ef07b1e70c6e9227d3657bf3452543e8fcc6861134deffaed05ce3dff0ac63059aa0997c32cc": "0x040300000002000000000000000000000000000000000c434841494e414c595349530c434841494e414c595349531d68747470733a2f2f7777772e636861696e616c797369732e636f6d2f002063687269737469616e2e6d656e646140636861696e616c797369732e636f6d00000d40636861696e616c79736973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148c7ff1340164f7757d1c361b50b0963e2a3d9533bf324bd7898729d41c82f483117f02af181d8fd6": "0x0400000000020000000000000000000000000000000014496e7641726368204173736f63696174696f6e0000000000001040496e76417263684e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148cb4556b548f669b787d4175bfe47411f2c567fbff326dba11aa94216c2fe904ab2c56b567b6220d": "0x04010000000200000000000000000000000000000000094861727269736f6e0000001b686d63676c6f62616c2e63727970746f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148cc04fabfccee3139a92efbf31781a4ef54d55d10220a3025f65bed342c53c2b8fc3061f3d09c041": "0x040000000002000000000000000000000000000000000c4d794d6574617665727365001768747470733a2f2f6d796d65746176657273652e696f00147465616d406d796d65746176657273652e696f00000d404d794d6574617665727365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d1ba1cf54c412597876aa7c5c9e71fd79444ae3af051244cd66e2700b875faeb1c280d3026b3d2d": "0x00000000000000000000000000000000000e54656b6f6e7978207a65616c7900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d211992716663e682635369d20e36ccce82c98283410bfa4a4153e31bedb52b33cbce5543cba21b": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f341042494e414e43455f5354414b455f34000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d23d124156802cc9e25b58a4b93c0c51a65333999fc9f857deb2eace23e3c83ed79b2c08287343d": "0x00000000000000000000000000000000000a5374616b6542616279001668747470733a2f2f7374616b65626162792e636f6d0016636f6e74616374407374616b65626162792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d2b0ff93d409b20b9f14d73888b5029adb7dedd443f88d2d56088a315626a1d79507deb24a41d42": "0x00000000000000000000000000000000000f4b6f6461446f74204d696e746572001468747470733a2f2f6b6f6461646f742e78797a0000000009406b6f6461646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d47493ee3a600117269f7eab2e5f91f9efe10d0dba0e7256d9433230a8f9fdc1c4af10981853476": "0x04000000000200000000000000000000000000000000066a6f6e6173000017406a6f6e61733a776562332e666f756e646174696f6e19676568726c65696e2e6a6f6e617340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148d60cac4e5cdd86746ce78ca56ca1114d6abf7cb86879839ec6bf9c0c027ef318af3a77ac661401e": "0x040300000002000000000000000000000000000000000e416e6479207c20426561636f6e00000015612e676173736d616e6e407061706572732e6368000010616e6472656173676173736d616e6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ddffc86aaebc2d41e5c61cb6941b247d22fa14392fb8710a23493db5857c2904a76b3bcfda7d217": "0x040100000002000000000000000000000000000000001e5765623320456475636174696f6e20616e6420496e766573746d656e740844722e2043616f00001261686a7863727a40676d61696c2e636f6d0000094063616f5f6c6162000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148df58d11b9c4504b7a748920fbf8b122f81c3b7d63f1bd116c75c3741f4aeb3b3d89c7bbdefb2339": "0x0403000000020000000000000000000000000000000018506f6c6b617373656d626c7920476f7665726e616e63650000001668656c6c6f40706f6c6b617373656d626c792e696f000009706f6c6b5f676f76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e1506cd6e1c1ab8103da75e835e84c21fd864cdea4484538e7394cdf81d607ae496168e587e1b47": "0x0000000000000000000000000000000000064861726973001668747470733a2f2f6861726973626f73732e636f6d00184861726973626f737340686f746d61696c2e636f2e756b00000c40696861726973626f7373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e28ba2eeb3d7c40f4168b94d0932bd7f917c00abb58c08e9d951e2718484d1e43ecabc506bd7c3d": "0x0400000000020000000000000000000000000000000019436f6e74726f6c6c657220446f7420436172626f6e7974650a436172626f6e7974651568747470733a2f2f636172626f6e7974652e696f0018446576656c6f7065724079656c6c6f77737475642e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e46b19352a48af22483ec13c881ea5921623c6bc3b792559dd59df31eb5d42163dc1bb6505d453e": "0x040300000002000000000000000000000000000000000c626964696269646962756d00000012626964696269646962756d40706d2e6d6500000f40626964696269646962756d5f78000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e534b2433a5f1501096e62e5bef031b7189ac027fcc3eaba9e1743c314e5fa2e7357b45636d7d41": "0x040300000002000000000000000000000000000000000d53657267696f61644c49424d1353657267696f204d6172636865736f74746900001473657267696f4061646c69626e65742e636f6d00000b405365725f61646c6962000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e7257b4702ef819d2982658654fb6785977f89a5b1aab885021365dbb4b006b0ff550c219d98d33": "0x0403000000020000000000000000000000000000000009446547616d696e6709446547616d696e6700001268656c6c6f40646567616d696e672e696f00000c646567616d696e675f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e7879bd31890686c879bc272c2afef97bc36cb48543598dd460776f082e51d5239efda3ab7fff15": "0x04030000000200000000000000000000000000000000074875626e65740000001f776f6f6c7374656e68756c6d65616c6472656e6140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148e92984083d101c32c8feeab5bd9a317375e01adb6cb959f1fea78c751936d556fa2e36ede425a47": "0x0403000000020000000000000000000000000000000010436f6c6f7266756c204e6f74696f6e0000001b736f757261626840636f6c6f7266756c6e6f74696f6e2e636f6d00000f636f6c6f7266756c6e6f74696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148eaabd6d5a651ac5f45684f68ec654742c29fc6782be9921004192a1851c51154cf7b1cce2c6b518": "0x00000000000000000000000000000000000547656172184765617220546563686e6f6c6f676965732c20496e632e1568747470733a2f2f676561722d746563682e696f001368656c6c6f40676561722d746563682e696f00000c40676561725f7465636873000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148eb4ba0034502556f87dc01c2e647a407ec091e8ba718d691562d85ba49a97d55b9f7a7b56e81023": "0x000000000000000000000000000000000009536f7261746f676100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148eb8c14e9575686dc6201c7b373207514df98b17daa489a8d206b474cdcad455201b8b6efa936b0d": "0x040300000002000000000000000000000000000000000a506f6c6b61736166650a506f6c6b61736166651768747470733a2f2f706f6c6b61736166652e78797a2f001468656c6c6f40706f6c6b61736166652e78797a00000b40506f6c6b6153616665000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ec37554e12de10ab08b555a5a3b2725e01ba15eb40aa32dc5b781532854b797808ed45e752b047c": "0x040300000002000000000000000000000000000000000742656e64616b0000001862656e64616b7374616b696e6740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148eccee83ae40fd3db6167d010df1931f8440f02a199bb30d7d00440db494ead7a66c9d564202aa35": "0x00000000000000000000000000000000000f526f636b58204f6666696369616c1d416c747374616b6520546563686e6f6c6f6779205074652e204c74641768747470733a2f2f7777772e726f636b782e636f6d2f0012696e717569727940726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ed3cdd8f85271b0a215a54a9ad2ae7acb7ce71d6bf95e950bb20323b4d8153ba0059e20b5fd2923": "0x0400000000020000000000000000000000000000000016456e646572627920456e7465727461696e6d656e7416456e646572627920456e7465727461696e6d656e742168747470733a2f2f656e6465726279656e7465727461696e6d656e742e636f6d001f7269636b6440656e6465726279656e7465727461696e6d656e742e636f6d00000c40456e6465726279456e74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ee7853e903b944aec9da8307266c9d21b5c5abb97429930acd24d53fd2f8212c40822322248406c": "0x040300000002000000000000000000000000000000001250617363616c207cc2a0416375726173740000001370617363616c40616375726173742e636f6d00000b49416d50617363616c42000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148f3e547c92a9f976e48cf28184fede6322720d00b8cdd7f8505499460dc19dc36280b430cc160a1c": "0x00000000000000000000000000000000000544475f3100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148fcb6335f1a565451cd6b5692fb62af477d385a940bf36ccb9dd085a20f5e01bfd4904fef461f5e3": "0x0000000000000000000000000000000000046f72650e4f6c6976657220456e6369736f0000196f6c69766572656e6369736f303740676d61696c2e636f6d00001140656e6369736f5f6f6c693136383630000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148fedd41107e5eb65720f2a91be2692cee676ba11405101ec67422a5dbc749c501c607dbfc585c27e": "0x040300000002000000000000000000000000000000000c6368726973676c6f62616c000000166d616c697a65636872697340676d61696c2e636f6d00000e4063687269736d616c697a6533000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ff4d63ea65c2c7cfe6e0141f1f9c11b8ff9298df8ba96169aee6dfeb3b2e57d27c9ae2b029d6f11": "0x04030000000200000000000000000000000000000000076672616e6a730000001b6672616e6a732e6672616e636973636f40676d61696c2e636f6d00000a406672616e6a733237000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047148ff6163e3cfc08ee04e8b8b6a5c974f15c784fcabd18a4bf8fba4c5ade55210aa159c106009dfd3a": "0x00000000000000000000000000000000000953686f6b656e6e7900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714900a0b9f77ddf8434c108ee4a7fc5ad38e5af9d408486d66055a9a7893c644789d081040cfecff61": "0x04010000000200000000000000000000000000000000104465766f7073204d6167617a696e65184465766f7073204d6167617a696e6520507479204c74641c68747470733a2f2f6465766f70732d6d6167617a696e652e636f6d1c406465766f70732d6d6167617a696e653a6d61747269782e6f72671a6465766f70732e6d6167617a696e6540676d61696c2e636f6d000011406465766f70735f6d6167617a696e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714908ee65340aa835e9e1389d5ddfa43eddcc269e5b95bc69e72be36c43882da45cde097dd7703a217": "0x04030000000200000000000000000000000000000000114e61636869746f204167656e742331340331340000196e61636869746f2e63727970746f40676d61696c2e636f6d00000c406e61636869746f657468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149098a1473c99bf7e9a5e3760bdedaa34c256e0b28279d358b68a28cfd5967bd0f8cd5555496fa655": "0x00000000000000000000000000000000000c726567656e65737475726b1b456e6573204d61686d7574204fc49f757a68616e2054c3bc726b00000e656d6f7440676e7379732e696f00000d40726567656e65737475726b000e656e65737475726b233030313300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471490b7f1fb67016ea9caaeb20361e77d9114bdd85dc196c33e15da72f4c28699085c388a3ecaa17f1e": "0x04030000000200000000000000000000000000000000034c56000000124c56406461626c6f636b64616f2e636f6d00000b404b7573616d614e4654000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471490dd85b65e5cd020a40c551ab8f3bd70b9afc4bdc348f71e3403deb9b7dafe384ad536a5b42e7107": "0x0400000000020000000000000000000000000000000007726f64696f6e00001a40726f64696f6e706170613030373a6d61747269782e6f726718726f64696f6e7061706130303740676d61696c2e636f6d00001040526f64696f6e3034373039393331000f726f64696f6e303037233535353300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471490f81dd1ff30118bc44ee45000531bbf1aa4c23540940eb10599e14b4fbed5267c42a0ebf5d09f66": "0x04000000000200000000000000000000000000000000055245504500001140726570653a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149103dcfe925d4e52b2e6d8f0b56e1d493dc573448b702fed2b4318dcc46896527099cf5fc9e0d247": "0x00000000000000000000000000000000000e4c6974656e7472792f7465737400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714912655d634b54e9a086de7162fbfa0b91a67eee94b697646028edcf484ae78fdc0627e7eef1b2247": "0x040300000002000000000000000000000000000000000a53756257616c6c6574000000146167656e744073756277616c6c65742e61707000000e4073756277616c6c6574617070000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714913e194223487e6ad60cfbed680a5afbf2888ea18911a5d10abbc7398f19d4507cced58c8fc0d575": "0x00000000000000000000000000000000000c4865726d65735374617368074865726d6573000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714913e6dae982908ac300192a29bd4659b0f05b2263af3d602ea7960160d9e864228dd2f1697809b67": "0x00000000000000000000000000000000000c526567656e63792d3032301757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149187e9b68a6b4d794ef86b506a3a8023b78b27e079f19ad8d15a31924879678fd610bc2639b2bd81": "0x0403000000020000000000000000000000000000000006566965742e0d416e6856696574205472616e0000187472616e616e6876696574786440676d61696c2e636f6d00000940767472616e3037000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471491d20a44a8276c2a3241222d562ffe7f7a5fd8a4b13bdd035647cce34c6eeaf4ab43e431a3268349": "0x040000000002000000000000000000000000000000001d5061726176657273652054616c69736d616e2050726f706f73616c73000016407265706c67686f73743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149244fde1a07e17b6ec6fb19f22456336dbcaf2ce4d8da72a8d092f60cd123cc9cb972cc1e42e97dd": "0x00000000000000000000000000000000000a616e6465726d61747400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149253b68a74ca5ffce225f681546f6e540ebb18c2b217652e13abb443aaf5dfc8496ec2b0cb883200": "0x00000000000000000000000000000000000c6f7363617274657275656c196f736361722074657275656c2069207065726164616c74610000156f73636172747031304069636c6f75642e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492595c8ed770133ebc500ab02f6e42ccd4300f6e68a0eaa60a88a5caf900ef6be81d8ab559e7b939": "0x0403000000020000000000000000000000000000000005416c65730e416c6573204a75726b6f766963000018616c65732e6a75726b6f76696340676d61696c2e636f6d00000e40416c65734a75726b6f766963000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492856427f3f5a77c7c649a13f87c0d5b9b2b934e867a10304249752e96eebd4fe5ec6ff9fb82c078": "0x00000000000000000000000000000000000b616c6172636f6e736a631b4a75616e204361726c6f7320416c6172636f6e2053616e746f73000017616c6172636f6e2e732e6a6340676d61696c2e636f6d000009406a616c61726332000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149285fa22c885aa248e29df67564eddc299a2aa1cdacbec3c1ae061cf0835c87e5b46b920f7573a77": "0x04000000000300000000000000000000000000000000124a7574746120f09f91a9e2808df09f8ea40e4a7574746120537465696e65720018406a757474613a6d61747269782e7061726974792e696f106a75747461407061726974792e696f00000f406a757474615f737465696e6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492a9b8874561dc036464f15335eee136dd7c216b994ea6ac3394eb723590e9e065fd9061e05d0035": "0x0400000000030000000000000000000000000000000004524f4212526f626572742048616265726d65696572001b407270686d656965723a6d61747269782e7061726974792e696f0000000a407270686d65696572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492c85c6e1d4ad1da20426d3ac752d4b9c92c4c9090fb1115c379982fa665ab6f6914552adedd1a10": "0x04030000000200000000000000000000000000000000064b75646f73000000176b75646f732e706f7274616c40676d61696c2e636f6d00000c4b75646f73506f7274616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492da06c1a6bb3bdaa0e1c76edd8151d4841665925d01a029fe176eecc24297bf931d594502293159": "0x040300000002000000000000000000000000000000000e537472696e64626572676d616e0e537472696e64626572676d616e000019737472696e64626572676d616e4076656e616c6c2e636f6d00001040737472696e64626572676d616e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471492f879f180f6a02408b712a589f5cb71cd7094809785ab0a924358d3cb52b27efd4933b6efc14963": "0x000000000000000000000000000000000010446f6e446965676f53616e6368657a0000001c676176696e776f6f6469736d796775727540676d61696c2e636f6d00000f4053616e6368657a43727970746f001140646f6e646965676f73616e6368657a00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471493b1caaf799dd1859bddc94acc7518e753f3ca6710e2777a0dbfc5dd06a67b02a5f731c9621fb36f": "0x000000000000000000000000000000000014456467657472696275746f722053756244414f00001a40456467657472696275746f72733a6d61747269782e6f726721656467657472696275746f72734065646765776172652e636f6d6d756e69747900000f40456467657472696275746f7273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471493c499446dff130948b985dae79adcb9becca19ca2eba2aada6416020dc01abd59f8b4419cd8a002": "0x040300000002000000000000000000000000000000000b4d41442043524950544f000000136163736579696e6340676d61696c2e636f6d00000b406d617474756e636869000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471493d0e54cd18f21273eabb0f32cb0695fedb8d25f6299fe51f90b1e26ed858c1064aeeea0977c1e67": "0x040100000002000000000000000000000000000000000b4e6f727468776f6f6473001768747470733a2f2f6e6f727468776f6f64732e636f2f0016737570706f7274406e6f727468776f6f64732e636f00000d404e6f6178656e6565646564000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149405477f74a11219ba1c4070dc40c8c4f8619ad619382655a6f9764f454954457406f10a87ae164e": "0x040000000003000000000000000000000000000000000850617261646f78001568747470733a2f2f706172616e6f6465732e696f164070617261646f7878783a6d61747269782e6f72671470617261646f78787840676d61696c2e636f6d00000b40506172614e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714943fc2ac54f4c37ccc10dd1946b0fc65c8993ff7f47052713e9aa4b1cb72c913bd397c34adf4f949": "0x0400000000020000000000000000000000000000000009416264756c62656500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149446885b0b18680ae8e0ac0aa68a0c138a3aa84813f0accae4ed7d6ae4b4905495026f16eda4e069": "0x04000000000200000000000000000000000000000000097370617a636f696e000000137370617a636f696e40676d61696c2e636f6d000008407370617a7674000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471494770065de5e75f5d0e903b51697fa10a7f8c7e5c750fb3c2f90424b749be8b6c0f0b120f5d7277c": "0x00000000000000000000000000000000000b4441524b464f5245535400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714949975f6dd9018661c9855eb44b83e5916954e5dc4801b8e7333bffb9f5788a1f7245811421b600b": "0x04030000000200000000000000000000000000000000094744617661737369124769616e6c7569676920446176617373690000186769616e6c75696769406b796c69782e66696e616e636500000f6578717569736974757339343134000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471494af0873e9a60a1b025b4abda214f95f673f89f6d7139894f0b9486cb3f28e5c56956288b4876c69": "0x04000000000200000000000000000000000000000000066a756c696f0000001868694077686f69736a756c696f73616e746f732e636f6d00000d406a756c696f73616e746f73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471494bfb37d43938cba9cdbb4a6e2756511dfe6028fe26c3ca3fb6123753e7e222978b5183581cc0c75": "0x0000000000000000000000000000000000174765726172646f2050697a6172726f2047656f7267650f6765726172646f2067656f72676500001f6765726172646f70697a6172726f67656f72676540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471494db11932c4b24d4224eba2123974db88ab28f55b7dd4f8f330013cb431d5a9c121b3384bea81020": "0x040300000002000000000000000000000000000000000646656c69780646656c697800001666656c697834737761726d40676d61696c2e636f6d00000f40436174616c797374537761726d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471494ed5c295f9bfa2588f28e17671ba1808d7b02cd3caaf80113066a467127666f4d80afc50bfbc127": "0x04000000000200000000000000000000000000000000067a6f656d63000012407a6f656d633a6d61747269782e6f72670000000a407a6f656d63666f78000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471495034dce89216a0306a7f8d0b05138414746c1fd2c03695ada9d503e888977e0763fc427f50f7156": "0x0400000000020000000000000000000000000000000013457567656e696f2047696f76616e617264690000001d657567656e696f2e67696f76616e61726469406d6f6f6e69612e6974000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149508d34e1b2941b94a4081d3f77f3ae9304f78983183b8f015dacb620ce7eb0444e733b85422d931": "0x040000000002000000000000000000000000000000000a70616e6472657339351d5061626c6f20416e6472c3a97320446f7261646f205375c3a172657a1868747470733a2f2f7061626c6f646f7261646f2e636f6d174070616e6472657339353a626c6f7175652e7465616d15686f6c61407061626c6f646f7261646f2e636f6d00000b4070616e6472657339350a70616e6472657339350a70616e64726573393500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714953150ed314b45c2b2b3d7f25a51033a9fd84198e78c72fac4e9f23fc149d82200e0b423f1418671": "0x00000000000000000000000000000000000b507572706c65546f616400000017707572706c65746f6164303940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714955ba6c28b709d2f7a0a276b0053aa5d6291575d123aceb4efbc34b98102b967590c008b4cf54872": "0x0403000000020000000000000000000000000000000008427261696c6c650f427261696c6c65204167656e63791568747470733a2f2f627261696c6c652e7774662f0014636f6e7461637440627261696c6c652e77746600000d40627261696c6c655f777466000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471495b0575164a947673676eca79c8b6ff6a5b544274fc7d1e38b38ca8211ae59fd73b8c1073f64fa27": "0x0400000000020000000000000000000000000000000016f09f97bb20416c70696e654e6f64657320f09f97bb000016406b72697368313636323a6d61747269782e6f726716616c70696e656e6f6465734070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471495e5354b81f0f460da9f7fd3d9612a68d2ead69dde53297b172b7db514d0d261e7c5be987df7f32a": "0x040000000002000000000000000000000000000000001453696b207c2063726966666572656e742e646500001540646576305f73696b3a6d61747269782e6f72671a73696d6f6e2e6b726175734063726966666572656e742e646500000a40646576305f73696b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471495ffe83b7e4e53745ac11043321b5292fe5c644feaf53ff448ca444a527d51f380c799ed16565c89": "0x040100000002000000000000000000000000000000000b58656e6f70686f6269610000001f77656c746c6963682d696e6e696e67732e30684069636c6f75642e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471496841c11a7beb5d5c2fe15c1d94dc26f396102556264826f7a197ba897ae75aa5e52d220153cb679": "0x0403000000020000000000000000000000000000000012736f6d656b696e646f6667616d656465760000001c736f6d656b696e646f6667616d6564657640676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471496dad83abc32ee034c260b3a7196660071ca1b27e79bf234cb7efaa125300a696a0a42ee686b1734": "0x040100000002000000000000000000000000000000000664616b6b6b0000124064616b6b6b3a6d61747269782e6f72671464616b2e6c696e757840676d61696c2e636f6d00000840646167696465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714972228f5d624edf372e9d0af25b9e826acc65a8d4233ca1149d57eff4a7d78e620889cd37174c57d": "0x00000000000000000000000000000000001c313335204361706974616c20496e636f72706f726174656420303210416e74686f6e7920457566656d696f0f68747470733a2f2f3133352e696f000b616365403133352e696f00000f407265616c4143457566656d696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149730aaa91834c4fe403e9da23891aeb29efc4ba2785edc0ea8f4bc67f0f1942dfb5295191373a47b": "0x040300000002000000000000000000000000000000000c546f726f734167656e637900000012696e666f40746f726f732e6167656e637900000d40746f726f736167656e6379000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471497389e32ef925ccd6c0197856b35c7f631f5aa8d9cfd83f7e75202b0d821e67d2f344e4e4b5fc10f": "0x0801000000020300000002000000000000000000000000000000000d506f6c6b617373656d626c790d506f6c6b617373656d626c791968747470733a2f2f706f6c6b617373656d626c792e696f2f001668656c6c6f40706f6c6b617373656d626c792e696f00000a40706f6c6b5f676f76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471497caee6b287aa129f6cb33068e0f82887ed35a5e17e77021cd796902e5e2939c325b4f92d4f3957c": "0x0000000000000000000000000000000000114a4f49452028657874656e73696f6e290de68891e698afe9b8ade593a51068747470733a2f2f6a6f69652e696f14406a6f69656375693a6d61747269782e6f72670d6a6f6965634071712e636f6d000009406a6f6965637569000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471497f3d4c5777373935275676a7d8983923233084beb6faac0ea3773730c8abe70eed4795ee2815441": "0x04030000000200000000000000000000000000000000165279616e2044696e68207c2053756257616c6c65740a5279616e2044696e680000137279616e4073756277616c6c65742e61707000000b405279616e44696e6838000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471498426f2bcd57c422f4c8bc5da2f0d0e2f6e040005f783c023b85a8cb21df5c1f509c144fe1887202": "0x040000000002000000000000000000000000000000000858616c616d75730000144078616c616d75733a6d61747269782e6f726715706f6c6b61646f744078616c616d75732e78797a000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714986ea6df1fdbb2a51c20046a7e79f6a36c1f8f74a8caf1e573c448f7f2ca4d7e75928579ddbc134b": "0x040300000002000000000000000000000000000000000a6c74667363686f656e1d4c756b652054686f6d617320467269656472696368205363686f656e1d68747470733a2f2f706f6c6b6176657273652e636f6d2f406c756b6516406c74667363686f656e3a6d61747269782e6f7267146c74667363686f656e40676d61696c2e636f6d002168747470733a2f2f6769746875622e636f6d2f6c74667363686f656e2e706e670a6c74667363686f656e000a6c74667363686f656e00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714989747ec8e57b3315e7b86bae8d18cd7470cc4c03d47875d002cee651566030fea5312bf0e69562a": "0x0400000000020000000000000000000000000000000010477572755374616b696e67f09f91b3001868747470733a2f2f677572757374616b696e672e636f6d1840677572757374616b696e673a6d61747269782e6f7267167374616b6540677572757374616b696e672e636f6d00000d40477572755374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471498a44c6de372836c145d6c503d0cf97f4c7725ca773741bd02e1760bfb52e021af5a9f2de283012c": "0x0400000000020000000000000000000000000000000008546869626175740000124074626175743a6d61747269782e6f726700000007407462617574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471498d18fa62c6f4741589e41f29ab08f2d0e4e4bdf3d1c8a868162c720f9c31e22733f8d633fba901e": "0x04030000000200000000000000000000000000000000064d6f6869740b4d6f68697420426861741968747470733a2f2f6769746875622e636f6d2f6d6263736500126d62637365353040676d61696c2e636f6d000009406d626373653530000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471499004306bcbce5e41a4642fac1519da8a909bba8a1cc4ba6c6d096fac4da4e9a0f5dbe7eae16360a": "0x00000000000000000000000000000000000e6c616e64617320676c6f776e6500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714995d906364498e519ab4ee81530865538477c5f9fa76f57f2058f4d97476d028ccbb4bfe44a0f626": "0x00000000000000000000000000000000001a70686f656e69782d63727970746f2d636f6e74726f6c6c657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714996b1fd9ab500b524ab52bb8245e545fc6b7861df6cf6a2db175f95c99f6b4b27e8f3bb3e9d10c4b": "0x040000000002000000000000000000000000000000000344460000001464617070666f72636540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714998cd9a07d23d28d50ef3cbba6eefa5127e662a1286c69c3f8cd10aa328d394df9e69919af449b45": "0x000000000000000000000000000000000012496e73696768742046696e616e63652031001368747470733a2f2f676f7374616b652e696f001577656e6a756e6438343940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471499c40e700afa99fd3e9303650f53c8624593711265f153cea49411b1966da5d31142b6b88e721c38": "0x040000000002000000000000000000000000000000000a506f6c6b616e65787400001640706f6c6b616e6578743a6d61747269782e6f72671570726f6772616d40706f6c6b616e6578742e696f00000b40706f6c6b616e657874000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471499d7e43eb6d40f70b6ad8860b2acbb26cf3caaedc7deb8c5d7146ac5bbe77bf34a592a97e377a046": "0x00000000000000000000000000000000000644722e20540e54686f6d61732048616d6d65720000187468656469736375736d616e40776f682e72722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab870471499eef26ba196a8a8b089dedc24a15308874dc862b035d74f2f7b45cad475d6121a2d944921bbe237": "0x04000000000200000000000000000000000000000000135448454d414e574954484f5554414e414d4500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149a449d74fb4e4f6f80cac1fb723163fc032ac4db84fec2102f6897afa7dac42e379a7d41ad586b5e": "0x04030000000200000000000000000000000000000000094f74746f546f6f740000001e6f746f72696e6f6c6172696e676f6c6f67363640676d61696c2e636f6d00000c404f74746f546f6f743939000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149a8e7db7192318209e634dd70cbdbd492c6874c5613bcb06f1d8dc85eed3051f884c5458e7205655": "0x0403000000020000000000000000000000000000000008416e61746f6c7908416e61746f6c790000176e617a6172616e61746f6c7940676d61696c2e636f6d00000c40373737416e61746f6c79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149aadb0de0e3acc6ad0e409282db1aea4d91486a122492e7a130f681b7daa71cfd4db3db086ea7d65": "0x040300000002000000000000000000000000000000000a4475636b446567656e0f4461766964204c656f6e617264690000136461766964406a6f6273746173682e78797a00000a6475636b646567656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149acc963ace4fd466a228a70c2496ae500d79de266f9c759918256444c352d76bcc4a0c32e2dff716": "0x040300000002000000000000000000000000000000000b43727970746f52616e6b0e43727970746f52616e6b2e696f000011666d4063727970746f72616e6b2e696f00000e43727970746f52616e6b5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149b2f4bfc1eecbbb29003fe9042a2c3433ecbddf6b360c3f17993544f830dc75f73d9a13a8757bf26": "0x0403000000020000000000000000000000000000000006736875766f06536875766f0000166a616d62646b776c73333340676d61696c2e636f6d00000a40536875766f427463000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149bc7b64471beb6caa4a902266727d6859bbd3cd585e9f64460ed6289f95bd851bd441ff57573ab64": "0x00000000000000000000000000000000000b4461793163686565727a00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149bd6b99bd8180aace8c7ad65c15fa3ba64424a61b177382a0c5468135aecca9ca454f5e7ce4d305b": "0x040100000002000000000000000000000000000000001043503238372d434c4f554457414c4b001168747470733a2f2f637030782e636f6d1640696c6c6c65667234753a6d61747269782e6f726714696c6c6c656672347540676d61696c2e636f6d00000c406b61706c616e736b7931000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149bfeb795391ff04e92126d23f40d0707321f495a7ca4b97a86f2282cdf5229a4b315793e51dea246": "0x040300000002000000000000000000000000000000001643687269737469616e20436861696e616c797369731e43687269737469616e204d656e6461202d20436861696e616c7973697300002063687269737469616e2e6d656e646140636861696e616c797369732e636f6d00000840636d656e6461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c1d0530fd26bd0a347bf57a51b4924e76624612bcd7bbd269b3079fbcc4a2f72a2fcac55056286c": "0x04030000000200000000000000000000000000000000054e6f6f72104e6f6f72204d6f68616d6d6564204200001d6e6f6f726d6f68616d6d6564624070726f746f6e6d61696c2e636f6d0000114030786e6f6f726d6f68616d6d656462000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c21b6ab44c00eb3127a30e486492921e58f2564b36ab1ca21ff630672f0e76920edd601f8f2b89a": "0x0401000000020000000000000000000000000000000017506f6c6b61646f742e70726f202d205265616c676172001568747470733a2f2f706f6c6b61646f742e70726f14407265616c6761723a6d61747269782e6f72671368656c6c6f40706f6c6b61646f742e70726f00000d4070726f706f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c2d3779d2f3e4d20ae756ebc2b9527cb5634924b518af5a0edbedcf16e7d581648d770e4cb27844": "0x00000000000000000000000000000000000e54726962652f537461636b55700f54726962657820507465204c74641568747470733a2f2f737461636b75702e6465762f00136e6963686f6c6173407472696265782e636f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c54b3d06134b2da7c2754f11fe0d5e6b3c2174eacd1fe36d2738bfbefb541fb4f56eb298dc1491a": "0x04000000000200000000000000000000000000000000064f4e44494e000012406f6e64696e3a6d61747269782e6f7267136f6e64696e37373740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c6b526cb73c7a0f38e4240801ab3b93aa2312497116b9ced3dfaea754a6e18c45f4605ee3af490d": "0x0000000000000000000000000000000000075374617269740c4a616d6965204368656e671368747470733a2f2f7374617269742e6d652f18406a616d69652e6368656e673a6d61747269782e6f7267157374617269743139393240676d61696c2e636f6d00000c4073746172697431393932000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c74feb394678e854ae840a749725558ddb56d21b296ea057d8295ba7c7ded83fa0285afa24cc600": "0x00000000000000000000000000000000000f506f6c6b61646f74204a6170616e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c7aff229a5b7073468ae00d6e49251a2c0809df7e3283dd05fe8232e010734b0de316c5ab07431f": "0x040000000002000000000000000000000000000000001c4b6172696d207c2050617269747920496e66726120262044617461000011406b6172696d3a7061726974792e696f0000000b404b6172696d4a444441000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149c9cab497b19e1dad837b7a3a768b47b1210fc36f3157793bd95820092148f973e5f297a05412e5a": "0x04030000000200000000000000000000000000000000076b756d6173690f45766572677265656e20207961770000126f6c696337343740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149cafa1da45543da296c952e57d77a6acc899f39e7f043839309cc8527b089c5ca76d24c2b63ebb4b": "0x04030000000200000000000000000000000000000000096a736c7573736572154a616d65732043616c76696e20536c75737365721868747470733a2f2f7777772e6b75726b756d612e636f2f15406a736c75737365723a6d61747269782e6f7267146a736c7573736572406b75726b756d612e636f00000a406a736c757373657200096a736c757373657200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149cdf78c3a20b94bb2a86561dc118ec7d56488f5615de6b325f6dd97e6801aa8b3aa10aa687e8347a": "0x04010000000200000000000000000000000000000000064b6f74616c001168747470733a2f2f6b6f74616c2e636f0011737570706f7274406b6f74616c2e636f000009406b6f74616c636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d04e8142e8ca463bc94245f476d6d2f02c5c8c12a5914444a4b22fa38f2107025b1a092b376fd79": "0x0403000000020000000000000000000000000000000008416e6e79306e6e1c4672616e636973636f2056616c656e74696d2043617374696c686f00001a6672616e636973636f616e6e796f6e40676d61696c2e636f6d000008416e6e79306e6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d18dbe99b9ed7df4f4097d2ee14bfbac178efc25e50fda49b96b18d6f48958f179041a00c126ec8": "0x00000000000000000000000000000000000c526567656e63792d3030311757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d263a3ca965563a56b8d05d9dd7fef64c1cac6d69a674c5bea54c270a48170c6abebef698337221": "0x040300000002000000000000000000000000000000000b4e69636fe29aa1efb88f104e69636f6c61732041726576616c6f0000196e69636f6c61734076656c6f636974796c6162732e6f726700000d406e69636f6c617265733238000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d3d32c9a2a70e509a6d8b9ce3536600ca5e3235162058682c565f1b7c071d00bff49acfc7489e3f": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2033001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d3e6d4e7e999db42ecef72bcacac7b6f05920ea3593b27d3a8ae8ec55f4925eaf1caccdb57e5225": "0x040100000002000000000000000000000000000000000f4d584320466f756e646174696f6e154d584320466f756e646174696f6e2067476d62481468747470733a2f2f7777772e6d78632e6f7267000e68656c6c6f406d78632e6f726700000f404d5843666f756e646174696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d417fe5c3fd7281028b2fce5e73610790f841442376a9bfd38c2494cc7831c5481db451be550d5c": "0x040300000002000000000000000000000000000000000e4e494b48494c2052414e4a414e0e4e494b48494c2052414e4a414e0000176e696b6c6162683831312b3640676d61696c2e636f6d0000086e696b6c616268000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d430d0bdbcfdbc6f0de782e8bad3c663be60812f0a2ac63464f5da3ec448c73334c07d71ef27f2c": "0x040100000002000000000000000000000000000000000d5374616b6572205370616365001568747470733a2f2f7374616b65722e73706163651740676e6f737369656e6c693a6d61747269782e6f72671368656c6c6f407374616b65722e737061636500000d405374616b65725370616365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d5c0a5ff6bacb086ebe9137ac7ac32374b6459c8633314440b21be4356a718a408b10c9ab520e70": "0x040000000002000000000000000000000000000000000b636c6f636b636861696e00001740636c6f636b636861696e3a6d61747269782e6f726717636c6f636b636861696e687140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d8014dd68872e0de21727312b2b7ce579dc0f82f129d4edecbcf00abca607d73ccf16e8352cc777": "0x040000000002000000000000000000000000000000000e444f5a454e4f4445532e434f4d00001240646f7a656e3a6d61747269782e6f726716636f6e7461637440646f7a656e6f6465732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d87ee52b783a152bed497470a04ca4c13caccd69c7827e3ddc64473fd2d7c5d496c71061f452b05": "0x040100000002000000000000000000000000000000000b72656470656e6775696e0000174072656470656e6775696e3a6d61747269782e6f72671a72336470336e6775696e4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149d967298cdbfa73f664a2b3e8bd3b4ab1878c278d5b10482bd2b590ffeef1552e3c78fe045045a7f": "0x0403000000020000000000000000000000000000000010526f68697420536172706f7464617210526f68697420536172706f7464617200001b726f6869376e732b706f6c6b61646f7440676d61696c2e636f6d00000f726f686974736172706f74646172000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149da3e68b063e9e3fee046115156933810cf762fcb5928e5a750b25eb9cd7932f425972b94f17960a": "0x04010000000200000000000000000000000000000000076b6c65766572001268747470733a2f2f6b6c657665722e696f00106c6f756973406b6c657665722e696f00000b406b6c657665725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149da48123ab54b499c6477bfd57c12587b1075a80d944c7829784eed61a5c8b8255817e1d62d1070e": "0x040100000002000000000000000000000000000000000d4b495241205374616b696e670e4b69726120436f7265204a534314687474703a2f2f6b697261636f72652e636f6d15406b697261636f72653a6d61747269782e6f726716706172746e657273406b697261636f72652e636f6d00000b406b6972615f636f7265000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149db5c1943eccca8bc422b6d1cc9c0e9ad3e29b03134c8f1e45210f3f404ec3daa05f3aefe8257205": "0x040300000002000000000000000000000000000000000e5468652044617070204c69737400000018636f6e6e65637440746865646170706c6973742e636f6d00000c746865646170706c697374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149dcc277753735b96e04ca25cf1cbc516ed1c138492a7f2e606f60c5a9ac96cb405eaa3914fd12973": "0x040000000002000000000000000000000000000000000b626c6f636b736361706500000013626c6f636b7363617065406d7761792e696f00000f40426c6f636b73636170654c6162000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149def61665adc4306fec2c5ffb46bfe1dbc7935f493a5c9323520878aad74b5a32276a7a268abdb32": "0x04000000000200000000000000000000000000000000076e616667363900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149e21ce449387a9e130d6f231bc79dc0b10d4b09c38f9deada991ddf9234054b5bf8791a576c18a50": "0x00000000000000000000000000000000000d6320f09fa59e206c2065202100000013637874726f6e636f40676d61696c2e636f6d00000c40636f6c65735f5f626167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149e5b705cbdcc776ab4410d33f13c053dca87be657a0ae3cc87655baf43f7efdd454ff74e3a9d8a2f": "0x0400000000020000000000000000000000000000000014f09f98bb205374616b65204b617420f09f98bb00001340666d6f6e7a613a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149e6f51a51fd3dacb6a7d56a801015edae2ebdeafb80bd4191554965942141024a2014ea2a11c8477": "0x0400000000020000000000000000000000000000000007416e647265690d416e647265692053616e6475000018616e647265692d6d696861696c407061726974792e696f0000000973616e647265696d0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149e8bb46f23ea823584c5a40e2f5f6e6740ad9656099af2946938802c6f42d42dd6d40d7930a20e2b": "0x00000000000000000000000000000000000c7371756972726531646f74000000127777617264363640676d61696c2e636f6d00000f407371756972726531726164696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149ea70d098f006161264319ed6a0895c04112917fc9bdc0771f4a4773aae014a99d25bbe06fa1057a": "0x0401000000020000000000000000000000000000000014f09f909120484f444c2e4641524d20f09f9091001268747470733a2f2f686f646c2e6661726d1640686f646c5f6661726d3a6d61747269782e6f72671068656c6c6f40686f646c2e6661726d00000b40686f646c5f6661726d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149eb58bb1718cc7793e44001b8695199fa100fff9057e6e086eaf496a15bd82b71d2a66ac148fc46a": "0x04030000000200000000000000000000000000000000064a6f6e48510e4a6f6e20486f6c6d71756973740000186a6f6e68716175646974696e6740676d61696c2e636f6d0000076a6f6e5f6871000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149ebab134ded1549916a96314a4b60b23596683eebea29988aec9fae81a7b8d44887fd4c07a70981e": "0x040300000002000000000000000000000000000000000d57696e746572737072696e670000001477696e7465726b736d4070726f746f6e2e6d6500000b4077696e7465726b736d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149ed60c0f92e374f686e4a0805aa9cd02bf99cfe96bb9b84d1727949eca4b740bca8c1701ae931406": "0x0800000000020100000002000000000000000000000000000000000d537469722d4a502d426c75650d537469722d4a502d426c75651568747470733a2f2f737469722e6e6574776f726b0012696e666f40737469722e6e6574776f726b00000e40737469725f6e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149ef4be7403d4d6000c20e1797f6f0e239f7784c6a63a6c319836d9ecb89e1f32d05f0827bb1c7f64": "0x00000000000000000000000000000000001d5a756d69746f7720285370616e697368204e6577736c657474657229001568747470733a2f2f7a756d69746f772e636f6d2f0013686563746f72407a756d69746f772e636f6d000009407a756d69746f77000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f053c2746e722456610a5024c2a5db3d02056d4344d120ec7be283100d71a6715f09275167e4f38": "0x040000000002000000000000000000000000000000000e5374616b65776f726c642e696f001668747470733a2f2f7374616b65776f726c642e696f17407374616b65776f726c643a6d61747269782e6f726713696e666f407374616b65776f726c642e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f1252e4c39b7f7710a3bcbb259f08e2f9bfd79197e1a63ea44f47c7790139dcdc1faa9567130f30": "0x04030000000200000000000000000000000000000000055649585900000017736175726162686772696e6440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f1d97820c576865f25418311f6f3b70b3ebe74fc714aba44e177d104b6c2defb27f9b9936da17b9": "0x040300000002000000000000000000000000000000000d4d6f7361696320436861696e001768747470733a2f2f6d6f73616963636861696e2e696f000000000d406d6f73616963636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f1f101b199c8938e69cc993ca5061e9991dfa141144902af69c09a63077294edbff30f6876acadf": "0x040000000002000000000000000000000000000000001b506f6c6b61646f742048756e6761727920436f6d6d756e697479001568747470733a2f2f72622e67792f3736796f7865001a706f6c6b61646f7468756e676172794070726f746f6e2e6d6500001140506f6c6b61646f7448756e67617279000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f29f67769840c143eeaa160b12b6e319d7f6b2bc34cc2a402dc845cea0bf7b959b6917ef1568078": "0x08000000000201000000020000000000000000000000000000000011646f742e7374616b6572732e7a6f6e6500000011646f74407374616b6572732e7a6f6e65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f3937cb0047bfe065de063644e59d7eb67ac8954c00df696957f7422bd64e57ffe08eff305f4e2b": "0x040300000002000000000000000000000000000000000e43727970746f706f6c6974616e1243727970746f706f6c6974616e204c4c431a68747470733a2f2f63727970746f706f6c6974616e2e636f6d001a636f6e746163744063727970746f706f6c6974616e2e636f6d00000e4043504f6666696369616c7478000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f749b777c55719970584fa4834e2a822dbfeda69c24bbe1ffce611be40ec0fb13dac0ccca6bd077": "0x04000000000200000000000000000000000000000000107461736b6f6f682028506c61736d29000017407461736b5f706c61736d3a6d61747269782e6f7267167461736b6f6f682e757a6940676d61696c2e636f6d000009407461736b6f6f68000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149f8acf5eb9cf86b918bed2613c80d8905c60c4f1b55d262ae0fcebbafbb2b9f60068d26db6801206": "0x00000000000000000000000000000000001c313335204341504954414c20494e434f52504f524154454420303410416e74686f6e7920457566656d696f0f68747470733a2f2f3133352e696f000b616365403133352e696f00000f407265616c4143457566656d696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149fdd3c97960b9cbce12bea7fcd0ef144e784045ab007184e56f1dbea9dde0f496086946206911be9": "0x040300000002000000000000000000000000000000000e4d616e64616c6120436861696e00000015696e666f406d616e64616c61636861696e2e696f00000e404d616e64616c61436861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149fe12e720a82efc1fcdafa5a5ede1d56189d95430ba0125029978fea782a3f5480606ab1a2b1466f": "0x00000000000000000000000000000000000b6c65697465725f534e490e416e64726561204c65697465721c68747470733a2f2f736f7665726569676e6e61747572652e636f6d001b616e6472656140736f7665726569676e6e61747572652e636f6d00000f40616e647265615f6c6569746572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149fef0c4e3ed2df62246fd50494a2ad83cc5a5c8dee9db659ffb78a5b04d271de44f0a86f334adf2f": "0x04030000000200000000000000000000000000000000144c69666520776974686f7574207374726573730e4d617274696e6120476c69626f0000186d617274696e612e676c69626f407961686f6f2e636f6d00000e40476c69626f4d617274696e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab87047149ffb07437f7fb055b4351de5a0c28c5d9183126191dfbe2a0a9a709988e37727ec5d41594c17ab59": "0x00000000000000000000000000000000000850617274796679001768747470733a2f2f7777772e706172747966792e65750010696e666f40706172747966792e6575000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a026c6eb8dc072361858ef0a9f0778513333b5d761cd65e3e3e8fcc58c980fa2c4efe9ed03382c7b": "0x00000000000000000000000000000000000b5468656f20444f542031001d68747470733a2f2f7777772e7468656f6a616d696c6c65722e636f6d000000000e407468656f6a616d696c6c6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a02eb03d19a027d89608a774c479dd1908bb33e1f18529418c3b6d5e19f956887f892ca2c0902237": "0x040300000002000000000000000000000000000000000b4f4720547261636b65720000001763687269735f7061703840686f746d61696c2e636f6d00000c406f675f747261636b6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a0425165102d0e25091bb84ac5b08adf128e855e1cb079ed594be42af19d09d680dae982ac209ffb": "0x040000000002000000000000000000000000000000000c48616e647943727970746f001768747470733a2f2f68616e647963727970746f2e696f184068616e647963727970746f3a6d61747269782e6f726714696e666f4068616e647963727970746f2e696f00000d4048616e647963727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a04f3d43f3e99aad8c00226393a2a05d5d65bf7590e3c091feb897f8303a7de52cd637106dee2b37": "0x040300000002000000000000000000000000000000000b7068696c6f6e6961726513547567756c6475722042616967616c6d616100001474676c64723035313140676d61696c2e636f6d000010456c696f74426c6f636b466f726765000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a06e6b0fa55b7aa4d00e1d7c3523a41757d5698f367496356c8c7c3613f3ca796feb3491899a7b16": "0x040300000002000000000000000000000000000000000c446f7420416d706c6966790e416b65657261204d634361696e0000166b657261646d636361696e407961686f6f2e636f6d00000c40446f74416d706c696679000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a07b7c28fde24902742a3196b00c55823f0923395fc97bbba54268dfb0c04a22eb014dcf7afd2465": "0x0403000000020000000000000000000000000000000019496e66696e6974792057616c6c6574204f6666696369616c0000001a706172746e657240696e66696e69747977616c6c65742e696f00001040496e66696e69747977414c4c4554000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a097d201c62d3578f486ec0728d4c1ce1b6dbca881396f3a3bb9f6e890572a400d3064423f889747": "0x0000000000000000000000000000000000135761726c6f636b456e74657270726973657300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a09af68755800aad94ef44028b5c2649905e23e0abe33d4542688a2ed40bcc0f169f0d535816f43e": "0x0000000000000000000000000000000000094e656f4e756d6973001668747470733a2f2f6e656f6e756d69732e636f6d2f0012696e666f406e656f6e756d69732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a09f49890c6bdef1acbfbc894060d93d772850a601b3f4b69d02c8026b2e7d99433b4067feabeb29": "0x040000000002000000000000000000000000000000000f4a756c69616e6120436162657a610000001b6a756c69616e61636162657a61407961686f6f2e636f6d2e6272000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a0a010fabd2edd968a59a7a725d58dd2a2e3599dd3195c72dba5c8a6f701543eb9aaec7712dc137b": "0x040300000002000000000000000000000000000000000d42697363686f66665f534e491c536f7665726569676e204e617475726520496e69746961746976651d68747470733a2f2f736f7665726569676e6e61747572652e636f6d2f001e636174686572696e6540736f7665726569676e6e61747572652e636f6d00000f406361745f696e5f6265726c696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a0b5a3940af12c68a3483f31027939520c2bf25b1c7b9c495a442dadc10c393336d5a33951af31c8": "0x0400000000020000000000000000000000000000000012646563656e74657265642e73747564696f0000001a6f70656e676f7640646563656e74657265642e73747564696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a0b881b0063a363a02bf32e061073c44300056b416cd66a4fde1e6c120dbc0089bb65134f5693a3b": "0x040000000002000000000000000000000000000000000a6d7564646c6562656500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a107a21bb039f18f3b746c85a1ee00a6b0db9065182d8787c587cf843018c421a095a18b137828e1": "0x00000000000000000000000000000000000e4566696e697479202845464929084566696e6974791468747470733a2f2f6566696e6974792e696f2f000000000740656e6a696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a109a005bbf30981660ee2e14416b8a688b7de8db55c6dd3a2955ade58adf88156156969f584851a": "0x0000000000000000000000000000000000086a61636b6f6f6e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a11241f2be748c8c5a56c4e36507ff2f3efe7796aade67c1e62c5c013d88f7e9f9452ae9d1e7a41e": "0x0000000000000000000000000000000000064f7361617400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a1139026a8f4e1487447aeb48d61f3ecfcd98a44cf81cedafe80db40a95f80671b01e7c0fa531327": "0x040000000002000000000000000000000000000000001df09f8cb2f09f8cb3506c616e7420412054726565f09f8cb3f09f8cb200001940706c616e742d612d747265653a6d61747269782e6f72670f6c6a7564766140747574612e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a11a320b9a8feb01f857311106c8d7b0daf6e096db9a0d759b52403e439ab23fd6559780a8b1c803": "0x04000000000200000000000000000000000000000000095374616d70656465000000197374616d7065646563727970746f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a13589ec6bd328c6beec9afdb165a47264ed88e3fcc907da93142ed4e0578578fa44ab2cbb14170e": "0x040300000002000000000000000000000000000000000e4b796c69782046696e616e63650f4b796c6978204c616273204c4c43000013696e666f406b796c69782e66696e616e636500000d4b796c697846696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a16e9742ca98244e0cd1574cf7fc649a8571d82427b42732e83bcd62f0e3192e92f202ca06f0d53c": "0x040100000002000000000000000000000000000000000662656b6b610d41796f6d6964652042616a6f0000196f6c7577617368696e6162616a6f40676d61696c2e636f6d00000e4061796f6d6964655f62616a6f000862656b6b6b616100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a17e0d5970ac01707fceddeeb78dc1b3c9b8fff33b20fe9f7600edc6eaf21c8aedcd2451301492f3": "0x00000000000000000000000000000000000c526567656e63792d3031361757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a19b37e844707d72307183930b2264c5165f4a210a99520c5f1672b0413d57769fabc19e6866fb25": "0x0400000000020000000000000000000000000000000006537a65676f0d53657267656a2053616b616300001773616b6163737a657267656a40676d61696c2e636f6d00000d4053616b616353657267656a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a19bbfd9c78f6c5fba9db007fd692b3d1aa851ebc27e880f6f5848be07aa84cd16862c4ad3d86e1f": "0x04010000000200000000000000000000000000000000096d696b6562206364000000136d696b654063756c74757265646f742e696f00000e406d696b6562333030306e7963000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a1c377baa224441cfe5d84e3593dcbacb0a489b98a8be3d9e68af5d38dde584c93689e7732c7d40e": "0x0000000000000000000000000000000000084a656473616461084a6564736164611368747470733a2f2f6a6564736164612e696f00176a6564736164612e696f406f75746c6f6f6b2e636f6d00000c406a6564736164612e696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a20a8de9dde43fecb463a68a6b0a2d857dd0b11702d1d6a3b1b07ec76fbabaf807fdb545d62c9cde": "0x04030000000200000000000000000000000000000000054970706f134e677579656e2054686169205068756f6e67000017746861697068756f6e676e3140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a20d0b846e3d907e00555ee596210f641d2d48b9a1e2b258aead3fe8de4e973bcaf5f24674044367": "0x040000000002000000000000000000000000000000000842696754756e610000144074756e616269673a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a215c23d3f30e28acc4fac060bf7e92c94836df38993b1851e3c2a9728335340fff42ded89ea2326": "0x040300000002000000000000000000000000000000001e416e64726561202d2048656164206f662033546563682053747564696f10416e647265612056656e6472616d6500001d6465762e616e6472656176656e6472616d6540676d61696c2e636f6d00000e4076656e6472616d655f616e64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a21fc86d22b382fcc8f54a0dcd5310e3d4d099ab7972a5fb6ca284666651d4302459c92de4efaf2a": "0x040300000002000000000000000000000000000000001441637572617374204173736f63696174696f6e0000000f686940616375726173742e636f6d00000841637572617374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a250353c7dc8311b99f2f82db75c3af6484741f264039ff2e24e4ae7096516dae4ca77efd0da2d13": "0x00000000000000000000000000000000000c526567656e63792d3030361757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a30ff791ba0dd28618c7f5a8530d6aafc1b191156294a9e27bb674128607896f3fd5914282fb196d": "0x04010000000200000000000000000000000000000000046b6d6c104b616d696c2053616c616b686965761168747470733a2f2f716472766d2e696f14406b616d696c73613a6d61747269782e6f72670b6b40716472766d2e696f00000c406b616d696c5f61626979000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a337657934f576d5e2d126c3dffe301385f3d6da21756147d8f58040a9021e4196a89fffa2800a48": "0x0400000000020000000000000000000000000000000003416c00001a40616c6973746169723a776562332e666f756e646174696f6e00000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a3b0c3cd1f399efd62f1e96782eec4d59ff854b9fa623984b80decebea69292fa92659093421e120": "0x04030000000200000000000000000000000000000000084b687564656a610d4b687564656a61204b68616e00001c6b687564656a615f7368616862617a40686f746d61696c2e636f6d00000a404b4b687564656a61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a3e66c1866cb9999f4fa98b7ec05e11f0f3c5cef7a750e22acccd75cefcfa72c00b5af6346e2e47a": "0x04030000000200000000000000000000000000000000086b6f7065626f79124c6f72656e7a6f2047696f76656e616c690000126b6f7065626f7940676d61696c2e636f6d0000086b6f7065626f79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a3f67b4c0527d154dc3aee12519c19be02628b0f808bddda9aed564027ad809cd392c13e9b924b65": "0x040000000002000000000000000000000000000000000d504f4c4b414348552e434f4d001568747470733a2f2f706f6c6b616368752e636f6d1440736f6e676875613a6d61747269782e6f72671368656c6c6f40706f6c6b616368752e636f6d00000b40706f6c6b615f636875000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a3f97862b7d49be68cd2c9b46e07c20f2263540b993c2b25b3cb995ab873314ac10e8d5f1f50a55e": "0x04010000000200000000000000000000000000000000154554484943414c2056414c494441544f52532030134554484943414c2056414c494441544f525321687474703a2f2f7777772e6574686963616c76616c696461746f72732e636f6d17406576616c7561746f72733a6d61747269782e6f72671d6574686963616c2e76616c696461746f727340676d61696c2e636f6d00000d404556616c696461746f7273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a402b003cd008ec5ba38a1142964f0e049d842c9a932ce34f21017dd4e674aeb8a5bd67553f1846c": "0x000000000000000000000000000000000008426966726f737408426966726f73741368747470733a2f2f626966726f73742e696f001168656c6c6f40626966726f73742e696f00000940426966726f7374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a40acfeba897a3054831c976778f05db5b115be6b85ed7ba7099de3ec01b096c8a91d6074daf2746": "0x0400000000020000000000000000000000000000000004414d4200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a42915ffbd1e4d678e156836bd7dc0639ea54540eb6ec55aec2a3793876208bf5d71ff89eb746a07": "0x04030000000200000000000000000000000000000000064d6172696f124d6172696f20416c74656e6275726765720000166d6172696f40616c74656e6275726765722e6e6574000011404d6172696f34416c74656e62757267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a4298ccda952a9cf843ed05213492579c701c1cbca6f2d9622be202d81f305d01d37fbedbc99046d": "0x00000000000000000000000000000000000856696e63656e740000184076696e63656e746368616e3a6d61747269782e6f72671976696e63656e746368616e2e637640676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a47a74229619b37bfa515f4f9d5b9394fe8e5a71db0f44fd1c4dbbb569b6205ec5af981cd3e0794e": "0x00000000000000000000000000000000000e446f745f69735f467574757265064d6178204900001774686563727970746f6d617840676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a47a994958e0ce59ae58ba526977ac8c888aaec71da2be93459c2c6ee4a33f0881da7bd585b43a66": "0x040000000002000000000000000000000000000000000f546865204b7573616d617269616e00000016686579407468656b7573616d617269616e2e78797a00000f405468654b7573616d617269616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a490d8d4ffa73e2c52659f398c17705033d14b42950667700d2e50dcbf1cad45881fba6934fe1361": "0x040000000002000000000000000000000000000000000b426972646f20f09f90a50000000f697473626972646f40706d2e6d6500000b40697473626972646f5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a4a63b3ca43f4645fae67a2277ba75c89fff533a2cd9574791255b0dedb578234bca6935a6bc6c2f": "0x040300000002000000000000000000000000000000000e4d616e7461204e6574776f726b00000016636861726c6965406d616e74612e6e6574776f726b00000e404d616e74614e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a4e8003fe2fb58faba58db6c7bfc75aa2b8ec1c9b2624172c81f6d2391180047091dcd0cea5ec45c": "0x04010000000200000000000000000000000000000000054a4f49450b52454e4a4945204355491068747470733a2f2f6a6f69652e696f14406a6f69656375693a6d61747269782e6f72670d6a6f6965634071712e636f6d000009404a6f6965437569000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a4ed3b905ddf8085bee2c0254a1998a65fc2787a82cbecdca2c0a675be63ae9c5148e32ae753d01f": "0x0400000000020000000000000000000000000000000015546865204b757320444f542044656c656761746500000016686579407468656b7573616d617269616e2e78797a00000f405468654b7573616d617269616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a53864ffd30a765388d1505492274985d6049cfae833ce8ce11597aca19d0f06a29ddb0a7a5fb97e": "0x040300000002000000000000000000000000000000000756616d7073790000000000000c4076616d70737966656172000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a551a248cffb7fab926d3318e308ddc7abc0757edbe7661e6aa17f8e269585ca53556423382b267f": "0x00000000000000000000000000000000000e4e6f74426974636f696e43454f0c5365616e204c6179746f6e001a406e6f74626974636f696e63656f3a6d61747269782e6f7267166c696e6b6c6179746f6e3240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a56d11c227ad244b78e4c82b1882d5cfa1d4b47a04b8906c00110e28b764b92f674b26e02061de7e": "0x04010000000200000000000000000000000000000000114b52414e412e5620f09f9a80f09f8c9900001b406b72616e615f76656e74757265733a6d61747269782e6f726717737570706f7274406b72616e612e76656e7475726573000010406b72616e615f76656e7475726573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a59acabf7cc5c2db3a0b67c6e4b35133a18ff9c3b56d6cd28662f9e47f38afbfc508543087966870": "0x040100000002000000000000000000000000000000000c43525950544f4e495441530000001e63727970746f6e697461732e6365727665726140676d61696c2e636f6d00000e4063727970746f6e697461735f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a5afff021978b2b7b6c683f2280b9cb98172008de3fd6d0ef5e40b746bd2f58424850e48bc33233c": "0x040300000002000000000000000000000000000000000352341244616e69656c20526976617320536f746f00001464346e6e792e736b7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a5e1ae44678815b9744d9a778b5c53b54eb743dd93cc90079261a6e7fdffd8798e6406817d125d7b": "0x040000000002000000000000000000000000000000001144657574736368652054656c656b6f6d1a44657574736368652054656c656b6f6d204d4d5320476d62481968747470733a2f2f7777772e74656c656b6f6d2e636f6d2f001a7374616b696e6740742d73797374656d732d6d6d732e636f6d000010406d6d735f426c6f636b636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a6391f7854f254e8164c165c3dd34122f5005b617dc4941fed61fdfd1806ac31176c9a28d290ea06": "0x040000000002000000000000000000000000000000000b375f5468756e6465727300001640377468756e646572733a6d61747269782e6f726716375468756e64657273323140676d61696c2e636f6d00000c40375468756e6465727332000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a6433a6dcb5d8737833b5ca84aebe493b7e9bcab4e1b1cfd6d2eca6246dc8ed68fa9a31b87ae7166": "0x000000000000000000000000000000000012446966666572656e7469616c204c616273002068747470733a2f2f646966666572656e7469616c2e746563686e6f6c6f6779002164656c656761746540646966666572656e7469616c2e746563686e6f6c6f6779000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a687dc3f738f7410389373f82baeae3f3cf28a85284180ee443f41220de6901b5df8dc270e635215": "0x0403000000020000000000000000000000000000000008616476657269630f41647665726c6976652053726c73000010696e666f4061647665722e6c69766500000d61647665726c69766573726c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a693de5eabea317ab630005f93d977d7f3e58be6c8027af52620da1b35e7ad4b7c000ff303222f15": "0x040300000002000000000000000000000000000000000a4175646961726d6973114175646961726d6973204761726369610000156175646961726d69736740676d61696c2e636f6d00000a636173695f61756469000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a6eb394e364b8f9c7682e4e399a94b0dfc4a9bc476e0bc69f25413687d2b1c29bb7139dcc8e8714a": "0x0400000000020000000000000000000000000000000012537465616b20e299a8204e6f6f646c657300001e40737465616b5f616e645f6e6f6f646c65733a6d61747269782e6f72671a737465616b616e646e6f6f646c657340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a76c3d2bf5e8dd46d223e97cfb5260aa90a5f3cf5cb993f2658f07202847da92c712623e6c5da31d": "0x040000000002000000000000000000000000000000000a5374617475746f7279000000196d697368616b656c6d616e37373740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a7ad5ea2e1e25da12ab2efc45e91ccb7b8e116388d12dd3be3a57d65bf8c0e6e9f70fd17685d8f14": "0x040000000002000000000000000000000000000000001cf09f87a8f09f87adf09f8f94205377697373204d6f756e7461696e0000001370657465722e63727970746f40706d2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a7b516d797914c7022eac0df731345052fd1e5b11e2b6d7fba33192395c37dc98ecda764fac0a05d": "0x00000000000000000000000000000000000f4b65726e656c4b656e6e657468470000001c7a68656e68616f2e676f6840636f6d702e6e75732e6564752e7367000010404b65726e656c4b656e6e657468470d6461726b61727469737472790000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a7c46d5435a1e2d86ad3c3fdb53ec38b9f865b8e2a836fbac2da234f4e72d660c9935b42a3e4173f": "0x04030000000200000000000000000000000000000000194d6f6565696e76657374207c2054656163684d6544654669001b68747470733a2f2f7777772e74656163686d65646566692e64650014696e666f4074656163686d65646566692e646500000c406d6f6565696e76657374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a88c5f2dbe33d41afa9773cfd85e5d96165adec4ce7cc9265a267a57a241194cc868dbfa7e0c4301": "0x04000000000200000000000000000000000000000000084d61635a616d500000001763726970746f6d61637a616d40676d61696c2e636f6d00000f4043726970746f6d61637a616d31000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a8a3ea9a9a3cbf30d21eb80113b2f57759d263c0eb1f02291dbc81a41d5a98029ad55f941eea3153": "0x040000000002000000000000000000000000000000000d77656233616c6572742e696f001668747470733a2f2f77656233616c6572742e696f2f164077656233616c6572743a6d61747269782e6f726712696e666f4077656233616c6572742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a8aceb78297feebd48c689eebc3c38ac671e2d6604d6490c7ad4261b2c157af30443bc297784795a": "0x040300000002000000000000000000000000000000000b50726f6d65746865757313426f6c7577617469666520506f706f6f6c610000146f6c616f79656a6e7240676d61696c2e636f6d0000114049616d5f5f50726f6d657468657573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a8d8c5df784c714204fb9dcaa194ca3f66a6c695aa7cb84c07bb5706202e5891d46cf6087422e068": "0x00000000000000000000000000000000001d426c6f636b636861696e20547261696e696e6720416c6c69616e636500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a8f0bd6de05e2315fa2847dce28d6741e63a14509aa8aba663935f6d257b49434b202a026c672966": "0x040100000002000000000000000000000000000000000562656172096265726e6172646f1768747470733a2f2f6269742e6c792f334749576265421b406265726e6172646f3a6d61747269782e7061726974792e696f1a6265726e6172646f617261756a6f7240676d61696c2e636f6d00000d406265726e6172727272646f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a91237ad3fc3e223ae0d1db9082bdce75480ee80c3bf3c6496de1ef8171951de2edfe49fdbe30a67": "0x040000000002000000000000000000000000000000000c477233336e4861747433520000001b477233336e4861747433524070726f746f6e6d61696c2e636f6d00000d40477233336e486174743352000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a91aecbe4d3bb95ad3816c3f7974b12327fb40c8ec5dbc5b79ab47f114838fdac54ddc5f7e890a3c": "0x00000000000000000000000000000000001e4d75736963204576656e747320496e6974696174697665204d756c74690000001b68656c6c6f40706f6c6b61646f746d757369632e6576656e747300001040444f544d757369634576656e7473000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a93c6e207f351cebc5c184f0565e2192d6aedae584ee736cef875f0e1c558ee3ede26869acd0b4d6": "0x0400000000020000000000000000000000000000000013f09f8c8c204e6f766173616d6120f09f8c8c164e6f766173616d6120546563686e6f6c6f676965731568747470733a2f2f6e6f766173616d612e696f2f1140646179373a6d61747269782e6f726714616e746f6e406e6f766177616c6c65742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a957c1bfaa0ef8df8692dce19b16ed49226830ab9d2bab753c1118e797bf69fe63e00eceabd91278": "0x040000000002000000000000000000000000000000000a426c6f636b4465657012426c6f636b44656570204c61627320554700174067617574616d646565703a6d61747269782e6f72671467617574616d40626c6f636b646565702e696f00000d403078426c6f636b44656570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a9b541eb27d45610a4f59749234ff94a7325d0770303f2dd834b6e82fa91a7f7f6afe41bc6ee473f": "0x04000000000200000000000000000000000000000000104d61726b65744163726f73732d424200001c406d61726b65746163726f73735f62623a6d61747269782e6f7267196d61726b65746163726f7373626240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a9d8946d2ec5efc6f618b6cccdab512073431509d2c2d4cc92d188c18b6bb968a0869ad0df4ca05b": "0x040300000002000000000000000000000000000000000844614b616d7065144368726973746f7068204b616d70697473636800001a6368726973746f70684073637974616c652e6469676974616c00000844614b616d7065000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a9d916ee238e56e058e0e1940ab2089ce4f65dc63abad1a6b654561a9a0b09fe5cc679f0ded3fc28": "0x040000000002000000000000000000000000000000000a4e654e6120f09f8cbb000016406e616d6574616b656e3a6d61747269782e6f7267196d796d696e647365746f6e796f7540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a9ef632ace16178262fda88d72053d9381fce1d6fa240c5264be8f884995f6f6dc8fd6b76b41fe19": "0x04030000000200000000000000000000000000000000084465656c616273084465656c61627300001364616e69656c406465656c6162732e78797a00000b6465656c61627378797a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714a9f08d3911f890e17a0625bffca33ce094f74f399580b16674ae3e0cc8ef259cde618e60e927ae53": "0x040000000002000000000000000000000000000000000d4b525950544f53434841494e0000000000000e404b727970746f73436861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aa51aec5596c16c9be84f63b9e30f438711f49b4a2f3e251c541f9a6e43b0e9df4f64e8394ba517e": "0x04000000000200000000000000000000000000000000075374616b696e000014406564776172646c3a6d61747269782e6f72671168656c6c6f407374616b696e2e636f6d000010405374616b696e4f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aad0604ad649cd85b6332bfd1e18c86739c3c5e7e76c95e7b0e95339005066cd34d89b842ca57d69": "0x0000000000000000000000000000000000064d617820470000000000000d40477261766974794d617878000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab17ce0890ca2cdce229054651147bc5f6f0ab32ca19ce2c679aa663c212dac43c84ed2c3e494d27": "0x0800000000020300000002000000000000000000000000000000000a416c6578204265616e10416c6578204265616e2043617361731c68747470733a2f2f6769746875622e636f6d2f416c657844313053001d616c656a616e64726f6265616e636173617340676d61696c2e636f6d00000b404265616e5f44313053000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab3f37c5fb7156fd86d918a899c95866c7a826e103307a9eb27318642550a300d56838d08c93e653": "0x00000000000000000000000000000000000c464f5552424c4f434b533300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab53275528e71c4a1fd7775fc942283e61155bb5aa033ebd62e76cdc83a9d4b7dc4c611d7082da80": "0x04000000000200000000000000000000000000000000064f4e595a45001a68747470733a2f2f7777772e6f6e797a652e636f6d2f656e2f0010686f776479406f6e797a652e636f6d000010404f6e797a655f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab5eb6225eb473c4c4b00316a66db95fe01dae8970cad009688713c1a4432c2af716ddd364535008": "0x00000000000000000000000000000000000a564c414449534c415600000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab6dc514ec367fe662f93efa125cfb7f0ec984625f8fc53cdc2f8aa936fc7d1b846831d132e4f701": "0x04000000000200000000000000000000000000000000105374616b65f09fa7b24d61676e6574001c68747470733a2f2f7777772e7374616b656d61676e65742e636f6d18407374616b656d61676e65743a6d61747269782e6f726715696e666f407374616b656d61676e65742e636f6d00000d407374616b656d61676e6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab6e86b3ee5baa49d26a9a27ddedcc27b12275126b023f4cd1d0bc3eb533c220a6584a26b18c2774": "0x00000000000000000000000000000000000a446f72614861636b730a446f72614861636b731968747470733a2f2f6861636b65726c696e6b2e696f2f656e0014737465766540646f72616861636b732e636f6d00000b40446f72614861636b73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab7e3e98c718729f7a895955042cb3fe863f3564e7b30e9130e37b6d905be11c0cf91064de1cd83a": "0x040000000002000000000000000000000000000000000853544b442e494f000015406672617a7a6c65643a6d61747269782e6f726700000011406672617a7a6c65645f64617a7a6c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ab8afcc57061038068ecba10b973c7673eb761ade1ba23e48d03c35e9f42f80745acfe234565936f": "0x0801000000020300000002000000000000000000000000000000000e4d6f6f6e736f6e67204c616273124d6f6f6e736f6e67204c61627320496e631a68747470733a2f2f6d6f6f6e736f6e676c6162732e636f6d2f0019636f6e74616374406d6f6f6e736f6e676c6162732e636f6d00000f406d6f6f6e736f6e676c6162735f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714abe1d2fca3693953ae931623d3a530f2286c06b91e6f82a09cb757f6cf5b8d3d0f3dcbd60f1ab26b": "0x0400000000020000000000000000000000000000000005626962690000000e74656368406274616e672e636e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714abf0f8ad2f6106869cc09a0521e12de2e2cca2ba86feb5df7506d9f9123e0f2687aadf171a47bc5c": "0x00000000000000000000000000000000000650726f746f1d416c746f726f73204c4c432028206462612050726f746f666972652900001c79756c6979612e6d75726173686b6f40616c746f726f732e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ac05ff7688083e8697b2ad8a1a194bf8104462fc283cfe8ea0cc039eee8ca312cd58abf65a2105f6": "0x04000000000200000000000000000000000000000000094242435f42616c6900001c4062616c695f626c6f636b636861696e3a6d61747269782e6f72671c61646d696e4062616c69626c6f636b636861696e2e63656e74657200001040626c6f636b636861696e62616c69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ac220ad36e69b7cec697d17a1916f9313f9894d1db4016b2e1d64384f1e9cb49a735ea6a86328d01": "0x0403000000020000000000000000000000000000000010416c656a616e64726f5f52304755450a416c656a616e64726f000013616c656a616e64726f4072306775652e696f00000a40616c336d6172745f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ac39f36e309d037db40f4abb8698fdab096b0dcbe258ca86e64cd7cdd21633393b54fd74f22b1818": "0x040300000002000000000000000000000000000000000f4b61726f6c204b6f6b6f737a6b610f4b61726f6c204b6f6b6f737a6b610000146b61726f6c2e6b393140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ac6535d22692ff19365a58294c023e466c88ba2dd910a4a3c622c666c6a0c9f523c13feeef02ec21": "0x00000000000000000000000000000000001c313335204361706974616c20496e636f72706f726174656420303110416e74686f6e7920457566656d696f0f68747470733a2f2f3133352e696f000b616365403133352e696f00000f407265616c4143457566656d696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aca973e143819fc644f6dd8841fc39979ef97aedf99a72c873c44d799938c03d96ef1e1fb2624c14": "0x04030000000200000000000000000000000000000000174f70656e20496d7061637420466f756e646174696f6e1b4f70656e20496d7061637420466f756e646174696f6e2050434300001c68656c6c6f406f70656e696d706163742e666f756e646174696f6e00000c7768657265736164646965000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714acdb8f7d99b9b4f82cd49434353de1d51598b44df15fcfed1e26224e055923acc9f9af881dc31d5a": "0x040100000002000000000000000000000000000000000843757272656e741546696e436f2053657276696365732c20496e632e1568747470733a2f2f63757272656e742e636f6d2f1b4063757272656e742d63727970746f3a6d61747269782e6f72671363727970746f4063757272656e742e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ad18028edc6538a02cb70c06950d8d61663a960c7e6664203696390388882bd305600fc1aedf520f": "0x00000000000000000000000000000000000c43727970746f6e617574730000001a636f6e746163744063727970746f6e617574732e73706163650000114043727970746f6e6175747353686f77000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ad2b158f9740a61618e66fcce7649125ff39ccf9f6ab0b1b88d1ec6b7bbd6824d04879a669589026": "0x040300000002000000000000000000000000000000000747617574616d0f47617574616d204468616d656a6100001467617574616d40626c6f636b646565702e696f00000e67617574616d6468616d656a61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ad3e18f67bdae596e8d0e24aa19d8b502a4b778f6172d6ecdc11bd3b9d320c70cec262e291d4a540": "0x0000000000000000000000000000000000055f5f5f5f0000001368656c6c6f4077656274687265652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ad78c5b50e5a1535aad6496e2b96928ca236cb15b3ec0c43305b6edc3418296a4f01812378996a40": "0x0000000000000000000000000000000000054b6f656e0d4b6f656e20437579706572730000156f7074696d6f766540686f746d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ad874555459d7afb60621cb801a995bd99811fb64c3736affcf9ec823badb45c5ee6a812e292ca6d": "0x0000000000000000000000000000000000096a7573746475646500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ada7fdb39f37a1913c8664b0c41d35ec1c68c290d3b2a4e6c323e3c6199a1a3d5a301ae134a20344": "0x00000000000000000000000000000000000b746869636b34726573740a4a696e68616e20496d0000146a696e68616e2e696d40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714adbd010c539216a1b8fecc72fb024b6102c53a3924e8b7e2c163cfe6e5b84299c4481efa0580694c": "0x0401000000020000000000000000000000000000000006696c67696f001468747470733a2f2f706f6f6c67696f2e636f6d1240696c67696f3a6d61747269782e6f726712696c67696f40706f6f6c67696f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714adc47ca95984db1b2cae6f34fcc3b96db7ffcd6ec5f6a91df93adbe09bcdc2adaf6bb1b8658ed05c": "0x040300000002000000000000000000000000000000000a4173796e63476f6b750000001a7961796f696b7573616d617269616e40676d61696c2e636f6d0000083078676f6b755f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae10508827bed8b3385a3a535bf10808c4d6b1609d36042d9b867bb9446b03f4e6503245dc0c9e40": "0x00000000000000000000000000000000000a5869614d69506f6f6c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae3f2963b6c6f88ad4b61f6445b374d12ae0c94fa138ab0241beb18edb8a270118ad474b42fc062d": "0x040300000002000000000000000000000000000000000a796a686d656c6f6479094a696168616f5965000017796a6834363534303236333440676d61696c2e636f6d00000a796a686d656c6f6479000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae60b338fc29997e986a4fdcd53d0e438f9694c9a6bb76665bc50acf76180049117caf3ca9bbcc6a": "0x040000000002000000000000000000000000000000000f747572626f666c616b65732e696f001768747470733a2f2f747572626f666c616b65732e696f1840747572626f666c616b65733a6d61747269782e6f726717737570706f727440747572626f666c616b65732e696f00000d40747572626f666c616b6573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae6704a5589ed96274b1b6289e6796fc444ca7848a000ff1033fdb8aa867891a3b6a3580d312af58": "0x0000000000000000000000000000000000094d6f6f6e204d616e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae820f0cf7b3fc26522523da8f16bc0b51cfd6e8b113f65f6be19f19681d5d6269cb980f9582c334": "0x0400000000020000000000000000000000000000000007746f6d616b6100001540746f6d616b6131373a6d61747269782e6f72671d7069657272652e6b7269656765723137303840676d61696c2e636f6d00000007746f6d616b610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ae92f7865e89af5b3881c20170b3cfadb60b8455333d313ef17296f86321ef1c7b3a72e10693a00b": "0x040300000002000000000000000000000000000000000a4d61676e6174726f6e13436c696e746f6e204a616d6573205377616e000017636c696e746f6e2e7377616e40676d61696c2e636f6d0000104070697a7a61333134313539323635000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aea3907ec456c507e23cf25bdabd9cf5532e11922e9c4d5b8188ded994a0c5647f16d5e325624158": "0x040300000002000000000000000000000000000000000c426c61636b4d696b4d616b1443687269737469616e204e746f75746f756d6500001e63687269737469616e2e6e746f75746f756d6540676d61696c2e636f6d00000b40546f75746f756d654e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aea617318e829b5f12ae4cc150cef3f9e224d7b6cb10383e91a355a9c9052e21c1c638dbebab9921": "0x00000000000000000000000000000000001457696c6c69616d207c20506172617665727365000016407265706c67686f73743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aedcaf5c1d328d6a4a5e6693907b2e0647ddb0706e89f7227064060c1de7d10cadee84da22cd8360": "0x04030000000200000000000000000000000000000000086477756c6636390d446f75676c6173204b75686e0000176b75686e2e6f6e2e6b61736840676d61696c2e636f6d00000e406b75686e5f6f6e5f6b617368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714aefad5055f10fa735e1d3caa2ac17c3d9376b773bd112e70edbeccef39789d70d41f9dc468181a01": "0x000000000000000000000000000000000021506f6c6b64744d6f6f6e426d506172616368417563437277644c6e474c494d520000001d696e74656e74696f6e323032354070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714af2fd699547c9f4bb4fd1795608e7424be43ddfaa50cf1f80621630df192fd4f9f02fa0e40308a7f": "0x0400000000020000000000000000000000000000000011506f6c6b617374617274657220526561000013407265615f63683a6d61747269782e6f72671472656173636865676740676d61696c2e636f6d000008407265615f6368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714af9ae6e4f434181d9c322cfa42b80ffb1fa0a096ffbbe08ff44423ea7e6626183ba14bfb20c98c53": "0x040100000002000000000000000000000000000000000c456e73526174696f6e6973001c68747470733a2f2f726f626f6e6f6d6963732e6e6574776f726b2f1840656e73726174696f6e69733a6d61747269782e6f7267166c7340726f626f6e6f6d6963732e6e6574776f726b00000d40456e73526174696f6e6973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714af9bf5521f86ae142ea24923f4561c7393dfee80dbf7d069efda507c76dbc2a160a6f02021ae017f": "0x00000000000000000000000000000000000c54696d204a616e7373656e1f54696d2048656e72696375732057696c68656c6d7573204a616e7373656e2168747470733a2f2f7777772e6c696e6b6564696e2e636f6d2f696e2f74696d6a00177468776a616e7373656e383940676d61696c2e636f6d00000e407468776a616e7373656e3839000f74696d6a616e7373656e3139383900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714afa63c93073adc978e06bfc989509d6d625c085209adb405867bdbe4f167ded7e61ec126c683165d": "0x04000000000200000000000000000000000000000000135361736861207c2046656c6c6f77736869700000000d68694073617368612e696e6b0000000b4061677279617a6e6f760000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714afb2682abe1821512097f59f6298ee6903bf8b0f183a5a2967fa2d790e94d62aab7ee87247dd346d": "0x0403000000020000000000000000000000000000000017416268696a616e61204167756e672052616d616e646117416268696a616e61204167756e672052616d616e646100001a616268696a616e6172616d616e646140676d61696c2e636f6d0000104072616d616e64616268696a616e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714afc50c1d950a2badd46e3e3ed41155f5f6971639b0fe8fb1afb792f9a7aaf267dc4c61693bbe2645": "0x0403000000020000000000000000000000000000000016426c6f636b636861696e204865616468756e746572000000146d2e73686c6179656e40676d61696c2e636f6d00000d626c6f636b636861696e6868000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714afdda45f48b9d6ccf0a0ba50ffb1d6b6af46b0ae93a21f6943ffe046c9e0423e7c603c46c6696f16": "0x00000000000000000000000000000000000c444f54205374616b696e670000001a6d6174746572686f726e4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b045191cd50fbf997059b7d9ad6e9f5bab40385874989cd04aabbe821094b7e45b5e4de5ecf2bf4a": "0x040100000002000000000000000000000000000000000e416e736f6e202620466162696f16416e736f6e204c61752c20466162696f204c616d611668747470733a2f2f616e736f6e2d6661622e696f2f1d23416e736f6e26466162696f3a776562332e666f756e646174696f6e16616e736f6e40776562332e666f756e646174696f6e00000c40416e736f6e466162696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b07ceda0d965ecfb8233864aaf64f98f44f718a1ea60ebffdd0d4997de67f4b5e7f3b01f1d712d1e": "0x04030000000200000000000000000000000000000000064446472031000000126a616d65732e77406466672e67726f7570000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b09f0dc1cd5bdd13b0a08173d9322251d85475ae44c1325bfbb0254f20318b0aade97b250af5c010": "0x04010000000200000000000000000000000000000000084d6574686f6435001468747470733a2f2f6d6574686f64352e636f6d0011696e666f406d6574686f64352e636f6d000009406d6574686f6435000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b0a07ed5a19f8b6a90fcde4b37a2b8100dd2dc66cc9e195587e3bf396cb376c4589921d1bcd11905": "0x0000000000000000000000000000000000135354414b454241425920444f54205045525300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b0b594ec0cee6911fb9cdfce8071d94d5226bb1746bcafbd3bff4ef7ca9f923f9ba24d6c501002fb": "0x00000000000000000000000000000000000a4672657175656e637900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b0c28bc153cfcb785e71bc8d34c9270330e524544df34af4113a66bf1a300cfd6e67e6bc522cdd1a": "0x04030000000200000000000000000000000000000000064d6174656a0d4d6174656a2053747275636c00001773747275636c2e6d6174656a40676d61696c2e636f6d0000097363687472756c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b0f623591c049c48d238ccb2dae20c1ebb4ce235085255a5d5d0d7bc55bf8b312fdeabac027daf3c": "0x000000000000000000000000000000000009436861696e494445074b75646f77751568747470733a2f2f636861696e6964652e636f6d00146b75646f406d61747269786c6162732e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b156c95d777eb874c4d118037ecd231792bbc725102956f2f0488cd30ffd46c2f3dd5b1e17502137": "0x04030000000200000000000000000000000000000000074d626c6f636b074d626c6f636b00001576616c696461746f72406d2d626c6f636b2e696f00000f404d626c6f636b636f6d70616e79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b1580a59c1acfdc54421050207b47ba1bddef66d1e1deee5b27d27d7fc526cfd68e4be18a5b9b146": "0x080000000002010000000200000000000000000000000000000000104555534b4f494e2056697a63617961104575736b6f696e2070726f6a6563741168747470733a2f2f6575736b6f2e696e14406575736b6f696e3a6d61747269782e6f72670f6b6169786f406575736b6f2e696e000011404575736b6f696e4f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b168e3b84020d6822dcd0e9ec909fc8e672d8708223330eac4613042b2c63c8d913fc6a12bd99fd8": "0x0400000000020000000000000000000000000000000004524a5f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b18604d7d7a798faa40aa369106391b44027cbfd19b4e8e475971c90f78717f85bb6a5976299567f": "0x04030000000200000000000000000000000000000000094772696d66616365000000126e6f7461746b6940676d61696c2e636f6d000007403162696e31000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b1a455bf3d4031c6b422d3e099417a341702fc9e4dd318da3c2993adcb81a3cf35ba18679724b36e": "0x000000000000000000000000000000000014f09f8c9f20616c6578616e64726120f09f8c9f0000000000000b40616c7868656c6c6572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b216fc8c00c1967038406fc5553270a770f2b9afe29ef48028738645f7bc0f221460634d1a7c9a07": "0x040000000002000000000000000000000000000000001f4d6f6465726174696f6e205465616d20426f756e74792043757261746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b237135b4b47977700321713f671d3c1fb706209062ffd05e74bb4a42470156d8103a25d4dc0201a": "0x04000000000200000000000000000000000000000000064b414e4459124b616d616c6120496d6d6163756c61746500001c696d6d6163756c6174656b616d616c686140676d61696c2e636f6d00000d406b616d616c61496d6d6163000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b23d190eeefbfb6f7a9bd53c257e7c227609b012a33e9e17537cadc7740b22be73883942c673b34f": "0x040300000002000000000000000000000000000000001157656233204173736f63696174696f6e1147656f726765204c6f766567726f766500001968656c6c6f40776562336173736f63696174696f6e2e636f00000f4057334173736f63696174696f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b26d5289874157380c300de9970a72be7155e43892cc29b4d4b4c8a571b61cfd5430a52afa1af85e": "0x0403000000020000000000000000000000000000000006637962696f11446f6d696e6971756520536962657564000011637962696f40686f746d61696c2e667200000940446f6d69536962000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b27baa39147ef36e8ae3ad2c81ef018e08ea05d0422b9cf276d6c909936b04105c1686cb3eb2fd0a": "0x0400000000020000000000000000000000000000000014506f6c6b61646f74205068696c6f736f70687900002040706f6c6b61646f745f7068696c6f736f7068793a6d61747269782e6f72671f636f6e7461637440706f6c6b61646f747068696c6f736f7068792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b2867f14046b21d05a33766207d51925e4b9a2302870bf737305cddd5bb2df2dffa379963e586771": "0x040100000002000000000000000000000000000000000b5374616b656454656368001868747470733a2f2f7777772e7374616b65642e746563681340766564646f6f3a6d61747269782e6f72671b7374616b65642e746563684070726f746f6e6d61696c2e636f6d00000c405374616b656454656368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b2c78530b4a796f2f8f0244b95932b7a67caffd31de91edc5cfb3aa2a13f6199f127ce51c558204a": "0x00000000000000000000000000000000000b4441524b464f5245535400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b2d135d5db3b036bce4761ea5d8d29dd92a78dc606246d8146320a5e9292de240ab15f60c7802e4a": "0x00000000000000000000000000000000000a534e5a506f6f6c2d3108534e5a506f6f6c1768747470733a2f2f736e7a686f6c64696e672e636f6d0012686940736e7a686f6c64696e672e636f6d00000c40736e7a686f6c64696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b2fb008da08ac54bf6dddfb2f535dd62fdac8b70b241d590e7838c5f553e66cf8bbbafd47fce817b": "0x040300000002000000000000000000000000000000000b4c61726b2044617669730b4c61726b20446176697300001874686563727970746f6c61726b40676d61696c2e636f6d00000f4074686563727970746f6c61726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b340199e34eab193aa612c6fb0748838d721b854a70cb1838cc4fc0814e80d4785dab72125e8a010": "0x0000000000000000000000000000000000086e616e6173736511414e4153534520454c2048414e414e4900001a656c68616e616e692e616e6173736540676d61696c2e636f6d00000000056136653700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b3b2f5054ad51dabe830cd17659a15933def85ed0afa8f681e5db64551c1ea411b5e9be3e7349e1c": "0x040300000002000000000000000000000000000000000e57414c4c4554434f4e4e4543540e57616c6c6574436f6e6e6563740000176a6573734077616c6c6574636f6e6e6563742e636f6d00000e77616c6c6574636f6e6e656374000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b3b4ecc4022f0e1630a3eb5333cc487d3754d4c76346343611dfbfb5eb55c15045daae38282a3939": "0x0403000000020000000000000000000000000000000005526f77690f526f7561726b204c65657264616d000019526f77695f6c65657264616d40686f746d61696c2e636f6d00000c4c65657264616d526f7769000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b3d2b9874fe0df30cc7a6b245f0617fa48c27e56589cd6954c0448ced7c54df2325b007ee5b4ca02": "0x0403000000020000000000000000000000000000000007636f6e7232640b4a6565796f6e6720556d000011636f6e72326440676d61696c2e636f6d000007636f6e723264000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b3dac7c4c99b7c0d8e851ed992228f2268ee8c614fe6075d3800060ae14098e0309413a0a81c4470": "0x040000000002000000000000000000000000000000000b427279616e204368656e00001340786c6368656e3a6d61747269782e6f726714627279616e406163616c612e6e6574776f726b00000d4058696c69616e674368656e04786c630000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b409b598d1b08171e0a38871f4a1941fdd3af5a049c463a4cec1df86f594c61dda778d07b4693c7a": "0x0000000000000000000000000000000000194d4554415350414e2028706f6c6b61646f7420706f6f6c290d6d6574617370616e206c746400000000000d406d6574617370616e5f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b43789f78727cee3c885a011dbc63183416fa77f78a967ad0ffbbbb62e444e9eb490abd2fc67d326": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f331042494e414e43455f5354414b455f33000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b471bc360e5a3e9548020d0712411b7ebf7f757f9f0d3f69f1660d636fb2c9811d81140cf84f561d": "0x0000000000000000000000000000000000074341505045580743617070657800000000000e4043727970746f436170706578000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b49940857135462fa0db8c6cb723c474639931cae07e095e6e8d9b870c90f5b499bd8e6fdf4bd54f": "0x040000000002000000000000000000000000000000000a4c696d65436861696e000000126869406c696d65636861696e2e74656368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b4a5da87e533f5dff58927b296a23cbf25794b7cbb8fe31c5e68f2bcd2c2483e9c9cd0712216f232": "0x040100000002000000000000000000000000000000000f3125202d2047545354414b494e47001768747470733a2f2f67747374616b696e672e636f6d2f14406761757468387a3a6d61747269782e6f7267166761757468387a4067747374616b696e672e636f6d00000a40475374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b4ab7a3aac34e144a8643e2e7c9f9bec10df82710ba1181b7b07b6cc15674584995f911ebd304661": "0x00000000000000000000000000000000000f4b656b6f7365206f66506865656200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b4c98d3a42ca87e8eadf02d15ffa95f56be8b5d91825988362d5f8918ba3070e258dea7b0c67806d": "0x040000000002000000000000000000000000000000000f506f6c6b61646f74204172656e61002068747470733a2f2f7777772e706f6c6b61646f746172656e612e626c6f672f0018706f6c6b61646f746172656e6140676d61696c2e636f6d00000f40506f6c6b61646f744172656e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b4d353916a9420c20c65d7c1489d18dedea3b4acf5443bd0f088e6062d20f15e774ee860e39e3d2a": "0x0403000000020000000000000000000000000000000008626b6f6e747572124272616e69736c6176204b6f6e74c3ba72001c406272616e69736c61765f6b6f6e7475723a7061726974792e696f12626b6f6e74757240676d61696c2e636f6d000011404272616e69736c61764b6f6e74757208626b6f6e7475720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b4e729082bc0effa0c691601793de060491dab143dfae19f5f6413d4ce4c363637e5ceacb2836a4e": "0x04000000000200000000000000000000000000000000064c65656d6f000000166c65656d6f407468656368616f7364616f2e636f6d000009404c65656d6f5844000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b508400087c4b7c3a800d94d09f32bd5d031bd76c9a832c34b291c964bbcc63a81ac3589b48f543d": "0x000000000000000000000000000000000013424946524f535420464f554e444154494f4e14424946524f535420474c4f42414c204c54442e1868747470733a2f2f626966726f73742e66696e616e6365001668656c6c6f40626966726f73742e66696e616e636500001140626966726f73745f66696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b51eff5e9260eafe64e6db572dcc9e5dc57445ff7c68ce85e42527aa74b2ed5d1e2bceefd308ed05": "0x0400000000020000000000000000000000000000000015434f4c442053544f52414745204341504954414c00001f40636f6c6473746f726167656361706974616c3a6d61747269782e6f7267207262617272617a6140636f6c6473746f726167656361706974616c2e636f6d00001040636f6c6473746f72616765636170000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b5638bc24447b04d3213d525c169d24ac664b8fb61afb7ff9c5c542d0942a9ae620513e2b83e787e": "0x04030000000200000000000000000000000000000000064d756e61790c4f6d6172204672616e636f0000166f6672616e636f6865616440676d61696c2e636f6d0000086d756e61797475000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b575b6cc98247c63f866d0c3a34620c8db7cd658083de421bbbbe597794f2911c1cb53975f5e83a0": "0x040000000002000000000000000000000000000000000ce2a793204170696c6c6f6e0000001168656c6c6f406170696c6c6f6e2e696f000009406170696c6c6f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b5857832389789b78af348b187a2e94f7dfcacc1de5c71b55f6ab8a50e75f0ac1a15baeebfd92e03": "0x040000000002000000000000000000000000000000000b47616975735f73616d6100000015672e756e69743234383140676d61696c2e636f6d00000b4067756e697433313234000b67616975735f73616d6100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b58ced053a478447f6f6cf81a81b368a0e419b9b6e205f3f9d2927a27e663e6601bad2e7c0df6276": "0x04010000000200000000000000000000000000000000074c7572706973074c75727069730000176c757270697340626966726f73742e66696e616e636500000a4030784c7572706973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b5c07bdf818842cb2cedffdd95011af0a1c5683f8445a05006f30487f0dd25beac664c54bf55441d": "0x00000000000000000000000000000000000f416e696d6f6361204272616e647300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b622b6f540376f72543919fb30b3e6e49c1e95a77c05b6d87f457e5cc4e7275584bc1021f808ef65": "0x040100000006000000000000000000000000000000001b6e616c756c756c616c615f506f6c6b61646f745f5265706c61790d594f4e47534f4f4e204c45450000156e616c756c756c616c61406e617665722e636f6d00000e406c756c756c616c6131383534000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b67813127799c8e920b456b7a8651f0b81f4517ffc79737cc392230cdd92a5b4bfa09ac728a0b10e": "0x040000000002000000000000000000000000000000000a536166655374616b65001568747470733a2f2f736166657374616b652e696f1640736166657374616b653a6d61747269782e6f726712696e666f40736166657374616b652e696f00000d40536166655374616b65494f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b6d59c328d706cfb061f3d8a0b63df2c81c3a5c1fa616fb3a3695d64249dcbb01d3cf73621fe8e3d": "0x00000000000000000000000000000000000f4675636b5f6368616f735f64616f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b6ecd013f449a75f58f2f7dd26682082ccd78611deeeffb89b38bfe97fe95be7e2047cd8e346ad1d": "0x0401000000020000000000000000000000000000000005474465650c47656f726765732044696200174067656f726765736469623a6d61747269782e6f72671667656f726765732e64696240676d61696c2e636f6d00000d4067656f726765735f646962000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b710ad30347143bdf2e76f70974fa08e941bffc14e3b2c8643a58a35f95bbe411b90ca62acd15a77": "0x0400000000020000000000000000000000000000000008537461747574650000001b73746174757465636f72704070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b7acf702b47d3804de064386a3512bba067ef6bd099e7f3a3e68fe6074a8c1ab872ddd7beb8c9002": "0x0400000000020000000000000000000000000000000007686972697368000013406869726973683a6d61747269782e6f7267166869726973684070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b7b376ac778360f7628da3d78e9d1d4af0ceba193397950ea8da074445f066aabc66c82a50fa4e4a": "0x0403000000020000000000000000000000000000000021506f6c6b61646f74204d75736963204576656e747320496e69746961746976650f6261736820617564696f204c4c4300001b68656c6c6f40706f6c6b61646f746d757369632e6576656e747300000b4062617368617564696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b7e8f2933e177fd140c32e6713cc47364b6998b554957eba420df2ab568e6d8e8c672086dd9d5358": "0x0000000000000000000000000000000000215b4d756c74697369675d4576656e7473426f756e747943757261746f727376320000001a706f6c6b61646f74406576656e7473626f756e74792e636f6d00001140444f544576656e7473426f756e7479000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b7ff6a0c4f676b75103fe40937daa62b317e7c8e87c32b0503f705461ea76fc4babcd0c4e2a30a2c": "0x0401000000020000000000000000000000000000000004726f620d726f62207468696a7373656e1268747470733a2f2f726f622e746e2f6376000a686940726f622e746e000009406772656e616465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b835555e3cf0e1b97645bce397d2046a059a06f0252ce845eef1eae32b9243a054d981ce11245c27": "0x04010000000500000000000000000000000000000000124d7974686f7320466f756e646174696f6e124d7974686f7320466f756e646174696f6e000012636f6e74616374406162696c65782e6368000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b85669beeb21dd0baa6646d5b85790bc0ab869d80385fdc10e1f4befa7f8a4bf31848f73012d2823": "0x040000000002000000000000000000000000000000000946616972204645450017687474703a2f2f666169726665652e62616c702e65750010666169726665654062616c702e6575000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b861b613b2b2cdab7a04046977ce345e873315f47f0a6cf6a3659abaa029d6cbf7135fdd53fb573a": "0x0400000000020000000000000000000000000000000018574f4a444f54202020ca9520e280a2e1b4a5e280a2ca9400000012776f6a646f7440776f6a646f742e636f6d00000840776f6a646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b87e14d1620810750e8ed639d511aae6e8213a795a521b6e088b292e45b9ff1e2dcf31cad748e91b": "0x000000000000000000000000000000000006706f6c6b6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b89d726fb1d2f438faac5c26d98f04b9b842e95e85244977a27fc7c93bc73679728d227172aa814d": "0x00000000000000000000000000000000000c526567656e63792d3031381757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b8a74d4a444db6f1bcf647b00211b2d6c8cdb9e091b95ba03ac8bc6a4dd0124f1f09f8c917d1d270": "0x040100000005000000000000000000000000000000000a44454741204953504f05444547411668747470733a2f2f7777772e646567612e6f72672f0011636f6e7461637440646567612e6f726700000a40444547415f6f7267001868747470733a2f2f646973636f72642e67672f6465676100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b8bf8f1e86641005011b82ff2f3419c087efdfb9490db431028f2a638d5c6aeee59c4fb3f1a30b81": "0x04030000000200000000000000000000000000000000094b617a756e6f62750f4b617a756e6f6275204e646f6e670000166e646f6e676d6566616e6540676d61696c2e636f6d00000e4b617a756e6f62754e646f6e67076e646b617a750000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b8c65c55ccbce8a00ad902bdbcd4bb2f81f505fa223b63310cd34e5eeb715b0e50ad3b7e0b412e59": "0x0403000000020000000000000000000000000000000009307877617369616e0f416e64726577204c69757469657600001f616e647265774073756d6d657262726f6f6b686f6c64696e67732e636f6d000009307877617369616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b8ebbd021ec2bde2f068505a66e272d987c377f0ae0c0a795edbb4db40be62187205803920118a28": "0x04000000000200000000000000000000000000000000086873696e636875000014406873696e6368753a6d61747269782e6f7267166969656c6974652e6c656540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b8fe9945a99464405661eeafb5d22cc01c4dfe7ddaf4af6210da32aa407b91be8af3f75bc6589871": "0x040000000003000000000000000000000000000000000c4879706572737068657265001d68747470733a2f2f68797065727370686572652e76656e7475726573001d6d616e616765724068797065727370686572652e76656e7475726573000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b902e56a5ec842fbc8018be75da4c5757d622874c1dd478950b27baff9b50ca4c0e7670c237f626d": "0x040300000002000000000000000000000000000000000a77336e3a657269636b0c457269636b2052616d6f7300001577336e657269636b40686f746d61696c2e636f6d00000a4077336e657269636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9544e0ad8a886ccfcfb0d15de7d1812d75d043f0bf16879a129a02498b40726280770bd38d3cf46": "0x040300000002000000000000000000000000000000000e4c69616d2050656e64756c756d001b68747470733a2f2f70656e64756c756d636861696e2e6f72672f00136c69616d407361746f7368697061792e696f00000e404c69616d50656e64756c756d000a70656e64756c69616d00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b970ba0a552b2a1b5a1f26de64611bef588e2d98deebffdf026e87b35385c2eb3959c47e4e73c74c": "0x00000000000000000000000000000000000c506f6c6b61646f7420545018416e746f6e696f205061736375616c204a696d656e657a000016747061736375616c6a406f75746c6f6f6b2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9744a1a4ac9720b28ce403471e5e1dcf0c84eaebeeec6abf5caecb0f65478c5a4e6e40414872e3c": "0x0800000000020100000002000000000000000000000000000000000c3238446179734f66446f74001c68747470733a2f2f7777772e3238646179736f66646f742e636f6d001a6368616c6c656e6765403238646179736f66646f742e636f6d00000d403238646179736f66646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9a0b6f1289fd337141f9165a69d007a81159ca9efe4b58aed0df50423fcb1bc90cddd9be417697a": "0x00000000000000000000000000000000000b4d757365756d5765656b001868747470733a2f2f6d757365756d2d7765656b2e6f7267002062656e6a616d696e2e62656e697461406d757365756d2d7765656b2e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9aa88162953b359807e371d9df95983e2b9face8efb67f962816f1a0c6681cb1e5455127ab45c09": "0x04000000000200000000000000000000000000000000154150455254555245204d494e494e4720f09f8e820000001d76616c696461746f724061706572747572656d696e696e672e636f6d0000104041706572747572654d696e696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9cb4016283da91d8686261e411fc4e31d3cb29074978a43851627965b4f4189c7777a83a624b11d": "0x00000000000000000000000000000000001d426c6f636b636861696e20547261696e696e6720416c6c69616e636500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714b9f7ccb0a5350c8ee185aadacee7bfae327e2f8104bb96e15d6e026bed15e1290d6f1f88ad681f23": "0x00000000000000000000000000000000000d6672656576657273652e696f0f46726565766572736520532e4c2e1968747470733a2f2f7777772e6672656576657273652e696f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ba371c7e28307a6d16a1fddb4cd14ff65b25f91ae81ba64df7e6318ed826746ed5298feaa38c6c1d": "0x040300000002000000000000000000000000000000000b506174726963696120410e5061747269636961204172726f00001e706174726963696163616d696c6c656172726f40676d61696c2e636f6d00000b40706f6c6b615f706174000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ba5082da70988302146fae5102954f580c20e67585bbd57aeb722bf29fe02607c8b876270706a901": "0x04000000000200000000000000000000000000000000074d65726c696e000000166d65726c696e6e6f6465734070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ba6da6ae5a6fff014e031ef11ea1fa0b7f1f0c07b0a5d36afeea49a8c094f6959d1c3702c5cd016c": "0x0800000000020100000000000000000000000000000000000000000e5869616f207c20537461726b7300001340787a68616e673a6d61747269782e6f7267127a68616e677840676263746563682e636e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ba7663c3b3aaf51b09cdd094e9a51d26bbc6cbb71d3f7c5b8edde629402e3e5370e7f6904512fc4a": "0x0401000000020000000000000000000000000000000011445241474f4e5354414b4520f09f90b210447261676f6e5374616b652c20534c1768747470733a2f2f647261676f6e7374616b652e696f154064657266726564793a6d61747269782e6f726714696e666f40647261676f6e7374616b652e696f00000d40447261676f6e5374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bac18b8eb37d5be29af7e1fc9dca350922e065a2ae8b3366f554e64c9519c55bf1dd7c8b2f8c2554": "0x00000000000000000000000000000000001054616c69736d616e20506f6f6c2031001568747470733a2f2f74616c69736d616e2e78797a000000000f40776561726574616c69736d616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bac296575a7da3090eb83479fa34dc63024ed44efa464427375a44de486e8d6007c7842b45ce817f": "0x04000000000200000000000000000000000000000000114255454e4f2056414c494441544f524f000017406275656e6f76616c69643a6d61747269782e6f72671a686f6c61406275656e6f2d76616c696461746f726f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bacc123aba961dfdac7c228c0c2f9f8bd69a79694a21c0aaa11fa0bdffb8a24f8a2b2c7c71dd4464": "0x0400000000020000000000000000000000000000000008616c657867676813416c6578616e647275204768656f7267686500000000000008616c65786767680000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bb6fb2c1a1cf337b7ed3dd1132e1f216cb30c2440b46423faf32c6effd0a2d9a9f24e52f57af6677": "0x040000000002000000000000000000000000000000000b4c415552454e5454524b000000186c617572656e742e747572656b40676d61696c2e636f6d00000c406c617572656e7474726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bb813580522537309ac6f5d9af351a6a087753ae455455f640508159d2455ba20f245403a14a2338": "0x00000000000000000000000000000000000a42697474656e736f720a42697474656e736f721668747470733a2f2f62697474656e736f722e636f6d00196f7065726174696f6e73406f70656e74656e736f722e616900000c4062697474656e736f725f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bb8e58b3f0252518fa04117758ff4b850ed983aa317d44ad71f28a5cc36caca35d4b60cc28c02061": "0x040300000002000000000000000000000000000000000b436f6e6e6563746966790000001c78696f6d6172616268756c6c617235323740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bb99afa281244f547837d6d2430ff5a0e6f8b7aa57f325f01ae204332d4cda591324dc09b5da1268": "0x04030000000200000000000000000000000000000000054d6f726b0000001e676f76406d6f726b6d6f726b6d6f726b2e616e6f6e616464792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbcb4a8bc42b334be86b14052f27742916a13482c39afc8d9a8f873d799c9aa070bbd045570baa66": "0x04000000000200000000000000000000000000000000114d69636861656c5f52657075626c696b00001d406d69636861656c5f72657075626c696b3a6d61747269782e6f72671861646d696e40676c6f62616c70617468776179732e696f00000d404750435f4d69636861656c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbe20aee1ef9d6a1a8955315ec9f709c88644db0bfc9df67e13c44336d15899eae335b2e0b05346e": "0x040000000002000000000000000000000000000000000d43727970746f6772617068790000001963727970746f677261706879766c4070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbe6cdadc6b5f81166abfdc8c3f01b4913bb09c1690b3ad15179ad20fb3e1f46d90e0104ea90951b": "0x00000000000000000000000000000000000b4e69636b20536d697468174e6963686f6c61732043616d65726f6e20536d6974680000126e69636b4074616c69736d616e2e78797a00000e406e69636b63616d736d697468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbee26bcd7ecf2ba823ef42d2d68197d69bab7d3cbade923c9ba19206656cfe238336e3df412581b": "0x00000000000000000000000000000000001250616369666963204d65746120496e632c1250616369666963204d65746120496e632c1c68747470733a2f2f706163696669632d6d6574612e636f2e6a702f00186b65697269407061636669632d6d6574612e636f2e6a7000000d40506163696669634d657461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbef2b0d9d60628cf627e295ecc92fc03a0f47172c8655f8d2a0d23df634fc94ce264807cf5bab23": "0x04000000000200000000000000000000000000000000074f7261636c6500001440616c6d6172696f3a6d61747269782e6f72671c76616c696461746f72706f6c6b61646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbf605712f9a94b89e2dad25d8b2be1adbae19a2063b835fab6a12c15bfb2c027420a5afc7381e7e": "0x04000000000200000000000000000000000000000000084d447564757461000000186475647574612e6d617269757340676d61696c2e636f6d000009404d447564757461000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bbfb887412ddd8c82e9bbb2cfebfeb22622c29ba56cd766025f4cf35c7737bdcc6762378b7cb207b": "0x0400000000020000000000000000000000000000000015616e6472656974612d76616c696461746f722d3000001540616e6472656974613a6d61747269782e6f72671b616e64726561662e7370657a69616c6540676d61696c2e636f6d00001140616e64726561667370657a69616c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bc3a76766e184695e0584b8462ed4202de4277676f6b1d2b77115672493e6f6fff429b660a0ab865": "0x0000000000000000000000000000000000164465636f6465642056696577696e672050617274790e44696c6c6f6e2048616e736f6e1868747470733a2f2f7777772e646961646174612e6f7267001a64696c6c6f6e2e68616e736f6e40646961646174612e6f72670000104064696c6c6f6e68616e736f6e3132000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bc7126812bf1df493e1630f099540e76e98b9fb0002c3a5ae3f40b6ec180df68fe5cd9bd2088fa18": "0x040000000002000000000000000000000000000000000a535445414b43484546000017407374616b652d636865663a6d61747269782e6f72671868656c6c6f40737465616b636865662e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bc9fa9104384658136e4b176f4f8c8e93d1f038c4ad53d6ce6308764888af81d0b2acc9903f59a3d": "0x00000000000000000000000000000000001850617261636861696e7a20556e204a6f6262656420544500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bcbd30ffb6d16c690237f4df962d9a15d5d2fa981f6f689fa4add977e746c01a07620a92caea5277": "0x04000000000200000000000000000000000000000000136c616e6465726f73207c205374616b655570000015406c616e6465726f733a6d61747269782e6f7267156c616e6465726f73756140676d61696c2e636f6d00000d406c616e6465726f7375615f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bcfdd67ea673f1f2641768da63aab1ad01b2ffed1a44b41c4475f3efdcb74d1e45cf3c490db0c11b": "0x040300000002000000000000000000000000000000000b7863526f6d312e646f74077863526f6d310000167863526f6d314070726f746f6e6d61696c2e636f6d00000a40726f6d315f646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bcffc29008504fd75ca3d296ca48e252a8029882a8218a8c821bb51d80f4852a4b61e29b3d8d3e79": "0x040100000002000000000000000000000000000000000c426c6f636b636f64657273001868747470733a2f2f626c6f636b636f646572732e696f2f001b656e67696e656572696e6740626c6f636b636f646572732e696f00000e40626c6f636b636f646572735f001e68747470733a2f2f646973636f72642e67672f7a6571466e7755786b5900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bd0c168620def27bea3a8ff4ae2930c102a7bb34d17374198a33d4250b6c5eb4689efc0035298107": "0x000000000000000000000000000000000016436f6e74726f6c6c6572204a6575206ec2b032202d084d6169734e6f6e000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bd3136476e89f2d1688a4b3d49b7fa3e1587f8a8e3b445c7c3e830d524a6dc0bfd89a0f8627a6f08": "0x00000000000000000000000000000000000741554b4c454e0000000000000c40616e746f6e6961796c79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bd45ee52acd85afa825872f7d324c8d97a9d5f5c94d918eea93ef783f305767b768a76f9fede7b4a": "0x0401000000020000000000000000000000000000000009414c4c4e4f4445530e416c6c6e6f64657320496e632e1968747470733a2f2f7777772e616c6c6e6f6465732e636f6d0015737570706f727440616c6c6e6f6465732e636f6d00000a40616c6c6e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bde7f741d77b7e0ea2e36a2a787a3d59588d756dd54b5d1cf5a464496d7c29d31438f1a8a2a0a80e": "0x040000000002000000000000000000000000000000000a436861696e5361666500000012696e666f40636861696e736166652e696f00000d40636861696e736166657468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be03b2298e56f6b680118fb6d4f674aebcecccfa0640584af7004d155d17fd88e0b5d1b682460a2a": "0x040000000002000000000000000000000000000000000c646f747374616b652e696f0000001268656c6c6f40646f747374616b652e696f00000d40646f747374616b655f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be084a2d67f3fe459800cbb128a37eb9e9ce630aebdaa4e3345ac67d75b766524cdf2e21de7b721a": "0x0403000000020000000000000000000000000000000006446f646f77000000156372797074646f74616f40676d61696c2e636f6d0000114066617368696f6e69737461776f6e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be09d91e809b5850d61b7925b1cfbbd6c618187421191758888a19df2d04f622da9d941c6066b47a": "0x0401000000020000000000000000000000000000000009444f5445522e494f09444f5445522e494f10687474703a2f2f646f7465722e696f14406a6f69656375693a6d61747269782e6f72670d6a6f6965634071712e636f6d00000a40646f7465725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be3183951dd1f1d5e626934768e68509f3b657372165e6f98fdefe615cc8e669d5bbe033a6478556": "0x040100000002000000000000000000000000000000000bf09f9491204b656974680d4b6569746820496e6772616d1968747470733a2f2f6b65697468696e6772616d2e696e666f18406b656974683a6d61747269782e7061726974792e696f106b65697468407061726974792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be58ca2ba19c9036f8596d3d1bfe4d7b96b76a35bb52078edb437a5e5b932fad5f653bf0080e0d50": "0x0400000000020000000000000000000000000000000008414c455353494f001d6c696e6b6564696e2e636f6d2f696e2f616c657373696f6f6e6f7269134069726f6e6f613a6d61747269782e6f726718616c657373696f2e6f6e6f726940676d61696c2e636f6d0000084069726f6e6f61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be88be4b51946ab0b45ad6a53e0a688752f3a40f49cf7e666169c787f83bf1c2ff8aa026d99ac177": "0x040100000002000000000000000000000000000000000e5354414b494e4744585f434f4d0e5354414b494e4744585f434f4d1668747470733a2f2f7374616b696e6764782e636f6d16407374616b696e6764783a6d61747269782e6f726713696e666f407374616b696e6764782e636f6d00000b405374616b696e674478000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714be90c353cce89dbc62838e85d6feea406b4544b851f10449c2f2376b9d3805a3b7cdb98ef2573f7d": "0x040100000002000000000000000000000000000000000c41576f726b65722d3030310000114066756e633a6d61747269782e6f7267156c69646977656e63686540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bea99ac32a4539bc724d262fd25c8cc975189c3ae4f0dee1ba2e17080cda69183412d0928b49db0f": "0x040000000002000000000000000000000000000000000b7375626c61622e64657619537562737472617465204c61626f7261746f7279204c4c431368747470733a2f2f7375626c61622e6465761a406f616b6c65792e7375626c61623a6d61747269782e6f7267126f616b6c6579407375626c61622e64657600000b407375626c6162646576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bed90d4bbefb67eb8485f4b667f18f10d2c523593467680fb28b501f93d053ed08a1eed3c9e5c852": "0x040000000002000000000000000000000000000000000c43524950544f4d454449410000001d63726970746f6d656469616f6e636861696e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bee71c5b95c53e49da92c32ab2b4e1a46bb659cb6fd22fc824611e4c2803fbedd93c246f97c67118": "0x040300000002000000000000000000000000000000000a566976616c646920300e476f6c616e20566976616c6469000018766976616c64692e676f6c616e40676d61696c2e636f6d00000e4042756c6c697368476f6c616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714beea5d629df9274d3ca902971765b01d4fc6e7b9a45d1e3e1f9ed351e5bd8554d3c812457f2579d0": "0x000000000000000000000000000000000012506f6c6b61646f742048656c73696e6b690000001b706f6c6b61646f7468656c73696e6b6940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bef0fe62add82534c03802bc59091c05f317f32a796a720027867fc14e6554a7be0c19d7f107b332": "0x000000000000000000000000000000000009506f6c6b61646f7408686f74206b6579000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bef1561c49f96ee16aff72a0c7b124579def4ebf4515e735b0fe3eea919c682e6d71ed9c0474da7c": "0x00000000000000000000000000000000001a4576656e747320426f756e74792056322043757261746f727321506f6c6b61646f7420436f6d6d756e697479204576656e747320426f756e747900001f706f6c6b61646f746576656e7473626f756e747940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf00044145d9dee7b6e0dce13b0bd22e17942bfa320877be89092b7e4f482fc68e1099109ca42938": "0x040300000002000000000000000000000000000000000f50494e4b20504f4f4c20233235340e4a757374696e205365656e657900001d6164766572746973696e674063726561747273747564696f732e636100000d4372656174724a757374696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf0ff86d35aedc7b309145b12c7144a895495d82d6ba5cefc34b841859d6732af2759287266a2b19": "0x04000000000200000000000000000000000000000000084d65726d61696400001a406d65726d6169646f6e6c696e653a6d61747269782e6f7267196d65726d6169642e6f6e6c696e65407961686f6f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf1fb55b1ab52a450857c62463c3671fa8ef7253b3380ff662b0963c86dd9d227c10428b2d8c746c": "0x04030000000200000000000000000000000000000000054572696b0d44756f6e6720416e68205475000016747564756f6e672e66747540676d61696c2e636f6d00000c4572696b64756f6e673731000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf74188b125a3306308b59a947eeb792acf6de27fa47a92ad37d53a15a7b97cd25f11c25455ba253": "0x00000000000000000000000000000000000e4c6f63616c436f696e53776170001a68747470733a2f2f6c6f63616c636f696e737761702e636f6d00177465616d406c6f63616c636f696e737761702e636f6d000010404c6f63616c436f696e537761705f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf95774f0918328726c943cbc77122d3e8b6a1b92179ee776b972eae6f333697f254f369e150473f": "0x040300000002000000000000000000000000000000000c56616c69644f72616e676500000015646f75674076616c69646f72616e67652e6e657400000f56616c69644f72616e6765444f54000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bf995359aa3940443a8389c4cbbce2c9761722bdcb9a53d1e15023f95af6aecd5deba6377003f919": "0x040300000002000000000000000000000000000000000a4d636f6f6b42616c69134d61747468657720427279616e20436f6f6b0000126d636f6f6b383140676d61696c2e636f6d00000c404d436361746170756c74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714bfe2bdce4846e722a0c3719d913e12ae573407a1b2584247c88a292ffbba8cc862211f7defd8f10f": "0x04030000000200000000000000000000000000000000064e696e6a6100000020706f6c6b617373656d626c792e71346d356440706173736d61696c2e6e657400000d4062616c616e6365626f726e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c0095c67a6440edf74db9a1104a31f8b431ece5bcabbe3e508d22fe13670d32875ff6347a88d1388": "0x0400000000020000000000000000000000000000000015506f6c6b617363616e20466f756e646174696f6e14537469636874696e6720506f6c6b617363616e1668747470733a2f2f706f6c6b617363616e2e6f72670013696e666f40706f6c6b617363616e2e6f726700000e40706f6c6b617363616e6f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c00b6c66130a22cc129c10048c90abf494afa1f1d2794d6afdd7e62e46d8bc073114bf42d1d64b3a": "0x0000000000000000000000000000000000084c7563616d657300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c029ee460555e12cb2692080bd814373a7c780dcc62922ba2e770c11a50bb1bb38fd3e69f0192a71": "0x040000000002000000000000000000000000000000001c416e756269204469676974616c204d61696e204964656e7469747900001940616e7562696469676974616c3a6d61747269782e6f726716696e666f40616e7562696469676974616c2e636f6d00000e40416e7562694469676974616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c02a0fb78fe9c0b6e60ae0c90c135ea717c10d2568a2ef847fbd201108f3f8b1a50608e83183574f": "0x040300000002000000000000000000000000000000000a4379706865727475780e4d6178696d65204576726172640000196379706865727475784070726f746f6e6d61696c2e636f6d00000a637970686572747578000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c0357d417cbd92c04e4c31b4c8d28f356b320a3186b82c979647af58b29a1573774e4bc7db1b7b5c": "0x040100000002000000000000000000000000000000001b566f6c74657265204361706974616c204d616e6167656d656e74001368747470733a2f2f766f6c746572652e63681540766f6c74657265353a6d61747269782e6f72671774726164696e67406f6465726d6174742e636c6f7564000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c038a43990a07bb81280a479ee3beca7af1636aca17582f30829782e2c9b1b9c72aaf8060563ab37": "0x040100000002000000000000000000000000000000000e494f53472056656e74757265730e494f53472056656e74757265731068747470733a2f2f696f73672e766311406a6f63793a6d61747269782e6f72670e68656c6c6f40696f73672e766300000840494f53475643000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c053a54bef0f336a9c217bcbcd61459955b47bafddefd16d131156fbb235c55d25f6374f0cd04610": "0x0000000000000000000000000000000000085175696e746f7300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c07690bc374b92f796acfe70c04eae75f56d603fa55ea58adc1a5be6f7780f6bb8b55ca788ad670f": "0x0000000000000000000000000000000000135375706572636f6c6f6e7920d0a16f72702e001968747470733a2f2f7375706572636f6c6f6e792e6e65742f164030786d61726b69616e3a6d61747269782e6f7267186d61726b69616e407375706572636f6c6f6e792e6e6574000010407375706572636f6c6f6e795f7673000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c07bdf560316d32b08ec72cbf62bb66f416f46f988e130585c834a381efdbb0755e30f47a2a0da5a": "0x040000000002000000000000000000000000000000000f50524f4f462e434f4d5055544552134d6f6f7365204c616273204c696d697465641768747470733a2f2f70726f6f662e636f6d7075746572001a76616c696461746f72734070726f6f662e636f6d707574657200000f4070726f6f66636f6d7075746572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c08fd019b5ff673488b8f51942016c72e537611887d58b4e6a44e0f435480472362dfc5244f08038": "0x040100000002000000000000000000000000000000000538425443053842544315687474703a2f2f7777772e386274632e636f6d2f000f77656e647940386274632e636f6d00000c40627463696e6368696e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c0b698fe85dc7f07f46a2cda2040566d6299f92cdb1132a231dc2632ff84b711e3db8634c344f93e": "0x040000000002000000000000000000000000000000000d47696f726765416264616c610000001767696f726765616264616c6140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c14003ed5bc24012503db62affc9c535c960ee60970a8357b7764be446b2dc100a3f77b4370ce165": "0x040000000002000000000000000000000000000000000c506172697479204461746100000014646174612d7465616d407061726974792e696f00000d40646f746c616b655f78797a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1470541a3b4a961448bfb9be2787bb39b122d5b1707e83e535899c58d919a7afeba26968e12382f": "0x0400000000020000000000000000000000000000000004573346105765623320466f756e646174696f6e1968747470733a2f2f776562332e666f756e646174696f6e2f001661646d696e40776562332e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1587ff616dd25a0560d57708a28e8cbb8794c04d67b66541c191d2effad8596ab63c619f257aa11": "0x040100000002000000000000000000000000000000000d384254432d504f4f4c2f30310d384254432d504f4f4c2f30311568747470733a2f2f7777772e386274632e636f6d000e79757a6240386274632e636f6d00000c40627463696e6368696e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1639ae30e11b073cc003ff85b9d4030c01000f725b0ca03088c45c8e9ab90853c56d1c7b6cbc470": "0x00000000000000000000000000000000000b506f6c6b61446f74203100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c17a5e2df8e467cbba3f7fae8b3156ca2a3b0b84d3b2d922938bc2ab1405aea7813740a02146750b": "0x000000000000000000000000000000000017504f4c4b41444f542d4252415a494c2d4556454e545300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c17b80d313e3c78cce44b6b392394133943e063102b113e0577108fb9cb3000fe04faec3a3ad3934": "0x0400000000020000000000000000000000000000000012f09f8f942048454c494b4f4e20f09f8f940000144068656c696b6f6e3a6d61747269782e6f726710696e666f4068656c696b6f6e2e696f00000d4068656c696b6f6e6c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c19ae875baf61fab3e3a490c516b2a3582e6400e33f3eec42a12589958cbb86c87b23bc94710d21b": "0x04010000000200000000000000000000000000000000134361706974616c5374616b696e672e636f6d001b68747470733a2f2f6361706974616c7374616b696e672e636f6d1c406361706974616c5f7374616b696e673a6d61747269782e6f72671b737570706f7274406361706974616c7374616b696e672e636f6d000010404361706974616c5374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1a0c9593f15c53958c46d422c8c3d1692f51889cf64e2e32cadce1d1d341ca6196a8d4b18a9a354": "0x04000000000200000000000000000000000000000000064d49444153000014406d6964617338393a6d61747269782e6f7267156d69646173676f64383940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1a153b6113c7dfb000b93d72dcc12bd5577438c92a19c4778e12cfb8ada871a17694e5a2f86c374": "0x00000000000000000000000000000000001042494e414e43455f5354414b455f391042494e414e43455f5354414b455f39000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1ab9046e485e6d5466ca78e64f7df8847d8c192f3daddf32426f72a3baa4c3e320082afdb884134": "0x040000000002000000000000000000000000000000001a624c64204e6f646573207c20436861645374616b654b696e6700001340626c643735393a6d61747269782e6f72670000000a40624c644e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1ba3367c853c0b7056fef6e642069325ec72887efa3e22034c6890beebceb935852d776a3d08a30": "0x00000000000000000000000000000000000c506f6c6b617573642e696f0c506f6c6b617573642e696f1468747470733a2f2f706f6c6b617573642e696f0013706f6c6b6175736440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1d50c9830174ca88c232c91ef2a9983ba65c4b75bb86fcbae4d909900ea8aa06c3644ca1161db48": "0x040000000002000000000000000000000000000000000c65636c6573696f6d656c6f0e45636cc3a973696f204d656c6f00184065636c6573696f6d656c6f3a6d61747269782e6f7267000000094065636c3373696f1245636c6573696f4d656c6f4a756e696f720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1d7648a3e3194dab2bdb0d774986625498e0b5fce860c7d58103bdb6b7b348054d525fddc3f3e7f": "0x000000000000000000000000000000000008576574657a2d3200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1d8ccc3c147543c94575c5627d7661400a3eccacf5440b5f877fa6099f4797a321523e3ade7215d": "0x00000000000000000000000000000000000448616f0948616f2044696e67000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1d9151efd144bc7c6e2ca836b28b68978aa39dc41d5b7ef3a7b8630a3e432d8ca99f24fd86cbd05": "0x040000000002000000000000000000000000000000000764616d736b790000001c63727970746f64616d736b794070726f746f6e6d61696c2e636f6d0000104068656c6c6f69747364616d736b79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1e0ca80539b15c8796b851c8164a129b23282ca4b3bb694364b0bfb504e98b5d2ffc5140d58078e": "0x0400000000020000000000000000000000000000000019416e74692d5363616d205465616d2045786563757469766500000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c1e288e289580287886286c58d67217bdd854832d5e9f1b218dec6a0ff7e0b7573147ca94a233a0a": "0x04010000000200000000000000000000000000000000204269742e436f756e7472792026204d65746176657273652e4e6574776f726b0014687474703a2f2f6269742e636f756e7472792f000f6869406269742e636f756e74727900000f40626974646f74636f756e747279000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2118a9d986b584ea8a3f426b435bc9415d2bae037d416a81c5b02c8cd6751549b37700c720aab15": "0x040300000002000000000000000000000000000000000e59616e6e204d6f7270686575730f59616e6e20506f696e636c6f7578000014636f6e74616374406f726962696b792e636f6d000009406f726962696b79000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c22c37787c57611ecc23ed33549e874ae7c7653fc5d95b3242dc7df5742664b4809e337a13126433": "0x040000000002000000000000000000000000000000001be29ca8f09f918de29ca8204461793720e29ca8f09f918de29ca800001140646179373a6d61747269782e6f726714616e746f6e406e6f766177616c6c65742e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c237c8c9d7bd4904bc267fea33668e3515a7c01f4acca67d73d30574b600a404d2b7210aaac85569": "0x040000000002000000000000000000000000000000000de29d84e29d84e29d84efb88f00001740696365636f6c646e61743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2846271fb408595e02d02d96dcacc309d5fb57319b26ca2334ce9d413929bb8ebbfe2ca5e614600": "0x0000000000000000000000000000000000094164696c2d446f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c28f8abd364479314411b54c486afdd65bbe6f482fab68a28443c845c004a1c5d141314577d67d0a": "0x00000000000000000000000000000000000a4669676d656e742031001368747470733a2f2f6669676d656e742e696f000100000b4669676d656e745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2910faeab8bbb21aa92898eb263b225b26d5af6d0899f4e628161089ebc308887c48716ba248d5f": "0x00000000000000000000000000000000000d557273756c61207c2057334600001840757273756c613a776562332e666f756e646174696f6e17757273756c6140776562332e666f756e646174696f6e00000a40757273756c616f6b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2a5b45c043e387bd2a0035cec74b2f90f7e72cab1fb16b6ba8317631976b138f7cced3e00668b0b": "0x04030000000200000000000000000000000000000000074d61676e65740f4d61676e6574204e6574776f726b0000136d6167706f7274406d6167706f72742e696f000010404d61676e65745f6e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2c055e89a151d2372eecb8803cc4c49b49b0897c51190c9e32f9509e0bb2d7ee174378c7ebf3c46": "0x040000000002000000000000000000000000000000000541636169000016406163616973686962613a6d61747269782e6f72671461636169736869626140676d61696c2e636f6d00000d406c65633238333531303833000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2ce802d4a097bfe0cd0767b5aaddecbfd90c086a3ae9c5efd0d2ab21b7d574ba605ded74c226125": "0x0000000000000000000000000000000000105361746f79616d6120233120444f54001768747470733a2f2f7361746f79616d612e746563682f00197361746f79616d612e7374616b6540676d61696c2e636f6d000010407361746f79616d615f7374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c2ceac9b196d4a9b7a44e4c663e89e2c161dcf2b0fa46ec92f4017ec832e681ae5ba5f917dc54b58": "0x0401000000050000000000000000000000000000000006746f656e6700000016746f6d6d792e746f656e6740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c31003d453d9cc76b1451f8962f76c9748e3ebeb43d5ba6cc25af020f2eb2316d6237115a3de72dc": "0x040300000002000000000000000000000000000000000762656533343418416c626572746f204e69636f6cc3a1732050656e61796f0012406265653334343a7061726974792e696f15616c626572746f407375676172637562652e6172000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c31738bafd189046ecef3a91c92840fb38e4cd3e20a604c75992cda08df8135416e5f4504e3d681d": "0x0403000000020000000000000000000000000000000003534b000000147477736b6875616e6740676d61696c2e636f6d00000b407477736b6875616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c32ddea12298867b068f5973c7e1c0739ff08393aeba931748af1156690cd6db3bdccbca7eb82752": "0x040300000002000000000000000000000000000000000642414e584100000017706172746e657273686970734062616e78612e636f6d00000f4042616e78614f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3361cdef8ce970506b2f22dc927017e40cb8834d89a7eeb49a598a965f00fa38ceea3b1c6ed6637": "0x040300000002000000000000000000000000000000000454696e0a54696e204368756e672068747470733a2f2f6769746875622e636f6d2f6368756e677175616e74696e0014637174696e3039303340676d61696c2e636f6d00000e406368756e677175616e74696e000c4063686173656368756e6700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c34aa17cf274fb0fce72013d22d568d7101bb1ecb5f43bb0d327619eb37337afdf24c5893fdfc06f": "0x00000000000000000000000000000000000c526567656e63792d3031351757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c38be37ff19e3a8a7617b9c6475f887ba801cee49b322a4d888224c8d0791bb0d5c999b6605e251a": "0x000000000000000000000000000000000009646f746875622d3109646f746875622d31000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3a245cb2d2a7e9b56e751974614540cafc9bc363a690d2b4196c79399dd6f9750c202f671125358": "0x00000000000000000000000000000000000b5042412044616e69656c1444616e69656c20506572657a2047617263696100001767617263696164616e79313240676d61696c2e636f6d00000f40446563656e7472616c44616e69000a64616d616e74696e6f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3aa97983f6ecffc96625a0cbd0931ad831add3bcaa6320950385aec23b3854c6ce987de1c9f8837": "0x04010000000200000000000000000000000000000000085032502e4f5247085032502e4f52471068747470733a2f2f7032702e6f7267000f6c657473676f407032702e6f726700000e4050325076616c696461746f72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3b628138bb91f0585ae10011f28f84a7403b3ad52c14fae856077d3be1cb18b88081577a52d1ea7": "0x040100000005000000000000000000000000000000000d446f747479447265616d657200000016646f747479647265616d6572406475636b2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3d4753480e3c1e936f6c360f80a8a9d2674a52440e1b41088663475ee6676796ce14bf3bcb4ae16": "0x040000000002000000000000000000000000000000000f7377656e7468656275696c646572001c687474703a2f2f7777772e7374616b65326275696c642e636f6d2f0000000009407377656e77333100097377656e3737353000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c3fdb0ea29d362e6b83d19e4a3ad242102f94a4452381300ace74c5d50fbdd9675a869401d3bff64": "0x040000000002000000000000000000000000000000000645726e69680000001a65726e6968656e656c626f7371756540676d61696c2e636f6d0000094065726e6968626f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c423231fa12d1b91a0606395f5c1ec90f373c26ff05ce375bc584608549d0dca2338dbc7a0fd814e": "0x00000000000000000000000000000000000450534317506f6c6b61646f74536d61727450617261436861696e1d68747470733a2f2f7777772e6f6d6e696274632e66696e616e63652f154069636f64657a6a623a6d61747269782e6f726714676176696e40636861696e6e65742e74656368000009404f6d6e69425443000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c4278e2e719c876ab430a1d38186a28164facec9010e36b1289eb6d3ad0f03f328188fd52bcb333a": "0x0403000000020000000000000000000000000000000005526973680e52697368616e74204b756d617200001a5269736840706f6c6b61646f746e6f77696e6469612e636f6d000011404f6666696369616c6c795f52697368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c43f93ee2474bcdbd0a26ba88664597d50d7a6cc478135d84a261d3efe0338de3a5c71b77b18ed3f": "0x0000000000000000000000000000000000094475627374617264001568747470733a2f2f64756273746172642e636f6d000000000a406475627374617264000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c451757b8ae3669366f108b7fa5e27b25dd980f303f110194181f5725f724db5258f497e3fd7c135": "0x040100000002000000000000000000000000000000000c536572706163727970746f002168747470733a2f2f706f6c6b61646f742e736572706163727970746f2e636f6d124070736572723a6d61747269782e6f726715696e666f40736572706163727970746f2e636f6d00000d40736572706163727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c47e6cc596c775ea049386f24725f9bf05946141f7baab4c1976ff5396ae250af174a04ef54a1962": "0x00000000000000000000000000000000000b4a6f616f2048617a696d0b4a6f616f2048617a696d0000146a6f616f68617a696d40676d61696c2e636f6d00000a6a6f616f68617a696d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c48c8cf649baa1400a8933d3f2164648399cc48cb8bb8c915abb94a2164c40ad6b48cee005f1cb6e": "0x040300000002000000000000000000000000000000000967696f74746f6466000000127665726966794067696f74746f2e78797a00000967696f74746f6466000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c4b4dd7580fa785794b57fffa14cca7b965e2179f8ae5a94a84ba15aabfd0ef3f67f8ebf74e9654d": "0x00000000000000000000000000000000001345726963207e44697374726163746976657e154572696320416c6578616e64657220486f6c7374000015657269632e686f6c737440706f7374656f2e646500000c40686f6c7374626c6f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c4dce5c7e5fc1055a4d9ffc123ea0bfd66aad52c6bc6f6740b23bcb36548761c5bbdbf156cd7577e": "0x040300000002000000000000000000000000000000000a4942432047726f7570114942432056656e7475726573204c5444000010626f624069626367726f75702e696f00000d404d6172696f4e617766616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c4f3bb9a6a26a4b7249aca910e224a87c14afb90980ef0db0a6b12c9d6b48c1acae111a1dda36617": "0x040000000002000000000000000000000000000000001050415241434841494e532e494e464f0000174070617261636861696e733a6d61747269782e6f72670000000c4070617261636861696e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c516af68b4b46adaa5c4954040dafae7716b80bc7d5069fcbad863fe020a518d2afa27086f205285": "0x0000000000000000000000000000000000064e696d6974114e696d6974206b756d617220676172670000156e696d6974363139393340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c562a9eed81aa2dadae2b867564f01654946a095e69f0f49df1eb5c0efce5730cc3d1d83da3f4b09": "0x040000000002000000000000000000000000000000001af09f8c9020646563656e747261444f542e636f6d20f09f8c90001868747470733a2f2f646563656e747261646f742e636f6d001661646d696e40646563656e747261646f742e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c587ad64f66fbec7eec4cf006491dfbbfcb46eb5c8adc1a7535d554061f7f01c87a1e80f55598f67": "0x040300000002000000000000000000000000000000001344656e69732053756b686f7665726b686f760000001d64656e69732e73756b686f7665726b686f7640676d61696c2e636f6d0000000007636b636e696b00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c58b75eb4a8be7450236cc1bd6896c2a467da5f74331cc91ad6175f58d67c4fc3f50b2f8aa070490": "0x00000000000000000000000000000000000c526567656e63792d3031391757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c5b2faae0caa0f972c6f57e9289919d242aa985c1963f2b4040ddc57df3682d890657d130c035576": "0x0800000000020100000002000000000000000000000000000000000b43686f727573204f6e650e43686f727573204f6e652041471468747470733a2f2f63686f7275732e6f6e652f001168656c6c6f4063686f7275732e6f6e6500000b4043686f7275734f6e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c5dad8e8b3b4327c8cc1b91e8946862c2c79915a4bc004926510fcf71c422fde977c0b0e9d9be40e": "0x00000000000000000000000000000000000976696b696976616c0956696b692056616c1068747470733a2f2f76696b2e696e6b144076696b6976616c3a6d61747269782e6f72671576696b696976616c406b6f6461646f742e78797a00000a4076696b696976616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c60c7e71ad50cedcc07b6eec14cd9119097bbf9bad28692a99e1c351e529c04793836183ce20bc45": "0x040300000002000000000000000000000000000000000a50617472696b2045420000001a74686973697370617472696b2e656240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c6b97ff91a535e9758b2c6f6766aab985078011ec8e759a965ab99168f7399f201b375400b9b0175": "0x040300000002000000000000000000000000000000000b576973656164766963650d73756d6974204b61706f6f7200001373756d697433356940676d61696c2e636f6d000011407769736561647669636573756d6974000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c6c19190ae451b5ae25e8c141e674ba58ca7fd0043366f6903488f3c585ff1180c9993eb896a3373": "0x040100000002000000000000000000000000000000000f44656c6567614e6574776f726b730f44656c6567614e6574776f726b731368747470733a2f2f64656c6567612e696f2f1440636f736d6175743a6d61747269782e6f72671664656c6567614070726f746f6e6d61696c2e636f6d0000104044656c6567614e6574776f726b73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c6da84d4d27caae500a8facc16c587e6b038173c4c85bcc36e7f506265012172163c29c9c0d8252d": "0x040300000002000000000000000000000000000000000a757365726d616e653111456476617264204e616674616c69657600001b6d69636861656c6e616674616c69657640676d61696c2e636f6d00001063727970746f5f757365726d616e65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c6ebdb2259f1d7d39ed0c9d18434f72d143cd55ae6d8add183e570d99674e334780029618f59c733": "0x04010000000200000000000000000000000000000000047a636f000000157a636f38394070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c704657f880bd0c07a34c5f475b5018f0d759283ff6a559713e8fe4fe672df009f3c812853b2ea35": "0x040300000002000000000000000000000000000000000f4d61726b6574204d6f62737465720d417368204461766964736f6e000016617368406d61726b65746d6f62737465722e636f6d0000104d61726b65744d6f6273746572554b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c7289bc44ade334e8db5c746c14cf05e182b10576a9ee765265366c3b7fd53c41d43640c97f4a8b8": "0x040100000002000000000000000000000000000000001144617277696e6961204e6574776f726b1144617277696e6961204e6574776f726b1a68747470733a2f2f64617277696e69612e6e6574776f726b2f001768656c6c6f4064617277696e69612e6e6574776f726b0000114044617277696e69614e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c74631fdb69272c020db24b51cc17362ffbaff228d977efd5fcc799ee877b1c6b8f144810555d25d": "0x040300000002000000000000000000000000000000000e436f696e74656c6567726170680000001c61647665727469736540636f696e74656c6567726170682e636f6d00000f40436f696e74656c656772617068000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c78dbbfac53841cd2c0d08e42e58247b57421f3239e0e192b21edaed4bca2458028c981634bdb607": "0x040000000002000000000000000000000000000000000f5354414b452048554c4bf09f91bd00001a407374616b6568756c6b69736d653a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c7a191740d407ab0362e53ccb59d8ef4125dcea1beb4a046797486adb9a7fe7c7496c8e8fe775d50": "0x000000000000000000000000000000000009444c494e4f444553174469737472696275746564204c656467657220496e632168747470733a2f2f64697374726962757465646c6564676572696e632e636f6d001f61646d696e4064697374726962757465646c6564676572696e632e636f6d00000c40646c6564676572696e63000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c7b59ed3c46118b33a5e67c5be0b1a151232d17929a6479d7d7187544a40c059664c6315e94c977c": "0x04030000000200000000000000000000000000000000064d696d6972001568747470733a2f2f6d696d69722e676c6f62616c001368656c6c6f406d696d69722e676c6f62616c00000e404d696d69725f676c6f62616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c7bda7f8eb7fbbb7b45897c0b5d286cf13edcac05f1089d8d5427964bd7deefb3e025857880b0d7f": "0x0000000000000000000000000000000000074b6c65766572001268747470733a2f2f6b6c657665722e696f0013666565646261636b406b6c657665722e696f00000b406b6c657665725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c894982e15d43f07fe8bc73363ddd77dbd0717156237bd0bf9b94036ba003fb6c938495a9002df68": "0x040300000002000000000000000000000000000000000c456e636f646520436c75621e456e636f646520436c756220456475636174696f6e204c696d69746564000014616e74686f6e7940656e636f64652e636c756200000b656e636f6465636c7562000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c89d000515601ae39c82e3f47021dbab243cffebb35e9b44bf2dd301f06778861ce3ab634f607001": "0x00000000000000000000000000000000000a53757065726d614e5a14466572677573204d617274696e20506f77657200001e646f6f646c65722e616972637265772e30664069636c6f75642e636f6d00001140706f776572735f746861696c616e64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c8c057868e022eb34c1bdac31e30cd50156586f5009d576c2efdc103be5ef0649d55d3b53941760e": "0x040100000002000000000000000000000000000000000d4b495241205374616b696e670e4b69726120436f7265204a53431568747470733a2f2f6b697261636f72652e636f6d15406b697261636f72653a6d61747269782e6f726716706172746e657273406b697261636f72652e636f6d00000b406b6972615f636f7265000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c8c34606dfbf7e1d0776a6d2dc585e66545d1538c8d8db9a221e7b67591790941d049992973e360d": "0x040300000002000000000000000000000000000000001250617472697a6961207c20414e414d495800001440646270617474793a6d61747269782e6f72671b70617472697a69612e646562656c6c6140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c90131946f8bd67ffa9d746a03245f55825fbe051be34eb34422bfa23f0b1d9317cdef087182ea5d": "0x040000000002000000000000000000000000000000001b494e46524153545255435455524520434f52504f524154494f4e000014407961796f692d763a6d61747269782e6f726720737570706f727440696e6672617374727563747572652d636f72702e636f6d00000c40494e4652415f434f5250000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9662fb2af085bcff6225c6c2ffe4074df65d2adc2dcdbc576e33ee43c4089b0c034966426ff4377": "0x040000000002000000000000000000000000000000000d4e69636b205368756c68696e001968747470733a2f2f6e69636b7368756c68696e2e636f6d2f18406e69636b7368756c68696e3a6d61747269782e6f72670000000d406e69636b7368756c68696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c96a6c22d4b03e5980d0f3b4ac7e29a54b4b4c6638d0a865aba5da8d2881ceac549c5e278e62a90d": "0x040300000002000000000000000000000000000000000931676e3072346e64134761626f7220546a6f6e6720412048756e67000019672e762e746a6f6e676168756e6740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c970e8c26c18107fc6a04790e90ef5ac434c22f9b7eaf891738931a7b7ad14d1949303ec79433850": "0x00000000000000000000000000000000000f4752422054726164657220444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c974eec21c6558fc0a6497cc5b43976b51f865da2ed13f750640abd317a44fc0be1d06ba41036732": "0x0403000000020000000000000000000000000000000009636f6465307866660c4a756e67796f6e6720556d00001a69616e2e6a756e67796f6e672e756d40676d61696c2e636f6d000009636f646530786666000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c99fde22c2a91b8042361acf91eb62232ddd85db70e0408d9812869a015e7dfc8cb91f685ff8e64c": "0x040300000002000000000000000000000000000000000f706c617970726f6a6563742e696f0d4e696e61204272657a6e696b0000166e696e616272657a6e696b40676d61696c2e636f6d00000f706c617970726f6a6563745f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9a3d35454d01d9a63206239ed004343cce85027f05c7fea001f12b65f257f11f53a414a1c1ee9a0": "0x04000000000200000000000000000000000000000000114368616f7344414f204f70656e476f760000000000000a404368616f7344414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9a62f8a51ee740a70e4021e1c2df9e68b5d0c0cb0a69668e45601c3dedb732ba64e020f34c96231": "0x00000000000000000000000000000000000753442d444f5400000012646173697a696e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9ceb72bb306b765f621771ddf37d482210b8c59617952eb1c2b40cfec55df47215231365186a057": "0x040000000002000000000000000000000000000000000f527573742053796e64696361746513527573742053796e646963617465204c4c431668747470733a2f2f7275737473796e64692e6361740013696e666f407275737473796e64692e636174000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9d264aa4e49a5a7a2e546a96f0a016b5103ca34bfec8fd77988fde0c1f427b2ed97b9af2934a27b": "0x0403000000020000000000000000000000000000000008526963686c796e08526963686c796e00001c636172756c6173616e72696368796e363240676d61696c2e636f6d0000087263766572677a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714c9d4715fc01dd3c55e91aeb058d11c897e1f6f510cfcb62b781b19bbcad30eacb81f4976d95e9cff": "0x00000000000000000000000000000000000f45422043555241544f525320505000000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ca08516f7be365cf1a21174f3333c2bb416072b2c31d8f1e60f8e4ad3cf9546ab47e5b6fd060d303": "0x04010000000200000000000000000000000000000000054b757a6f0c4b68616c696441686d656400114067757a6f3a6d61747269782e6f7267144261642e39342e697140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ca3402e483e6170efee3129dacd1d1b4820ea6f516d7bfaccc4b64b16730ac6282daf1dc476e0001": "0x04030000000200000000000000000000000000000000054d61726b0c4d61726b204361636869610000186d61726b2e652e63616368696140676d61696c2e636f6d00000e406d61726b5f6361636869615f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ca43fffc2927f1f788d340852d044285b8229e36012b665ca5b75412d5e2e83d66994b784b1f3f73": "0x00000000000000000000000000000000000b44616e20436f6d6963730944616e2047616b680017406765656b5f626c6f636b3a6d61747269782e6f726713646f6d313235646640676d61696c2e636f6d00001040506f6c6b61646f74436f6d696373000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ca550b4f7a101e7f344941abe7c5bd2da1688a7abf18b5244d0f524c5e085f5abb2257ca0c038f04": "0x040000000002000000000000000000000000000000000a683478407068616c610948616e672059696e1d68747470733a2f2f6769746875622e636f6d2f68347833726f746162164068347833726f7461623a6d61747269782e6f72671668616e6779696e407068616c612e6e6574776f726b00000a4062676d7368616e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714caa0b0ec39cf59af4e1550920067048086a9f30f799a1749508e222ad1a9d999f586e6f3e782c932": "0x040000000002000000000000000000000000000000000b706f6c6b61776f726c6400001740706f6c6b61776f726c643a6d61747269782e6f7267177869616f6a696540706f6c6b61776f726c642e6f726700001040706f6c6b61776f726c645f6f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714caae41ec132a0861a69de95059adda24b9b38dbe06908378c09ef0d917c7188992ed339e0e530076": "0x00000000000000000000000000000000000647756363690f4d617572697a696f204775636369000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cac1a4bc9a87003e757945316854910d449179fda9aedb37ab23a3dc9f8330ad77fcec3f4b18cc03": "0x040000000002000000000000000000000000000000001d4f524d4c20536563757269747920426f756e74792043757261746f720000001468656c6c6f406163616c612e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714caf961ad1b6e226da072610f1e1ffade38a6d64df55a89e6b07f65ed2be0eb6efffdade4ca576c12": "0x040300000002000000000000000000000000000000000b4b6972696c6c5f6e6577000014406272797a67616c3a6d61747269782e6f72671b6b6972696c6c2e6272797a67616c6f7640676d61696c2e636f6d000011404b6972696c6c4272797a67616c6f76000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cb1015e06f27ef398638bcb5e5ae5e04954d7fa2d29ccedf7f323482573198732af0b3fe32f8da03": "0x040300000002000000000000000000000000000000000973656164616e646100001140646f6e616c3a7061726974792e696f14646f6e616c6d4073656164616e64612e64657600000940646f6d756972690973656164616e64610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cb2e515a03279de32c2aabc0d8257e2dc928553a73d8bb18412665692e53505852328d0aa1126714": "0x00000000000000000000000000000000000e5068616c61204e6574776f726b0e5068616c61204e6574776f726b1668747470733a2f2f7068616c612e6e6574776f726b0016737570706f7274407068616c612e6e6574776f726b00000e405068616c614e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cb4a358712ffad148aee4e164d5d70ac67308f303c7e063e9156903e42c1087bbc530447487fa47f": "0x040000000002000000000000000000000000000000000b6c6f6c6d637368697a7a0000000000000c406c6f6c6d637368697a7a000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cb55ee48ce2e7cebb40d3324de0087ed64fa4e91ebd1ea92ad87e12c0903904285d5db76cff97f54": "0x000000000000000000000000000000000009586161535f444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cb61c8ed9c1a667e3c672a7ed8c3771e42829418dd6781ed468ea3612fbf0512e847fed2a8995535": "0x00000000000000000000000000000000000a494243204d656469610d456e626c6f63204d6564696100000e617669406962632e6d65646961000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cbb6063367ee9c92e81006772a8947817db9e6676f0d67eae9cff6354f2d6ac9392132de4b2a1034": "0x040100000002000000000000000000000000000000000e4956594e4554574f524b2e494f001668747470733a2f2f6976796e6574776f726b2e696f0013696e666f406976796e6574776f726b2e696f00000e404976794e6574776f726b494f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cbd0c872a0daf479a4848ac04c2ad298cfcbf27ade0ddebb2cc3b37b090dd933a1e988b7a3ead075": "0x040000000002000000000000000000000000000000000d436170742d4861726c6f636b0e4c756361204d6172726f63636f1d68747470733a2f2f7777772e636170742d6861726c6f636b2e636f6d1940636170742d6861726c6f636b3a6d61747269782e6f72671a706f6c6b61646f7440636170742d6861726c6f636b2e636f6d00001040546865436170744861726c6f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cc2507f5d267891bbcb50c2942b0d5c8095f4f5ed87d2dba92bbb5c46b78dcdde51fe9fd58c5113c": "0x0403000000020000000000000000000000000000000008526567696f6e5800000015737570706f727440726567696f6e782e7465636800000c526567696f6e584c616273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cc59dc16328b27565822491aa322469edf3e2fe31839f3daebb226c62fbff8c1d5c0a79d18853e2d": "0x00000000000000000000000000000000000644796c616e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cc6a7f8747bd5de8a3a5b1cbef050a59893598ed0817fcc42c7f4faee9d0bdef4a9325a2ad4d3b8c": "0x0400000000020000000000000000000000000000000019444f542047616d657320426f756e74792043757261746f7200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cc6bdb23395a5660e623a613a8a3fd529aaf39b6041c5dc86cae0a8fed13606d621366d876c37773": "0x040000000002000000000000000000000000000000000f4d696775656c204d617271756573001c68747470733a2f2f7777772e6b696e6572612e6e6574776f726b2f001c6d696775656c40696e76697369626c6568616e646c61622e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cc9df1794dc10741c11b9f12fa2747bff85d085211256f60824c4cc1d59459afec8119184fcbba15": "0x00000000000000000000000000000000001b53595354454d20434f4c4c41544f5220505552452050524f585900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ccb59fb10ff3b3c02e05b827a4ba848e1e43ae944fce00c7d0d4c96a38a01eb02cf867bfde7e6b5d": "0x0400000000020000000000000000000000000000000005434354460000124068657866663a6d61747269782e6f726716636f6e746163744063727970746f6374662e6f726700000b4043727970746f437466000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cd131804ccfea9ef22efc513587234d063cb685c5b68172893193192942a565b241626b207f27637": "0x000000000000000000000000000000000008476f6e7a616c6f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cd50be1c014b9821d220801e6e3f65c962363dd64baefae8b383799b3247b29892b15288c476e336": "0x040100000002000000000000000000000000000000000c574f4f4b5926574f4e4b590000001e6a6f686e736f6e2e66696e616e6369616c393940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cd5bc0fba06a116f64cc5984790978efca45099329e5dec0365922e84982e8a277ca4c58756ddb48": "0x00000000000000000000000000000000000b4c616b65727320444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cd624b47e3069b393e8faae4c5713c72aea65d52aa1616d3e918dee3819fbbe08cd4c76dbd754a50": "0x040000000002000000000000000000000000000000001450726f5374616b6572732e636f6d20f09f928e001768747470733a2f2f70726f7374616b6572732e636f6d1b4070726f7374616b6572732e636f6d3a6d61747269782e6f726718706f6c6b61646f744070726f7374616b6572732e636f6d00000f4050726f5374616b657273436f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cd936bdf7e1b9fa87ef3b54d0328f6a7928f8536c2dccb07e8796aca7f3d7e126659105d764d4d98": "0x00000000000000000000000000000000000c526567656e63792d3030351757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ce2ddd4fd1d67791dcba36567d6fbd47af19d77054475a0f4c56dbccab4c13dacd22410f8275da08": "0x040300000002000000000000000000000000000000000d4272756e6f2047616c76616f0d4272756e6f2047616c76616f0019406272756e6f7067616c76616f3a6d61747269782e6f7267176272756e6f7067616c76616f40676d61696c2e636f6d00000e406272756e6f7067616c76616f000d6272756e6f7067616c76616f00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ce2ff9c38ccd13f3964e98590170e1cd1b9a476ed5147431261ac43ac0a9931ac9a9593027619612": "0x0000000000000000000000000000000000086a616d6d61727300000013636363697272757340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ce8bead92c07b351cc83588b4681c7aa4e83598809e195fbce7b0bca4321fe09db96dd814de1fd36": "0x04030000000200000000000000000000000000000000084261766f766e61135061756c2053746576656e20436f74746f6e000017616c70656e6c6967687437304070726f746f6e2e6d6500000b40426564666f72643336000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ce9a50917cf77bb19681fe005baa3099a7d9c03a46e539b173d2b3de75b11e86cd5fbb7d4e92993c": "0x0403000000020000000000000000000000000000000009506564726f37373706506564726f1968747470733a2f2f7777772e726d74657272612e6f72672f00196c69676874736f6e656d7573696340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cedae9c81b8ef8ff42be75cb933073a967d8cb8c6c723028208a678c5a58f5e8f49a237eb33e1654": "0x040000000002000000000000000000000000000000000d4a61792043687261776e6e610d4a61792043687261776e6e610000196865796a617963687261776e6e6140676d61696c2e636f6d00000a40476c646e43616c66000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cee83f43ea0dd41a22b7a9ef681c4a3c1743e5c343ff5b6f8aec3dc43bb0d49e29243d79ed406365": "0x04030000000200000000000000000000000000000000054b494c4e054b696c6e1068747470733a2f2f6b696c6e2e66690010636f6e74616374406b696c6e2e666900000e404b696c6e5f66696e616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cf1074d3968196ede68f570f13d4581940602ee3ea8ebb7c3fca3ee8e21ddf90084b3df3a3ae7336": "0x040000000002000000000000000000000000000000000653696f33340000124073696f33343a6d61747269782e6f72670f696e666f4073696f33342e6f72670000084053696f333437000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cf421cf5662793c2d407fda03feb041adbdd1bed331b9c92168c8d21f31ae1639d0332433d5e2b07": "0x00000000000000000000000000000000000847726162626572001d68747470733a2f2f6170702e677261626265722e6e6574776f726b2f00146e696b40677261626265722e6e6574776f726b00001140677261626265726f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cf4ef5c9ad9aa87e3ac8adb41dbcf04f2d67294fa621940d040400987e05cff6326b1318939db159": "0x040100000002000000000000000000000000000000000d466f72626f6c6520f09f8ea00d466f72626f6c6520f09f8ea01468747470733a2f2f666f72626f6c652e636f6d16406b77756e7965756e673a6d61747269782e6f726711696e666f40666f72626f6c652e636f6d00000940666f72626f6c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cf81097fae6d315cba35e9bf428de9355a0e6fd6ef56ab5e0dabad5f5a8eac3af6f5202e84ac6b47": "0x04010000000200000000000000000000000000000000104e4f54415241535042455252595049000015406b736368657965723a6d61747269782e6f72671f6e6f746172617370626572727970694070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cf8a21b0cdae6e2d1e6e3b7ca66e70b75a1841f3ee48553b310484d34321335e55479232449d6f50": "0x040000000002000000000000000000000000000000001064656967656e76656b746f722e696f0000194064656967656e76656b746f723a6d61747269782e6f726715696e666f4064656967656e76656b746f722e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cfa782accd3d75bebe776c10ad0e1fe7f606cfe42448e02cdb640c21214ea6c0c99df36ec0ee3d0d": "0x040100000002000000000000000000000000000000000f436f6d707574652043727970746f001a68747470733a2f2f636f6d7075746563727970746f2e636f6d0018636f6d7075746563727970746f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cfac989e84b5ad935ee1e16ea093ea043d7f67a6f34f440c5fb921b56b54e81c177898d348685b51": "0x04000000000200000000000000000000000000000000095354414b452e5355000016406d722e6f776e6167653a6d61747269782e6f72671d7374616b652e736f766965742e756e696f6e40676d61696c2e636f6d00000a407374616b655f7375000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cfc0cc32c14f6b1b1c2a5f648afea2a94286c17f6c60d16c9ef8511fa4ae88a54ce2748b6c8fa90f": "0x080000000002010000000200000000000000000000000000000000054166726900000f406166723a7463686e63732e6465126166726940636861696e736166652e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714cfe3b56da886c4b6e23cf83af2b043696cefcbe2ffe680eba45ccf26d6d9a354d742bafd45aaf2e7": "0x00000000000000000000000000000000000c50414c2043757261746f72001f68747470733a2f2f706f6c6b61646f746173737572616e63652e636f6d2f000000001140506f6c6b61646f7441737375726564000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d094e3cac725c344ac1b1e12bfb60e8225efa102d2f6f74ccfa53d583571363505fb54feeacf8c2e": "0x00000000000000000000000000000000000d504f4c4b41444f54204d4143114d617274696e204d63446f6e6f7567680000196d61636d63646f6e6f75676840686f746d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d09eaf34f53d7c401480bc228ee751c1aca34061c4952efb304aa94beed8e38fd9c5e693f62c3f26": "0x04030000000200000000000000000000000000000000066365736172066365736172000016636573617267653133303240676d61696c2e636f6d00000a43657361725f476573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d0d3d5efedb29953decf71909282816105360e12c52694c8e39f30f82532be18b3e32e3e435dbf08": "0x0000000000000000000000000000000000064b43435f3300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d1067d55a33c02831232508adcaf57c6e78a850f9d715e3694b52000ce537832eb55c7a59f859e13": "0x040000000002000000000000000000000000000000000a524f544b4f2e4e4554001268747470733a2f2f726f746b6f2e6e657418406869746368686f6f6b65723a6d61747269782e6f72670d687140726f746b6f2e6e657400000f40726f746b6f6e6574776f726b73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d113bb3ee11e240450c816dc61aa6fa2afb1d48ab14435942be7296f10b310653c80325af700c166": "0x04000000000200000000000000000000000000000000134b6972696c6c5f5448452047656e6572616c00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d16f6c8ce2379b06a375190836f6df983719441a0f32b28a7448ed785bcfdb67c5f6061b9654335f": "0x000000000000000000000000000000000010416c69616e7a612048697370616e6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d183e95ab708f0d6785f4c6690a6c2bde954d46c627698f5730072791cb5485116c678d89974230c": "0x040000000002000000000000000000000000000000000c417263656d204d617269730000000f6e696368406b61786f6e2e6e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d1eaa7d142bf1e42a200be596abc1fb84833a9440274227b2f9709e573abf14d0c6b2fc58ed3a50f": "0x040000000002000000000000000000000000000000000d47726567205a61697473657600001540677a6169747365763a6d61747269782e6f726712677a40756e697175652e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d1ee388cb4a93ade8c16e2cb1309a3ab9b697e3c80a5cad5dfded90b04e2d8943f2e0835af140a77": "0x040300000002000000000000000000000000000000000856616c65726969125379646f726368756b2056616c6572696900001473766d31393835756140676d61696c2e636f6d000011405369646f726368756b76616c657232000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d1f6cf7981174df67aa5506d9391c78c760cf7490a5f7412a1fea6cb4969119a11f49429818b1d97": "0x00000000000000000000000000000000000631345745421757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d25b2b83caf5ac06d857fcac7bd9bb03551d70b9743895a98b74b06e54bdc34f1b27ab240356857d": "0x04000000000200000000000000000000000000000000065465736c610000001b7465736c612e76616c69646174696f6e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d27b00c2f56f7b336c31b105bf4566e9837d11fc54b523f7b3ec8993f8c880b1e0c283d7bcd0aa53": "0x0401000000020000000000000000000000000000000011e2999e47616d655468656f7279e2999c0000184067616d652e7468656f72793a6d61747269782e6f7267136d61696c4067616d657468656f72792e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d2f4c0196c97de9d14eb0f8e9dd9e3ad05eb774e3158b4c432bdbd5f64f0fb78a25b4d1863c0f468": "0x040100000002000000000000000000000000000000000f4c6f7569736520572e2052656564144c6f75697365205761727769636b20526565641668747470733a2f2f7374617961666c6f61742e696f00156c6f75697365407374617961666c6f61742e696f0000114041666c6f6174546178437265646974000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d2f5f529ff74e1246425fc08d539497b1f466d8528211fd89b2e222eda9d39f7bd1967bf9e6f5f16": "0x000000000000000000000000000000000006486572736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d343694d94be95e2744405c2356641a0d373433e220c5b03d3ffd2bc3e528574e19068b4c2490614": "0x040300000002000000000000000000000000000000000847c3bc726b616e1347c3bc726b616e2053656e656d6fc49f6c7500001a6775726b616e73656e656d6f676c7540676d61696c2e636f6d000009307863666c6f6b69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d3a269b657e1dfd090a4c78f16c247b4b438a25734d0479b32c196cacb25ecc95a79480dfc6cee7c": "0x04000000000200000000000000000000000000000000077368616d6230000013407368616d62303a6d61747269782e6f726713722e7261616a657940676d61696c2e636f6d00000940307368616d6230000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d40d5206d8ab23bb285de1abe8f2e26bceb56db8969b332803ecfba0d4baf49e1e9c31c80748747a": "0x00000000000000000000000000000000000f55542046696e74656368204c61620f55542046696e74656368204c6162001940757466696e746563686c61623a6d61747269782e6f726712636573617265407574657861732e656475000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d435a9777e7ecc393c5862ed65c524b7bb3564776a81904218f44f3d7c35162a608e39dbadbcda05": "0x0000000000000000000000000000000000084e61742d446f74134e6f7220536166696e617a20417a726169650000166e73612e70796e7574323840676d61696c2e636f6d00000a40316d5f39794e3437000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d43703150f1fcc536a21a0e28cbaa3132b3abfdc4240eaf50bd237467690de245441612261e37571": "0x040000000002000000000000000000000000000000000d456c6f646965207c2057334600001840656c6f6469653a776562332e666f756e646174696f6e17656c6f64696540776562332e666f756e646174696f6e000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d44074de089225b9404fb63cfb2153551f4497165a2262d420453628d4c0f790c9b11ca4748bb139": "0x040300000002000000000000000000000000000000001ff09f928e20537061726b6c696e6720426c6f636b636861696e20f09f92bc1a537061726b6c696e6720426c6f636b636861696e20f09f928e00001a7a766167656c736b79657667656e7940676d61696c2e636f6d00000b40457667656e79795f41000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d476d3200736c2bcc42bd98a8029cf3787ee280a8980b4a8d5f152ebc2705cb48b4c7ee6daad0268": "0x000000000000000000000000000000000014506f6c6b61446f742043726f77644c6f616e7300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d4859e78fba22c21ac2091f6d5251183c62941cde5cd3e10ffcb6d418d42e03ebc6f1945a817f76e": "0x040300000002000000000000000000000000000000000a4d6574686f642e67670f53636f7474204d634d696c6c616e1768747470733a2f2f7777772e6d6574686f642e67672f0013706f6c6b61646f74406d6574686f642e6767000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d4a79ae0ef45ec63a455ccc77072570b273044973e0ab6f56d3325421584a479eed68f84603e034f": "0x08010000000203000000020000000000000000000000000000000007417373657458001368747470733a2f2f61737365742d782e696f00107465616d4061737365742d782e696f00000b40444f54417373657458001334313630333438343133393436373537313200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d4ed4dd340a2cebbbc486ed2f394da6e6b58b130687b48d3d19f756ba6d0655d37bf58ff0f59f974": "0x04000000000200000000000000000000000000000000124164616d5f436c61795f53746565626572124164616d20436c6179205374656562657200154061737465656265723a6d61747269782e6f7267176164616d2e7374656562657240676d61696c2e636f6d00000e406164616d7374656562657231000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d4f4dfc6da461b20aa72c321b20bbd5b78b14f6fd800017bca47190956eb42ada2a4d8f8a8ca994d": "0x040000000002000000000000000000000000000000000df09f97bb4261736563616d7000001840776f6c667374726f6d32373a6d61747269782e6f72671b6261736563616d702e7374616b696e6740676d61696c2e636f6d000011404261736563616d705374616b696e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d509c5c59195b1ec5c3739d60301126756a7510e34f9d656d4435cd4fe64bbd001f1f3473bc9c333": "0x04000000000200000000000000000000000000000000055a656b65000017407a656b653a6d61747269782e7061726974792e696f0f7a656b65407061726974792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d5150021507a071f86420f7843bff8fcee7d1bafae828d0d0c3668bfca8150820be3e774e8aa8c2c": "0x040000000002000000000000000000000000000000000b5472616e736973746f721c5472616e736973746f7220506f6c6b61646f74204e412c204c4c4300001179407472616e736973746f722e777466000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d53a56fa8630064970eb89fbedb6567f5061f23f2da6c73feb710676d618a205a28d643451c48a72": "0x040300000002000000000000000000000000000000000a616476657269636b790f61647665726c6976652073726c73000014696e666f2b646f744061647665722e6c69766500000d61647665726c69766573726c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d5ab2f60e5f823fd07cd066334cc9ed0e17a3a845a9efb144c25c9741d63102d88380c7f20ecd7b9": "0x040000000002000000000000000000000000000000000d44617070466f726365204d530000001464617070666f72636540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d5e66d23eb784c1150fa056fe8636d5041e3a460e63839603087bf789ce60514f00bb2473b728e4b": "0x000000000000000000000000000000000014506f6c6b61646f74202d2050432047616d65721e53c3a97267696f204f74c3a176696f20466f6e736563612053696c76612168747470733a2f2f7777772e796f75747562652e636f6d2f6368616e6e656c2f001973657267696f2e6f746176696f4069636c6f75642e636f6d00000f4061706f6c6c6f74686562756c6c000d63726970746f6d6f6564617300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d5fdc8ab7d97949ee424b2ee4c8a8fb3334248367a7a7e5c2d236205368cd4aee4e8ae274fc45566": "0x040300000002000000000000000000000000000000000c4b616d70655369676e6572144368726973746f7068204b616d70697473636800001a6368726973746f70684073637974616c652e6469676974616c00000844614b616d7065000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d6392158cf43d6cab4358371ed445b0650e6b0a3c749c3a8674db5eeccc75103beb78b0a903bf32b": "0x00000000000000000000000000000000000a4d6574616b6f76616e135669676e6573682053756e6461726573616e1668747470733a2f2f6d6574616b6f76616e2e636f6d000000000b406d6574616b6f76616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d64d4d86c0b29268f2931a66c7207e83365c6425ff0756499e2130ad00b384731c7290c8536c53ed": "0x04030000000200000000000000000000000000000000084445444341505308444544434150531368747470733a2f2f6465642e67616d65732f0013444544434150535840676d61696c2e636f6d0000094044454443415053000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d6ad5303bac6267692286c3c817a7beb00fd0398384e170dcdb5dfcccae635adc3d8426119594a0a": "0x000000000000000000000000000000000008546f706f6c6b6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d6bff5ea3e68b58898185ec550ab27fe12285719dc1bfc83a8dd7d3e77a32c0fb4e12be09b79ad48": "0x040100000005000000000000000000000000000000000e41454d20416c676f726974686d0e41454d20416c676f726974686d1c68747470733a2f2f7777772e61656d616c676f726974686d2e696f0018737570706f72744061656d616c676f726974686d2e696f00000f4041454d5f416c676f726974686d000d6a616b7562736177637a756b00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d70ae159e1aa09aa28863c0c3e58d40a623b4cabef57d2ba807fdb703c4fb481d5fce365858e7224": "0x000000000000000000000000000000000006566974697300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d74bea4c3bf5621814d0ddb81faf43b169f397727a277d7cace318bdfce287d90314e72e4dce490c": "0x00000000000000000000000000000000000c4a61636b7974617572757300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d789194338d34070928263bfc144cfad6e7e62923f27cd0e8df2af4bee9eeb4784dbf7a48b0a296c": "0x00000000000000000000000000000000000a6d61645f616e676c650d53616368696e205465647761000019746564776173616368696e31323340676d61696c2e636f6d000000000a6d61645f616e676c6500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d78e3922994e68f87b1c17d66cb08fdf1d84ccca7767bb71ec36658ff95c522951b103c8cd8623ea": "0x000000000000000000000000000000000009596f6b6575736f6e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d7906ae903234547463a9cd3e7cec50ccc93515557ab58221d20c67a409583428ad67caff9415107": "0x0401000000020000000000000000000000000000000011436f68696261436f6e74726f6c6c65720e4d616179616e204b65736865741468747470733a2f2f6d616179616e6b2e636f6d14406d616179616e6b3a6d61747269782e6f7267136d616179616e406d616179616e6b2e636f6d00000e406d616179616e6b6573686574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d7a036c9790a85a62c0b2cfdc7507c42c88c22c0eadedd30251b090cc8de670c436ecd91186b5136": "0x000000000000000000000000000000000003421900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d7a5e201687ab46302982c3a62acf008c3ac7793286c0f7b93efeac8de80e9ec9733bfd477148707": "0x0403000000020000000000000000000000000000000007616277726c6400000018616268696d616e797540646f75726f6c6162732e78797a000008616277726c645f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d7b596e66afccd2bd89ea70e822e338b7519379e4a4685595da674fd167b7bd12dbfd10c9bc2b50e": "0x040100000002000000000000000000000000000000000d44617265646576696c337837000000134372797970746f7040676d61696c2e636f6d00000e4044617265646576696c337837000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d7efccf788fb1a6528d50241999da5b300f01f3004a67a25a11854608f1f437ab86ed2e115243a43": "0x040300000002000000000000000000000000000000000a4b7261746973743073000000186b72617469737430736e66747340676d61696c2e636f6d00000a6b7261746973743073000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d8462e30b1801504cc3d040787c25df74513d303f228e590e9e0156cc54790d6720d607420e80165": "0x04030000000200000000000000000000000000000000094c6176656e6465720000001c6c6176656e64657265737468657232303240676d61696c2e636f6d000011406c6176656e64657265737468657231000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d84deb4759f2e2e9f6a7fa830da55dde09b411ff877ed0ee8fd1ceb2009067ab5bc0ffdc54af4065": "0x0400000000020000000000000000000000000000000011416e6b616e2028706f6c6b61646f742900001140616e6b616e3a7061726974792e696f10616e6b616e407061726974792e696f00000006616e6b346e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d85c06897a6dfc1b8cee324d4a0f2bce600a681a3ba2f4cf507c83012008f01557f2c5e413b76066": "0x040000000002000000000000000000000000000000000e4441524b5f504f4c4b41444f54000019406461726b6c657373323030313a6d61747269782e6f7267196461726b6c65737363726970746f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d883005234a96e92bc64065524532ed9e805fb0d39a5c0199216b52871168e5e4d0ab612f8797d61": "0x040100000002000000000000000000000000000000000741524b5041521141726b61646979205061726f6e79616e00134061726b616469793a7061726974792e696f1261726b61646979407061726974792e696f0000000761726b7061720000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d8e0253a5ce94a9a125858e5bcf61ff597c01f811fe12e66f34e0b2ff135e48a03c51c3234afe97f": "0x04030000000200000000000000000000000000000000084d656e696c696b0f4d656e696c696b204573686574750014406d656e696c696b3a6d61747269782e6f726713737079786d656e6940676d61696c2e636f6d00000f404d656e696c696b457368657475000a406d656e696c696b3300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d8e02c95f42c870728c57701aff086e2d4d00536a35ebb0dea7732d5bd285c63fac7197b6bf3e37e": "0x00000000000000000000000000000000000a4c7567616e6f646573001668747470733a2f2f6c7567616e6f6465732e636f6d0013696e666f406c7567616e6f6465732e636f6d00000b406c7567616e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d90301728ff0374ae4d7ebfe2f9bce87c9b49975fe7de84393c376b29ee297be934ac540d8a6381b": "0x040000000002000000000000000000000000000000000a434f494e53494445520000000000000f406a6f696e636f696e7369646572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d9275dddf1009186a0c8063be933d442a3453e47d22a9d53344c604f71cb0f70c1f67c0129cf6137": "0x040300000002000000000000000000000000000000000a63727970746f6d616b0c446965676f204d6172696e000015646965676f6d616b40686f746d61696c2e636f6d00000e40446965676f6d616b5f6d6564000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d9402b8cd99c1552705e3020123277ead705580b26edbab0e534d5941db23a8216a430962ada9519": "0x00000000000000000000000000000000000a53616e74697468616d00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d9cef13374a70e655010efb7049583595fbe3da57dc5db048e590c28f107e5e4fa2bdcc4b1293f6f": "0x040000000002000000000000000000000000000000000b43727970746f6c6f677900000014746563684063727970746f6c6f67792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d9e0312b39961bc6726a98c27f84bf42fc842794a925418335fc9fe3badb1f535dce9c9d9efcc02d": "0x040000000002000000000000000000000000000000000b5473756b6920f09f8c9500000019636f6e74616374407473756b697374616b696e672e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714d9ebec847667f8a9dc028a7c1bfd7e24a64a11564b7384e571e27e33bddbae91f978ac1a6ead7310": "0x00000000000000000000000000000000000a5368756d6f20436875000000107368756d6f2e63687540706d2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714da23f4f6f4d9e6bc96140a201be6f41e63c5b3bf6b02f67da3f232c6715397302494f894f964ac78": "0x040300000002000000000000000000000000000000000d56696e6365436f72736963611856696e63656e74204469204769616d626174746973746100001076696e6365407061726974792e696f0000114056696e63656e7444694769616d6231000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714da40d28d53abbfcf16f9415c34da11ca5a35f3f18627af4ef312d90777ed086ea20e364b11656921": "0x040300000002000000000000000000000000000000000667656e67650d476f6e7a616c6f204574736500001667656e67656b7573616d6140676d61696c2e636f6d00000d4067656e67656b7573616d61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714da588541e0520af8802a229c888897bfe30ff149788e0dce8e078f2f4ebc0533dc44ca4c9960100b": "0x000000000000000000000000000000000018506f6c6b61646f74404574685461697065695f3230323400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714da6dfa4d6fcbad64768ac003ffdf15238a61c42e781d16331ca3cb2805e06f602469206d6a795734": "0x00000000000000000000000000000000001c62616c73656c6c732f506572646f6d6f2d70617261636861696e731e6672616e636973636f206a6f73652062616c73656c6c73206c6f70657a0000146662616c73656c6c73407961686f6f2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714daa67a441fadf00ca2b09b0a84ba632e3745eacd5cc7dde15c73b61255bd6376177a907b4e830079": "0x00000000000000000000000000000000000c4b6f746f2053747564696f0c4b6f746f2053747564696f1468747470733a2f2f6b6f746f2e73747564696f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714daa6f458469f7726be386bfcdd57a31913902c8092cbb4e721e9bdcd6babebe0831a4ff52c260431": "0x0400000000020000000000000000000000000000000004737077000018407370656c6c7765617665723a6d61747269782e6f7267147370656c6c77656176657240676d782e6e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714daadc5f0b3a48319d4f44a50f35f9340aad2b3666011f78afa719f5e80a0c4f3969525729c35e654": "0x0000000000000000000000000000000000174a61636b20506f6c6b61646f74202f204b7573616d6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714daf5619ede74e518e90ce79e0167f82e66250b1cfab388aa86a2e2b1e893907b19932e6751a08e04": "0x040300000002000000000000000000000000000000000c416c6c696e43727970746f001968747470733a2f2f616c6c696e63727970746f2e636f6d2f0015696e666f40616c6c696e63727970746f2e636f6d000011405265616c416c6c696e43727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714db02485938505b5136bae49de1ebc06355938e2cfe64ae4b27d6741c070bf817042eaeeae226d741": "0x04030000000200000000000000000000000000000000065742526f620e526f6265727420486f6c6d6573000014686f6c6d6573726a406c6976652e636f2e756b00000d40486f6c6d6573726a526f62000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714db20fbbd4ec3b172c1df5c7e8ca56037450c58734326ebe34aec8f7d1928322a12164856365fea73": "0x00000000000000000000000000000000000d44617669642053616c616d690000000000000f64617669645f6f665f6561727468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714db39fbf092d6577f4d5cfb0370c406b3cd3d9db1517bca918bdc96629af87092cfb09989a2d0388a": "0x00000000000000000000000000000000000f63727970746f76656e64696d6961001c68747470733a2f2f63727970746f76656e64696d69612e636f6d2f00000000104063727970746f76656e64696d6961000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714db4e290a8c8e6d7d4c8dfef612efd6af3b857c60a4350f446e795aaef08c419649d7f8f65955eb15": "0x04030000000200000000000000000000000000000000144a756d696e73746f636b20506f6c6b61646f74124361726c6f7320526f6472c3ad6775657a0000156a756d696e73746f636b40676d61696c2e636f6d00000b6a756d696e73746f636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714db51125ce2e8c4560c2017a4f115c013d899b494c955a7ec4cc9786a3997f1823baacc213896a35a": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2031001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dbc32343b195f2c99256c8dc61df081bf36a5ee0f1bb8c987003aa1ed4fa3dcc93c05dfec013f27b": "0x00000000000000000000000000000000000b416c657068205a65726f001a68747470733a2f2f7777772e616c6570687a65726f2e6f7267001468656c6c6f40616c6570687a65726f2e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dbc647e39c873964a0f2dda8e1a5b5f1820545ba2f4d33f1d99e259c9a3e8071329f84c07f40f514": "0x04030000000200000000000000000000000000000000064a616e6b6f114a65616e6d6172636f2052616e6768690000166a65616e6d6172636f696e40676d61696c2e636f6d00000752616e676869000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dbf7430d0eb6bd0486c273a2e537718a8bb986e964a0eb5e5e525ab6ee44e191d7ba645cac2efe05": "0x000000000000000000000000000000000017506f6c6b61646f74206961627369732067696c6c65730747696c6c65731568747470733a2f2f61697264726f702e636f6d2f001567696c6c65732e684061697264726f702e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dbfc69131dbd305c4c2ded7ca2dd19095123de090a46149c2047d0aa4c6ce195490563d881f7491b": "0x04000000000200000000000000000000000000000000085369726a657931000014405369726a6579313a6d61747269782e6f72671b6e69636b6f6c61736a6f73687561303040676d61696c2e636f6d00000b4044725f5369726a6579000d5369726a657931233237313300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc22c730a7ef5a54488b87e574eee2f9b8e7810eb3567edffc303c4f9c76946da200ce429b444d59": "0x040000000002000000000000000000000000000000000a4d617843726970746f000000166d617863726970746f6f6b40676d61696c2e636f6d00000c404d61785f43726970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc33802d5bdfa7529ef6dd302c66ad6ee5ee679f6fd7c3ff4b19489daad6680691aa209b719f2139": "0x040000000002000000000000000000000000000000000a6c756e617220646f74000000196c756e61722e706f6c6b61646f7440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc5da19e1472ceec06dd5a888daa57d1bcb763f269e5cf4bfe73b44d106b34ce572dcee124057a6b": "0x040000000002000000000000000000000000000000000a414c454a414e44524f001c68747470733a2f2f6769746875622e636f6d2f616c336d6172742f1440616c336d6172743a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc60ff49e9f778bbd24bfa7e01cb86e6eab810a04a61d7bc3c32c094afd5b4739194c9583a69d238": "0x000000000000000000000000000000000015506172616c6c656c2046696e616e6365202d2032001568747470733a2f2f706172616c6c656c2e66692f000000001f68747470733a2f2f747769747465722e636f6d2f506172616c6c656c4669000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc6d83874526905136aff2ede1563784631d6149024982108f661b079b6b79f3d042041a9da11e2a": "0x040100000002000000000000000000000000000000000748616e77656e0d48616e77656e204368656e671d68747470733a2f2f7777772e68616e77656e6368656e672e636f6d2f164068656177656e3131303a6d61747269782e6f72671468616e77656e406c6974656e7472792e636f6d00000a40635f68616e77656e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc79486ab3b689692440bee5d463a2cd234b5d8fb3b6eeb3f91b5fe9e26267846abaf7cbb154524b": "0x040000000002000000000000000000000000000000000b416e64726564796c616e14416e647265204443204472204c616e7a6f6e692168747470733a2f2f7777772e6c696e6b6564696e2e636f6d2f696e2f6164636c11406164636c3a6d61747269782e6f726717616e6472652e64632e6c616e7a6f6e6940706d2e6d6500001040616e64726564636c616e7a6f6e69000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc7d270f233cb625a6ac5af2b37a6bb6d5c9cbb7fa56748fb1c9cf9ad1ef43334efa76a431aa3d22": "0x04010000000200000000000000000000000000000000175375706572636f6d707574696e672053797374656d731a5375706572636f6d707574696e672053797374656d732041471368747470733a2f2f7777772e7363732e6368000c696e666f407363732e6368000008405343535f4147000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc87dbc53489aff444fd1d056884026869c3a2ca0d5f75455995962bbd5f5676b9aefed98d176c22": "0x0403000000020000000000000000000000000000000005526963680b526963682043617365790000177269636869656a636173657940676d61696c2e636f6d0000097269746368637379000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dc98458dbb1371bf08d31593110e775453dea202d90d97424b66f31b337467ecd5f3bf86329d3b97": "0x040300000002000000000000000000000000000000000a43617270656469656d000012406a6469656d3a6d61747269782e6f7267146a7361766f406d61696c66656e63652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dcb7b0516f93e814720d807d46b941703ffe0278e8b173dc6738c5af8af812ceffc90c69390bbf1f": "0x04000000000200000000000000000000000000000000076f726469616e00000018706f6c6b61407265757361626c652e736f667477617265000000076f726469616e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dcded909158c7cfe7cca49e0d4903aeefcfb804fb07b71195a216074f9194f611991ede515e8ba46": "0x0403000000020000000000000000000000000000000006417661746111417661746120486f6c64696e6720425600000e696e666f4061766174612e676700000961766174615f6767000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dd3ab7da34fe2f80d646eb13c8251f905355c49d20ff0fff32f649474a97d040d8b5165e9ec74926": "0x00000000000000000000000000000000000e4a6f6e6174616e20537461736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dd5ac43b991d5bfdf68fd95ffc9cc02f15e28ce9df041da32f3b564e249fb4a8caa1c5135b1fad4d": "0x0400000000020000000000000000000000000000000005496767790000001869676e6173692e616c6265726f40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ddd17007ceeb939fb4d78a8bb35a7b0ff8ae6a7808f9b17c83efd28b8612c2388034d0e35ce51376": "0x040100000002000000000000000000000000000000000c5374616b696e675465616d0c5374616b696e675465616d1968747470733a2f2f7374616b696e677465616d2e636f6d2f18407374616b696e677465616d3a6d61747269782e6f726715696e666f407374616b696e677465616d2e636f6d00000d405374616b696e675465616d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ddee1d127f978b69654acc3f002ced5c8d1fbce6268485fe0a2be3d624d32b6e53132daf8f28a380": "0x0400000000020000000000000000000000000000000018564953494f4e5354414b4520f09f9181e2808df09f97a800001840766973696f6e7374616b653a6d61747269782e6f726715696e666f40766973696f6e7374616b652e636f6d00000d40766973696f6e7374616b65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de11e082d85cbef160f94710848d9dce161724f257a240494c901728bdf2fa51c138fc5580ee3134": "0x00000000000000000000000000000000000e4a6f6162204e697761676162610e4a6f6162204e6977616761626100001b6e697761676162616a6f61623130303040676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de218ead5d0a168c9228177e3d9e1bfbd17975b3185cc99dc6b235a2bfd42609ab31f3f3059d6e6b": "0x040100000002000000000000000000000000000000000d6469676974616c6d696e747310542e20412e204d696e7a656e6d61791968747470733a2f2f6469676974616c6d696e74732e636f6d0019636f6e74616374406469676974616c6d696e74732e636f6d000011406469676974616c6d696e7473636f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de4e384e5c5bcda65ac4bbe840e332da2656c0e760904003fa7a2123a216a33e81b8531400600304": "0x04010000000200000000000000000000000000000000095869616f476f6e67095869616f476f6e6700144072696368656e673a6d61747269782e6f7267113435353433393034344071712e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de5652b31dd1f614c6aff670231f257996dcabb052286394791d85d4be9d8635cc14df0c11e67864": "0x04030000000200000000000000000000000000000000144a6f686e206f662074686520707269657374730f4a6f686e204d756c6c6f776e657900001b6a6f686e6f667468657072696573747340676d61696c2e636f6d00000f404a30686e4d756c6c30776e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de570a3f6eb03219824c1f132f117e3bfad5f23d7d68cfbd3022c11214b4154ad0ab329351365547": "0x040300000002000000000000000000000000000000000a56616c656e74696e610000000d73636861696e40706d2e6d6500000d40307876616c656e74696e61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714de8c0cc61d322ab8b0a6788e02cfb0b5c9629a2153e9f26b9f1122ea8a03abf85cf8e3aacc76ec2b": "0x04030000000200000000000000000000000000000000076c696b6b65650e4c696b204b65652043686f6e670000196c696b6b65652e63686f6e6740686f746d61696c2e636f6d00000c6d61706c65726963686965000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714deb3e9bfbd8d3c590cf6b6cdababf69c2af37a41a2f360820bb7dff2f61c20bb61a9503a8901ee20": "0x040000000002000000000000000000000000000000000f4861736865642053797374656d73001268747470733a2f2f6861736865642e696f124074656b69743a6d61747269782e6f72671068656c6c6f406861736865642e696f00000f4048617368656453797374656d73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dedb59bd6fbcfbabc75c3b5f909a0c53c58fe9ab06b9cd336e82918b3275d402c2dd8501455f1769": "0x00000000000000000000000000000000001b5765625a65726f204576656e7420426f756e74792050726f787900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714deefe5d90b67b654b66953df31de525fd4c075b30b266f8fca1f29533c9dd7d45128408726d19979": "0x040000000002000000000000000000000000000000000f73656e7365696e6f64652e636f6d001c68747470733a2f2f7777772e73656e7365696e6f64652e636f6d2f0014696e666f4073656e7365696e6f64652e636f6d00000c4053656e7365694e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714df04aa6913361fbfc6c5094505321fb73284b9882d87d66bd6ba692faf1a4f5254d977dad8934801": "0x000000000000000000000000000000000011496e7465726c6179204e6574776f726b0014687474703a2f2f696e7465726c61792e696f2f000000000c40496e7465726c61794851000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714df081b6eb6159ca822e0586d9ca1db9e8e60a7eaea3fdbbe6fd5238477c91d04e1532b1ed251d251": "0x04030000000200000000000000000000000000000000085042415f54494d0a54696d20446f62696500001574696d40706f6c6b61646f742e61636164656d7900000a4074696d6164616d64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714df3b8158c3a22b52c8660fc9479c8b741d2065985d0b77d00a36a50900438d83ba70ab138f528326": "0x00000000000000000000000000000000001054616c69736d616e20506f6f6c2032001568747470733a2f2f74616c69736d616e2e78797a000000000f40776561726574616c69736d616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714df56e27f047aded67252b4b1f8103acd6ff363c971c7dea21afc0285ad5ad75176dd53947a6aca4b": "0x000000000000000000000000000000000012636172746569726120706f6c6b61646f7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714df658b757ba3a7aa702baf94343fc34fc6b80b225c14758484c91816726a7b3951bc0ce1daae9f53": "0x000000000000000000000000000000000005696e6b21001068747470733a2f2f7573652e696e6b000000000a40696e6b5f6c616e67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dfdd2a5f61982fba4297a93d2faba768a0be3c2a69bee7a17d73264b9adebae51e28e7b37463f91d": "0x04000000000200000000000000000000000000000000064e3444524f00000000000007404e3444524f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714dfe38f3528e245c5c66d295453335e1fac0d88b96160f5643d0bc4ae9eeeb8402f26c866187b9960": "0x040000000002000000000000000000000000000000000d426c6f636b2042726964676500000016626c6f636b6272696467654070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e01ab7ee15ada6e3eeef86dcd6803a23da2d5a8834ce66fe3e9f705bc756dc0e835741d68f200762": "0x04000000000200000000000000000000000000000000056c6163680000000c69616d406c6163682e7077000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e02c902560555f54d44824ac8d1edecca67639ca74d208bd2044a10e67c9677e288080191e3fec13": "0x0000000000000000000000000000000000076f6c616e6f640d44616e69656c204f6c616e6f0018406f6c616e6f643a766972746f2e636f6d6d756e6974791264616e69656c40766972746f2e7465616d000000076f6c616e6f640000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e050fe4b1877288206c7ea7684b6aac6cd63cf88c92b0f05398bc3e13e0b0c5936c3027b8e0c7e2f": "0x04000000000200000000000000000000000000000000105b5279752d4361706974616c5d2031000017407279756361706974616c3a6d61747269782e6f726713727975407279756361706974616c2e636f6d00000c405279754361706974616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e08890d6de27a2900e117eb473a2617377b8ddcab2e411131969c226ba36618ea24514b6f736b77c": "0x0000000000000000000000000000000000094d6f6f6e4e6f6465094d6f6f6e4e6f6465000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e09d6b3fcb94c12410446dd351747cd3a9557e288b706aa824c74440006e9730a806a2b5d16f2e51": "0x040000000002000000000000000000000000000000000e4b494c542050726f746f636f6c0000000d6b696c74406b696c742e696f00000e404b696c7470726f746f636f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e09e422aff2862656cb9c61a3d59451f446f191f7e41facb800ab8c789255af69fe0d6ca397e1238": "0x040100000002000000000000000000000000000000000b6b616974656e63757261000000156b616974656e637572614070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e15938b3e3caed8b5c0ad5714ebe5c2ff7ba60c09f693cfe2582ba7dd65e1feb74b1c99cccb75079": "0x00000000000000000000000000000000000f4c415945522043414b45202d2031001968747470733a2f2f6c6179657263616b656361702e636f6d000000000e406c6179657263616b65636170000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e16c7dc70b9d971f180f3232cf72cfbc3f350733ec10eb9ba8a135e3831d813259c3c7e3d46fca2c": "0x00000000000000000000000000000000000b43727970746869726f6e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e177989adf0462e92c02b3a008b94bf4a9e846002dba45ed38eb41ef3c8edc223403723b3301a331": "0x04030000000200000000000000000000000000000000065a65657665065a6565766500000e72617669407a656576652e696f00000830785a65657665000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e18d41e2249b70ec4eb32a5fbbccb1d97d31237172fbfd92945caa6822d5f8afb558aa7b89bc5a11": "0x040000000002000000000000000000000000000000000753616b7572610000174073616b757261746563683a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e1b94c49ca35815a7e9b1d7500a5e651f1faf14965e6993c10eddb1bdbcc1ca2e4d0812320c42216": "0x0000000000000000000000000000000000104d656e6e6120416275656c6e616761164d656e6e6174616c6c61682041626f656c6e61676100001b6d656e6e61742e616275656c6e61676140676d61696c2e636f6d00000000106d656e6e6174616275656c6e61676100", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e207ae5a1f676e495a39c793248e0a8cac2ec88172c7d1a3b2f10c6c2455e20c5dbb739cf3e9ea0a": "0x040000000002000000000000000000000000000000000959414f20476d6268000000176c756b6162616c6173686f7640676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e21241c1f77eea219c34bbbde6bff80d45a0e9f3500e7aebd52d558fcd919b2e0d788dd8728a047a": "0x0403000000020000000000000000000000000000000018416e61656c6c65204c5444207c2045636f73797374656d00001740616e61656c6c656c74643a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e25361ec814d346808ebc46e11c7f7ba99411e693af6481ceb7cc935cfc5b2344a9831f915f6555e": "0x040100000002000000000000000000000000000000000d444953432d534f46542d31310e4469736320536f6674204c74641a68747470733a2f2f7777772e646973632d736f66742e636f6d154064697363736f66743a6d61747269782e6f72671876616c696461746f7240646973632d736f66742e636f6d00000e4044697363536f667457656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e26d187c65071fe036da1284412c9f435d93ae01474705ea7f0ac3154103a0d08f3efabdbb389345": "0x000000000000000000000000000000000009436f696e62617365002168747470733a2f2f7777772e636f696e626173652e636f6d2f7374616b696e67000000000d40436f696e62617365446576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e2bc3b02d70c5dd5bab650983063ab81171b9efc65665326b507438d99994d489f07ef16bcc93d6b": "0x040000000002000000000000000000000000000000000f535452415742455252592d444f5400001740737765657462657272793a6d61747269782e6f72671d73776565747374726177626572727933303240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e2de10fd49d4b23394472b8251f87622be5a6c44f9eb3fcd59038eda7f08163511cbe8aeeb584136": "0x00000000000000000000000000000000000b4d494b452d537461736800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e2f69a0dbf9d98314642514ce6e9e7fb66ef4334728307f47be8b2509e6fa870a7685f3e560e3a08": "0x0400000000020000000000000000000000000000000007706569726f6e00001340706569726f6e3a6d61747269782e6f7267177461696368756e673939363140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e31041f839b1c98afe111b571b0ba64cb8365c7e9bba1e412d6fd57634a54bd1996314689e061a68": "0x00000000000000000000000000000000000843727970746f72002168747470733a2f2f7777772e796f75747562652e636f6d2f4043727970746f72000000000c4043727970746f725f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e31192e1956f8f3aa6996ba5fce10b5419b5a9fd55998b5d7fde4922e61f93b021cb2cf6dfd5707e": "0x0400000000030000000000000000000000000000000006426a6f726e0e426ac3b6726e205761676e6572001840626a6f726e3a6d61747269782e7061726974792e696f10626a6f726e407061726974792e696f00000b40626a6f726e77676e72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e333905c7589ca5182526dcb428e7f915dc46c895f155ff1b31a93371b4f7c59aa89569beacd2b03": "0x00000000000000000000000000000000000c506f6c6b6177616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e33504e56333a26eec8073c78e4291eadb0184b89afe2f9389c762e6e869329275dde3f729507251": "0x040300000002000000000000000000000000000000000748656e7279500f48656e72792050616c6163696f7300001968656e72796470616c6163696f7340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e35aea91533fa89ffc7995246b1a9c38001bcf09a7338b892dc8ce10cc201c4567ac4c56f4658846": "0x00000000000000000000000000000000000c43727970746f20415049731243727970746f20415049732c20496e632e1668747470733a2f2f63727970746f617069732e696f000000000c4063727970746f61706973000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e35b67b937cc75caa81dfbac142664eb6f7ff61c5c0b2c8a180059b27ccb68ccc6b9c152be120b70": "0x040000000002000000000000000000000000000000000c6669616c6b612e6c697665001468747470733a2f2f6669616c6b612e6c6976650012706f6c6b61406669616c6b612e6c69766500000c406669616c6b61706f6f6c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e38e649e5f9f7676b4d599b32c954b0a9e554c96b248f3e66046a82f46ac914fc675938f771f8372": "0x040000000002000000000000000000000000000000000942696762616c6c7a0000154062696762616c6c7a3a6d61747269782e6f726716696e666f4062696762616c6c7a2e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e393f842833927bb48a751e3ab512dda0be14000c63798a628ee5c8bad55e947c356dbf38b0b0210": "0x040300000002000000000000000000000000000000000745737468657215457374686572204a61646520506172746c616e6400001369616d406573746865726a6164652e636f6d00000d404573746865724a61646531000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e3d6c0bdba37bbdc244c335b828809b83644239e5c6df4b01630483c410c6f380cd58aee02f6b830": "0x0401000000020000000000000000000000000000000015576562332056656e74757265204361706974616c15576562332056656e74757265204361706974616c1068747470733a2f2f776562332e76631440776562332e76633a6d61747269782e6f72670b686940776562332e766300000d4056656e7475726557656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e40a8cb9cddb8c20106261d48665f2a3f6f015d725285ae547e9b3e83bfd332a39b1ef8cf1a22a3d": "0x000000000000000000000000000000000007416d666f72630a416d666f72632041471368747470733a2f2f616d666f72632e636f6d0013636f6e7461637440616d666f72632e636f6d00000a40616d666f72636167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e46168425cb085b326ef1ebd6770b8291ce61d9f3cfee80c6a459b7e564988cd9fe6e4be89c9aabd": "0x040300000002000000000000000000000000000000000f506f6c6b61506f72742045617374001a68747470733a2f2f706f6c6b61706f7274656173742e78797a001a636f6e7461637440706f6c6b61706f7274656173742e78797a000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e4643365f6f183049456976091da2f5b7483d689df155834018d42a99572e4582beda8f879f0a11b": "0x000000000000000000000000000000000008746861646f756b17417468616e6173696f7320446f756b6f7564616b697300001761646f756b6f7564616b697340676d61696c2e636f6d00000b40746861646f756b383408746861646f756b0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e4b32bdcfe8a21ed50b428a44aee6d7d7971bc278208f295b647bd1cd44985423c3cf405adc2e336": "0x00000000000000000000000000000000000b6d616c696b656c626179001c68747470733a2f2f7777772e6d616c696b656c6261792e636f6d2f0013686579406d616c696b656c6261792e636f6d00000c406d616c696b656c626179000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e4c774b7f47a03509d8c2041692eed6612bae5f84f15d6e5e3943d3ee38dabd26dd2ded79780e6b2": "0x00000000000000000000000000000000000c526567656e63792d3031341757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e4ccf4e65ffa766b5af0f6de364a186904df50d92e02723052cc2187692243e6dbeba9f7fa30e33d": "0x0000000000000000000000000000000000085044204e79747400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e4e4cd2e3863bdd6e4395b60d99030b923a52cd9ef3468a2a7ee4a21cb88a1fc276f763a67656618": "0x040000000002000000000000000000000000000000000f44617669642053656d616b756c6100001a40646176696473656d616b756c613a6d61747269782e6f72671868656c6c6f40646176696473656d616b756c612e636f6d00000f40646176696473656d616b756c61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e5018c1728c62231664513c046d4497ba05c19efac47cb0dbe498e20b089dff25aa08d1a77ec970b": "0x040100000002000000000000000000000000000000000a5374616b65666c6f77002068747470733a2f2f76616c696461746f722e7374616b65666c6f772e696f2f124069373439353a6d61747269782e6f7267127465616d407374616b65666c6f772e696f00000e4073665f76616c696461746f72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e557553c94ed289f20e7fc24fdb992bc25566724e1533d7e861fe1a902394cf823a49f1a9c6d6520": "0x00000000000000000000000000000000001a4d616e7461204e6574776f726b206f6e20506f6c6b61646f740e4d616e7461204e6574776f726b1668747470733a2f2f6d616e74612e6e6574776f726b0016636f6e74616374406d616e74612e6e6574776f726b00000e406d616e74616e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e55dfe32a8ec457fb669bdbd25438dcf9a34ab730a518fa6594d888439187042e9607803e9fd756e": "0x04000000000200000000000000000000000000000000085269636172646f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e57b6fff5aa31fc5dc73e84c4d039277ae7819cf959a0092683ea8e6e7e9d2447c918d8aa89d681e": "0x0400000000020000000000000000000000000000000009456c2050696e746f00000015656c70696e746f6d616e40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e5a27d3189e99969dad042c036fcd9897945a880458b8e7104b30617a9640eaa22b7e23e675e0a02": "0x0400000000020000000000000000000000000000000014504f5745525354414b4520504f4c4b41444f5400001740706f7765727374616b653a6d61747269782e6f726719706f77657240706f7765727374616b652e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e5ec7a33cbbb8d9e04f3da939fa351c562c7e06e1e3716976b5e14230e83a45995cbad9086f49e17": "0x040000000002000000000000000000000000000000000a506f6c6b61676174650a506f6c6b616761746515687474703a2f2f706f6c6b61676174652e78797a1640706f6c6b61676174653a6d61747269782e6f726716706f6c6b6167617465406f75746c6f6f6b2e636f6d00000b40506f6c6b6147617465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e5efd10bd264dbe62c0adc4df234352b61fd60a32c2890fc64c2c0a3de5e33ee1c5bc9d8f581642d": "0x0400000000020000000000000000000000000000000017f09fa7b12053656974616e20426c6f636b20f09fa7b10000184073656974616e626c6f636b3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e601d44489655af884301af9b7a04d8e8cbc7e13b463fd50bea892b3e7952d62c44cd70815e0567a": "0x040300000002000000000000000000000000000000001d4c414f5320436861696e20466f756e646174696f6e204d656d6265721d4c414f5320436861696e20466f756e646174696f6e204d656d626572000017696e666f406c616f73666f756e646174696f6e2e696f00000c6c616f736e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e60910119cc2ea203e87ac01090985a916808ebe0f45ed24ae099c59d163bc073fef792b1309ec0c": "0x00000000000000000000000000000000000f4f676e6a656e20416c656b7369630f4f676e6a656e20416c656b7369630000216f676e6a656e406365726573626c6f636b636861696e2e736f6c7574696f6e73000000000b6f676e6a656e3038303000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e61549e518cc68adc8a5bf93006b7fd50ffc2abaffd57ef06c67f2171b5097070892fa1a195d920f": "0x04030000000200000000000000000000000000000000184d43207c204d43536572766963652e696f207cf09f92a50c4d61726b204372696e63650000156d61726b6372696e636540676d61696c2e636f6d00000c404372696e63654d61726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e63ab25a74c3ba8458baf0f841ed4154e046e8567bff89dbb50dd8302c248394234a0ab191de0d30": "0x0400000000020000000000000000000000000000000007434543434f4e0000000e646f7440636563636f6e2e6d6500000b40636563636f6e5f6d65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e676ae0036688fbf1cfe7dfca152379d21d1fd8dd18698889590afa4abd3cd05cbf4f6d15cd5454f": "0x040000000002000000000000000000000000000000000c4576657279646f746f72670a45766572792e6f72671668747470733a2f2f7777772e65766572792e6f72670012737570706f72744065766572792e6f726700000d404576657279646f746f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e6d19e9cf5f198f5205b1d0649f02b8d82c090a215995a883e0e4d709c4513e8e9890a110fb5420d": "0x040300000002000000000000000000000000000000000841757468656e61134665726e616e646f2052657920476169646f00001e6665726e616e646f2e7265792e676169646f4061757468656e612e696f00000a66726579676169646f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e768b256ec04939e689582a5e1411cd4bdc5086ec5604dd4dcbe4255339299de13d428335c46902f": "0x00000000000000000000000000000000000a6c61726b6e6574353100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e79ea902982619aa3283cc9f4408df3ccaef653fc163e56509619c1e0e46bb4e677d227fa50bef7f": "0x0403000000020000000000000000000000000000000006436973636f124672616e636973636f2041677569727265001140636973636f3a7061726974792e696f206672616e636973636f61677569727265706572657a40676d61696c2e636f6d00001040636973636f5f6167756972726570116672616e636973636f616775697272650000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7b5d2aa3f9d8295b8e06dc2e6bb6bd269319ace4cf8f663338f8f285a0564d6a139063c985d2310": "0x040100000002000000000000000000000000000000000a48617368517561726b0a48617368517561726b1568747470733a2f2f68617368717561726b2e696f0015636f6e746163744068617368717561726b2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7b7e5fca7ee9bcc9607759a0532ec6ceda78a076d3a63eb7f7b7be9a87ace1f94b2f25df3d0702c": "0x040000000002000000000000000000000000000000000d4f70656e5a657070656c696e175a657070656c696e2047726f7570204c696d697465641e68747470733a2f2f7777772e6f70656e7a657070656c696e2e636f6d2f001966696e616e6365406f70656e7a657070656c696e2e636f6d00000e406f70656e7a657070656c696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7cb8e1a29da70a064f4c7e6a5f3f25b4d063e5461bf3882569aad883b6db400695ccfd7c6e6ef22": "0x00000000000000000000000000000000000c5843417374726f6e6175740f44616b6f7461204261726e65747400001764616b6f746140696e76617263682e6e6574776f726b00000d405843417374726f6e617574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7cfb082496967f7ec22eb74dea33d78388ca084d35bb754ab5256d4d606d83818f639d0c63dd541": "0x040300000002000000000000000000000000000000000d4e69786f6e204a6176696572000000196e6969786f6e6a6176696572797440676d61696c2e636f6d00000d6e6969786f6e6a6176696572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7dfd30137a8f95b6201961514cf5ad87f1c4dd0c392ee28231f805f77975147bf2c33bd671b9822": "0x0000000000000000000000000000000000106b697368616e736167617468697961114b697368616e20536167617468697961001d406b697368616e6d7361676174686979613a6d61747269782e6f726700000000106b697368616e7361676174686979610000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e7fa098460d3db9eb088c46557805c70d888174482b02e258482e5e3f5ae7a20bbdc333c9c046d04": "0x00000000000000000000000000000000000b696e6b21756261746f72001868747470733a2f2f7573652e696e6b2f756261746f722f0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e819164bbb79142da4d26dd19482ab1dfae06825850bc2a3e3c82821977573c80eb9f19747b9215d": "0x00000000000000000000000000000000000c4f6b6f74206a6f736875610c4f6b6f74204a6f736875610000176f6b6f746a6f73687561393340676d61696c2e636f6d00000e404f4b4f544a4f534855413433000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e82757563afd35c4501f6db8fa8f98a21f0a62678bbd5f0f91be1c0a6c7215f2610a782d0d3a2458": "0x0000000000000000000000000000000000094a75616e6f444f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e85d0bcdbe07f1da309409e68f563d9e9160bc30f7418cbe5735e3e2dc9922db1826807029b8ba5e": "0x04000000000200000000000000000000000000000000104d61785f43727970746f7a696c6c6100001c406d61785f63727970746f7a696c6c613a6d61747269782e6f72671963727970746f7a696c6c616d617840676d61696c2e636f6d0000104043727970746f7a696c6c615f6d67000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e86c54857827324682635b83e254e0ed6438dd7d9bc229658cf164cebf4322cf4932815d4d7ad323": "0x040000000002000000000000000000000000000000000f47656c69746f202d204f6e797a6500000010616e67656c406f6e797a652e636f6d0000084067656c69746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e87135bfa99a9afc6ad7c1595e740abcfe3a9b2cc4243d13341ebdf1ddebfe5184822cbc4fdb6116": "0x00000000000000000000000000000000000f53616e6a656577612053696c76611850205355524553482053414e4a454557412053494c564100001873616e6a656577612e73696c7661406c6976652e636f6d00000b407373616e6a65657761000f7373616e6a65657761233830383500", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e876a25b4b1879f1746b2591bb9bf87e8b24cb5e4b265192187471475c775ed7708f7cab9f76617e": "0x040300000002000000000000000000000000000000000a4e334d55534e65616c0c4e65616c2050657465727300000f6e65616c406e336d75732e636f6d00000a406e65616c5f6e7065000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e883951f96e016e628c1641676e9e4f0c271a9b92fb49311bb7cfc00a0478dc92908fd30005a194b": "0x040100000002000000000000000000000000000000001b444f542056616c696461746f7220416c6c69616e63652044414f001b68747470733a2f2f646f7476616c696461746f72732e6f72672f1440706d656e73696b3a6d61747269782e6f72671b646f74616c6c69616e63654070726f746f6e6d61696c2e636f6d00001040444f5456616c416c6c69616e6365000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e88d81bf95788cc15a9616ee0f6737de3d1a75ee0c6a2101f70671cc68da4ceda653a18cd751ea3d": "0x00000000000000000000000000000000000a4d6178446f744465760d4d6178204b7261766368756b0000156d636b7261766164657640676d61696c2e636f6d00000f404d61785f5f4b7261766368756b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e8b5663905f9c3c0f861ce44b57a59f1f6953a922920de251b138c3a751b3f9adf075dcd4d2c9851": "0x040100000002000000000000000000000000000000000b506f6c5f43727970746f0b506f6c5f43727970746f0000196d7073686964616c676f3139393040676d61696c2e636f6d00000c40706f6c5f63727970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e8c5f28ea575985d2cbf07f54d172d80de65ac3f2707f660dd53f7ead6013a9d47921e881d258e64": "0x040000000002000000000000000000000000000000000f424c4f434b434841494e425241440000000000000d40427261645f4c6175726965000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e8cb1cf7b100db583c343c62a938e255060d46435233ab16bb11168adfa99c770fca459af08b0241": "0x040000000002000000000000000000000000000000001156616e636f757665722043616e6e6f6e1d416476616e636564204461746162617365204e6574776f726b696e6717687474703a2f2f7777772e4144622e4e65742f444f5411406a617a643a6d61747269782e6f72670c444f54404144622e4e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e8edd00301de472cb4e98052ea4e41501850a90d99cd46fe92a91bfe039fff0f4e5c0d5eb69f5813": "0x0000000000000000000000000000000000097968616d61636e75001c68747470733a2f2f6769746875622e636f6d2f7968616d61636e750000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e8f8b7184f9a04c0ca72d01b6c36c383e4ba984681b7b467dafefec8f44dab1ed507ae6ab2704c30": "0x040300000002000000000000000000000000000000000930785461796c6f720930785461796c6f7200001630787461796c6f72406368616f7364616f2e6f726700000a30787461796c6f725f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e91edd91ccfc5f024617b7364d403c2b44cc4ae58ec9f2b3b412d3b9cdf57ec06e3cb878a228a70a": "0x04000000000200000000000000000000000000000000054761626f000013406761626f31383a6d61747269782e6f72671178636761626f4070726f746f6e2e6d65000009405f78636761626f000c4761626f3138233932333800", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e935216ece9e99210a44ceb024e05ccf8c9153a48c24dda24a5eb82db438cdc55b1b234c613eac14": "0x00000000000000000000000000000000000c4765726d616e676c657a61194765726dc3a16e20476f6e7ac3a16c657a204172616e64611b68747470733a2f2f736f6d6f7363727970746f6d782e636f6d2f00176765726d616e676c657a617240676d61696c2e636f6d00000d406765726d616e676c657a61000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e940a76f99d2ec9f40e8a79a9a76b954f2e08ffd985d6f6a3bd3fca001baee4e235cb67ed9cda635": "0x040300000002000000000000000000000000000000000b6a6f686e6e796b6177610d43616573617220446974616e0000156a6f686e6e796b617761407961686f6f2e636f6d00000c404a6f686e6e794b617761000b6361657361723030383800", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e9705190c69f75e984a135c14c92b678df586c20c8e3ca3511043f0dc8bfd88017d0bb97bfcff63a": "0x04030000000200000000000000000000000000000000054a617773144a61756d65204d6f72656e6f20526f766972610000136a61756d6540676f6c646a6177732e636f6d00000b40676f6c646a6177735f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e97f51eae0303cf7d07d209d7880ecdc39f636e4390f665c563274bfe9a981c6c31f2995c184b0c2": "0x040000000002000000000000000000000000000000000d4261677069706573204f7267001468747470733a2f2f62616770697065732e696f000000000d4042616770697065734f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e999e16a19189c1f8c8897c6e9a74d582959e1d4273719c9edbd33d5c44815ebe162fe0ee8191863": "0x0000000000000000000000000000000000046d696f096761627269656c65000015672e6c756e676869373140676d61696c2e636f6d000011406761627269656c3037333531393039000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e9ea0dabafbeec8280251f075ec25c5b4fd4272d81fb78eeeeef9819356f102b5e7bde1154a73f2e": "0x00000000000000000000000000000000001d44757463682054756c69706661726d657220436f6c6c656374697665001b68747470733a2f2f6474662d636f6c6c6563746976652e636f6d001961646d696e406474662d636f6c6c6563746976652e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714e9fdc68bc008f11eaf24540bccc2a2661e0301d4e45b87ab8e961db49e4660ef217619bdcd5fc638": "0x00000000000000000000000000000000000e617263686973696e616c5f696f20417263686973696e616c20546563686e6f6c6f67696573204c696d69746564000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ea0e1b22a44d19352c2a55b5e0d28cc772b47bb9b25981cbb69eca73f7c3388fb6464e7d24be470e": "0x040000000002000000000000000000000000000000000c5a7567204361706974616c001768747470733a2f2f7a75676361706974616c2e636f6d0017636f6e74616374407a75676361706974616c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ea1425c366c9ab900a2831bc1a5cfdfd6aca13c77cf934fdf2a6010d041d4d76a62698cd58c87956": "0x040300000002000000000000000000000000000000001f446563656e7472616c697a656420436c6f756420466f756e646174696f6e1f446563656e7472616c697a656420436c6f756420466f756e646174696f6e1768747470733a2f2f63727573742e6e6574776f726b2f001168694063727573742e6e6574776f726b00000e4043727573744e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ea2794691c218be17657796360e40e5d980d7b7835108a8534538dc530bce1b77c49cde4b7f97b36": "0x040000000002000000000000000000000000000000000641726a616e0000134061726a616e7a3a6d61747269782e6f7267000000114061726a616e7a696a64657276656c64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ea2c0371426ff011ea857aabed70020c0433dfba617fdd3abe9dc3b22b427f884b13f4f4dcb6481b": "0x04030000000200000000000000000000000000000000074261746d616e001a68747470733a2f2f6c696e6b74722e65652f5f6261746d616e1c4030787468657265616c6261746d616e3a6d61747269782e6f72671a30787468657265616c6261746d616e40676d61696c2e636f6d0000114030787468657265616c6261746d616e1469616d6d617374657262727563657761796e650000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ea92920fa526337e0c06466c9aab1dac1ca8bddbf02a3f0913358bf068012a0478d62c7cd076c12c": "0x04000000000200000000000000000000000000000000104672657368437265646974204f7267194672657368437265646974204f7267616e697a6174696f6e1868747470733a2f2f66726573686372656469742e6f7267001f63657361722e74696e616a65726f4066726573686372656469742e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eabad1af85b4f2da751b2f1dc8d7e182eb3615a1894330dfd769ca25e945004b9c28a0309a875757": "0x04030000000200000000000000000000000000000000087375626f7469630d4976616e205375626f74696300000d69407375626f7469632e63680000087375626f746963087375626f7469630000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eabd7ed4ca42f780a8ebd4a61d47391a24659b5762d9ef578229c4fc2186f5f88174f8e728f27f78": "0x0403000000020000000000000000000000000000000013546961676f207c20616464726f70732e696f0e546961676f2054617661726573000015746961676f6d6d74323040676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eac493d2c384d548f0f3c639e5a8ee634594037f1f6eaba8a3d06c791615f80fa892deb77c0bf346": "0x04030000000200000000000000000000000000000000094c656f205068616d0f5068616d20486f6e672054686169000016686f6e677468616970726f40676d61696c2e636f6d00000c406c656f7068616d5f6974000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eaf34109655642c20a6d7337f0454acdaf58ff349faf36febd6f9dadddbebd1198919523b91f6b11": "0x00000000000000000000000000000000000c4e6573636166657573657200000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eb00f7c148179177909f4d84481e5466f7af1143a7193f40bd8c0606d75eb089666c29ca0347606a": "0x040300000002000000000000000000000000000000000a4c75697320f09f8c80000000166c7569736567723331303140676d61696c2e636f6d00000d40456e72697175656b736d5f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eb1d5fd73e1080ee944ade7aa7487574933c8394cc8c74d9073c65de1d77534b7effcc6cf34aefac": "0x0400000000020000000000000000000000000000000010496e66696e6974792057616c6c65740000001a706172746e657240696e66696e69747977616c6c65742e696f00001040496e66696e69747957616c6c6574000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eb307eab2c6490695ee3b9f948b36e799b4190bd0a025c1cc5132f52b3701c0a0912296120176d30": "0x04010000000200000000000000000000000000000000066450726f70000000176176696461636f6e74726f6c40676d61696c2e636f6d00001040426c6f636b636861696e65723931000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eb374a353870a2b9bac27ccc2a336ec0f7920048d460197d4abde56e977771aec19b3c9c6d110c7a": "0x00000000000000000000000000000000000b53706f6f6e79426172640000001a612e6e746f6c676b6f764070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eba5f322b497160118a5657b88d667ab46d1070d58ecc1f15011f60df20f510ee0aac61754bb9e01": "0x00000000000000000000000000000000001142494e414e43455f5354414b455f31311142494e414e43455f5354414b455f3131000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ebdea675e3bab66142780fa79136b5a383ca1180c911553235f69e97edb9aa09b6f80acd437da754": "0x04030000000200000000000000000000000000000000064265747479000000176d616b65736974626574747940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ebee8c2dc7e37890e84b20a21cd1f35835bb85d8e27d3b6d02bf08300998555443ec4cd3206ec37a": "0x0000000000000000000000000000000000056a75737400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ebf17402f1a0c5314e936e1e0efeeb5090b1f8afdf530d798c7d54a747704755ea03b110144e5150": "0x040300000002000000000000000000000000000000000c6775746f6d617274696e6f0d4775746f204d617274696e6f0000197375706572647570616866756e6b40676d61696c2e636f6d00000c6775746f6d617274696e6f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ec14530f7667a130dae5b67f7237a4ecc7daf168ee45d8b9f2fcfa07e7ae255daad9e09912595d4b": "0x040000000002000000000000000000000000000000001e494e20535042202d20f09f8dbef09fa582f09f8db7f09f8db9f09f8db8000015407370626472696e6b3a6d61747269782e6f7267185350424472696e6b4070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ec3029bbd85364b1f4792917b47917519e2c05619763a4e7b45b84815f902f62e16f23e9f2b22653": "0x04000000000200000000000000000000000000000000104972696e61204b61726167796175720442513900000d6972696e61406271392e696f000010404972696e614b6172616779617572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ec49f5213562f6f6309c4389039f51c4d308dd49f39c28e4d4f5e51413f123d3f7ebf050c2307877": "0x000000000000000000000000000000000013426c6f636b636861696e656420496e64696113426c6f636b636861696e656420496e64696121687474703a2f2f7777772e626c6f636b636861696e6564696e6469612e636f6d1a406d616e617661696c61776164693a6d61747269782e6f72671c6d616e617640626c6f636b636861696e6564696e6469612e636f6d00001140626c6f636b636861696e6564696e64000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ecc49e9888c4723b003be57bf884dd5eb5ea5274429e80980c136324444c5771a4a4c67a5124106b": "0x0000000000000000000000000000000000114172747572204775696d6172c3a36573194172747572204775696d6172c3a36573205065726569726100001761727475724065616363726970746f2e636f6d2e62720000114061727475726775696d617261657370000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ecd1bc9bdcddbb405437eaad7661fc64223db26c26db0c8aa317f5c56e3c640830495b4786d6e635": "0x040000000002000000000000000000000000000000001d4d61726b205279616e202d204576656e7473205369676e61746f72790a4d61726b205279616e0017406d61726b2e656d6265723a6d61747269782e6f726700000011406d61726b5f656d6265725f7279616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed229b4f9a288d7518790dd7ca07916547aeab9f8155af2cb219bbdc7df93974d04c101bf9f18a1d": "0x0000000000000000000000000000000000066d312e7663066d312e76630e68747470733a2f2f6d312e76630000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed6de9d282688326da649a9855dbd7872b852ef786c270f57cb1462262ebdb67ee0729a3eef90122": "0x00000000000000000000000000000000000c54454143484d4544454649001b68747470733a2f2f7777772e74656163686d65646566692e64650014696e666f4074656163686d65646566692e646500000d4054454143484d4544454649000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed7f24e195293ab9d638bd6f76c3b3aa2810fa97ca64a8195d9460c08c8a509b78e9a6ec82c6e920": "0x0000000000000000000000000000000000115a4f454d432d434f4e54524f4c4c4552000012407a6f656d633a6d61747269782e6f72670000000a407a6f656d78666f780007407a6f656d6300", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed90d5a15a85da0268cfeae1986b9acaa08e6d3264672b32f62e784bc8447bb52e3c79c840b79877": "0x0403000000020000000000000000000000000000000008546865204847410000001b48696c6c47726f7774684167656e637940676d61696c2e636f6d00000c4048696c6c47726f777468000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed956e0a56bcce19c5d607c5643cace51ad268171f8b62bc30a1913178c92393f3a7b1ef3283e316": "0x040000000002000000000000000000000000000000001146494e4f50535f5042415f50524f58591c506f6c6b61646f7420426c6f636b636861696e2041636164656d792168747470733a2f2f706f6c6b61646f742e6e6574776f726b2f61636164656d79001961636164656d7940706f6c6b61646f742e6e6574776f726b0000114041636164656d79506f6c6b61646f74000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ed9d129015daefd5b2d89b7dbf920e6cd64997f1b3ee49c4de09327342dbbba971a362062817a24e": "0x000000000000000000000000000000000008677564753136390c4c494a554e205a48414e470000177a68616e673438373733393240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714edcb62732d88d5a1983ac92a9005b595553a62a3522499a38af23ae77e0c71f3b617abf004147e5b": "0x00000000000000000000000000000000000f5041524954592054495020424f5400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee00d20c4599b66920e43fc4c70fa7fd379f66551283b0b39b7d81a8934bc38a0eff954c13211039": "0x040100000002000000000000000000000000000000000449424f0449424f0f68747470733a2f2f69626f2e696f000a68694069626f2e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee1637b31feeb6eb1250f6160df84e6e3a53754e1da799eaf11ab3fb77bf2958b8bcb14829a8a109": "0x04030000000200000000000000000000000000000000096a75737461646576001468747470733a2f2f6a757374616465762e696f00156a75737461646576303940676d61696c2e636f6d00000b406a7573745f61646576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee1ca131ec7060eeac214900c36399dc45f36261c677a53ea58cce1e5d113deed23227ab523fc53f": "0x0000000000000000000000000000000000125761674d656469612054726561737572790000000000000e40746861744d65646961576167000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee2b9d3d30c267cd2a62706ffa8c0fa1406c5a61ff4759b0b0c450f8cca8e6cb337e5f9d8a7bc21f": "0x040000000002000000000000000000000000000000000853616d737439330f53616d75656c204a2053746f6e6500001773616d73746f6e653933393340676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee3695245c82732db5bc42b793f36f2174681d45b224f6e5222d64508a0a28454ffc085bd3d33210": "0x0000000000000000000000000000000000104252455720436f6e666572656e6365104252455720436f6e666572656e63651c68747470733a2f2f7777772e627265776265726c696e2e78797a2f001568656c6c6f40627265776265726c696e2e78797a000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee528ad5e6be0beb7a5e9031237026ed1babffdd92e6ef7c73e3212cdcd62c7559644596c3398175": "0x00000000000000000000000000000000002153796454656b2044414f202620576f6d656e20696e20426c6f636b636861696e001268747470733a2f2f73796474656b2e6169001a6a757374696e2e676f6c6473746f6e4073796474656b2e6169000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee610577caaf8b311cb53a337df19dd608aa3e6bb703e8e2817ee1fbddc7536f097b90f3e1910f66": "0x00000000000000000000000000000000000a4e696768744861776b00000000000011404e696768746861776b506c7567696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee704d3e290801f7c2c7f984de75f10a8ab85a9945e79890b776970fd15e39de1cbaa0816aaab920": "0x00000000000000000000000000000000000c617265636f6e742e70726f14417265636f6e742053657276696365204c4c431568747470733a2f2f617265636f6e742e70726f2f1840617265636f6e742e70726f3a6d61747269782e6f7267117765623340617265636f6e742e70726f00000d40617265636f6e745f70726f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee710f5d44a205f970e6681d2a90ec58ea62e45205b7663bdcebf659aa162fe0b4d31474e5c24914": "0x040000000002000000000000000000000000000000000f637265616d5f667261696368655f0e4b617265656d2046617268616e1c68747470733a2f2f7777772e63616d62726f74686572732e64652f00166b617265656d4063616d62726f74686572732e646500001040637265616d5f667261696368655f000b6b617265656d3437353200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ee977649867b775e26f6ba0b2c596d1a471444945c9fdbdfe25e3f8862096f8f6de11d87da1a7111": "0x040000000002000000000000000000000000000000000f546865205068756e6b79204f6e65000017407468657068756e6b79313a6d61747269782e6f7267147279616e406c75636b796672696461792e696f00000c407468657068756e6b7931000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eec11b5fca7cddef5270ec35ba01254d8bff046a1a58f16d3ae615c235efd6e99a35f233b2d9df2c": "0x040000000002000000000000000000000000000000000d506f6c6b61646f747465727300001440706d656e73696b3a6d61747269782e6f72671c706f6c6b61646f74746572734070726f746f6e6d61696c2e636f6d00000f40506f6c6b61646f747465727331000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eed6418d5b4cb40034fee14ee94a7350a0c839cd4a41dd465e77717b257b55265ce7f577188c8257": "0x0403000000020000000000000000000000000000000019506f6c6b61646f74204461707073206f766572204170707314416264756c6b617265656d204f79656e65796500001844617070736f7665726170707340676d61696c2e636f6d00000e64617070736f76657261707073000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eed972f494e31056d64ccc7e84c99634be22610d47abd531d36b7793703c129fa21658f27cf5c42b": "0x0400000000020000000000000000000000000000000011426c6f636b6f7073204e6574776f726b0000001d656e67696e656572696e6740626c6f636b6f70732e6e6574776f726b000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714eedee3a95fe6fb672e2a4419244bd15a7af48d6556acfeaccb5f2f54a9892882f243160eac6eef52": "0x040000000002000000000000000000000000000000000c457175696c69627269756d0000000000001040657175696c69627269756d5f636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ef422814dc3e336a24cf826d945c3cfddd0e76c8b1f093bc5dbcfceef4e30817337887813567fb04": "0x0401000000020000000000000000000000000000000010526f636b585f506f6c6b61646f743206526f636b581668747470733a2f2f7777772e726f636b782e636f6d0012737570706f727440726f636b782e636f6d00001040726f636b785f6f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ef5874a92f7239d9b2312d7e5b7f8209e6b7bcc4535401fbae5dd1098fdf5fe06b5f638620e6351f": "0x040300000002000000000000000000000000000000000844697461766961214469746176696120436f6e73756c746f726961206520547265696e616d656e741968747470733a2f2f7777772e646974617669612e636f6d2f0014636f6e7461637440646974617669612e636f6d00000b40646974617669616272000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ef6d8e4c19a55597bc42516c44e05faa2b4b905fb91fa1652c65e04d376414e39f79bad7dced6c55": "0x00000000000000000000000000000000000c426974636f696e696e757300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ef87b5cbae78ad371c7529b314d9e87a1c241cfe54312668a3159e1063a0aed9f70d3db1f03f8d10": "0x040000000002000000000000000000000000000000000b6c69616d616861726f6e000010406c69616d3a7061726974792e696f186c69616d2e616861726f6e40686f746d61696c2e636f6d00000c406c69616d616861726f6e0b6c69616d616861726f6e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f003382b575752d0b88d9d28cd21ec20bf31abadbc04405045fc0781f5c13e63d8a369d371de2e55": "0x0400000000020000000000000000000000000000000020506f6c6b61646f742050696f6e65657273205072697a652043757261746f720000001f70696f6e656572737072697a6563757261746f72407061726974792e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f0291cc04e6365cddca89b135d1a6aee0a498610a70eeaed056727c8a4d220da245842e540a54a74": "0x040000000002000000000000000000000000000000000d66657272656c6c2d636f6465002068747470733a2f2f6769746875622e636f6d2f66657272656c6c2d636f6465194066657272656c6c2d636f64653a6d61747269782e6f72671666657272656c6c3939393940676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f0391ee85a4435190fe8ecbba7a1e216bd1c3bb7e749a98fcae77b4185c5522cbad8e826d0d92371": "0x0400000000020000000000000000000000000000000016f09f9ba1204457454c4c495220444f5420f09f9ba1001468747470733a2f2f6477656c6c69722e636f6d14406477656c6c69723a6d61747269782e6f726711696e666f406477656c6c69722e636f6d000011404477656c6c69724f6666696369616c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f065def57c0ed66e2e001e3f827e6eed45a60d131d97df1a5b429ed1d0f89fdedf3eda0a16502d3a": "0x0000000000000000000000000000000000064b616d696c104b616d696c2053616c616b686965761168747470733a2f2f716472766d2e696f14406b616d696c73613a6d61747269782e6f72670b6b40716472766d2e696f00000c406b616d696c5f61626979000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f0970b3f474766050ea760413255de0a565b08a056a1b4100de8df4d5135ae4dbe51ddb6fd23de7b": "0x00000000000000000000000000000000000e4465636f646564556e697175650f556e69717565204e6574776f726b1868747470733a2f2f756e697175652e6e6574776f726b2f0012637340756e697175652e6e6574776f726b00001140556e697175655f4e4654636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f09b8c6be35500bfea06e81f2bd502063fe57a0447f6c1b4576a2f5a0e3e5794757bb565abce363e": "0x040300000002000000000000000000000000000000000d6c6f6c616c6f766573646f74000000146c6f6c616c7576723140676d61696c2e636f6d0000097734743376726d38000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f0ad4ed5898f2b8c80af4d39c625c32b2b6ea0b94c341ac826c49fa28451768e71afb46bc7afac04": "0x080000000002010000000200000000000000000000000000000000034147001568747470733a2f2f76616c696461746f722e6167154061677831303030303a6d61747269782e6f72671368656c6c6f4076616c696461746f722e61670000084041477831306b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f0ef7d0b30432179d6ee0051f7d4642b88616d632ba4457ca6c1169501cb9c2513c6b168f4df1252": "0x040100000002000000000000000000000000000000000d706f6c6b61646f7420636869096368696469206f6c0000187765616c746830314070726f746f6e6d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f1024f494b9ebee98a1671bda9ae5c92eb8b3697a52b8f112222eeee80994306b8c6b8d817f22351": "0x0403000000020000000000000000000000000000000014f09fa6b420426f6e65205465636820f09fa6b400000013626f6e65746563684070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f13fcfe46ac782db6eb166bebe4af81c4b929fff65b437b18eb9c7a3c668dc6c53f39d895d00943e": "0x000000000000000000000000000000000008686f616e67766d000000167675686f616e673033303740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f141bc71dafe807f7cd5f5ff9b7eefb11b8b32c1bb1e1fc63c08019d81124b3aa85f24ae8c779a31": "0x040300000002000000000000000000000000000000000f74686520686f646c6661746865720f41726d616e646f2043617374726f00001861726d616e646f63617374727040676d61696c2e636f6d00000f40746833686f646c666174686572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f18a58b0fa8cec93dcd35aa554e0ac5db78e83bfc51649fc9b550bec1b162c70509199c1b4c0cc1a": "0x0403000000020000000000000000000000000000000011506f6c6b61646f7420496e736964657211506f6c6b61646f7420496e7369646572000015726973696e676170616340676d61696c2e636f6d00001140506f6c6b61646f74496e7369646572000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f1c80fdef53d785909cb20eb25e42c2fa106d75ee4d44b9c2bac20323a540529e9f4f40da5337bb3": "0x040000000002000000000000000000000000000000000c4d65726b6c657472696265001768747470733a2f2f6d65726b6c6574726962652e696f18406d65726b6c6574726962653a6d61747269782e6f726714696e666f406d65726b6c6574726962652e696f00000d404d65726b6c657472696265000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f1d74521ceb0a868249bf7f403ca14e4d0b0f4ff5c9d447772ce079b9b7c389e86587a2589fd7558": "0x0403000000020000000000000000000000000000000007456e7a6f726f114e617267697a61204b7572616b696e61000015656e7a6f726f2e64657640676d61696c2e636f6d00000d40656e7a6f726f5f7465616d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f1f8c71902a2a288729d9e0636390cc1ec43a6f95d06475b0e42017c6726e5f17e8e70e67cf69d56": "0x040300000002000000000000000000000000000000000b5b6167616c6c696e695d10416c626572746f2047616c6c696e6900001a616c626572746f2e67616c6c696e6940676d61696c2e636f6d0000104047616c6c696e69416c626572746f00096167616c6c696e6900", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f1fa33e1c88a625cf278bbe8c33fe8fe03c6c684b44dfc26dfb5bcefb3ef511f5446530af859c112": "0x040000000002000000000000000000000000000000000e4d697463682d576172696e657200001a406d697463682d776172696e65723a6d61747269782e6f72671d646f742e6d696e6572732e736369656e636540676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f2005476fdc5028fb4ac19c9a723477c0b31ef41dd0cfd9539a3a8d763e6a6c4c96eba6eba5e4d7f": "0x040000000002000000000000000000000000000000000c7072656d61747572617461000018407072656d617475726174613a6d61747269782e6f7267207072656d617475726174612e76616c696461746f7240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f23d01c894e574b19abbbcee9ebaa3a753da127bf308e33cac065110734cc2b689cff009d94ee62a": "0x040300000002000000000000000000000000000000000e426c6f6b42726f6b657261676500000018626c6f6b62726f6b657261676540676d61696c2e636f6d00000e426c6f6b42726f6b6572616765000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f23d30d0a705bc35c69d8c568b24a3108b6f9604f118359c268804e5a0de2b415ce978160dec2359": "0x04000000000200000000000000000000000000000000134261626573506170657328444f5429636f6d0c42616265732050617065731c68747470733a2f2f7777772e626162657370617065732e636f6d2f184062616265735f70617065733a6d61747269782e6f7267166f666669636540626162657370617065732e636f6d00000c406261626573706170657300184062616265735f70617065733a6d61747269782e6f726700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f2988908eea3feb7586b9f5a2e5fad9175b0a540b7bf2ffcca689f99ee06cbc207b4f15a26b58363": "0x040100000002000000000000000000000000000000000e4147475245474154452e4f5041001b68747470733a2f2f6167677265676174656e6f6465732e636f6d16406167677265676174653a6d61747269782e6f7267206765742d696e2d746f756368406167677265676174656e6f6465732e636f6d000010404167677265676174654e6f646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f2a816b6bd3a924c32a54d822b72d04a74a61509cb66376129556412bfaec8fd8d41f50ed423c957": "0x040000000002000000000000000000000000000000000c564c4144494d495250524f00001a406772617465766c6164696d69723a6d61747269782e6f7267196772617465766c6164696d69724072616d626c65722e7275000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f2ad51c6c76e65c8d0bb4d4b0f530b756f58c53f814710ee17fc79324d6b21c3ae22398c1ed5dc1b": "0x0403000000020000000000000000000000000000000017546f6b656e67756172642042656e65666963696172791b426c6f636b20536f6c7574696f6e732053702e207a206f2e6f2e000016636f6e7461637440746f6b656e67756172642e696f00000e546f6b656e67756172645f696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3194d5c012787bae6edf7a6551c93e9ac1c9bd0daf98b25abefc01eb7afa918d322539b997d462e": "0x00000000000000000000000000000000000b646f63746f726368696e0e7469656e20627569206d696e6800001c6275696d696e687469656e3139383475734067616d696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f33c3d7c430f900954eb2d8672a2aaa09a149fae1d2cca54cda463da043b276e246881a2f4e9e179": "0x00000000000000000000000000000000000b506174696b6120696e630b506174696b6120496e631868747470733a2f2f7777772e706174696b612e6465762f001267756c63616e40706174696b612e64657600000c4072697365696e5f636f6d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3430f9486eebcb28423c2127c4f7199f134cad21d786dc788effc31b9164767bbb4cd8ce740ab29": "0x00000000000000000000000000000000000e43726f7764204163636f756e7400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3a8cb14bfca5d3d82c5c0e26848d49b32a7ae09a67f6822f2a18310b69a3ed9c31ee02144020826": "0x040000000002000000000000000000000000000000000f486173686564204e6574776f726b0000000000000f404861736865644e6574776f726b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3bb05b647c9705134ba460ddb05a10ff78533182868e683684300888b0029e09123a945f0823020": "0x040300000002000000000000000000000000000000000645796173750e45796173752042697268616e750000156a6f736874656368333940676d61696c2e636f6d00000f40457961737542697268616e7537000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3d619806458ce0ea8070648f6e43b7d8a8f10418b696130d2046c10645f10085de80e6098b85f09": "0x04000000000200000000000000000000000000000000134875746368202d20436f6e74726f6c6c65720000001d70617072696b615f766f6361626c65306a4069636c6f75642e636f6d00001040746865666c79696e676875746368001040746865666c79696e67687574636800", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f3e3959f84b063bcd6c29a7c39cee45b0e045a94081bc188ef73be2be086d66aefd850fc7eeacc45": "0x040100000002000000000000000000000000000000000e4f6e46696e616c6974792e696f0f4f6e46696e616c697479204c74641a68747470733a2f2f7777772e6f6e66696e616c6974792e696f124069616e68653a6d61747269782e6f726717706f6c6b61646f74406f6e66696e616c6974792e696f00000c404f6e46696e616c697479000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f4137709d90899e9fb2d80eed7a8b28753f70afb95bda3edda074ffd7708116acb919cf484854777": "0x0000000000000000000000000000000000094c6564676572203100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f41c7a3cee29ba2d784c9c917350f814d7b3600e688da3ce67ad920cc321be65addb3e6ae0b51451": "0x040000000002000000000000000000000000000000000e4578696c65642052616365727300000016696e666f406578696c65647261636572732e636f6d00000e406578696c6564726163657273000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f41c81026445f16f0ad8516cbee7751114909ea4199c27ec84911bbc85c01449c3b418a754f91e69": "0x04010000000200000000000000000000000000000000075472616e73580a7472616e73782e696f1268747470733a2f2f7472616e73782e696f13407472616e73783a6d61747269782e6f72670d6869407472616e73782e696f00000a405472616e73583131000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f428a77ef581364ada86cee6a178b43ac0e605d8dac093106dadcac8f00f0a8a5b8431c4b56a775b": "0x00000000000000000000000000000000000e566963746f72204d657a72696e0e566963746f72204d657a72696e1368747470733a2f2f74726169742e7465636813406d657a72696e3a6d61747269782e6f726719766963746f722e6d657a72696e4074726169742e746563680000000a7472616974746563680000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f43858092a1274370ce14f14486f3fb3513a44a19970a0bbf4da8b642c9837cfa251b33384dec257": "0x040000000002000000000000000000000000000000000c477265656e20436c6f756400001840677265656e2d636c6f75643a6d61747269782e6f72671f677265656e2d636c6f75642d6b7573616d61406f75746c6f6f6b2e636f6d00000f40477265656e436c6f75644b534d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f4f0e33d9ec9b36d224872ad60345d726772361291b4cf7f3e1b8087f2277e2b5cc25a9b309f4727": "0x040000000002000000000000000000000000000000000753656e7365690c53656e736569204e6f64651768747470733a2f2f73656e7365696e6f64652e636f6d14406a6368697474793a6d61747269782e6f726714696e666f4073656e7365696e6f64652e636f6d00000c4053656e7365694e6f6465000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f53e59e4baae9e387082636ca5c22aaad30b64c9fb6af0c6b91055d1834f1a5badaeec7091dd8b8b": "0x040000000002000000000000000000000000000000000846696c6970706f1246696c6970706f204672616e6368696e6900194066696c6970706f3a776562332e666f756e646174696f6e1866696c6970706f40776562332e666f756e646174696f6e00000d4066696c6970706f77656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5485e0e720d2144ed5f93b8f24ce936d3df4faad4c247e1e57503b2be42904520d0018162ebc76c": "0x00000000000000000000000000000000000f42656e736869676572752044414f00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5912d36263b8f7806a2129ac63420996a943d410317bd705dad70b5073f4f8edd63901fe332d56d": "0x00000000000000000000000000000000001357696c6c69616d202854616c69736d616e290d57696c6c69616d204368656e0016407265706c67686f73743a6d61747269782e6f72671577696c6c69616d4074616c69736d616e2e78797a000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5bcc47f0db2d6a236a561a21a65f5106286c1d983cfaf4da5115a90073d1c9c6e053d4bbf596d27": "0x04000000000200000000000000000000000000000000104865616c74687920506f636b65747300000018696e666f406865616c746879706f636b6574732e6e6574000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5d0ba7a9e0e043b545b7958451cd22afb0367d6c99af1360190813571c47b8a94a055d575d38249": "0x040000000002000000000000000000000000000000001443525950544f204a41434b2053504152524f5700001e406a61636b73706172726f7763727970746f3a6d61747269782e6f726700000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5d53ab33cd6333ae62fd2fd91105ee48911b567b815318f9a9c5f1002c88dc3c568aea2e0f8eb34": "0x00000000000000000000000000000000000c546f746f2043727970746f0e546f746f2043727970746f6e791a68747470733a2f2f746f746f63727970746f2e7375622e69641740746f746f63727970746f3a6d61747269782e6f726717746f746f63727970746f373740676d61696c2e636f6d00000e40746f746f63727970746f3737000d746f746f63727970746f373700", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5e5a1e323e94d19728453ef7429569c384e3e39ffc0f147aabb8a71185dedca4ffab6fe44815500": "0x0000000000000000000000000000000000065452554a4900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f5f2eeffe9c9cf62a22ff027237d3f1f468e46ebaa49f910df2affac228efed30a62ab3daaa99e57": "0x0403000000020000000000000000000000000000000007763064306c3007763064306c30000013736f72616e6f64654070726f746f6e2e6d650000094076696e7364656c000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f609c73b2b467ef264c3558888b7bcb721cf6803dac859f125de0afa615c461bd1b2587ad461c81d": "0x040300000002000000000000000000000000000000000b53616c696e61204465760000001773616c696e6164657664657640676d61696c2e636f6d00000b53616c696e615f646576000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f6198f55b54f219a44a65df7135dd3fd5e958140e4800abdb5db615d7f4aefd21d5d746b7e456b34": "0x040000000002000000000000000000000000000000000944616e70756c6c6f0f5341424955204d5548414d4d4144000015736d64616e66696c6c6f40676d61696c2e636f6d00000e40535f4d5f44616e70756c6c6f000f5361686167756d656c233032313200", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f623c11edc7a4858d6c8c22c86dda329b85d76f7f7d68623ddeb1e9649819900e6b715967a0aff36": "0x00000000000000000000000000000000000c526567656e63792d3031311757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f6678cee6fb3557e047d9556653e9335812ba87a2463e04f455a68dd5391e22397d55d89cb8cb116": "0x00000000000000000000000000000000000a525542524f5353414e00000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f668ff8ab90e05ebf047b090d2e8e2406ccc97a60df3452fc8574333b91009c91e00ce8fe11551f9": "0x00000000000000000000000000000000000c4170696c6c6f6e204d4b54001468747470733a2f2f6170696c6c6f6e2e696f2f0015636f6d6d756e697479406170696c6c6f6e2e696f000009404170696c6c6f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f67278c03253af6c20f057efcf26c451d58366c5906a3468517b624fb5674a547422726ebea3eb16": "0x000000000000000000000000000000000008446f744b696e6700000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f685fe8bfef999d22074f20847843acac10a56948a6634e827bcaabb455b9c958d285b2ec9090314": "0x04000000000200000000000000000000000000000000094e5244204c616273000000136572696e7665373740676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f69bb097d37ec3ca7e406ae038214b907dfa08e190c4d61bf43d28be997541747e3465ada083d262": "0x04010000000500000000000000000000000000000000064a554c494f0f4a554c494f2043415244454e415300001364697061706f636240676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f6a51af30694c2c19a820a93a16c1def7154cdd57c063e1a4630411e076f1e1e1ce93ca953af333e": "0x040300000002000000000000000000000000000000000b41434f42204a61736f6e0f4a61736f6e2046726965646d616e00001b61636861696e6f66626c6f636b73406f75746c6f6f6b2e636f6d00000a41434f424a61736f6e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f6db4258f530c658ca676edbf98876ab4fd6ad742f7954773a0e234345d6551a8ee9738a8ae33d42": "0x040100000002000000000000000000000000000000000753524c6162731f5352205365637572697479205265736561726368204c61627320476d62481268747470733a2f2f73726c6162732e6465000f6e6f686c4073726c6162732e6465000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f6e7d7d57efb1158faf96a8cf4ac3d4de8b04b607a7a70cc4aeb5ea742ea2c59836057a2678dad64": "0x000000000000000000000000000000000017537061636577616c6b207c20506f6c6b61204861757300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f73159fa6ef16058625b21fc3cfe39c52cf4d753fe8ad5f3b2ace458d9d11d266f080216e5e885e6": "0x040000000002000000000000000000000000000000001d4368616f7344414f204576656e747320426f756e74792050726f78790000000000000a404368616f7344414f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f738bf8232b5657ec2401487a14072ba228693b006c7be226b17b2bf498630b41631f91065e17875": "0x040000000002000000000000000000000000000000001143726f75746f6e4469676974616c2d3100001540746f7861333333333a6d61747269782e6f72671763726f75746f6e6469676974616c40616f6c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f740ceb4be9720dce0f0f94962fc0a8c1a0f0527dc8e592c67939c46c903b6016cc0a8515da0044d": "0x00000000000000000000000000000000000a656c697a6162657468000013406c696c6574683a6d61747269782e6f726700000000056e6f6f740000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f77e7d1a38a5e4b2befe71ab1f2719097a35e93e9114427bcd71e5109c14d82b9b3d9080f16dec2f": "0x04010000000200000000000000000000000000000000045a4b56001968747470733a2f2f7a6b76616c696461746f722e636f6d2f001668656c6c6f407a6b76616c696461746f722e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f78baea38e12315a6c7fdb8b8eaad1af9faaf918493606e1a3e8c20f9d852773ab5ebfbb93bd1948": "0x040000000002000000000000000000000000000000000757656233476f0757656233476f1468747470733a2f2f77656233676f2e78797a2f0010696e666f4077656233676f2e78797a0000084057656233476f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f79f574773cdeb99eacf14f2850c8d4145f07936bad43325bb0d150b1111757e944d62ecd0abcce6": "0x00000000000000000000000000000000001bf09faaac2054616c69736d616e20476f762044656c6567617465001568747470733a2f2f74616c69736d616e2e78797a000000000f40776561726574616c69736d616e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f7a35e45eb5c8f006a4e76d530fa715a95388b889ad33c1665062c3dec9bf0aca3a9e4ff45781e48": "0x000000000000000000000000000000000007526f73c5a56113526f737469736c6176204c69746f766b696e0000000000000009726f73746164657600", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f7f56e24024aa32cc0aacd65996d35fa753d12fc099078f0357d5628950585143e953675c7aee712": "0x00000000000000000000000000000000001c313335204341504954414c20494e434f52504f524154454420303310416e74686f6e7920457566656d696f0f68747470733a2f2f3133352e696f000b616365403133352e696f00000f407265616c4143457566656d696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f7f82bb21d26a5d0647201c657cb2ea9a6f15069728a26a9bf195c93adfa947cace0e7df16d7e102": "0x040100000002000000000000000000000000000000001054726962652f416e67656c4861636b12416e67656c4861636b20507465204c74641768747470733a2f2f616e67656c6861636b2e636f6d2f00186a757374696e2e6e6740616e67656c6861636b2e636f6d00000b40416e67656c4861636b000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f7f8fa46e9ed81a89ce3de1cd55ad6f4ab351ab212431d94cec798e1727176cca174fa661c8f636e": "0x040300000002000000000000000000000000000000000856696e63656e740f56696e63656e7420476564646573001440766765646465733a6d61747269782e6f72671576696e63656e7440736e6f77666f726b2e636f6d0000094076676564646573000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f80b38f6992cd55c0e06a7b3013bdbcd4f649d47a82e646be1223be5ceb8d32e8847fb7dbd2ccf57": "0x0401000000020000000000000000000000000000000015535543482046494e54454348205354414b494e4715535543482046494e54454348205354414b494e470018407375636866696e746563683a6d61747269782e6f7267196465766f7073407375636866696e746563682e636f2e6e7a00000d407375636866696e74656368000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f81ec86fea69eb9bfb430ce27d4be287efa0c50ef42c36c3ef14e55ecaf40ac53e1df33b0720d176": "0x00000000000000000000000000000000000631574542341757656233204c6567616c20456e67696e656572696e671268747470733a2f2f6f6e656c61772e7573001073636f7474406f6e656c61772e757300000b4074656e66696e6e6579000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f898daa4756e63c5ca467889146a7467efffe20d97c077cb961d176dfa96f669857d3aaa8485fc0a": "0x0000000000000000000000000000000000114d696368616c40416c6570685a65726f0f4d696368616c205377696574656b1668747470733a2f2f616c6570687a65726f2e6f7267001d6d696368616c2e7377696574656b40616c6570687a65726f2e6f7267000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f98bc77ab23b03eed401f460e0251ed41d7fb32ca463b5233b620cb9569eef5327def27fbd7c7b57": "0x04000000000200000000000000000000000000000000084361626c652d58000012406361626c653a6d61747269782e6f72671e6379636c6f707373756d6d6572734070726f746f6e6d61696c2e636f6d00000f4073756d6d6572735f6361626c65000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f9a33b675b34b0c00a7cbce722b9e8f16e7c0a9bb209f761cc94e25191e7599cb0d0234d1ad11d66": "0x00000000000000000000000000000000000a4942502050726f787900000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f9ace18a7f38e38e94204c6fb288a7302b1ff34b6aafd5edf6de6b895db07f3d6ca1a75d1681f37e": "0x040300000002000000000000000000000000000000000f506564726f204c6f75726569726f1e506564726f2052616661656c204c6f75726569726f204c65616e64726f000019706564726f2e706f6c6b61646f7440676d61696c2e636f6d000011404368656d6963616c4f7074696f6e73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f9b0358c010b6eb69ecfdf118a26b3c2926e7ba57cb2c08eac9e981318d88b958c0e06e97e774c1e": "0x040000000002000000000000000000000000000000000f556e69717565204e6574776f726b0000001568656c6c6f40756e697175652e6e6574776f726b00001140556e697175655f4e4654636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714f9e4ceaaa31d1e273ec9398e00987bf25afda5d3f3e3a1a1f1b121d8728d7da7a30dd1b545eb3d49": "0x0403000000020000000000000000000000000000000012436861696e616c79736973204c6567616c0000001b6a616d65732e7061696b40636861696e616c797369732e636f6d00000a6b6f6e657368693133000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fa2d9158713aa2daac18d0d46a223a6576df578a0c7f7e087d7dceb3608cbdf792b279c532631c09": "0x00000000000000000000000000000000001367726568656920706f6c6b61646f74204772000013406772656865693a6d61747269782e6f72671167726568656940676d61696c2e636f6d000009404772655f486569000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fa4279b211bd820ab22c2075548019dd268e74f3aa69c9703b129e989d230f935797975d5ed9247d": "0x04000000000200000000000000000000000000000000125a6574657469632056616c696461746f7200001d407a65746574696376616c696461746f723a6d61747269782e6f72671e6f70657261746f72407a65746574696376616c696461746f722e636f6d000010405a6574696356616c696461746f72000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fa4c4ebe45297c58e8435412cd8649ed9d5212898af799270589d46d53af6c9b30dc6103b5917454": "0x0000000000000000000000000000000000064b61696f6800000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fa701643441fc0cc0a73047c4bca127582fa1541c886915b2a872c95fb538fcea099bab0a47b8f54": "0x040100000002000000000000000000000000000000001153554e5348494e454155544f53444f5400001f4073756e7368696e656175746f736e6f6465733a6d61747269782e6f72671c73756e7368696e656175746f73696e666f40676d61696c2e636f6d0000114053756e7368696e655f4175746f735f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714faa55b79d5b983962aad2d511e0a2ade151b1e3442675156b71aea1f049ce004311cf33c9d70c474": "0x040000000002000000000000000000000000000000000a53656261737469616e00001c4073656261737469616e63726970746f3a6d61747269782e6f72671b73656261737469616e63727970746f3840676d61696c2e636f6d0000114053656261737469616e43726970746f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fad7d2ce54667f8c1ea80b0dde0e207c8ec57ac05fbec636502cb216bb423642919679fe8f074051": "0x0401000000020000000000000000000000000000000015525454492d353232302028504f4c4b41444f54290f5261756c20526f6d616e75747469001c407261756c2e727474693a6d61747269782e7061726974792e696f177261756c406a7573746f70656e736f757263652e696f00000b406e6163686f72747469000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fadf532a0cd06f2c30bdeebf156313a98c5235fd02e6086502e320acf1791ec4390b8bb4735e5033": "0x04030000000200000000000000000000000000000000064b6f6b6f4c000000186e696b686f6c65636c7563617340676d61696c2e636f6d00000e406e696b686f6c656c75636173000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fae4899c3cb40a9ee6c87f4b9656543d64815b6626ba2ee48c8c54de210dfa98bfe53333fdf26744": "0x040100000002000000000000000000000000000000000d41646472657373204c6162731141646472657373204c61627320496e6300001b6861727269736f6e2e636f6d666f727440676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fb0bc5a64f81e0ca7cbb0ed8bf228935241774290753bf282020d73e45f6724b0196c97b3bd53462": "0x040000000002000000000000000000000000000000000b6f70656e6269746c6162000018406f70656e6269746c61625f3a6d61747269782e6f72671c6461766964652e6f70656e6269746c616240676d61696c2e636f6d00000c404f70656e4269744c6162000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fb2ad09a8a07f8da26c3fc13ac393359abbdbec7ad3de6f6dd110169e0ef401b19c693afcfc38f08": "0x040100000002000000000000000000000000000000001e545247207c204469676974616c20496e6e6f766174696f6e2046756e642054524720496e737572616e63652042726f6b657273202850747929204c74641f68747470733a2f2f7777772e726f6265727467726f75702e636f2e7a612f00184b6576696e40726f6265727467726f75702e636f2e7a6100000d40526f6265727447726f7570000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fb7fa862606e0cd75626fb92ce5aacc7ac4dd042dd55308832ba8dde38c557b140ae8740948fe76c": "0x040000000002000000000000000000000000000000000763776368756100000000000000076368756163770000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fb983efc82b2f0f392d5c737ce301d743f39f522a06af54bc5f37c1f9037c22c40722ec16a07364d": "0x00000000000000000000000000000000000b646174646f742e6f72670000000000000b40646174646f746f7267000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fbc4385a1a8a38b114dd7b536252ac1b8294062b9f93fbd0b8c2632010aef94753354a3721def21b": "0x00000000000000000000000000000000000f506f6c6b61204578706c6f726572001168747470733a2f2f706f6c6b612e696f000b6940706f6c6b612e696f00000940706f6c6b61696f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fbe4b7926dff6bda8c7b7c1af5f115225fb19bbba44e2b9b68acc26d2dfeff02d948183ffcdc0d0f": "0x000000000000000000000000000000000008484d204d4152530f48616e747573204d6f737465727400001968616e7475736d6f73746572743140676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fbeb0670b76a6ac8ea614ce8bc4baa3c39e8019636cc6f8d9a67291f19dabb2d898a308b6b93b72e": "0x000000000000000000000000000000000009616e67657765623312416e67656c696361204772617465726f6c000020616e67656c6963616161677265726f6c2e3037303440676d61696c2e636f6d00000b616e6765696e77656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fbef5ae8c51b799f2a0e4eb85f552a217a9ddd86b965229be3210d010f0f0f78398d8d9a5a5f0537": "0x040000000002000000000000000000000000000000000f395374616b65206279203947414700001840397374616b652e396761673a6d61747269782e6f726719397374616b652e706f6c6b61646f7440396761672e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fc06d1b8b9ab844be64bc946c10a1f75e683f236e72a44d6d61b3bdcf72ffd8c738e488efc6e1567": "0x040000000002000000000000000000000000000000000b4d61746843727970746f001c68747470733a2f2f7777772e6d6174682d63727970746f2e636f6d17406d61746863727970746f3a6d61747269782e6f7267116d61746863727970746f40696b2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fc6a42b3b802fc9518d54ea25ad26acd7094fba6bdb278e769f9ac350cc36b2f631da13fa92bed79": "0x040100000002000000000000000000000000000000000c5374616b652e576f726b730c5374616b652e576f726b731468747470733a2f2f7374616b652e776f726b73154077656264657639393a6d61747269782e6f726711696e666f407374616b652e776f726b7300000c405374616b65576f726b73000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fcbacdb7dda02f70504baa1f30e0267703f471e94de948bd9f09caaf3c3a2f4c2dad3685a79ee000": "0x0400000000020000000000000000000000000000000006616e76656c00001240616e76656c3a6d61747269782e6f726717616e647265792e76656c646540676d61696c2e636f6d00000d40416e6472657956656c64650007616e76656c2e00", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fcd27506d243061f2edf0fd8948ea642f135b314b1358c77ec6d0a4af83220b6ea18136e5ce36277": "0x04000000000200000000000000000000000000000000124368726973404f414b204e6574776f726b0000000f6368726973406f616b2e7465636800000d4063687269736c6932303436000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fce864e50b620f11ad65f8153459863f71364d90f27265da0084743373e0c75ae69d651efc95b62e": "0x00000000000000000000000000000000000b506f6c6b61205269636f0b506f6c6b61205269636f1668747470733a2f2f706f6c6b617269636f2e636f6d0000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd0157da0fed5e2b4805c5f3b7f9abe9da4189cead8a9a8453ab2cfc637a0f9cd93d59661aba9954": "0x04030000000200000000000000000000000000000000074a6179436565164a756c69616e6120506572657a20436172646f7a6f00001d6a756c69616e61636172646f7a6f313740686f746d61696c2e636f6d00000c49616d4a756c69616e6143000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd050f61009683f92e62fe384b5820c81695aa763b54daf138b67b014714c5c6f75d68e4d1b3785b": "0x00000000000000000000000000000000001944617272656c6c202d20506f6c6b61646f74204163616c6100000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd0ec0420825c1bfce2490656709c33bdd50d72dc0ec562bb72db84945ef7a1be45be14bbc6fc877": "0x04000000000200000000000000000000000000000000047369780000124068657866663a6d61747269782e6f7267127369784063727970746f6374662e6f726700000c4053697854686544617665000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd32583ae5aff69da2d756efc15354d37aafecf3a850808b1276d1cee16f14a14397e81b616e9a4a": "0x040300000002000000000000000000000000000000000a5368696b615f7770771657697061776565204c696d6b6173657473616b756c00001b6b77616e672e6c696d6b40656e746572746f73746172742e636f00000e40456e746572746f5374617274000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd4f36a10fe246e4e87f578ff46b741dafc7ffd2b6e223f50269ea6b8260b9bde108d6e5870f877c": "0x040300000002000000000000000000000000000000000a64617374616e73616d0000001664617374616e73616d313640676d61696c2e636f6d00000b6b696e676c656172645f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd64180d1412f211888c6e2c05a5db8fb2ce4a31ffc434049fac143401d77e862dea055bf5607073": "0x0000000000000000000000000000000000134d61726375732720446f742077616c6c657400000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd71c324186304a590c5d23600de15438062c91c4976d001a14cecf539c2b8db9399c4b56e6b1166": "0x0403000000020000000000000000000000000000000008487970654c6162084a6f65204b696d00001268656c6c6f40687970656c61622e636f6d00000b40676f687970656c6162000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd8929a3a5cb6d462fd09555017774e81bda25510ca97864e9bc350620523fd11508f99b8fdc8b7d": "0x0000000000000000000000000000000000145765625a65726f205632204d756c74697369670000000000000d406a6f696e7765627a65726f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fd9785f8772870809eee1e58c17ff7b037f2da5766e9bc78d5568c58d45cf363b9630ef32b2ccd79": "0x040100000002000000000000000000000000000000000a507572655374616b650e507572655374616b65204c74641b68747470733a2f2f7777772e707572657374616b652e636f6d2f0013696e666f40707572657374616b652e636f6d00000d40707572657374616b65636f000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fdc037f375e9e4c3961db3fef76ece3b513f6896e19fd09588d62f5c6a99d577275d7db8005e610f": "0x040100000002000000000000000000000000000000000d4175677573746f204c6172611a4365736172204175677573746f204c61726120476176696e6f0000126175677573746f406861736865642e696f00000d404175677573746f4c617261000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fdc296dd3da2e409e472fc53af693baa4199e1edd6a3d86badfc6d2d4aad3331d8a40fd6b18b751a": "0x00000000000000000000000000000000000d6361726c6974726f7374657300000000000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fdf70154c5cd66e448b3ed689e1d1c790052dfea406cff690cbf0354a3598c961c7e8054068a6c9d": "0x040000000002000000000000000000000000000000000a70616e7661645348310000134070616e7661643a6d61747269782e6f72671669616d70616e766164696d40676d61696c2e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fe0f1e8f0e428f0ffa859a32665b4dd29d647732d0d8e0b794cb21ae44862153bfca9522c14e9c71": "0x040300000002000000000000000000000000000000000a486f7065436c6172790d486f706520476f6f646d616e000013486f7065696f756d40676d61696c2e636f6d000009486f7065696f756d000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fe7066486cbde784e0d0031d0a450dfc4bb16333fe575dfb8452bb0f79c768181478190a5d9a653f": "0x04000000000200000000000000000000000000000000144c6974656e74727920436f6c6c61746f72203100000012696e666f406c6974656e7472792e636f6d000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fea0c4e647948252eccdb05e3f618a3da74db2ca0a4c635b94c388e3e620c7ef7093ef34f206ca7c": "0x04030000000200000000000000000000000000000000144175746f6e6f6d6f75732050726f6a65637473144175746f6e6f6d6f75732050726f6a6563747300001b7468656f406175746f6e6f6d6f757370726f6a656374732e636f000011406175746f6e6f6d6f75735f77656233000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fecc695c6a87d6466ecb07b7a8f63febc1c458983d4ec414e4cbb76ec3f128d9cedd5f4c4fd2965b": "0x040000000002000000000000000000000000000000001073306d65306e652d756e6b6e30776e000000000000001073306d65306e652d756e6b6e30776e0000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714fedff71a46bae1ee98388d733bfdc1edad482ef118803415e01703eb7e20e7822a3a322f999c3177": "0x0000000000000000000000000000000000084d756375323536104d7563756e67757a69204d6f7365730000126d6f656d75637540676d61696c2e636f6d00000d4063727970746f70726f5567000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ff02177bcafc5807e274c36b3b6efe4d0de454afa853ce1e7a4f789aaa2f3c9613a61fb365f9362b": "0x040000000002000000000000000000000000000000000746696e7369670e53746576656e20426f796e657300134066696e7369673a6d61747269782e6f72671073746576654066696e7369672e696f000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ff643fe3320aabbafcba1bf303b55be82bf6e48504909dfb85be27bcbbb2a330e9f4fc1261d8f02a": "0x040000000002000000000000000000000000000000000e47656e657269632d636861696e00001a4067656e657269632d636861696e3a6d61747269782e6f726716696e666f4067656e657269632d636861696e2e696f00000f4067656e657269635f636861696e000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ff68e68c8f4329adc0fb1e91315aff633f7889e1b32c46b2b33e534d059f29a4fda276ce4e59f83a": "0x04000000000200000000000000000000000000000000084469616d6f6e640000001776616c69646469616d6f6e644070726f746f6e2e6d65000000000000", + "0x2aeddc77fe58c98d50bd37f1b90840f9cd7f37317cd20b61e9bd46fab8704714ffc544aa04d3feb9a69484f2b10ec2f1dea19394423d576f91c6b5ab2315b389f4e108bcf0aa2840": "0x000000000000000000000000000000000005466162690000184066616269616e3a776562332e666f756e646174696f6e0000000d4066616269616e676f6d7066000000" + }, + "childrenDefault": {} + } + } +} diff --git a/cumulus/parachains/chain-specs/people-rococo.json b/cumulus/parachains/chain-specs/people-rococo.json index a4361b77df790ad816d3c95afcf93c0575ee2b85..952e1516c117cfc22e79fed91d48d0f8718b77b9 100644 --- a/cumulus/parachains/chain-specs/people-rococo.json +++ b/cumulus/parachains/chain-specs/people-rococo.json @@ -1,7 +1,4 @@ { - "name": "Rococo People", - "id": "people-rococo", - "chainType": "Live", "bootNodes": [ "/dns/rococo-people-collator-node-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWDZg5jMYhKXTu6RU491V5sxsFnP4oaEmZJEUfcRkYzps5", "/dns/rococo-people-collator-node-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWGGR5i6qQqfo7iDNp7vjDRKPWuDk53idGV6nFLwS12X5H", @@ -10,18 +7,15 @@ "/dns/rococo-people-collator-node-0.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWDZg5jMYhKXTu6RU491V5sxsFnP4oaEmZJEUfcRkYzps5", "/dns/rococo-people-collator-node-1.parity-testnet.parity.io/tcp/443/wss/p2p/12D3KooWGGR5i6qQqfo7iDNp7vjDRKPWuDk53idGV6nFLwS12X5H" ], - "telemetryEndpoints": null, - "protocolId": null, - "properties": { - "ss58Format": 42, - "tokenDecimals": 12, - "tokenSymbol": "ROC" - }, "relay_chain": "rococo", "para_id": 1004, - "codeSubstitutes": {}, + "chainType": "Live", + "codeSubstitutes": { + "1209599": "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" + }, "genesis": { "raw": { + "childrenDefault": {}, "top": { "0x0d715f2646c8f85767b5d2764bb2782604a74d81251e398fd8a0a4d55023bb3f": "0xec030000", "0x0d715f2646c8f85767b5d2764bb278264e7b9012096b41c4eb3aaf947f6ea429": "0x0000", @@ -73,8 +67,16 @@ "0xe38f185207498abb5c213d0fb059b3d84e7b9012096b41c4eb3aaf947f6ea429": "0x0100", "0xe38f185207498abb5c213d0fb059b3d86323ae84c43568be0d1394d5d0d522c4": "0x03000000", "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} + } } - } + }, + "id": "people-rococo", + "name": "Rococo People", + "properties": { + "ss58Format": 42, + "tokenDecimals": 12, + "tokenSymbol": "ROC" + }, + "protocolId": null, + "telemetryEndpoints": null } diff --git a/cumulus/parachains/chain-specs/people-westend.json b/cumulus/parachains/chain-specs/people-westend.json index 93b8c064113f01c133ef301056ff79ade6dd032a..ac24b2e6435922e67e2cb07d66b90b2bac2fa5b8 100644 --- a/cumulus/parachains/chain-specs/people-westend.json +++ b/cumulus/parachains/chain-specs/people-westend.json @@ -17,14 +17,16 @@ "/dns/boot-node.helikon.io/tcp/9522/wss/p2p/12D3KooWHhZk21Wzvsd3Un1Cp63diXqr6idbG1MEiUWaitUZuX4c", "/dns/boot.metaspan.io/tcp/35068/p2p/12D3KooWAtw8ybFXNmNdTUsvt2gfKwtuea9wDQT2b8FpbVNKYGwc", "/dns/boot.metaspan.io/tcp/35069/wss/p2p/12D3KooWAtw8ybFXNmNdTUsvt2gfKwtuea9wDQT2b8FpbVNKYGwc", - "/dns/boot.stake.plus/tcp/46333/p2p/12D3KooWLNWUF4H5WE3dy2rPB56gVcR48XY2rHwEaZ6pGTK6HYFi", - "/dns/boot.stake.plus/tcp/46334/wss/p2p/12D3KooWLNWUF4H5WE3dy2rPB56gVcR48XY2rHwEaZ6pGTK6HYFi", + "/dns/people-westend.boot.stake.plus/tcp/30332/wss/p2p/12D3KooWD5T1YN8oZUEsRXWod69kYH67jrSXHm6tSvs7RvH4Cb3p", + "/dns/people-westend.boot.stake.plus/tcp/31332/wss/p2p/12D3KooWSByQrekhxx7pyDMTZcnnWBBFdj2LtqN9QtTCBDckc2zi", "/dns/boot.gatotech.network/tcp/33340/p2p/12D3KooWHwURYtEHpexfrZa8k8hVgVi5FTFr4N8HBnn9kPDsWfgA", "/dns/boot.gatotech.network/tcp/35340/wss/p2p/12D3KooWHwURYtEHpexfrZa8k8hVgVi5FTFr4N8HBnn9kPDsWfgA", - "/dns/people-westend.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWQrMQFAXxJJJCtVr8nViBR6EDsuT1RyqU3eoCMebRQxTf", - "/dns/people-westend.bootnode.amforc.com/tcp/30346/p2p/12D3KooWQrMQFAXxJJJCtVr8nViBR6EDsuT1RyqU3eoCMebRQxTf", + "/dns/people-westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWE1btdwDhNpApg8BEe2QwJxdVDtz6a6BRhgTeUh9HMhWs", + "/dns/people-westend.bootnode.amforc.com/tcp/30016/p2p/12D3KooWE1btdwDhNpApg8BEe2QwJxdVDtz6a6BRhgTeUh9HMhWs", "/dns/people-westend-bootnode.turboflakes.io/tcp/30650/p2p/12D3KooWQEhmZg3uMkuxVUx3jbsD84zEX4dUKtvHfmCoBWMhybKW", "/dns/people-westend-bootnode.turboflakes.io/tcp/30750/wss/p2p/12D3KooWQEhmZg3uMkuxVUx3jbsD84zEX4dUKtvHfmCoBWMhybKW", + "/dns/wppl16.rotko.net/tcp/33766/p2p/12D3KooWHwUXBUo2WRMUBwPLC2ttVbnEk1KvDyESYAeKcNoCn7WS", + "/dns/wppl16.rotko.net/tcp/35766/wss/p2p/12D3KooWHwUXBUo2WRMUBwPLC2ttVbnEk1KvDyESYAeKcNoCn7WS", "/dns/people-westend-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWBdCpCabhgBpLn67LWcXE2JJCCTMhuJHrfDNiTiCCr3KX", "/dns/people-westend-boot-ng.dwellir.com/tcp/30355/p2p/12D3KooWBdCpCabhgBpLn67LWcXE2JJCCTMhuJHrfDNiTiCCr3KX" ], diff --git a/cumulus/parachains/common/Cargo.toml b/cumulus/parachains/common/Cargo.toml index fa16205d0fd1adee1491cf3abb92a55829b16a44..6d436bdf799a4f7682ced2098f4926ec9bc50379 100644 --- a/cumulus/parachains/common/Cargo.toml +++ b/cumulus/parachains/common/Cargo.toml @@ -13,42 +13,41 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", features = ["derive"], default-features = false } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", 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-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura", 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 } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-asset-tx-payment = { workspace = true } +pallet-assets = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +polkadot-primitives = { workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -pallet-collator-selection = { path = "../../pallets/collator-selection", default-features = false } -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../primitives/utility", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../pallets/parachain-info", default-features = false } +pallet-collator-selection = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +parachain-info = { workspace = true } [dev-dependencies] -pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } +pallet-authorship = { workspace = true } +sp-io = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -73,7 +72,6 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-executor/std", "xcm/std", ] diff --git a/cumulus/parachains/common/src/impls.rs b/cumulus/parachains/common/src/impls.rs index d70fdfeb7095a2dbd6f5fd9a53caeb1272476743..c1797c0a75132d4cd3b64ac3e90791fab4dc516a 100644 --- a/cumulus/parachains/common/src/impls.rs +++ b/cumulus/parachains/common/src/impls.rs @@ -16,6 +16,8 @@ //! Auxiliary struct/enums for parachain runtimes. //! Taken from polkadot/runtime/common (at a21cd64) and adapted for parachains. +use alloc::boxed::Box; +use core::marker::PhantomData; use frame_support::traits::{ fungible, fungibles, tokens::imbalance::ResolveTo, Contains, ContainsPair, Currency, Defensive, Get, Imbalance, OnUnbalanced, OriginTrait, @@ -23,7 +25,6 @@ use frame_support::traits::{ use pallet_asset_tx_payment::HandleCredit; use pallet_collator_selection::StakingPotAccountId; use sp_runtime::traits::Zero; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::latest::{ Asset, AssetId, Fungibility, Fungibility::Fungible, Junction, Junctions::Here, Location, Parent, WeightLimit, @@ -66,7 +67,7 @@ where AccountIdOf: From + Into, ::RuntimeEvent: From>, { - fn on_unbalanceds( + fn on_unbalanceds( mut fees_then_tips: impl Iterator< Item = fungible::Credit>, >, @@ -202,7 +203,7 @@ mod tests { use frame_system::{limits, EnsureRoot}; use pallet_collator_selection::IdentityCollator; use polkadot_primitives::AccountId; - use sp_core::{ConstU64, H256}; + use sp_core::H256; use sp_runtime::{ traits::{BlakeTwo256, IdentityLookup}, BuildStorage, Perbill, @@ -222,10 +223,8 @@ mod tests { ); parameter_types! { - pub const BlockHashCount: u64 = 250; pub BlockLength: limits::BlockLength = limits::BlockLength::max(2 * 1024); pub const AvailableBlockRatio: Perbill = Perbill::one(); - pub const MaxReserves: u32 = 50; } #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] @@ -240,7 +239,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type BlockLength = BlockLength; type BlockWeights = (); type DbWeight = (); @@ -255,20 +253,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ConstU64<1>; type AccountStore = System; - type MaxLocks = (); - type WeightInfo = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } pub struct OneAuthor; diff --git a/cumulus/parachains/common/src/lib.rs b/cumulus/parachains/common/src/lib.rs index b01d623d2b93da529f37bbfd8cf139ea5b98d9ae..3cffb69daac3fae6d5729a985489433f442bf22c 100644 --- a/cumulus/parachains/common/src/lib.rs +++ b/cumulus/parachains/common/src/lib.rs @@ -15,6 +15,8 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + pub mod impls; pub mod message_queue; pub mod xcm_config; diff --git a/cumulus/parachains/common/src/message_queue.rs b/cumulus/parachains/common/src/message_queue.rs index 0c9f4b840c9166ba9380f06970ad15bb1cac14c6..511d6243cb8c47a0e137f9eec03bbb1afdf5e644 100644 --- a/cumulus/parachains/common/src/message_queue.rs +++ b/cumulus/parachains/common/src/message_queue.rs @@ -16,10 +16,10 @@ //! Helpers to deal with configuring the message queue in the runtime. +use core::marker::PhantomData; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; use frame_support::traits::{QueueFootprint, QueuePausedQuery}; use pallet_message_queue::OnQueueChanged; -use sp_std::marker::PhantomData; /// Narrow the scope of the `Inner` query from `AggregateMessageOrigin` to `ParaId`. /// diff --git a/cumulus/parachains/common/src/xcm_config.rs b/cumulus/parachains/common/src/xcm_config.rs index a9756af7aed245ea792d12addbbb2fff529eedaf..7c58a2b2405c73477b0b88b95f99af870fdb5c90 100644 --- a/cumulus/parachains/common/src/xcm_config.rs +++ b/cumulus/parachains/common/src/xcm_config.rs @@ -14,13 +14,13 @@ // limitations under the License. use crate::impls::AccountIdOf; +use core::marker::PhantomData; use cumulus_primitives_core::{IsSystem, ParaId}; use frame_support::{ traits::{fungibles::Inspect, tokens::ConversionToAssetBalance, Contains, ContainsPair}, weights::Weight, }; use sp_runtime::traits::Get; -use sp_std::marker::PhantomData; use xcm::latest::prelude::*; /// A `ChargeFeeInFungibles` implementation that converts the output of diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/Cargo.toml index 8100e681348836fb28c9236b9ba20d27f117d71b..7bd91ae6774c61f93b12a91af298e64777980ac1 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/Cargo.toml @@ -13,16 +13,16 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -asset-hub-rococo-runtime = { path = "../../../../../../runtimes/assets/asset-hub-rococo" } -rococo-emulated-chain = { path = "../../../relays/rococo" } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["rococo"] } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +asset-hub-rococo-runtime = { workspace = true, default-features = true } +rococo-emulated-chain = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true, default-features = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/genesis.rs index e5378b35f5e484e10db94c66bc5244099b682604..5b70ed490c633b7d78558e72762fb60a2f7d0635 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/genesis.rs @@ -21,7 +21,7 @@ use sp_core::{sr25519, storage::Storage}; use emulated_integration_tests_common::{ accounts, build_genesis_storage, collators, get_account_id_from_seed, PenpalSiblingSovereignAccount, PenpalTeleportableAssetLocation, RESERVABLE_ASSET_ID, - SAFE_XCM_VERSION, + SAFE_XCM_VERSION, USDT_ID, }; use parachains_common::{AccountId, Balance}; @@ -62,13 +62,17 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: asset_hub_rococo_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), ..Default::default() }, assets: asset_hub_rococo_runtime::AssetsConfig { - assets: vec![(RESERVABLE_ASSET_ID, AssetHubRococoAssetOwner::get(), true, ED)], + assets: vec![ + (RESERVABLE_ASSET_ID, AssetHubRococoAssetOwner::get(), false, ED), + (USDT_ID, AssetHubRococoAssetOwner::get(), true, ED), + ], ..Default::default() }, foreign_assets: asset_hub_rococo_runtime::ForeignAssetsConfig { @@ -77,7 +81,7 @@ pub fn genesis() -> Storage { ( PenpalTeleportableAssetLocation::get(), PenpalSiblingSovereignAccount::get(), - true, + false, ED, ), ], diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/lib.rs index 202d02b250bb2e90261a01c13c6aab59c674b511..1f98d3ba964d8b808f42f17fdb44a4add24beb90 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-rococo/src/lib.rs @@ -13,6 +13,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub use asset_hub_rococo_runtime; + pub mod genesis; // Substrate @@ -57,5 +59,5 @@ impl_accounts_helpers_for_parachain!(AssetHubRococo); impl_assert_events_helpers_for_parachain!(AssetHubRococo); impl_assets_helpers_for_system_parachain!(AssetHubRococo, Rococo); impl_assets_helpers_for_parachain!(AssetHubRococo); -impl_foreign_assets_helpers_for_parachain!(AssetHubRococo, xcm::v3::Location); +impl_foreign_assets_helpers_for_parachain!(AssetHubRococo, xcm::v4::Location); impl_xcm_helpers_for_parachain!(AssetHubRococo); diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/Cargo.toml index e0abaa66c5cabba445b91c19436f9a4ce3642386..86d4ce3e7ac829e959aa3169adbd22a257cc26a5 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/Cargo.toml @@ -13,16 +13,16 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -asset-hub-westend-runtime = { path = "../../../../../../runtimes/assets/asset-hub-westend" } -westend-emulated-chain = { path = "../../../relays/westend" } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["westend"] } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +asset-hub-westend-runtime = { workspace = true } +westend-emulated-chain = { workspace = true, default-features = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/genesis.rs index 219d1306906cbc6c20609870bec496c5bd16eaeb..d20e059f9fea48a649934b6ca2a0470327ee5e54 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/genesis.rs @@ -21,7 +21,7 @@ use sp_core::{sr25519, storage::Storage}; use emulated_integration_tests_common::{ accounts, build_genesis_storage, collators, get_account_id_from_seed, PenpalSiblingSovereignAccount, PenpalTeleportableAssetLocation, RESERVABLE_ASSET_ID, - SAFE_XCM_VERSION, + SAFE_XCM_VERSION, USDT_ID, }; use parachains_common::{AccountId, Balance}; @@ -58,13 +58,17 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: asset_hub_westend_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), ..Default::default() }, assets: asset_hub_westend_runtime::AssetsConfig { - assets: vec![(RESERVABLE_ASSET_ID, AssetHubWestendAssetOwner::get(), true, ED)], + assets: vec![ + (RESERVABLE_ASSET_ID, AssetHubWestendAssetOwner::get(), false, ED), + (USDT_ID, AssetHubWestendAssetOwner::get(), true, ED), + ], ..Default::default() }, foreign_assets: asset_hub_westend_runtime::ForeignAssetsConfig { @@ -73,7 +77,7 @@ pub fn genesis() -> Storage { ( PenpalTeleportableAssetLocation::get(), PenpalSiblingSovereignAccount::get(), - true, + false, ED, ), ], diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/lib.rs index 6043a6aeda48f1e1ec010ac42e98a50feaae3a30..6066adec52c30020e2c9b26cf2db303e0948fa9c 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/assets/asset-hub-westend/src/lib.rs @@ -13,6 +13,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub use asset_hub_westend_runtime; + pub mod genesis; // Substrate @@ -57,5 +59,5 @@ impl_accounts_helpers_for_parachain!(AssetHubWestend); impl_assert_events_helpers_for_parachain!(AssetHubWestend); impl_assets_helpers_for_system_parachain!(AssetHubWestend, Westend); impl_assets_helpers_for_parachain!(AssetHubWestend); -impl_foreign_assets_helpers_for_parachain!(AssetHubWestend, xcm::v3::Location); +impl_foreign_assets_helpers_for_parachain!(AssetHubWestend, xcm::v4::Location); impl_xcm_helpers_for_parachain!(AssetHubWestend); diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/Cargo.toml index 789f10a35f268c62e0cc9fa153c99e7e5282ee8d..f3c0799ad0f6acf14b3e99d4e27e46921c4e9cb9 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/Cargo.toml @@ -13,12 +13,12 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -bridge-hub-rococo-runtime = { path = "../../../../../../runtimes/bridge-hubs/bridge-hub-rococo" } -bridge-hub-common = { path = "../../../../../../runtimes/bridge-hubs/common", default-features = false } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["rococo"] } +parachains-common = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +bridge-hub-rococo-runtime = { workspace = true, default-features = true } +bridge-hub-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/genesis.rs index 12778215b1320f591bec787198243c825313e858..3786d529ea6502988f92c18955722a7a0f9ebded 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/genesis.rs @@ -52,6 +52,7 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: bridge_hub_rococo_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/lib.rs index 8c18d112bc12fb4883d313106fa66841dcad8d2e..5ef0993f70a1ce33daa68ec23b474716e6bee956 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-rococo/src/lib.rs @@ -15,6 +15,12 @@ pub mod genesis; +pub use bridge_hub_rococo_runtime::{ + xcm_config::XcmConfig as BridgeHubRococoXcmConfig, EthereumBeaconClient, EthereumInboundQueue, + ExistentialDeposit as BridgeHubRococoExistentialDeposit, + RuntimeOrigin as BridgeHubRococoRuntimeOrigin, +}; + // Substrate use frame_support::traits::OnInitialize; diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/Cargo.toml index d82971cf55aeddf20032be952b8a980014434f6b..ebcec9641e7d9f122f5b6737769bc140d9c877a5 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/Cargo.toml @@ -13,12 +13,12 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -bridge-hub-westend-runtime = { path = "../../../../../../runtimes/bridge-hubs/bridge-hub-westend" } -bridge-hub-common = { path = "../../../../../../runtimes/bridge-hubs/common", default-features = false } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["westend"] } +parachains-common = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +bridge-hub-westend-runtime = { workspace = true, default-features = true } +bridge-hub-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/genesis.rs index 4be68e510f4d254dcf645db682b6cf34ff69e634..f38f385db65068928b0f83de4cdef998813c0dba 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/genesis.rs @@ -23,6 +23,7 @@ use emulated_integration_tests_common::{ use parachains_common::Balance; pub const PARA_ID: u32 = 1002; +pub const ASSETHUB_PARA_ID: u32 = 1000; pub const ED: Balance = testnet_parachains_constants::westend::currency::EXISTENTIAL_DEPOSIT; pub fn genesis() -> Storage { @@ -51,6 +52,7 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: bridge_hub_westend_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), @@ -64,6 +66,11 @@ pub fn genesis() -> Storage { owner: Some(get_account_id_from_seed::(accounts::BOB)), ..Default::default() }, + ethereum_system: bridge_hub_westend_runtime::EthereumSystemConfig { + para_id: PARA_ID.into(), + asset_hub_para_id: ASSETHUB_PARA_ID.into(), + ..Default::default() + }, ..Default::default() }; diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/lib.rs index b0dddc9dbf9a5b71a776e3ae48b97bbb9f29adf2..feb59c411c8df488c748fe79e3fd485757fd0de0 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/bridges/bridge-hub-westend/src/lib.rs @@ -15,6 +15,11 @@ pub mod genesis; +pub use bridge_hub_westend_runtime::{ + xcm_config::XcmConfig as BridgeHubWestendXcmConfig, + ExistentialDeposit as BridgeHubWestendExistentialDeposit, +}; + // Substrate use frame_support::traits::OnInitialize; diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/Cargo.toml index 4c2a7d3c274dce6eade9c9d42be00301bd6dc462..87dfd73ab05bab063bedeebae9feb03bcc4af46f 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/Cargo.toml @@ -13,12 +13,12 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -collectives-westend-runtime = { path = "../../../../../../runtimes/collectives/collectives-westend" } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["westend"] } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +collectives-westend-runtime = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/genesis.rs index 6a28b1a9dddb8ca8b118592d85ef11367569d2a0..d4ef184ea392de3bcd936b889aa030e032ad120c 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/genesis.rs @@ -51,6 +51,7 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: collectives_westend_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/lib.rs index a32e865dd9ce8497755a261c6922273aea8b49f6..f90d82231a3bb1ea64cfb6acad2759bcd486f1f9 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/collectives/collectives-westend/src/lib.rs @@ -13,6 +13,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub use collectives_westend_runtime; + pub mod genesis; // Substrate diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..6af3f270a905f504b471374d0b29687f766409e4 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "coretime-rococo-emulated-chain" +version = "0.0.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +description = "Coretime Rococo emulated chain" +publish = false + +[lints] +workspace = true + +[dependencies] + +# Substrate +sp-core = { workspace = true } +frame-support = { workspace = true } + +# Cumulus +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +coretime-rococo-runtime = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/genesis.rs new file mode 100644 index 0000000000000000000000000000000000000000..e0f035c368e3966f1d2fc08b7d0bf2597fadda01 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/genesis.rs @@ -0,0 +1,67 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Substrate +use sp_core::storage::Storage; + +// Cumulus +use emulated_integration_tests_common::{ + accounts, build_genesis_storage, collators, SAFE_XCM_VERSION, +}; +use parachains_common::Balance; + +pub const PARA_ID: u32 = 1005; +pub const ED: Balance = testnet_parachains_constants::rococo::currency::EXISTENTIAL_DEPOSIT; + +pub fn genesis() -> Storage { + let genesis_config = coretime_rococo_runtime::RuntimeGenesisConfig { + system: coretime_rococo_runtime::SystemConfig::default(), + balances: coretime_rococo_runtime::BalancesConfig { + balances: accounts::init_balances().iter().cloned().map(|k| (k, ED * 4096)).collect(), + }, + parachain_info: coretime_rococo_runtime::ParachainInfoConfig { + parachain_id: PARA_ID.into(), + ..Default::default() + }, + collator_selection: coretime_rococo_runtime::CollatorSelectionConfig { + invulnerables: collators::invulnerables().iter().cloned().map(|(acc, _)| acc).collect(), + candidacy_bond: ED * 16, + ..Default::default() + }, + session: coretime_rococo_runtime::SessionConfig { + keys: collators::invulnerables() + .into_iter() + .map(|(acc, aura)| { + ( + acc.clone(), // account id + acc, // validator id + coretime_rococo_runtime::SessionKeys { aura }, // session keys + ) + }) + .collect(), + ..Default::default() + }, + polkadot_xcm: coretime_rococo_runtime::PolkadotXcmConfig { + safe_xcm_version: Some(SAFE_XCM_VERSION), + ..Default::default() + }, + ..Default::default() + }; + + build_genesis_storage( + &genesis_config, + coretime_rococo_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), + ) +} diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..a15303a22e12d44020364fe173000ad4ded467d8 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-rococo/src/lib.rs @@ -0,0 +1,53 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +pub use coretime_rococo_runtime; + +pub mod genesis; + +// Substrate +use frame_support::traits::OnInitialize; + +// Cumulus +use emulated_integration_tests_common::{ + impl_accounts_helpers_for_parachain, impl_assert_events_helpers_for_parachain, + impls::Parachain, xcm_emulator::decl_test_parachains, +}; + +// CoretimeRococo Parachain declaration +decl_test_parachains! { + pub struct CoretimeRococo { + genesis = genesis::genesis(), + on_init = { + coretime_rococo_runtime::AuraExt::on_initialize(1); + }, + runtime = coretime_rococo_runtime, + core = { + XcmpMessageHandler: coretime_rococo_runtime::XcmpQueue, + LocationToAccountId: coretime_rococo_runtime::xcm_config::LocationToAccountId, + ParachainInfo: coretime_rococo_runtime::ParachainInfo, + MessageOrigin: cumulus_primitives_core::AggregateMessageOrigin, + }, + pallets = { + PolkadotXcm: coretime_rococo_runtime::PolkadotXcm, + Balances: coretime_rococo_runtime::Balances, + Broker: coretime_rococo_runtime::Broker, + } + }, +} + +// CoretimeRococo implementation +impl_accounts_helpers_for_parachain!(CoretimeRococo); +impl_assert_events_helpers_for_parachain!(CoretimeRococo); diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..895a984eccb2d049d849f8cf65b44cc667990e4f --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "coretime-westend-emulated-chain" +version = "0.0.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +description = "Coretime Westend emulated chain" +publish = false + +[lints] +workspace = true + +[dependencies] + +# Substrate +sp-core = { workspace = true } +frame-support = { workspace = true } + +# Cumulus +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +coretime-westend-runtime = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/genesis.rs new file mode 100644 index 0000000000000000000000000000000000000000..239ad3760c1120b5bfdf04f93e442bf1a50f2976 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/genesis.rs @@ -0,0 +1,67 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Substrate +use sp_core::storage::Storage; + +// Cumulus +use emulated_integration_tests_common::{ + accounts, build_genesis_storage, collators, SAFE_XCM_VERSION, +}; +use parachains_common::Balance; + +pub const PARA_ID: u32 = 1005; +pub const ED: Balance = testnet_parachains_constants::westend::currency::EXISTENTIAL_DEPOSIT; + +pub fn genesis() -> Storage { + let genesis_config = coretime_westend_runtime::RuntimeGenesisConfig { + system: coretime_westend_runtime::SystemConfig::default(), + balances: coretime_westend_runtime::BalancesConfig { + balances: accounts::init_balances().iter().cloned().map(|k| (k, ED * 4096)).collect(), + }, + parachain_info: coretime_westend_runtime::ParachainInfoConfig { + parachain_id: PARA_ID.into(), + ..Default::default() + }, + collator_selection: coretime_westend_runtime::CollatorSelectionConfig { + invulnerables: collators::invulnerables().iter().cloned().map(|(acc, _)| acc).collect(), + candidacy_bond: ED * 16, + ..Default::default() + }, + session: coretime_westend_runtime::SessionConfig { + keys: collators::invulnerables() + .into_iter() + .map(|(acc, aura)| { + ( + acc.clone(), // account id + acc, // validator id + coretime_westend_runtime::SessionKeys { aura }, // session keys + ) + }) + .collect(), + ..Default::default() + }, + polkadot_xcm: coretime_westend_runtime::PolkadotXcmConfig { + safe_xcm_version: Some(SAFE_XCM_VERSION), + ..Default::default() + }, + ..Default::default() + }; + + build_genesis_storage( + &genesis_config, + coretime_westend_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), + ) +} diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..41949843b02be666c7c95a404ed89326f2e59983 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/coretime/coretime-westend/src/lib.rs @@ -0,0 +1,53 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +pub use coretime_westend_runtime; + +pub mod genesis; + +// Substrate +use frame_support::traits::OnInitialize; + +// Cumulus +use emulated_integration_tests_common::{ + impl_accounts_helpers_for_parachain, impl_assert_events_helpers_for_parachain, + impls::Parachain, xcm_emulator::decl_test_parachains, +}; + +// CoretimeWestend Parachain declaration +decl_test_parachains! { + pub struct CoretimeWestend { + genesis = genesis::genesis(), + on_init = { + coretime_westend_runtime::AuraExt::on_initialize(1); + }, + runtime = coretime_westend_runtime, + core = { + XcmpMessageHandler: coretime_westend_runtime::XcmpQueue, + LocationToAccountId: coretime_westend_runtime::xcm_config::LocationToAccountId, + ParachainInfo: coretime_westend_runtime::ParachainInfo, + MessageOrigin: cumulus_primitives_core::AggregateMessageOrigin, + }, + pallets = { + PolkadotXcm: coretime_westend_runtime::PolkadotXcm, + Balances: coretime_westend_runtime::Balances, + Broker: coretime_westend_runtime::Broker, + } + }, +} + +// CoretimeWestend implementation +impl_accounts_helpers_for_parachain!(CoretimeWestend); +impl_assert_events_helpers_for_parachain!(CoretimeWestend); diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/Cargo.toml index f7fe93d27775a28cb560d8791a3b0d8ed49c9d68..1549d6a2ab6ba1de05d9233ff7bc29951501a43d 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/Cargo.toml @@ -10,12 +10,12 @@ publish = false [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -people-rococo-runtime = { path = "../../../../../../runtimes/people/people-rococo" } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["rococo"] } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +people-rococo-runtime = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/genesis.rs index b14009933029bfbc5cd5eeda9263126cd92a23c6..36a701d24c27e9cda44a06d033332e7f03177d88 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/genesis.rs @@ -18,7 +18,9 @@ use sp_core::storage::Storage; // Cumulus use cumulus_primitives_core::ParaId; -use emulated_integration_tests_common::{build_genesis_storage, collators, SAFE_XCM_VERSION}; +use emulated_integration_tests_common::{ + accounts, build_genesis_storage, collators, SAFE_XCM_VERSION, +}; use parachains_common::Balance; pub const PARA_ID: u32 = 1004; @@ -27,6 +29,9 @@ pub const ED: Balance = testnet_parachains_constants::rococo::currency::EXISTENT pub fn genesis() -> Storage { let genesis_config = people_rococo_runtime::RuntimeGenesisConfig { system: people_rococo_runtime::SystemConfig::default(), + balances: people_rococo_runtime::BalancesConfig { + balances: accounts::init_balances().iter().cloned().map(|k| (k, ED * 4096)).collect(), + }, parachain_info: people_rococo_runtime::ParachainInfoConfig { parachain_id: ParaId::from(PARA_ID), ..Default::default() @@ -47,6 +52,7 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: people_rococo_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/lib.rs index fa818bf81bf60ac6358c1c983faf8657cb139dd3..c8da97cc3e8bf6371ddcb2d6a122f06fb80cb518 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-rococo/src/lib.rs @@ -12,6 +12,7 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. +pub use people_rococo_runtime; pub mod genesis; diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/Cargo.toml index 57a767e0c2a3eb7d23df7f8d95fd78128c996f35..9c5ac0bca9de7ae2f201aba958b8220b9a24a013 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/Cargo.toml @@ -10,12 +10,12 @@ publish = false [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -people-westend-runtime = { path = "../../../../../../runtimes/people/people-westend" } -testnet-parachains-constants = { path = "../../../../../../runtimes/constants", features = ["westend"] } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +people-westend-runtime = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/genesis.rs index d385fbebc821c05205f55bc5ea5f04d57ec9af21..942ec1b31d2b46f3b3ec9c253a1c6ee521119b4d 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/genesis.rs @@ -18,7 +18,9 @@ use sp_core::storage::Storage; // Cumulus use cumulus_primitives_core::ParaId; -use emulated_integration_tests_common::{build_genesis_storage, collators, SAFE_XCM_VERSION}; +use emulated_integration_tests_common::{ + accounts, build_genesis_storage, collators, SAFE_XCM_VERSION, +}; use parachains_common::Balance; pub const PARA_ID: u32 = 1004; @@ -27,6 +29,9 @@ pub const ED: Balance = testnet_parachains_constants::westend::currency::EXISTEN pub fn genesis() -> Storage { let genesis_config = people_westend_runtime::RuntimeGenesisConfig { system: people_westend_runtime::SystemConfig::default(), + balances: people_westend_runtime::BalancesConfig { + balances: accounts::init_balances().iter().cloned().map(|k| (k, ED * 4096)).collect(), + }, parachain_info: people_westend_runtime::ParachainInfoConfig { parachain_id: ParaId::from(PARA_ID), ..Default::default() @@ -47,6 +52,7 @@ pub fn genesis() -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: people_westend_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/lib.rs index 775b89ac208b022f898c7c54423e8a21b7214ae3..904ce34d8c08a63500a1b3c815b8d1c469a89861 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/people/people-westend/src/lib.rs @@ -12,6 +12,7 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. +pub use people_westend_runtime; pub mod genesis; diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/Cargo.toml index 2ac508273c6158ddae08615d8574102f98e3e788..9e6b14b585984d9b384f835f1b51f8a3e2e658a8 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/Cargo.toml @@ -13,14 +13,14 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../../substrate/frame/support", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../../common" } -cumulus-primitives-core = { path = "../../../../../../../primitives/core", default-features = false } -emulated-integration-tests-common = { path = "../../../../common", default-features = false } -penpal-runtime = { path = "../../../../../../runtimes/testing/penpal" } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true } +emulated-integration-tests-common = { workspace = true } +penpal-runtime = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/genesis.rs index 450439f5ea3080b66c5c572dfdae972c23c52a4b..38c94b34aa2e3bfc7b81f8ee46737ba4e153c659 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/genesis.rs @@ -22,7 +22,7 @@ use emulated_integration_tests_common::{ accounts, build_genesis_storage, collators, get_account_id_from_seed, SAFE_XCM_VERSION, }; use parachains_common::{AccountId, Balance}; -use penpal_runtime::xcm_config::{LocalReservableFromAssetHub, RelayLocation}; +use penpal_runtime::xcm_config::{LocalReservableFromAssetHub, RelayLocation, UsdtFromAssetHub}; // Penpal pub const PARA_ID_A: u32 = 2000; pub const PARA_ID_B: u32 = 2001; @@ -59,6 +59,7 @@ pub fn genesis(para_id: u32) -> Storage { ) }) .collect(), + ..Default::default() }, polkadot_xcm: penpal_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), @@ -80,6 +81,8 @@ pub fn genesis(para_id: u32) -> Storage { (RelayLocation::get(), PenpalAssetOwner::get(), true, ED), // Sufficient AssetHub asset representation (LocalReservableFromAssetHub::get(), PenpalAssetOwner::get(), true, ED), + // USDT from Asset Hub + (UsdtFromAssetHub::get(), PenpalAssetOwner::get(), true, ED), ], ..Default::default() }, diff --git a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/lib.rs index c268b014bfa34e1b8c0a450ae2e446bb6f636c9d..91793d33f304fbbf4d1d2aeea0bf315730a5794f 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/parachains/testing/penpal/src/lib.rs @@ -13,11 +13,10 @@ // See the License for the specific language governing permissions and // limitations under the License. +pub use penpal_runtime::{self, xcm_config::RelayNetworkId as PenpalRelayNetworkId}; + mod genesis; pub use genesis::{genesis, PenpalAssetOwner, PenpalSudoAccount, ED, PARA_ID_A, PARA_ID_B}; -pub use penpal_runtime::xcm_config::{ - CustomizableAssetFromSystemAssetHub, RelayNetworkId as PenpalRelayNetworkId, -}; // Substrate use frame_support::traits::OnInitialize; diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml index 7ac65b0ee1ded60939072ff61d6886fa53a10b94..9376687947e6c3683d5c1c58fdaf77452fd01449 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/Cargo.toml @@ -13,17 +13,17 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false } -sp-authority-discovery = { path = "../../../../../../../substrate/primitives/authority-discovery", default-features = false } -sp-consensus-babe = { path = "../../../../../../../substrate/primitives/consensus/babe", default-features = false } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../../../substrate/primitives/consensus/beefy" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false } +sp-core = { workspace = true } +sp-authority-discovery = { workspace = true } +sp-consensus-babe = { workspace = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true } # Polkadot -polkadot-primitives = { path = "../../../../../../../polkadot/primitives", default-features = false } -rococo-runtime-constants = { path = "../../../../../../../polkadot/runtime/rococo/constants", default-features = false } -rococo-runtime = { path = "../../../../../../../polkadot/runtime/rococo" } +polkadot-primitives = { workspace = true } +rococo-runtime-constants = { workspace = true } +rococo-runtime = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../common" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } +parachains-common = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs index 55437645b0523b577c2e9d455952f5526ba9df0b..9cb25b403600f7b8318b6d1ab41129a66107f0ac 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/genesis.rs @@ -14,10 +14,10 @@ // limitations under the License. // Substrate -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; -use grandpa::AuthorityId as GrandpaId; +use sc_consensus_grandpa::AuthorityId as GrandpaId; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; use sp_core::{sr25519, storage::Storage}; // Polkadot @@ -75,6 +75,7 @@ pub fn genesis() -> Storage { ) }) .collect::>(), + ..Default::default() }, babe: rococo_runtime::BabeConfig { authorities: Default::default(), diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs index 7a3a936ec972f0a8c99e3b472c7cce9e9914e29c..bd637a5f7965bca47b171283bb37473b009bdbc1 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/rococo/src/lib.rs @@ -12,6 +12,7 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. +pub use rococo_runtime; pub mod genesis; diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml index e4688a1c9f022dd9aafd821ee39bfc5906a7b2a0..de285d9885a2f78fdea1a27ea8b8d9dc3840d300 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/Cargo.toml @@ -13,21 +13,21 @@ workspace = true [dependencies] # Substrate -sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false } -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -sp-authority-discovery = { path = "../../../../../../../substrate/primitives/authority-discovery", default-features = false } -sp-consensus-babe = { path = "../../../../../../../substrate/primitives/consensus/babe", default-features = false } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../../../substrate/primitives/consensus/beefy" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../../../../../substrate/client/consensus/grandpa", default-features = false } -pallet-staking = { path = "../../../../../../../substrate/frame/staking", default-features = false } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-authority-discovery = { workspace = true } +sp-consensus-babe = { workspace = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true } +pallet-staking = { workspace = true } # Polkadot -polkadot-primitives = { path = "../../../../../../../polkadot/primitives", default-features = false } -westend-runtime-constants = { path = "../../../../../../../polkadot/runtime/westend/constants", default-features = false } -westend-runtime = { path = "../../../../../../../polkadot/runtime/westend" } -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false } +polkadot-primitives = { workspace = true } +westend-runtime-constants = { workspace = true } +westend-runtime = { workspace = true } +xcm = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../common" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } +parachains-common = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs index 700b80e63f6cf68e6095b7e02d84bb285ce720f9..172e6e0ac93ec9cf2ec2f95257ffa1af450ad5a1 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/genesis.rs @@ -14,10 +14,10 @@ // limitations under the License. // Substrate -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; -use grandpa::AuthorityId as GrandpaId; +use sc_consensus_grandpa::AuthorityId as GrandpaId; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; use sp_core::storage::Storage; use sp_runtime::Perbill; @@ -77,6 +77,7 @@ pub fn genesis() -> Storage { ) }) .collect::>(), + ..Default::default() }, staking: westend_runtime::StakingConfig { validator_count: validators::initial_authorities().len() as u32, diff --git a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs index 83af58f61732d7c0e545c365ab2d049125f3777e..ce9fafcd5bda8bd815d197b7e4a1ee70f6eb426c 100644 --- a/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/chains/relays/westend/src/lib.rs @@ -12,6 +12,7 @@ // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. +pub use westend_runtime; pub mod genesis; diff --git a/cumulus/parachains/integration-tests/emulated/common/Cargo.toml b/cumulus/parachains/integration-tests/emulated/common/Cargo.toml index 8c44cce7d922dff0a69a4273af7adb69819d2fce..7152f1dbc272bd8eef49e2343b2c5cbbeb9f1ba4 100644 --- a/cumulus/parachains/integration-tests/emulated/common/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/common/Cargo.toml @@ -10,37 +10,37 @@ description = "Common resources for integration testing with xcm-emulator" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } -paste = "1.0.14" +codec = { workspace = true } +paste = { workspace = true, default-features = true } # Substrate -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../../../substrate/primitives/consensus/beefy" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../../../substrate/client/consensus/grandpa" } -sp-authority-discovery = { path = "../../../../../substrate/primitives/authority-discovery" } -sp-runtime = { path = "../../../../../substrate/primitives/runtime" } -frame-support = { path = "../../../../../substrate/frame/support" } -sp-core = { path = "../../../../../substrate/primitives/core" } -sp-consensus-babe = { path = "../../../../../substrate/primitives/consensus/babe" } -pallet-assets = { path = "../../../../../substrate/frame/assets" } -pallet-balances = { path = "../../../../../substrate/frame/balances" } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue" } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +frame-support = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +pallet-assets = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-message-queue = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../../../polkadot/primitives" } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain" } -polkadot-runtime-parachains = { path = "../../../../../polkadot/runtime/parachains" } -xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm" } -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +xcm = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } # Cumulus -parachains-common = { path = "../../../common" } -cumulus-primitives-core = { path = "../../../../primitives/core" } -xcm-emulator = { path = "../../../../xcm/xcm-emulator" } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue" } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system" } -asset-test-utils = { path = "../../../runtimes/assets/test-utils" } +parachains-common = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +xcm-emulator = { workspace = true, default-features = true } +cumulus-pallet-xcmp-queue = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true, default-features = true } +asset-test-utils = { workspace = true, default-features = true } # Bridges -bp-messages = { path = "../../../../../bridges/primitives/messages" } -pallet-bridge-messages = { path = "../../../../../bridges/modules/messages" } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common" } +bp-messages = { workspace = true, default-features = true } +pallet-bridge-messages = { workspace = true, default-features = true } +bridge-runtime-common = { workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/common/src/lib.rs b/cumulus/parachains/integration-tests/emulated/common/src/lib.rs index cbde0642f1a2965579196cda7e7ada4f291e9d98..30e66ced1fb08f640d912a1c08c3354090b67db4 100644 --- a/cumulus/parachains/integration-tests/emulated/common/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/common/src/lib.rs @@ -20,11 +20,11 @@ pub mod xcm_helpers; pub use xcm_emulator; // Substrate -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; use frame_support::parameter_types; -use grandpa::AuthorityId as GrandpaId; +use sc_consensus_grandpa::AuthorityId as GrandpaId; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; use sp_core::{sr25519, storage::Storage, Pair, Public}; use sp_runtime::{ traits::{AccountIdConversion, IdentifyAccount, Verify}, @@ -51,20 +51,23 @@ pub const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION; type AccountPublic = ::Signer; -// This asset is added to AH as Asset and reserved transfer between Parachain and AH +// (trust-backed) Asset registered on AH and reserve-transferred between Parachain and AH pub const RESERVABLE_ASSET_ID: u32 = 1; -// This asset is added to AH as ForeignAsset and teleported between Penpal and AH +// ForeignAsset registered on AH and teleported between Penpal and AH pub const TELEPORTABLE_ASSET_ID: u32 = 2; +// USDT registered on AH as (trust-backed) Asset and reserve-transferred between Parachain and AH +pub const USDT_ID: u32 = 1984; + pub const PENPAL_ID: u32 = 2000; pub const ASSETS_PALLET_ID: u8 = 50; parameter_types! { - pub PenpalTeleportableAssetLocation: xcm::v3::Location - = xcm::v3::Location::new(1, [ - xcm::v3::Junction::Parachain(PENPAL_ID), - xcm::v3::Junction::PalletInstance(ASSETS_PALLET_ID), - xcm::v3::Junction::GeneralIndex(TELEPORTABLE_ASSET_ID.into()), + pub PenpalTeleportableAssetLocation: xcm::v4::Location + = xcm::v4::Location::new(1, [ + xcm::v4::Junction::Parachain(PENPAL_ID), + xcm::v4::Junction::PalletInstance(ASSETS_PALLET_ID), + xcm::v4::Junction::GeneralIndex(TELEPORTABLE_ASSET_ID.into()), ] ); pub PenpalSiblingSovereignAccount: AccountId = Sibling::from(PENPAL_ID).into_account_truncating(); @@ -129,6 +132,7 @@ pub mod accounts { pub const EVE_STASH: &str = "Eve//stash"; pub const FERDIE_STASH: &str = "Ferdie//stash"; pub const FERDIE_BEEFY: &str = "Ferdie//stash"; + pub const DUMMY_EMPTY: &str = "JohnDoe"; pub fn init_balances() -> Vec { vec![ diff --git a/cumulus/parachains/integration-tests/emulated/common/src/macros.rs b/cumulus/parachains/integration-tests/emulated/common/src/macros.rs index 6f6bbe41e01bd208ee6d40a9f3b4ba8f98f7975b..578bca84ce5a54df1973803888e9d9d8d1cfe511 100644 --- a/cumulus/parachains/integration-tests/emulated/common/src/macros.rs +++ b/cumulus/parachains/integration-tests/emulated/common/src/macros.rs @@ -27,7 +27,7 @@ pub use xcm::{ prelude::{ AccountId32, All, Asset, AssetId, BuyExecution, DepositAsset, ExpectTransactStatus, Fungible, Here, Location, MaybeErrorCode, OriginKind, RefundSurplus, Transact, Unlimited, - VersionedXcm, WeightLimit, WithdrawAsset, Xcm, + VersionedAssets, VersionedXcm, WeightLimit, WithdrawAsset, Xcm, }, v3::Location as V3Location, }; @@ -130,3 +130,276 @@ macro_rules! test_parachain_is_trusted_teleporter { } }; } + +#[macro_export] +macro_rules! test_relay_is_trusted_teleporter { + ( $sender_relay:ty, $sender_xcm_config:ty, vec![$( $receiver_para:ty ),+], ($assets:expr, $amount:expr) ) => { + $crate::macros::paste::paste! { + // init Origin variables + let sender = [<$sender_relay Sender>]::get(); + let mut relay_sender_balance_before = + <$sender_relay as $crate::macros::Chain>::account_data_of(sender.clone()).free; + let origin = <$sender_relay as $crate::macros::Chain>::RuntimeOrigin::signed(sender.clone()); + let fee_asset_item = 0; + let weight_limit = $crate::macros::WeightLimit::Unlimited; + + $( + { + // init Destination variables + let receiver = [<$receiver_para Receiver>]::get(); + let para_receiver_balance_before = + <$receiver_para as $crate::macros::Chain>::account_data_of(receiver.clone()).free; + let para_destination = + <$sender_relay>::child_location_of(<$receiver_para>::para_id()); + let beneficiary: Location = + $crate::macros::AccountId32 { network: None, id: receiver.clone().into() }.into(); + + // Send XCM message from Relay + <$sender_relay>::execute_with(|| { + assert_ok!(<$sender_relay as [<$sender_relay Pallet>]>::XcmPallet::limited_teleport_assets( + origin.clone(), + bx!(para_destination.clone().into()), + bx!(beneficiary.clone().into()), + bx!($assets.clone().into()), + fee_asset_item, + weight_limit.clone(), + )); + + type RuntimeEvent = <$sender_relay as $crate::macros::Chain>::RuntimeEvent; + + assert_expected_events!( + $sender_relay, + vec![ + RuntimeEvent::XcmPallet( + $crate::macros::pallet_xcm::Event::Attempted { outcome: Outcome::Complete { .. } } + ) => {}, + RuntimeEvent::Balances( + $crate::macros::pallet_balances::Event::Burned { who: sender, amount } + ) => {}, + RuntimeEvent::XcmPallet( + $crate::macros::pallet_xcm::Event::Sent { .. } + ) => {}, + ] + ); + }); + + // Receive XCM message in Destination Parachain + <$receiver_para>::execute_with(|| { + type RuntimeEvent = <$receiver_para as $crate::macros::Chain>::RuntimeEvent; + + assert_expected_events!( + $receiver_para, + vec![ + RuntimeEvent::Balances( + $crate::macros::pallet_balances::Event::Minted { who: receiver, .. } + ) => {}, + RuntimeEvent::MessageQueue( + $crate::macros::pallet_message_queue::Event::Processed { success: true, .. } + ) => {}, + ] + ); + }); + + // Check if balances are updated accordingly in Origin and Parachain + let relay_sender_balance_after = + <$sender_relay as $crate::macros::Chain>::account_data_of(sender.clone()).free; + let para_receiver_balance_after = + <$receiver_para as $crate::macros::Chain>::account_data_of(receiver.clone()).free; + let delivery_fees = <$sender_relay>::execute_with(|| { + $crate::macros::asset_test_utils::xcm_helpers::teleport_assets_delivery_fees::< + <$sender_xcm_config as xcm_executor::Config>::XcmSender, + >($assets.clone(), fee_asset_item, weight_limit.clone(), beneficiary, para_destination) + }); + + assert_eq!(relay_sender_balance_before - $amount - delivery_fees, relay_sender_balance_after); + assert!(para_receiver_balance_after > para_receiver_balance_before); + + // Update sender balance + relay_sender_balance_before = <$sender_relay as $crate::macros::Chain>::account_data_of(sender.clone()).free; + } + )+ + } + }; +} + +#[macro_export] +macro_rules! test_parachain_is_trusted_teleporter_for_relay { + ( $sender_para:ty, $sender_xcm_config:ty, $receiver_relay:ty, $amount:expr ) => { + $crate::macros::paste::paste! { + // init Origin variables + let sender = [<$sender_para Sender>]::get(); + let para_sender_balance_before = + <$sender_para as $crate::macros::Chain>::account_data_of(sender.clone()).free; + let origin = <$sender_para as $crate::macros::Chain>::RuntimeOrigin::signed(sender.clone()); + let assets: Assets = (Parent, $amount).into(); + let fee_asset_item = 0; + let weight_limit = $crate::macros::WeightLimit::Unlimited; + + // init Destination variables + let receiver = [<$receiver_relay Receiver>]::get(); + let relay_receiver_balance_before = + <$receiver_relay as $crate::macros::Chain>::account_data_of(receiver.clone()).free; + let relay_destination: Location = Parent.into(); + let beneficiary: Location = + $crate::macros::AccountId32 { network: None, id: receiver.clone().into() }.into(); + + // Send XCM message from Parachain + <$sender_para>::execute_with(|| { + assert_ok!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::limited_teleport_assets( + origin.clone(), + bx!(relay_destination.clone().into()), + bx!(beneficiary.clone().into()), + bx!(assets.clone().into()), + fee_asset_item, + weight_limit.clone(), + )); + + type RuntimeEvent = <$sender_para as $crate::macros::Chain>::RuntimeEvent; + + assert_expected_events!( + $sender_para, + vec![ + RuntimeEvent::PolkadotXcm( + $crate::macros::pallet_xcm::Event::Attempted { outcome: Outcome::Complete { .. } } + ) => {}, + RuntimeEvent::Balances( + $crate::macros::pallet_balances::Event::Burned { who: sender, amount } + ) => {}, + RuntimeEvent::PolkadotXcm( + $crate::macros::pallet_xcm::Event::Sent { .. } + ) => {}, + ] + ); + }); + + // Receive XCM message in Destination Parachain + <$receiver_relay>::execute_with(|| { + type RuntimeEvent = <$receiver_relay as $crate::macros::Chain>::RuntimeEvent; + + assert_expected_events!( + $receiver_relay, + vec![ + RuntimeEvent::Balances( + $crate::macros::pallet_balances::Event::Minted { who: receiver, .. } + ) => {}, + RuntimeEvent::MessageQueue( + $crate::macros::pallet_message_queue::Event::Processed { success: true, .. } + ) => {}, + ] + ); + }); + + // Check if balances are updated accordingly in Origin and Relay Chain + let para_sender_balance_after = + <$sender_para as $crate::macros::Chain>::account_data_of(sender.clone()).free; + let relay_receiver_balance_after = + <$receiver_relay as $crate::macros::Chain>::account_data_of(receiver.clone()).free; + let delivery_fees = <$sender_para>::execute_with(|| { + $crate::macros::asset_test_utils::xcm_helpers::teleport_assets_delivery_fees::< + <$sender_xcm_config as xcm_executor::Config>::XcmSender, + >(assets, fee_asset_item, weight_limit.clone(), beneficiary, relay_destination) + }); + + assert_eq!(para_sender_balance_before - $amount - delivery_fees, para_sender_balance_after); + assert!(relay_receiver_balance_after > relay_receiver_balance_before); + } + }; +} + +#[macro_export] +macro_rules! test_chain_can_claim_assets { + ( $sender_para:ty, $runtime_call:ty, $network_id:expr, $assets:expr, $amount:expr ) => { + $crate::macros::paste::paste! { + let sender = [<$sender_para Sender>]::get(); + let origin = <$sender_para as $crate::macros::Chain>::RuntimeOrigin::signed(sender.clone()); + // Receiver is the same as sender + let beneficiary: Location = + $crate::macros::AccountId32 { network: Some($network_id), id: sender.clone().into() }.into(); + let versioned_assets: $crate::macros::VersionedAssets = $assets.clone().into(); + + <$sender_para>::execute_with(|| { + // Assets are trapped for whatever reason. + // The possible reasons for this might differ from runtime to runtime, so here we just drop them directly. + <$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::drop_assets( + &beneficiary, + $assets.clone().into(), + &XcmContext { origin: None, message_id: [0u8; 32], topic: None }, + ); + + type RuntimeEvent = <$sender_para as $crate::macros::Chain>::RuntimeEvent; + assert_expected_events!( + $sender_para, + vec![ + RuntimeEvent::PolkadotXcm( + $crate::macros::pallet_xcm::Event::AssetsTrapped { origin: beneficiary, assets: versioned_assets, .. } + ) => {}, + ] + ); + + let balance_before = <$sender_para as [<$sender_para Pallet>]>::Balances::free_balance(&sender); + + // Different origin or different assets won't work. + let other_origin = <$sender_para as $crate::macros::Chain>::RuntimeOrigin::signed([<$sender_para Receiver>]::get()); + assert!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::claim_assets( + other_origin, + bx!(versioned_assets.clone().into()), + bx!(beneficiary.clone().into()), + ).is_err()); + let other_versioned_assets: $crate::macros::VersionedAssets = Assets::new().into(); + assert!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::claim_assets( + origin.clone(), + bx!(other_versioned_assets.into()), + bx!(beneficiary.clone().into()), + ).is_err()); + + // Assets will be claimed to `beneficiary`, which is the same as `sender`. + assert_ok!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::claim_assets( + origin.clone(), + bx!(versioned_assets.clone().into()), + bx!(beneficiary.clone().into()), + )); + + assert_expected_events!( + $sender_para, + vec![ + RuntimeEvent::PolkadotXcm( + $crate::macros::pallet_xcm::Event::AssetsClaimed { origin: beneficiary, assets: versioned_assets, .. } + ) => {}, + ] + ); + + // After claiming the assets, the balance has increased. + let balance_after = <$sender_para as [<$sender_para Pallet>]>::Balances::free_balance(&sender); + assert_eq!(balance_after, balance_before + $amount); + + // Claiming the assets again doesn't work. + assert!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::claim_assets( + origin.clone(), + bx!(versioned_assets.clone().into()), + bx!(beneficiary.clone().into()), + ).is_err()); + + let balance = <$sender_para as [<$sender_para Pallet>]>::Balances::free_balance(&sender); + assert_eq!(balance, balance_after); + + // You can also claim assets and send them to a different account. + <$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::drop_assets( + &beneficiary, + $assets.clone().into(), + &XcmContext { origin: None, message_id: [0u8; 32], topic: None }, + ); + let receiver = [<$sender_para Receiver>]::get(); + let other_beneficiary: Location = + $crate::macros::AccountId32 { network: Some($network_id), id: receiver.clone().into() }.into(); + let balance_before = <$sender_para as [<$sender_para Pallet>]>::Balances::free_balance(&receiver); + assert_ok!(<$sender_para as [<$sender_para Pallet>]>::PolkadotXcm::claim_assets( + origin.clone(), + bx!(versioned_assets.clone().into()), + bx!(other_beneficiary.clone().into()), + )); + let balance_after = <$sender_para as [<$sender_para Pallet>]>::Balances::free_balance(&receiver); + assert_eq!(balance_after, balance_before + $amount); + }); + } + }; +} diff --git a/cumulus/parachains/integration-tests/emulated/common/src/xcm_helpers.rs b/cumulus/parachains/integration-tests/emulated/common/src/xcm_helpers.rs index 25e1cffad543c0aad6d955315721b63c6d509ca1..7a289a3f1ac62383e834645a57080ffa04c00710 100644 --- a/cumulus/parachains/integration-tests/emulated/common/src/xcm_helpers.rs +++ b/cumulus/parachains/integration-tests/emulated/common/src/xcm_helpers.rs @@ -23,16 +23,15 @@ use xcm::{prelude::*, DoubleEncoded}; pub fn xcm_transact_paid_execution( call: DoubleEncoded<()>, origin_kind: OriginKind, - native_asset: Asset, + fees: Asset, beneficiary: AccountId, ) -> VersionedXcm<()> { let weight_limit = WeightLimit::Unlimited; let require_weight_at_most = Weight::from_parts(1000000000, 200000); - let native_assets: Assets = native_asset.clone().into(); VersionedXcm::from(Xcm(vec![ - WithdrawAsset(native_assets), - BuyExecution { fees: native_asset, weight_limit }, + WithdrawAsset(fees.clone().into()), + BuyExecution { fees, weight_limit }, Transact { require_weight_at_most, origin_kind, call }, RefundSurplus, DepositAsset { @@ -69,3 +68,11 @@ pub fn non_fee_asset(assets: &Assets, fee_idx: usize) -> Option<(Location, u128) }; Some((asset.id.0, asset_amount)) } + +pub fn get_amount_from_versioned_assets(assets: VersionedAssets) -> u128 { + let latest_assets: Assets = assets.try_into().unwrap(); + let Fungible(amount) = latest_assets.inner()[0].fun else { + unreachable!("asset is non-fungible"); + }; + amount +} diff --git a/cumulus/parachains/integration-tests/emulated/networks/rococo-system/Cargo.toml b/cumulus/parachains/integration-tests/emulated/networks/rococo-system/Cargo.toml index eb0a8a850d06928d67147dc14a11f566d1ad7c9d..864f3c6edd7e3f91566666c65c509d2494009d4d 100644 --- a/cumulus/parachains/integration-tests/emulated/networks/rococo-system/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/networks/rococo-system/Cargo.toml @@ -12,9 +12,10 @@ workspace = true [dependencies] # Cumulus -emulated-integration-tests-common = { path = "../../common", default-features = false } -rococo-emulated-chain = { path = "../../chains/relays/rococo" } -asset-hub-rococo-emulated-chain = { path = "../../chains/parachains/assets/asset-hub-rococo" } -bridge-hub-rococo-emulated-chain = { path = "../../chains/parachains/bridges/bridge-hub-rococo" } -people-rococo-emulated-chain = { path = "../../chains/parachains/people/people-rococo" } -penpal-emulated-chain = { path = "../../chains/parachains/testing/penpal" } +emulated-integration-tests-common = { workspace = true } +rococo-emulated-chain = { workspace = true } +asset-hub-rococo-emulated-chain = { workspace = true } +bridge-hub-rococo-emulated-chain = { workspace = true } +people-rococo-emulated-chain = { workspace = true } +penpal-emulated-chain = { workspace = true } +coretime-rococo-emulated-chain = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/networks/rococo-system/src/lib.rs b/cumulus/parachains/integration-tests/emulated/networks/rococo-system/src/lib.rs index 70f23ef8260ca408e55079e5797b09cc817872cd..53808bc5a8010128c6e490361127eadda56fecbb 100644 --- a/cumulus/parachains/integration-tests/emulated/networks/rococo-system/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/networks/rococo-system/src/lib.rs @@ -15,12 +15,14 @@ pub use asset_hub_rococo_emulated_chain; pub use bridge_hub_rococo_emulated_chain; +pub use coretime_rococo_emulated_chain; pub use penpal_emulated_chain; pub use people_rococo_emulated_chain; pub use rococo_emulated_chain; use asset_hub_rococo_emulated_chain::AssetHubRococo; use bridge_hub_rococo_emulated_chain::BridgeHubRococo; +use coretime_rococo_emulated_chain::CoretimeRococo; use penpal_emulated_chain::{PenpalA, PenpalB}; use people_rococo_emulated_chain::PeopleRococo; use rococo_emulated_chain::Rococo; @@ -37,6 +39,7 @@ decl_test_networks! { parachains = vec![ AssetHubRococo, BridgeHubRococo, + CoretimeRococo, PenpalA, PenpalB, PeopleRococo, @@ -49,6 +52,7 @@ decl_test_sender_receiver_accounts_parameter_types! { RococoRelay { sender: ALICE, receiver: BOB }, AssetHubRococoPara { sender: ALICE, receiver: BOB }, BridgeHubRococoPara { sender: ALICE, receiver: BOB }, + CoretimeRococoPara { sender: ALICE, receiver: BOB }, PenpalAPara { sender: ALICE, receiver: BOB }, PenpalBPara { sender: ALICE, receiver: BOB }, PeopleRococoPara { sender: ALICE, receiver: BOB } diff --git a/cumulus/parachains/integration-tests/emulated/networks/rococo-westend-system/Cargo.toml b/cumulus/parachains/integration-tests/emulated/networks/rococo-westend-system/Cargo.toml index 744cbe4f8c1e31ed5a9b122a5b5939509234236a..cd0cb272b7f5ea9bea09835b7cf4612ad9c377be 100644 --- a/cumulus/parachains/integration-tests/emulated/networks/rococo-westend-system/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/networks/rococo-westend-system/Cargo.toml @@ -12,11 +12,11 @@ workspace = true [dependencies] # Cumulus -emulated-integration-tests-common = { path = "../../common", default-features = false } -rococo-emulated-chain = { path = "../../chains/relays/rococo" } -westend-emulated-chain = { path = "../../chains/relays/westend" } -asset-hub-rococo-emulated-chain = { path = "../../chains/parachains/assets/asset-hub-rococo" } -asset-hub-westend-emulated-chain = { path = "../../chains/parachains/assets/asset-hub-westend" } -bridge-hub-rococo-emulated-chain = { path = "../../chains/parachains/bridges/bridge-hub-rococo" } -bridge-hub-westend-emulated-chain = { path = "../../chains/parachains/bridges/bridge-hub-westend" } -penpal-emulated-chain = { path = "../../chains/parachains/testing/penpal" } +emulated-integration-tests-common = { workspace = true } +rococo-emulated-chain = { workspace = true } +westend-emulated-chain = { workspace = true, default-features = true } +asset-hub-rococo-emulated-chain = { workspace = true } +asset-hub-westend-emulated-chain = { workspace = true } +bridge-hub-rococo-emulated-chain = { workspace = true } +bridge-hub-westend-emulated-chain = { workspace = true } +penpal-emulated-chain = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/networks/westend-system/Cargo.toml b/cumulus/parachains/integration-tests/emulated/networks/westend-system/Cargo.toml index 64bc91f442d1b27166fbc4f0a2dc22798c97ff39..cec2e3733b2a0fbe83608f75981e5c288c70ea7f 100644 --- a/cumulus/parachains/integration-tests/emulated/networks/westend-system/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/networks/westend-system/Cargo.toml @@ -12,10 +12,11 @@ workspace = true [dependencies] # Cumulus -emulated-integration-tests-common = { path = "../../common", default-features = false } -westend-emulated-chain = { path = "../../chains/relays/westend", default-features = false } -asset-hub-westend-emulated-chain = { path = "../../chains/parachains/assets/asset-hub-westend" } -bridge-hub-westend-emulated-chain = { path = "../../chains/parachains/bridges/bridge-hub-westend" } -collectives-westend-emulated-chain = { path = "../../chains/parachains/collectives/collectives-westend" } -penpal-emulated-chain = { path = "../../chains/parachains/testing/penpal" } -people-westend-emulated-chain = { path = "../../chains/parachains/people/people-westend" } +emulated-integration-tests-common = { workspace = true } +westend-emulated-chain = { workspace = true } +asset-hub-westend-emulated-chain = { workspace = true } +bridge-hub-westend-emulated-chain = { workspace = true } +collectives-westend-emulated-chain = { workspace = true } +penpal-emulated-chain = { workspace = true } +people-westend-emulated-chain = { workspace = true } +coretime-westend-emulated-chain = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/networks/westend-system/src/lib.rs b/cumulus/parachains/integration-tests/emulated/networks/westend-system/src/lib.rs index 9fbc773bc50e136af3272e851f826d7cf63bc0b6..6949a985629d9cce5b774d3dce5a93e76d6e46c9 100644 --- a/cumulus/parachains/integration-tests/emulated/networks/westend-system/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/networks/westend-system/src/lib.rs @@ -16,6 +16,7 @@ pub use asset_hub_westend_emulated_chain; pub use bridge_hub_westend_emulated_chain; pub use collectives_westend_emulated_chain; +pub use coretime_westend_emulated_chain; pub use penpal_emulated_chain; pub use people_westend_emulated_chain; pub use westend_emulated_chain; @@ -23,6 +24,7 @@ pub use westend_emulated_chain; use asset_hub_westend_emulated_chain::AssetHubWestend; use bridge_hub_westend_emulated_chain::BridgeHubWestend; use collectives_westend_emulated_chain::CollectivesWestend; +use coretime_westend_emulated_chain::CoretimeWestend; use penpal_emulated_chain::{PenpalA, PenpalB}; use people_westend_emulated_chain::PeopleWestend; use westend_emulated_chain::Westend; @@ -40,6 +42,7 @@ decl_test_networks! { AssetHubWestend, BridgeHubWestend, CollectivesWestend, + CoretimeWestend, PeopleWestend, PenpalA, PenpalB, @@ -53,6 +56,7 @@ decl_test_sender_receiver_accounts_parameter_types! { AssetHubWestendPara { sender: ALICE, receiver: BOB }, BridgeHubWestendPara { sender: ALICE, receiver: BOB }, CollectivesWestendPara { sender: ALICE, receiver: BOB }, + CoretimeWestendPara { sender: ALICE, receiver: BOB }, PeopleWestendPara { sender: ALICE, receiver: BOB }, PenpalAPara { sender: ALICE, receiver: BOB }, PenpalBPara { sender: ALICE, receiver: BOB } diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/Cargo.toml index ddd6d2d049823f36ed193597ff438f39468a8a55..f66a5f1d5fe7e0dc0aaee8325a9717e25e9f1068 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/Cargo.toml @@ -11,32 +11,30 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } -assert_matches = "1.5.0" +codec = { workspace = true } +assert_matches = { workspace = true } # Substrate -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion = { path = "../../../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue", default-features = false } -pallet-treasury = { path = "../../../../../../../substrate/frame/treasury", default-features = false } -pallet-utility = { path = "../../../../../../../substrate/frame/utility", default-features = false } +sp-runtime = { workspace = true } +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-treasury = { workspace = true } +pallet-utility = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -pallet-xcm = { path = "../../../../../../../polkadot/xcm/pallet-xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } -rococo-runtime = { path = "../../../../../../../polkadot/runtime/rococo" } -polkadot-runtime-common = { path = "../../../../../../../polkadot/runtime/common" } -rococo-runtime-constants = { path = "../../../../../../../polkadot/runtime/rococo/constants" } +xcm = { workspace = true } +pallet-xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true, default-features = true } +polkadot-runtime-common = { workspace = true, default-features = true } +rococo-runtime-constants = { workspace = true, default-features = true } # Cumulus -asset-test-utils = { path = "../../../../../runtimes/assets/test-utils" } -cumulus-pallet-parachain-system = { path = "../../../../../../pallets/parachain-system", default-features = false } -parachains-common = { path = "../../../../../common" } -asset-hub-rococo-runtime = { path = "../../../../../runtimes/assets/asset-hub-rococo" } -penpal-runtime = { path = "../../../../../runtimes/testing/penpal" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -rococo-system-emulated-network = { path = "../../../networks/rococo-system" } +asset-test-utils = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true } +parachains-common = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +rococo-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/lib.rs index 2bd388bee400ed2e61869e126a1828b93422f2c0..87a090bf1ae68cb79f43b4c06a8871b7ccbdf865 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/lib.rs @@ -35,25 +35,52 @@ mod imports { // Cumulus pub use asset_test_utils::xcm_helpers; pub use emulated_integration_tests_common::{ - test_parachain_is_trusted_teleporter, + accounts::DUMMY_EMPTY, + get_account_id_from_seed, test_parachain_is_trusted_teleporter, + test_parachain_is_trusted_teleporter_for_relay, test_relay_is_trusted_teleporter, xcm_emulator::{ assert_expected_events, bx, Chain, Parachain as Para, RelayChain as Relay, Test, TestArgs, TestContext, TestExt, }, - xcm_helpers::{non_fee_asset, xcm_transact_paid_execution}, + xcm_helpers::{ + get_amount_from_versioned_assets, non_fee_asset, xcm_transact_paid_execution, + }, ASSETS_PALLET_ID, RESERVABLE_ASSET_ID, XCM_V3, }; pub use parachains_common::Balance; pub use rococo_system_emulated_network::{ asset_hub_rococo_emulated_chain::{ + asset_hub_rococo_runtime::{ + xcm_config::{ + self as ahr_xcm_config, TokenLocation as RelayLocation, + XcmConfig as AssetHubRococoXcmConfig, + }, + AssetConversionOrigin as AssetHubRococoAssetConversionOrigin, + ExistentialDeposit as AssetHubRococoExistentialDeposit, + }, genesis::{AssetHubRococoAssetOwner, ED as ASSET_HUB_ROCOCO_ED}, AssetHubRococoParaPallet as AssetHubRococoPallet, }, penpal_emulated_chain::{ + penpal_runtime::xcm_config::{ + CustomizableAssetFromSystemAssetHub as PenpalCustomizableAssetFromSystemAssetHub, + LocalReservableFromAssetHub as PenpalLocalReservableFromAssetHub, + LocalTeleportableToAssetHub as PenpalLocalTeleportableToAssetHub, + }, PenpalAParaPallet as PenpalAPallet, PenpalAssetOwner, PenpalBParaPallet as PenpalBPallet, ED as PENPAL_ED, }, - rococo_emulated_chain::{genesis::ED as ROCOCO_ED, RococoRelayPallet as RococoPallet}, + rococo_emulated_chain::{ + genesis::ED as ROCOCO_ED, + rococo_runtime::{ + governance as rococo_governance, + xcm_config::{ + UniversalLocation as RococoUniversalLocation, XcmConfig as RococoXcmConfig, + }, + OriginCaller as RococoOriginCaller, + }, + RococoRelayPallet as RococoPallet, + }, AssetHubRococoPara as AssetHubRococo, AssetHubRococoParaReceiver as AssetHubRococoReceiver, AssetHubRococoParaSender as AssetHubRococoSender, BridgeHubRococoPara as BridgeHubRococo, BridgeHubRococoParaReceiver as BridgeHubRococoReceiver, PenpalAPara as PenpalA, @@ -62,22 +89,9 @@ mod imports { RococoRelayReceiver as RococoReceiver, RococoRelaySender as RococoSender, }; - // Runtimes - pub use asset_hub_rococo_runtime::xcm_config::{ - TokenLocation as RelayLocation, XcmConfig as AssetHubRococoXcmConfig, - }; - pub use penpal_runtime::xcm_config::{ - LocalReservableFromAssetHub as PenpalLocalReservableFromAssetHub, - LocalTeleportableToAssetHub as PenpalLocalTeleportableToAssetHub, - }; - pub use rococo_runtime::xcm_config::{ - UniversalLocation as RococoUniversalLocation, XcmConfig as RococoXcmConfig, - }; - pub const ASSET_ID: u32 = 3; pub const ASSET_MIN_BALANCE: u128 = 1000; - pub type RelayToSystemParaTest = Test; pub type RelayToParaTest = Test; pub type ParaToRelayTest = Test; pub type SystemParaToRelayTest = Test; diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..99b31aba4be010f48f0551cc1115b97caa63f409 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = AssetHubRococoExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(AssetHubRococo, RuntimeCall, NetworkId::Rococo, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/hybrid_transfers.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/hybrid_transfers.rs index edaaa998a9ca11f97b9d2c85e8b2b88d1c570fbc..7ff6d6c193c9b414632b13e267220a59c770449a 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/hybrid_transfers.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/hybrid_transfers.rs @@ -170,7 +170,7 @@ fn transfer_foreign_assets_from_asset_hub_to_para() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Westend)]).encode(), )], )); @@ -300,7 +300,7 @@ fn transfer_foreign_assets_from_para_to_asset_hub() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Westend)]).encode(), )], )); @@ -454,7 +454,7 @@ fn transfer_foreign_assets_from_para_to_para_through_asset_hub() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Westend)]).encode(), )], )); diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/mod.rs index 138ce419757b98b03d4e9a6b26259d81ca779d69..88fa379c4072b97e867f3eccb68bb23b0eeedff2 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/mod.rs @@ -13,6 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +mod claim_assets; mod hybrid_transfers; mod reserve_transfer; mod send; @@ -20,3 +21,4 @@ mod set_xcm_versions; mod swap; mod teleport; mod treasury; +mod xcm_fee_estimation; diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/reserve_transfer.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/reserve_transfer.rs index 8b9fedcd4947cf5aaef5db0233166c6bc7cbcf21..70dde03d75a27ed300f1dbaa18a9af6536df2c13 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/reserve_transfer.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/reserve_transfer.rs @@ -493,9 +493,9 @@ fn para_to_para_through_relay_limited_reserve_transfer_assets( ) } -/// Reserve Transfers of native asset from Relay Chain to the System Parachain shouldn't work +/// Reserve Transfers of native asset from Relay Chain to the Asset Hub shouldn't work #[test] -fn reserve_transfer_native_asset_from_relay_to_system_para_fails() { +fn reserve_transfer_native_asset_from_relay_to_asset_hub_fails() { // Init values for Relay Chain let signed_origin = ::RuntimeOrigin::signed(RococoSender::get().into()); let destination = Rococo::child_location_of(AssetHubRococo::para_id()); @@ -526,10 +526,10 @@ fn reserve_transfer_native_asset_from_relay_to_system_para_fails() { }); } -/// Reserve Transfers of native asset from System Parachain to Relay Chain shouldn't work +/// Reserve Transfers of native asset from Asset Hub to Relay Chain shouldn't work #[test] -fn reserve_transfer_native_asset_from_system_para_to_relay_fails() { - // Init values for System Parachain +fn reserve_transfer_native_asset_from_asset_hub_to_relay_fails() { + // Init values for Asset Hub let signed_origin = ::RuntimeOrigin::signed(AssetHubRococoSender::get().into()); let destination = AssetHubRococo::parent_location(); @@ -691,10 +691,10 @@ fn reserve_transfer_native_asset_from_para_to_relay() { // ========================================================================= // ======= Reserve Transfers - Native Asset - AssetHub<>Parachain ========== // ========================================================================= -/// Reserve Transfers of native asset from System Parachain to Parachain should work +/// Reserve Transfers of native asset from Asset Hub to Parachain should work #[test] -fn reserve_transfer_native_asset_from_system_para_to_para() { - // Init values for System Parachain +fn reserve_transfer_native_asset_from_asset_hub_to_para() { + // Init values for Asset Hub let destination = AssetHubRococo::sibling_location_of(PenpalA::para_id()); let sender = AssetHubRococoSender::get(); let amount_to_send: Balance = ASSET_HUB_ROCOCO_ED * 10000; @@ -749,9 +749,9 @@ fn reserve_transfer_native_asset_from_system_para_to_para() { assert!(receiver_assets_after < receiver_assets_before + amount_to_send); } -/// Reserve Transfers of native asset from Parachain to System Parachain should work +/// Reserve Transfers of native asset from Parachain to Asset Hub should work #[test] -fn reserve_transfer_native_asset_from_para_to_system_para() { +fn reserve_transfer_native_asset_from_para_to_asset_hub() { // Init values for Parachain let destination = PenpalA::sibling_location_of(AssetHubRococo::para_id()); let sender = PenpalASender::get(); @@ -768,12 +768,12 @@ fn reserve_transfer_native_asset_from_para_to_system_para() { amount_to_send * 2, ); - // Init values for System Parachain + // Init values for Asset Hub let receiver = AssetHubRococoReceiver::get(); let penpal_location_as_seen_by_ahr = AssetHubRococo::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(penpal_location_as_seen_by_ahr); - // fund Parachain's SA on System Parachain with the native tokens held in reserve + // fund Parachain's SA on Asset Hub with the native tokens held in reserve AssetHubRococo::fund_accounts(vec![(sov_penpal_on_ahr.into(), amount_to_send * 2)]); // Init Test @@ -824,11 +824,11 @@ fn reserve_transfer_native_asset_from_para_to_system_para() { // ================================================================================== // ======= Reserve Transfers - Native + Non-system Asset - AssetHub<>Parachain ====== // ================================================================================== -/// Reserve Transfers of a local asset and native asset from System Parachain to Parachain should +/// Reserve Transfers of a local asset and native asset from Asset Hub to Parachain should /// work #[test] -fn reserve_transfer_assets_from_system_para_to_para() { - // Init values for System Parachain +fn reserve_transfer_multiple_assets_from_asset_hub_to_para() { + // Init values for Asset Hub let destination = AssetHubRococo::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(destination.clone()); let sender = AssetHubRococoSender::get(); @@ -939,10 +939,12 @@ fn reserve_transfer_assets_from_system_para_to_para() { ); } -/// Reserve Transfers of a foreign asset and native asset from Parachain to System Para should -/// work +/// Reserve Transfers of a random asset and native asset from Parachain to Asset Hub should work +/// Receiver is empty account to show deposit works as long as transfer includes enough DOT for ED. +/// Once we have https://github.com/paritytech/polkadot-sdk/issues/5298, +/// we should do equivalent test with USDT instead of DOT. #[test] -fn reserve_transfer_assets_from_para_to_system_para() { +fn reserve_transfer_multiple_assets_from_para_to_asset_hub() { // Init values for Parachain let destination = PenpalA::sibling_location_of(AssetHubRococo::para_id()); let sender = PenpalASender::get(); @@ -965,24 +967,23 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Fund Parachain's sender account with some foreign assets PenpalA::mint_foreign_asset( penpal_asset_owner_signer.clone(), - asset_location_on_penpal, + asset_location_on_penpal.clone(), sender.clone(), asset_amount_to_send * 2, ); // Fund Parachain's sender account with some system assets PenpalA::mint_foreign_asset( penpal_asset_owner_signer, - system_asset_location_on_penpal, + system_asset_location_on_penpal.clone(), sender.clone(), fee_amount_to_send * 2, ); - // Init values for System Parachain - let receiver = AssetHubRococoReceiver::get(); + // Beneficiary is a new (empty) account + let receiver = get_account_id_from_seed::(DUMMY_EMPTY); + // Init values for Asset Hub let penpal_location_as_seen_by_ahr = AssetHubRococo::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(penpal_location_as_seen_by_ahr); - let system_para_native_asset_location = RelayLocation::get(); - let system_para_foreign_asset_location = PenpalLocalReservableFromAssetHub::get(); let ah_asset_owner = AssetHubRococoAssetOwner::get(); let ah_asset_owner_signer = ::RuntimeOrigin::signed(ah_asset_owner); @@ -1017,11 +1018,11 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Query initial balances let sender_system_assets_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_native_asset_location.clone(), &sender) + >::balance(system_asset_location_on_penpal.clone(), &sender) }); let sender_foreign_assets_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_foreign_asset_location.clone(), &sender) + >::balance(asset_location_on_penpal.clone(), &sender) }); let receiver_balance_before = test.receiver.balance; let receiver_assets_before = AssetHubRococo::execute_with(|| { @@ -1038,11 +1039,11 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Query final balances let sender_system_assets_after = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_native_asset_location.clone(), &sender) + >::balance(system_asset_location_on_penpal, &sender) }); let sender_foreign_assets_after = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_foreign_asset_location, &sender) + >::balance(asset_location_on_penpal, &sender) }); let receiver_balance_after = test.receiver.balance; let receiver_assets_after = AssetHubRococo::execute_with(|| { diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/send.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/send.rs index 364fbd0d439f62ed1fce356d1935331ec8e0d90b..29eaa96946436fcafd189adcee9ec0bde6dc3548 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/send.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/send.rs @@ -18,7 +18,7 @@ use crate::imports::*; /// Relay Chain should be able to execute `Transact` instructions in System Parachain /// when `OriginKind::Superuser`. #[test] -fn send_transact_as_superuser_from_relay_to_system_para_works() { +fn send_transact_as_superuser_from_relay_to_asset_hub_works() { AssetHubRococo::force_create_asset_from_relay_as_root( ASSET_ID, ASSET_MIN_BALANCE, @@ -29,28 +29,25 @@ fn send_transact_as_superuser_from_relay_to_system_para_works() { } /// We tests two things here: -/// - Parachain should be able to send XCM paying its fee with system asset in the System Parachain -/// - Parachain should be able to create a new Foreign Asset in the System Parachain +/// - Parachain should be able to send XCM paying its fee at Asset Hub using system asset +/// - Parachain should be able to create a new Foreign Asset at Asset Hub #[test] -fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { +fn send_xcm_from_para_to_asset_hub_paying_fee_with_system_asset() { let para_sovereign_account = AssetHubRococo::sovereign_account_id_of( AssetHubRococo::sibling_location_of(PenpalA::para_id()), ); - let asset_location_on_penpal = v3::Location::new( + let asset_location_on_penpal = Location::new( 0, - [ - v3::Junction::PalletInstance(ASSETS_PALLET_ID), - v3::Junction::GeneralIndex(ASSET_ID.into()), - ], + [Junction::PalletInstance(ASSETS_PALLET_ID), Junction::GeneralIndex(ASSET_ID.into())], ); let foreign_asset_at_asset_hub = - v3::Location::new(1, [v3::Junction::Parachain(PenpalA::para_id().into())]) + Location::new(1, [Junction::Parachain(PenpalA::para_id().into())]) .appended_with(asset_location_on_penpal) .unwrap(); // Encoded `create_asset` call to be executed in AssetHub let call = AssetHubRococo::create_foreign_asset_call( - foreign_asset_at_asset_hub, + foreign_asset_at_asset_hub.clone(), ASSET_MIN_BALANCE, para_sovereign_account.clone(), ); @@ -86,12 +83,7 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; - - AssetHubRococo::assert_xcmp_queue_success(Some(Weight::from_parts( - 15_594_564_000, - 562_893, - ))); - + AssetHubRococo::assert_xcmp_queue_success(None); assert_expected_events!( AssetHubRococo, vec![ @@ -115,15 +107,15 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { } /// We tests two things here: -/// - Parachain should be able to send XCM paying its fee with system assets in the System Parachain -/// - Parachain should be able to create a new Asset in the System Parachain +/// - Parachain should be able to send XCM paying its fee at Asset Hub using sufficient asset +/// - Parachain should be able to create a new Asset at Asset Hub #[test] -fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() { +fn send_xcm_from_para_to_asset_hub_paying_fee_with_sufficient_asset() { let para_sovereign_account = AssetHubRococo::sovereign_account_id_of( AssetHubRococo::sibling_location_of(PenpalA::para_id()), ); - // Force create and mint assets for Parachain's sovereign account + // Force create and mint sufficient assets for Parachain's sovereign account AssetHubRococo::force_create_and_mint_asset( ASSET_ID, ASSET_MIN_BALANCE, @@ -170,12 +162,7 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() { AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; - - AssetHubRococo::assert_xcmp_queue_success(Some(Weight::from_parts( - 15_594_564_000, - 562_893, - ))); - + AssetHubRococo::assert_xcmp_queue_success(None); assert_expected_events!( AssetHubRococo, vec![ diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/swap.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/swap.rs index ec48e400ff545686fe728025eacc7ea5cd783d6f..ac0c90ba198d0542f55412a7763efc6c2f0ee199 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/swap.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/swap.rs @@ -17,16 +17,10 @@ use crate::imports::*; #[test] fn swap_locally_on_chain_using_local_assets() { - let asset_native = Box::new( - v3::Location::try_from(asset_hub_rococo_runtime::xcm_config::TokenLocation::get()) - .expect("conversion works"), - ); - let asset_one = Box::new(v3::Location::new( + let asset_native = Box::new(Location::try_from(RelayLocation::get()).unwrap()); + let asset_one = Box::new(Location::new( 0, - [ - v3::Junction::PalletInstance(ASSETS_PALLET_ID), - v3::Junction::GeneralIndex(ASSET_ID.into()), - ], + [Junction::PalletInstance(ASSETS_PALLET_ID), Junction::GeneralIndex(ASSET_ID.into())], )); AssetHubRococo::execute_with(|| { @@ -115,11 +109,11 @@ fn swap_locally_on_chain_using_local_assets() { #[test] fn swap_locally_on_chain_using_foreign_assets() { - let asset_native = Box::new(v3::Location::try_from(RelayLocation::get()).unwrap()); + let asset_native = Box::new(Location::try_from(RelayLocation::get()).unwrap()); let asset_location_on_penpal = - v3::Location::try_from(PenpalLocalTeleportableToAssetHub::get()).unwrap(); + Location::try_from(PenpalLocalTeleportableToAssetHub::get()).unwrap(); let foreign_asset_at_asset_hub_rococo = - v3::Location::new(1, [v3::Junction::Parachain(PenpalA::para_id().into())]) + Location::new(1, [Junction::Parachain(PenpalA::para_id().into())]) .appended_with(asset_location_on_penpal) .unwrap(); @@ -144,7 +138,7 @@ fn swap_locally_on_chain_using_foreign_assets() { // 1. Mint foreign asset (in reality this should be a teleport or some such) assert_ok!(::ForeignAssets::mint( ::RuntimeOrigin::signed(sov_penpal_on_ahr.clone().into()), - foreign_asset_at_asset_hub_rococo, + foreign_asset_at_asset_hub_rococo.clone(), sov_penpal_on_ahr.clone().into(), ASSET_HUB_ROCOCO_ED * 3_000_000_000_000, )); @@ -160,7 +154,7 @@ fn swap_locally_on_chain_using_foreign_assets() { assert_ok!(::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubRococoSender::get()), asset_native.clone(), - Box::new(foreign_asset_at_asset_hub_rococo), + Box::new(foreign_asset_at_asset_hub_rococo.clone()), )); assert_expected_events!( @@ -174,7 +168,7 @@ fn swap_locally_on_chain_using_foreign_assets() { assert_ok!(::AssetConversion::add_liquidity( ::RuntimeOrigin::signed(sov_penpal_on_ahr.clone()), asset_native.clone(), - Box::new(foreign_asset_at_asset_hub_rococo), + Box::new(foreign_asset_at_asset_hub_rococo.clone()), 1_000_000_000_000, 2_000_000_000_000, 0, @@ -192,7 +186,7 @@ fn swap_locally_on_chain_using_foreign_assets() { ); // 4. Swap! - let path = vec![asset_native.clone(), Box::new(foreign_asset_at_asset_hub_rococo)]; + let path = vec![asset_native.clone(), Box::new(foreign_asset_at_asset_hub_rococo.clone())]; assert_ok!( ::AssetConversion::swap_exact_tokens_for_tokens( @@ -219,7 +213,7 @@ fn swap_locally_on_chain_using_foreign_assets() { assert_ok!(::AssetConversion::remove_liquidity( ::RuntimeOrigin::signed(sov_penpal_on_ahr.clone()), asset_native.clone(), - Box::new(foreign_asset_at_asset_hub_rococo), + Box::new(foreign_asset_at_asset_hub_rococo.clone()), 1414213562273 - ASSET_HUB_ROCOCO_ED * 2, // all but the 2 EDs can't be retrieved. 0, 0, @@ -230,12 +224,12 @@ fn swap_locally_on_chain_using_foreign_assets() { #[test] fn cannot_create_pool_from_pool_assets() { - let asset_native = asset_hub_rococo_runtime::xcm_config::TokenLocation::get(); - let mut asset_one = asset_hub_rococo_runtime::xcm_config::PoolAssetsPalletLocation::get(); + let asset_native = RelayLocation::get(); + let mut asset_one = ahr_xcm_config::PoolAssetsPalletLocation::get(); asset_one.append_with(GeneralIndex(ASSET_ID.into())).expect("pool assets"); AssetHubRococo::execute_with(|| { - let pool_owner_account_id = asset_hub_rococo_runtime::AssetConversionOrigin::get(); + let pool_owner_account_id = AssetHubRococoAssetConversionOrigin::get(); assert_ok!(::PoolAssets::create( ::RuntimeOrigin::signed(pool_owner_account_id.clone()), @@ -255,8 +249,8 @@ fn cannot_create_pool_from_pool_assets() { assert_matches::assert_matches!( ::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubRococoSender::get()), - Box::new(v3::Location::try_from(asset_native).expect("conversion works")), - Box::new(v3::Location::try_from(asset_one).expect("conversion works")), + Box::new(Location::try_from(asset_native).unwrap()), + Box::new(Location::try_from(asset_one).unwrap()), ), Err(DispatchError::Module(ModuleError{index: _, error: _, message})) => assert_eq!(message, Some("Unknown")) ); @@ -265,14 +259,12 @@ fn cannot_create_pool_from_pool_assets() { #[test] fn pay_xcm_fee_with_some_asset_swapped_for_native() { - let asset_native = - v3::Location::try_from(asset_hub_rococo_runtime::xcm_config::TokenLocation::get()) - .expect("conversion works"); - let asset_one = xcm::v3::Location { + let asset_native = Location::try_from(RelayLocation::get()).unwrap(); + let asset_one = Location { parents: 0, interior: [ - xcm::v3::Junction::PalletInstance(ASSETS_PALLET_ID), - xcm::v3::Junction::GeneralIndex(ASSET_ID.into()), + Junction::PalletInstance(ASSETS_PALLET_ID), + Junction::GeneralIndex(ASSET_ID.into()), ] .into(), }; @@ -301,8 +293,8 @@ fn pay_xcm_fee_with_some_asset_swapped_for_native() { assert_ok!(::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubRococoSender::get()), - Box::new(asset_native), - Box::new(asset_one), + Box::new(asset_native.clone()), + Box::new(asset_one.clone()), )); assert_expected_events!( diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/teleport.rs index f74378d7631a610a57c61153e62aedfcb588a611..c8da801a14bff5adea1a695313672dfb9c9d8437 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/teleport.rs @@ -15,53 +15,6 @@ use crate::imports::*; -fn relay_origin_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - Rococo::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(631_531_000, 7_186))); - - assert_expected_events!( - Rococo, - vec![ - // Amount to teleport is withdrawn from Sender - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == t.sender.account_id, - amount: *amount == t.args.amount, - }, - // Amount to teleport is deposited in Relay's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - ] - ); -} - -fn relay_dest_assertions(t: SystemParaToRelayTest) { - type RuntimeEvent = ::RuntimeEvent; - - Rococo::assert_ump_queue_processed( - true, - Some(AssetHubRococo::para_id()), - Some(Weight::from_parts(307_225_000, 7_186)), - ); - - assert_expected_events!( - Rococo, - vec![ - // Amount is withdrawn from Relay Chain's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - fn relay_dest_assertions_fail(_t: SystemParaToRelayTest) { Rococo::assert_ump_queue_processed( false, @@ -92,22 +45,6 @@ fn para_origin_assertions(t: SystemParaToRelayTest) { ); } -fn para_dest_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - AssetHubRococo::assert_dmp_queue_complete(Some(Weight::from_parts(157_718_000, 3593))); - - assert_expected_events!( - AssetHubRococo, - vec![ - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - fn penpal_to_ah_foreign_assets_sender_assertions(t: ParaToSystemParaTest) { type RuntimeEvent = ::RuntimeEvent; let system_para_native_asset_location = RelayLocation::get(); @@ -141,7 +78,6 @@ fn penpal_to_ah_foreign_assets_receiver_assertions(t: ParaToSystemParaTest) { ); let (expected_foreign_asset_id, expected_foreign_asset_amount) = non_fee_asset(&t.args.assets, t.args.fee_asset_item as usize).unwrap(); - let expected_foreign_asset_id_v3: v3::Location = expected_foreign_asset_id.try_into().unwrap(); AssetHubRococo::assert_xcmp_queue_success(None); @@ -159,7 +95,7 @@ fn penpal_to_ah_foreign_assets_receiver_assertions(t: ParaToSystemParaTest) { who: *who == t.receiver.account_id, }, RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, amount }) => { - asset_id: *asset_id == expected_foreign_asset_id_v3, + asset_id: *asset_id == expected_foreign_asset_id, owner: *owner == t.receiver.account_id, amount: *amount == expected_foreign_asset_amount, }, @@ -173,7 +109,6 @@ fn ah_to_penpal_foreign_assets_sender_assertions(t: SystemParaToParaTest) { AssetHubRococo::assert_xcm_pallet_attempted_complete(None); let (expected_foreign_asset_id, expected_foreign_asset_amount) = non_fee_asset(&t.args.assets, t.args.fee_asset_item as usize).unwrap(); - let expected_foreign_asset_id_v3: v3::Location = expected_foreign_asset_id.try_into().unwrap(); assert_expected_events!( AssetHubRococo, vec![ @@ -189,7 +124,7 @@ fn ah_to_penpal_foreign_assets_sender_assertions(t: SystemParaToParaTest) { }, // foreign asset is burned locally as part of teleportation RuntimeEvent::ForeignAssets(pallet_assets::Event::Burned { asset_id, owner, balance }) => { - asset_id: *asset_id == expected_foreign_asset_id_v3, + asset_id: *asset_id == expected_foreign_asset_id, owner: *owner == t.sender.account_id, balance: *balance == expected_foreign_asset_amount, }, @@ -232,17 +167,6 @@ fn ah_to_penpal_foreign_assets_receiver_assertions(t: SystemParaToParaTest) { ); } -fn relay_limited_teleport_assets(t: RelayToSystemParaTest) -> DispatchResult { - ::XcmPallet::limited_teleport_assets( - t.signed_origin, - bx!(t.args.dest.into()), - bx!(t.args.beneficiary.into()), - bx!(t.args.assets.into()), - t.args.fee_asset_item, - t.args.weight_limit, - ) -} - fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResult { ::PolkadotXcm::limited_teleport_assets( t.signed_origin, @@ -276,90 +200,41 @@ fn system_para_to_para_transfer_assets(t: SystemParaToParaTest) -> DispatchResul ) } -/// Limited Teleport of native asset from Relay Chain to the System Parachain should work #[test] -fn limited_teleport_native_assets_from_relay_to_system_para_works() { - // Init values for Relay Chain - let amount_to_send: Balance = ROCOCO_ED * 1000; - let dest = Rococo::child_location_of(AssetHubRococo::para_id()); - let beneficiary_id = AssetHubRococoReceiver::get(); - let test_args = TestContext { - sender: RococoSender::get(), - receiver: AssetHubRococoReceiver::get(), - args: TestArgs::new_relay(dest, beneficiary_id, amount_to_send), - }; - - let mut test = RelayToSystemParaTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(relay_origin_assertions); - test.set_assertion::(para_dest_assertions); - test.set_dispatchable::(relay_limited_teleport_assets); - test.assert(); - - let delivery_fees = Rococo::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; +fn teleport_to_other_system_parachains_works() { + let amount = ASSET_HUB_ROCOCO_ED * 100; + let native_asset: Assets = (Parent, amount).into(); - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); + test_parachain_is_trusted_teleporter!( + AssetHubRococo, // Origin + AssetHubRococoXcmConfig, // XCM Configuration + vec![BridgeHubRococo], // Destinations + (native_asset, amount) + ); } -/// Limited Teleport of native asset from System Parachain to Relay Chain -/// should work when there is enough balance in Relay Chain's `CheckAccount` #[test] -fn limited_teleport_native_assets_back_from_system_para_to_relay_works() { - // Dependency - Relay Chain's `CheckAccount` should have enough balance - limited_teleport_native_assets_from_relay_to_system_para_works(); - - // Init values for Relay Chain - let amount_to_send: Balance = ASSET_HUB_ROCOCO_ED * 1000; - let destination = AssetHubRococo::parent_location(); - let beneficiary_id = RococoReceiver::get(); - let assets = (Parent, amount_to_send).into(); - - let test_args = TestContext { - sender: AssetHubRococoSender::get(), - receiver: RococoReceiver::get(), - args: TestArgs::new_para(destination, beneficiary_id, amount_to_send, assets, None, 0), - }; - - let mut test = SystemParaToRelayTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(para_origin_assertions); - test.set_assertion::(relay_dest_assertions); - test.set_dispatchable::(system_para_limited_teleport_assets); - test.assert(); +fn teleport_from_and_to_relay() { + let amount = ROCOCO_ED * 100; + let native_asset: Assets = (Here, amount).into(); - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - let delivery_fees = AssetHubRococo::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); + test_relay_is_trusted_teleporter!( + Rococo, + RococoXcmConfig, + vec![AssetHubRococo], + (native_asset, amount) + ); - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); + test_parachain_is_trusted_teleporter_for_relay!( + AssetHubRococo, + AssetHubRococoXcmConfig, + Rococo, + amount + ); } /// Limited Teleport of native asset from System Parachain to Relay Chain -/// should't work when there is not enough balance in Relay Chain's `CheckAccount` +/// shouldn't work when there is not enough balance in Relay Chain's `CheckAccount` #[test] fn limited_teleport_native_assets_from_system_para_to_relay_fails() { // Init values for Relay Chain @@ -399,19 +274,6 @@ fn limited_teleport_native_assets_from_system_para_to_relay_fails() { assert_eq!(receiver_balance_after, receiver_balance_before); } -#[test] -fn teleport_to_other_system_parachains_works() { - let amount = ASSET_HUB_ROCOCO_ED * 100; - let native_asset: Assets = (Parent, amount).into(); - - test_parachain_is_trusted_teleporter!( - AssetHubRococo, // Origin - AssetHubRococoXcmConfig, // XCM Configuration - vec![BridgeHubRococo], // Destinations - (native_asset, amount) - ); -} - /// Bidirectional teleports of local Penpal assets to Asset Hub as foreign assets while paying /// fees using (reserve transferred) native asset. pub fn do_bidirectional_teleport_foreign_assets_between_para_and_asset_hub_using_xt( diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/treasury.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/treasury.rs index 01bf40ae8fdf2cf87092c83ef604ef25427e2939..3320392b495d281bf9c127ab299793535362ddcd 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/treasury.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/treasury.rs @@ -14,18 +14,20 @@ // limitations under the License. use crate::imports::*; -use emulated_integration_tests_common::accounts::{ALICE, BOB}; +use emulated_integration_tests_common::{ + accounts::{ALICE, BOB}, + USDT_ID, +}; use frame_support::{ dispatch::RawOrigin, sp_runtime::traits::Dispatchable, traits::{ fungible::Inspect, - fungibles::{Create, Inspect as FungiblesInspect, Mutate}, + fungibles::{Inspect as FungiblesInspect, Mutate}, }, }; use parachains_common::AccountId; use polkadot_runtime_common::impls::VersionedLocatableAsset; -use rococo_runtime::OriginCaller; use rococo_runtime_constants::currency::GRAND; use xcm_executor::traits::ConvertLocation; @@ -67,7 +69,7 @@ fn spend_roc_on_asset_hub() { let treasury_location: Location = (Parent, PalletInstance(18)).into(); let teleport_call = RuntimeCall::Utility(pallet_utility::Call::::dispatch_as { - as_origin: bx!(OriginCaller::system(RawOrigin::Signed(treasury_account))), + as_origin: bx!(RococoOriginCaller::system(RawOrigin::Signed(treasury_account))), call: bx!(RuntimeCall::XcmPallet(pallet_xcm::Call::::teleport_assets { dest: bx!(VersionedLocation::V4(asset_hub_location.clone())), beneficiary: bx!(VersionedLocation::V4(treasury_location)), @@ -99,7 +101,7 @@ fn spend_roc_on_asset_hub() { // Fund Alice account from Rococo Treasury account on Asset Hub. let treasury_origin: RuntimeOrigin = - rococo_runtime::governance::pallet_custom_origins::Origin::Treasurer.into(); + rococo_governance::pallet_custom_origins::Origin::Treasurer.into(); let alice_location: Location = [Junction::AccountId32 { network: None, id: Rococo::account_id_of(ALICE).into() }] @@ -162,16 +164,12 @@ fn spend_roc_on_asset_hub() { #[test] fn create_and_claim_treasury_spend_in_usdt() { - const ASSET_ID: u32 = 1984; - const SPEND_AMOUNT: u128 = 1_000_000; + const SPEND_AMOUNT: u128 = 10_000_000; // treasury location from a sibling parachain. let treasury_location: Location = Location::new(1, PalletInstance(18)); // treasury account on a sibling parachain. let treasury_account = - asset_hub_rococo_runtime::xcm_config::LocationToAccountId::convert_location( - &treasury_location, - ) - .unwrap(); + ahr_xcm_config::LocationToAccountId::convert_location(&treasury_location).unwrap(); let asset_hub_location = v3::Location::new(0, v3::Junction::Parachain(AssetHubRococo::para_id().into())); let root = ::RuntimeOrigin::root(); @@ -179,7 +177,7 @@ fn create_and_claim_treasury_spend_in_usdt() { let asset_kind = VersionedLocatableAsset::V3 { location: asset_hub_location, asset_id: v3::AssetId::Concrete( - (v3::Junction::PalletInstance(50), v3::Junction::GeneralIndex(ASSET_ID.into())).into(), + (v3::Junction::PalletInstance(50), v3::Junction::GeneralIndex(USDT_ID.into())).into(), ), }; // treasury spend beneficiary. @@ -190,16 +188,10 @@ fn create_and_claim_treasury_spend_in_usdt() { AssetHubRococo::execute_with(|| { type Assets = ::Assets; - // create an asset class and mint some assets to the treasury account. - assert_ok!(>::create( - ASSET_ID, - treasury_account.clone(), - true, - SPEND_AMOUNT / 2 - )); - assert_ok!(>::mint_into(ASSET_ID, &treasury_account, SPEND_AMOUNT * 4)); + // USDT created at genesis, mint some assets to the treasury account. + assert_ok!(>::mint_into(USDT_ID, &treasury_account, SPEND_AMOUNT * 4)); // beneficiary has zero balance. - assert_eq!(>::balance(ASSET_ID, &alice,), 0u128,); + assert_eq!(>::balance(USDT_ID, &alice,), 0u128,); }); Rococo::execute_with(|| { @@ -241,7 +233,7 @@ fn create_and_claim_treasury_spend_in_usdt() { AssetHubRococo, vec![ RuntimeEvent::Assets(pallet_assets::Event::Transferred { asset_id: id, from, to, amount }) => { - id: id == &ASSET_ID, + id: id == &USDT_ID, from: from == &treasury_account, to: to == &alice, amount: amount == &SPEND_AMOUNT, @@ -251,7 +243,7 @@ fn create_and_claim_treasury_spend_in_usdt() { ] ); // beneficiary received the assets from the treasury. - assert_eq!(>::balance(ASSET_ID, &alice,), SPEND_AMOUNT,); + assert_eq!(>::balance(USDT_ID, &alice,), SPEND_AMOUNT,); }); Rococo::execute_with(|| { diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/xcm_fee_estimation.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/xcm_fee_estimation.rs new file mode 100644 index 0000000000000000000000000000000000000000..aa0e183ecddaf1a07c1f91d04253138b2625df46 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-rococo/src/tests/xcm_fee_estimation.rs @@ -0,0 +1,286 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests for XCM fee estimation in the runtime. + +use crate::imports::*; +use frame_support::{ + dispatch::RawOrigin, + sp_runtime::{traits::Dispatchable, DispatchResult}, +}; +use xcm_runtime_apis::{ + dry_run::runtime_decl_for_dry_run_api::DryRunApiV1, + fees::runtime_decl_for_xcm_payment_api::XcmPaymentApiV1, +}; + +fn sender_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + PenpalA::assert_xcm_pallet_attempted_complete(None); + + assert_expected_events!( + PenpalA, + vec![ + RuntimeEvent::ForeignAssets( + pallet_assets::Event::Burned { asset_id, owner, balance } + ) => { + asset_id: *asset_id == Location::new(1, []), + owner: *owner == test.sender.account_id, + balance: *balance == test.args.amount, + }, + ] + ); +} + +fn hop_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + AssetHubRococo::assert_xcmp_queue_success(None); + + assert_expected_events!( + AssetHubRococo, + vec![ + RuntimeEvent::Balances( + pallet_balances::Event::Burned { amount, .. } + ) => { + amount: *amount == test.args.amount, + }, + ] + ); +} + +fn receiver_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + PenpalB::assert_xcmp_queue_success(None); + + assert_expected_events!( + PenpalB, + vec![ + RuntimeEvent::ForeignAssets( + pallet_assets::Event::Issued { asset_id, owner, .. } + ) => { + asset_id: *asset_id == Location::new(1, []), + owner: *owner == test.receiver.account_id, + }, + ] + ); +} + +fn transfer_assets_para_to_para_through_ah_dispatchable( + test: ParaToParaThroughAHTest, +) -> DispatchResult { + let call = transfer_assets_para_to_para_through_ah_call(test.clone()); + match call.dispatch(test.signed_origin) { + Ok(_) => Ok(()), + Err(error_with_post_info) => Err(error_with_post_info.error), + } +} + +fn transfer_assets_para_to_para_through_ah_call( + test: ParaToParaThroughAHTest, +) -> ::RuntimeCall { + type RuntimeCall = ::RuntimeCall; + + let asset_hub_location: Location = PenpalB::sibling_location_of(AssetHubRococo::para_id()); + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(test.args.assets.len() as u32)), + beneficiary: test.args.beneficiary, + }]); + RuntimeCall::PolkadotXcm(pallet_xcm::Call::transfer_assets_using_type_and_then { + dest: bx!(test.args.dest.into()), + assets: bx!(test.args.assets.clone().into()), + assets_transfer_type: bx!(TransferType::RemoteReserve(asset_hub_location.clone().into())), + remote_fees_id: bx!(VersionedAssetId::V4(AssetId(Location::new(1, [])))), + fees_transfer_type: bx!(TransferType::RemoteReserve(asset_hub_location.into())), + custom_xcm_on_dest: bx!(VersionedXcm::from(custom_xcm_on_dest)), + weight_limit: test.args.weight_limit, + }) +} + +/// We are able to dry-run and estimate the fees for a multi-hop XCM journey. +/// Scenario: Alice on PenpalA has some DOTs and wants to send them to PenpalB. +/// We want to know the fees using the `DryRunApi` and `XcmPaymentApi`. +#[test] +fn multi_hop_works() { + let destination = PenpalA::sibling_location_of(PenpalB::para_id()); + let sender = PenpalASender::get(); + let amount_to_send = 1_000_000_000_000; + let asset_owner = PenpalAssetOwner::get(); + let assets: Assets = (Parent, amount_to_send).into(); + let relay_native_asset_location = Location::parent(); + let sender_as_seen_by_ah = AssetHubRococo::sibling_location_of(PenpalA::para_id()); + let sov_of_sender_on_ah = AssetHubRococo::sovereign_account_id_of(sender_as_seen_by_ah.clone()); + + // fund Parachain's sender account + PenpalA::mint_foreign_asset( + ::RuntimeOrigin::signed(asset_owner.clone()), + relay_native_asset_location.clone(), + sender.clone(), + amount_to_send * 2, + ); + + // fund the Parachain Origin's SA on AssetHub with the native tokens held in reserve. + AssetHubRococo::fund_accounts(vec![(sov_of_sender_on_ah.clone(), amount_to_send * 2)]); + + // Init values for Parachain Destination + let beneficiary_id = PenpalBReceiver::get(); + + let test_args = TestContext { + sender: PenpalASender::get(), // Bob in PenpalB. + receiver: PenpalBReceiver::get(), // Alice. + args: TestArgs::new_para( + destination, + beneficiary_id.clone(), + amount_to_send, + assets, + None, + 0, + ), + }; + let mut test = ParaToParaThroughAHTest::new(test_args); + + // We get them from the PenpalA closure. + let mut delivery_fees_amount = 0; + let mut remote_message = VersionedXcm::V4(Xcm(Vec::new())); + ::execute_with(|| { + type Runtime = ::Runtime; + type OriginCaller = ::OriginCaller; + + let call = transfer_assets_para_to_para_through_ah_call(test.clone()); + let origin = OriginCaller::system(RawOrigin::Signed(sender.clone())); + let result = Runtime::dry_run_call(origin, call).unwrap(); + // We filter the result to get only the messages we are interested in. + let (destination_to_query, messages_to_query) = &result + .forwarded_xcms + .iter() + .find(|(destination, _)| { + *destination == VersionedLocation::V4(Location::new(1, [Parachain(1000)])) + }) + .unwrap(); + assert_eq!(messages_to_query.len(), 1); + remote_message = messages_to_query[0].clone(); + let delivery_fees = + Runtime::query_delivery_fees(destination_to_query.clone(), remote_message.clone()) + .unwrap(); + delivery_fees_amount = get_amount_from_versioned_assets(delivery_fees); + }); + + // These are set in the AssetHub closure. + let mut intermediate_execution_fees = 0; + let mut intermediate_delivery_fees_amount = 0; + let mut intermediate_remote_message = VersionedXcm::V4(Xcm::<()>(Vec::new())); + ::execute_with(|| { + type Runtime = ::Runtime; + type RuntimeCall = ::RuntimeCall; + + // First we get the execution fees. + let weight = Runtime::query_xcm_weight(remote_message.clone()).unwrap(); + intermediate_execution_fees = Runtime::query_weight_to_asset_fee( + weight, + VersionedAssetId::V4(Location::new(1, []).into()), + ) + .unwrap(); + + // We have to do this to turn `VersionedXcm<()>` into `VersionedXcm`. + let xcm_program = + VersionedXcm::V4(Xcm::::from(remote_message.clone().try_into().unwrap())); + + // Now we get the delivery fees to the final destination. + let result = + Runtime::dry_run_xcm(sender_as_seen_by_ah.clone().into(), xcm_program).unwrap(); + let (destination_to_query, messages_to_query) = &result + .forwarded_xcms + .iter() + .find(|(destination, _)| { + *destination == VersionedLocation::V4(Location::new(1, [Parachain(2001)])) + }) + .unwrap(); + // There's actually two messages here. + // One created when the message we sent from PenpalA arrived and was executed. + // The second one when we dry-run the xcm. + // We could've gotten the message from the queue without having to dry-run, but + // offchain applications would have to dry-run, so we do it here as well. + intermediate_remote_message = messages_to_query[0].clone(); + let delivery_fees = Runtime::query_delivery_fees( + destination_to_query.clone(), + intermediate_remote_message.clone(), + ) + .unwrap(); + intermediate_delivery_fees_amount = get_amount_from_versioned_assets(delivery_fees); + }); + + // Get the final execution fees in the destination. + let mut final_execution_fees = 0; + ::execute_with(|| { + type Runtime = ::Runtime; + + let weight = Runtime::query_xcm_weight(intermediate_remote_message.clone()).unwrap(); + final_execution_fees = + Runtime::query_weight_to_asset_fee(weight, VersionedAssetId::V4(Parent.into())) + .unwrap(); + }); + + // Dry-running is done. + PenpalA::reset_ext(); + AssetHubRococo::reset_ext(); + PenpalB::reset_ext(); + + // Fund accounts again. + PenpalA::mint_foreign_asset( + ::RuntimeOrigin::signed(asset_owner), + relay_native_asset_location.clone(), + sender.clone(), + amount_to_send * 2, + ); + AssetHubRococo::fund_accounts(vec![(sov_of_sender_on_ah, amount_to_send * 2)]); + + // Actually run the extrinsic. + let sender_assets_before = PenpalA::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(relay_native_asset_location.clone(), &sender) + }); + let receiver_assets_before = PenpalB::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(relay_native_asset_location.clone(), &beneficiary_id) + }); + + test.set_assertion::(sender_assertions); + test.set_assertion::(hop_assertions); + test.set_assertion::(receiver_assertions); + test.set_dispatchable::(transfer_assets_para_to_para_through_ah_dispatchable); + test.assert(); + + let sender_assets_after = PenpalA::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(relay_native_asset_location.clone(), &sender) + }); + let receiver_assets_after = PenpalB::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(relay_native_asset_location, &beneficiary_id) + }); + + // We know the exact fees on every hop. + assert_eq!( + sender_assets_after, + sender_assets_before - amount_to_send - delivery_fees_amount /* This is charged directly + * from the sender's + * account. */ + ); + assert_eq!( + receiver_assets_after, + receiver_assets_before + amount_to_send - + intermediate_execution_fees - + intermediate_delivery_fees_amount - + final_execution_fees + ); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml index 0a2b0f6d45ee0480fe91392576068b1cafcb6cdf..6b50b6f473ed087e55ba994fd7cae0f97c48dace 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/Cargo.toml @@ -11,37 +11,35 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } -assert_matches = "1.5.0" +codec = { workspace = true } +assert_matches = { workspace = true } # Substrate -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -sp-keyring = { path = "../../../../../../../substrate/primitives/keyring", default-features = false } -sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../../../substrate/frame/system", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion = { path = "../../../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-treasury = { path = "../../../../../../../substrate/frame/treasury", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue", default-features = false } -pallet-transaction-payment = { path = "../../../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-asset-tx-payment = { path = "../../../../../../../substrate/frame/transaction-payment/asset-tx-payment", default-features = false } +sp-runtime = { workspace = true } +sp-keyring = { workspace = true } +sp-core = { workspace = true } +frame-metadata-hash-extension = { workspace = true, default-features = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-balances = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-treasury = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-asset-tx-payment = { workspace = true } # Polkadot -polkadot-runtime-common = { path = "../../../../../../../polkadot/runtime/common" } -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } -pallet-xcm = { path = "../../../../../../../polkadot/xcm/pallet-xcm", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false } -westend-runtime = { path = "../../../../../../../polkadot/runtime/westend" } +polkadot-runtime-common = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } +pallet-xcm = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../common" } -penpal-runtime = { path = "../../../../../runtimes/testing/penpal" } -asset-hub-westend-runtime = { path = "../../../../../runtimes/assets/asset-hub-westend" } -asset-test-utils = { path = "../../../../../runtimes/assets/test-utils" } -cumulus-pallet-xcmp-queue = { path = "../../../../../../pallets/xcmp-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../../../pallets/parachain-system", default-features = false } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -westend-system-emulated-network = { path = "../../../networks/westend-system" } +parachains-common = { workspace = true, default-features = true } +asset-test-utils = { workspace = true, default-features = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +emulated-integration-tests-common = { workspace = true } +westend-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/lib.rs index 1c4a0ef4c8d2af7f773fbb6916391012ec9fdfc2..a887ee6a532a68eed9914d0df80d32c1ead761a7 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/lib.rs @@ -26,35 +26,55 @@ mod imports { }; // Polkadot - pub use xcm::{ - prelude::{AccountId32 as AccountId32Junction, *}, - v3, - }; + pub use xcm::prelude::{AccountId32 as AccountId32Junction, *}; pub use xcm_executor::traits::TransferType; // Cumulus pub use asset_test_utils::xcm_helpers; pub use emulated_integration_tests_common::{ - test_parachain_is_trusted_teleporter, + accounts::DUMMY_EMPTY, + get_account_id_from_seed, test_parachain_is_trusted_teleporter, + test_parachain_is_trusted_teleporter_for_relay, test_relay_is_trusted_teleporter, xcm_emulator::{ assert_expected_events, bx, Chain, Parachain as Para, RelayChain as Relay, Test, TestArgs, TestContext, TestExt, }, - xcm_helpers::{non_fee_asset, xcm_transact_paid_execution}, + xcm_helpers::{ + get_amount_from_versioned_assets, non_fee_asset, xcm_transact_paid_execution, + }, ASSETS_PALLET_ID, RESERVABLE_ASSET_ID, XCM_V3, }; pub use parachains_common::{AccountId, Balance}; pub use westend_system_emulated_network::{ asset_hub_westend_emulated_chain::{ + asset_hub_westend_runtime::{ + xcm_config::{ + self as ahw_xcm_config, WestendLocation as RelayLocation, + XcmConfig as AssetHubWestendXcmConfig, + }, + AssetConversionOrigin as AssetHubWestendAssetConversionOrigin, + ExistentialDeposit as AssetHubWestendExistentialDeposit, + }, genesis::{AssetHubWestendAssetOwner, ED as ASSET_HUB_WESTEND_ED}, AssetHubWestendParaPallet as AssetHubWestendPallet, }, collectives_westend_emulated_chain::CollectivesWestendParaPallet as CollectivesWestendPallet, penpal_emulated_chain::{ + penpal_runtime::xcm_config::{ + CustomizableAssetFromSystemAssetHub as PenpalCustomizableAssetFromSystemAssetHub, + LocalReservableFromAssetHub as PenpalLocalReservableFromAssetHub, + LocalTeleportableToAssetHub as PenpalLocalTeleportableToAssetHub, + }, PenpalAParaPallet as PenpalAPallet, PenpalAssetOwner, PenpalBParaPallet as PenpalBPallet, }, - westend_emulated_chain::{genesis::ED as WESTEND_ED, WestendRelayPallet as WestendPallet}, + westend_emulated_chain::{ + genesis::ED as WESTEND_ED, + westend_runtime::xcm_config::{ + UniversalLocation as WestendUniversalLocation, XcmConfig as WestendXcmConfig, + }, + WestendRelayPallet as WestendPallet, + }, AssetHubWestendPara as AssetHubWestend, AssetHubWestendParaReceiver as AssetHubWestendReceiver, AssetHubWestendParaSender as AssetHubWestendSender, @@ -66,22 +86,9 @@ mod imports { WestendRelayReceiver as WestendReceiver, WestendRelaySender as WestendSender, }; - // Runtimes - pub use asset_hub_westend_runtime::xcm_config::{ - WestendLocation as RelayLocation, XcmConfig as AssetHubWestendXcmConfig, - }; - pub use penpal_runtime::xcm_config::{ - LocalReservableFromAssetHub as PenpalLocalReservableFromAssetHub, - LocalTeleportableToAssetHub as PenpalLocalTeleportableToAssetHub, - }; - pub use westend_runtime::xcm_config::{ - UniversalLocation as WestendUniversalLocation, XcmConfig as WestendXcmConfig, - }; - pub const ASSET_ID: u32 = 3; pub const ASSET_MIN_BALANCE: u128 = 1000; - pub type RelayToSystemParaTest = Test; pub type RelayToParaTest = Test; pub type ParaToRelayTest = Test; pub type SystemParaToRelayTest = Test; diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..de58839634f1b438c50d369bb025fc8750bda396 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = AssetHubWestendExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(AssetHubWestend, RuntimeCall, NetworkId::Westend, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/fellowship_treasury.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/fellowship_treasury.rs index 2d02e90f47fb834326a7268394671f5ef03f84e7..9520659712fc625ff479da489ffdae7acbb7d185 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/fellowship_treasury.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/fellowship_treasury.rs @@ -14,30 +14,29 @@ // limitations under the License. use crate::imports::*; -use emulated_integration_tests_common::accounts::{ALICE, BOB}; -use frame_support::traits::fungibles::{Create, Inspect, Mutate}; +use emulated_integration_tests_common::{ + accounts::{ALICE, BOB}, + USDT_ID, +}; +use frame_support::traits::fungibles::{Inspect, Mutate}; use polkadot_runtime_common::impls::VersionedLocatableAsset; use xcm_executor::traits::ConvertLocation; #[test] fn create_and_claim_treasury_spend() { - const ASSET_ID: u32 = 1984; - const SPEND_AMOUNT: u128 = 1_000_000; + const SPEND_AMOUNT: u128 = 1_000_000_000; // treasury location from a sibling parachain. let treasury_location: Location = Location::new(1, [Parachain(CollectivesWestend::para_id().into()), PalletInstance(65)]); // treasury account on a sibling parachain. let treasury_account = - asset_hub_westend_runtime::xcm_config::LocationToAccountId::convert_location( - &treasury_location, - ) - .unwrap(); + ahw_xcm_config::LocationToAccountId::convert_location(&treasury_location).unwrap(); let asset_hub_location = Location::new(1, [Parachain(AssetHubWestend::para_id().into())]); let root = ::RuntimeOrigin::root(); // asset kind to be spent from the treasury. let asset_kind = VersionedLocatableAsset::V4 { location: asset_hub_location, - asset_id: AssetId((PalletInstance(50), GeneralIndex(ASSET_ID.into())).into()), + asset_id: AssetId((PalletInstance(50), GeneralIndex(USDT_ID.into())).into()), }; // treasury spend beneficiary. let alice: AccountId = Westend::account_id_of(ALICE); @@ -47,16 +46,10 @@ fn create_and_claim_treasury_spend() { AssetHubWestend::execute_with(|| { type Assets = ::Assets; - // create an asset class and mint some assets to the treasury account. - assert_ok!(>::create( - ASSET_ID, - treasury_account.clone(), - true, - SPEND_AMOUNT / 2 - )); - assert_ok!(>::mint_into(ASSET_ID, &treasury_account, SPEND_AMOUNT * 4)); + // USDT created at genesis, mint some assets to the fellowship treasury account. + assert_ok!(>::mint_into(USDT_ID, &treasury_account, SPEND_AMOUNT * 4)); // beneficiary has zero balance. - assert_eq!(>::balance(ASSET_ID, &alice,), 0u128,); + assert_eq!(>::balance(USDT_ID, &alice,), 0u128,); }); CollectivesWestend::execute_with(|| { @@ -99,7 +92,7 @@ fn create_and_claim_treasury_spend() { AssetHubWestend, vec![ RuntimeEvent::Assets(pallet_assets::Event::Transferred { asset_id: id, from, to, amount }) => { - id: id == &ASSET_ID, + id: id == &USDT_ID, from: from == &treasury_account, to: to == &alice, amount: amount == &SPEND_AMOUNT, @@ -109,7 +102,7 @@ fn create_and_claim_treasury_spend() { ] ); // beneficiary received the assets from the treasury. - assert_eq!(>::balance(ASSET_ID, &alice,), SPEND_AMOUNT,); + assert_eq!(>::balance(USDT_ID, &alice,), SPEND_AMOUNT,); }); CollectivesWestend::execute_with(|| { diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/hybrid_transfers.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/hybrid_transfers.rs index d39c72c7c5f0d21815ca0091e9fd888b5ab54924..49dfe8d58394c9ae7b69fba75e8147e7fa94e2db 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/hybrid_transfers.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/hybrid_transfers.rs @@ -170,7 +170,7 @@ fn transfer_foreign_assets_from_asset_hub_to_para() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Rococo)]).encode(), )], )); @@ -300,7 +300,7 @@ fn transfer_foreign_assets_from_para_to_asset_hub() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Rococo)]).encode(), )], )); @@ -455,7 +455,7 @@ fn transfer_foreign_assets_from_para_to_para_through_asset_hub() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - penpal_runtime::xcm_config::CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Rococo)]).encode(), )], )); diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/mod.rs index 61eb70524fc9ae2a23e5061400c57ca719bae4e1..73b73b239a1bb54e818cad575084ae775c6f9db1 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/mod.rs @@ -13,6 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +mod claim_assets; mod fellowship_treasury; mod hybrid_transfers; mod reserve_transfer; diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/reserve_transfer.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/reserve_transfer.rs index 65d013a0eec40aa90b42a475f40dca9197f318e9..59f63d3805908d29e553b3d710e2843165edfe78 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/reserve_transfer.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/reserve_transfer.rs @@ -493,9 +493,9 @@ fn para_to_para_through_relay_limited_reserve_transfer_assets( ) } -/// Reserve Transfers of native asset from Relay Chain to the System Parachain shouldn't work +/// Reserve Transfers of native asset from Relay Chain to the Asset Hub shouldn't work #[test] -fn reserve_transfer_native_asset_from_relay_to_system_para_fails() { +fn reserve_transfer_native_asset_from_relay_to_asset_hub_fails() { // Init values for Relay Chain let signed_origin = ::RuntimeOrigin::signed(WestendSender::get().into()); let destination = Westend::child_location_of(AssetHubWestend::para_id()); @@ -526,10 +526,10 @@ fn reserve_transfer_native_asset_from_relay_to_system_para_fails() { }); } -/// Reserve Transfers of native asset from System Parachain to Relay Chain shouldn't work +/// Reserve Transfers of native asset from Asset Hub to Relay Chain shouldn't work #[test] -fn reserve_transfer_native_asset_from_system_para_to_relay_fails() { - // Init values for System Parachain +fn reserve_transfer_native_asset_from_asset_hub_to_relay_fails() { + // Init values for Asset Hub let signed_origin = ::RuntimeOrigin::signed(AssetHubWestendSender::get().into()); let destination = AssetHubWestend::parent_location(); @@ -691,10 +691,10 @@ fn reserve_transfer_native_asset_from_para_to_relay() { // ========================================================================= // ======= Reserve Transfers - Native Asset - AssetHub<>Parachain ========== // ========================================================================= -/// Reserve Transfers of native asset from System Parachain to Parachain should work +/// Reserve Transfers of native asset from Asset Hub to Parachain should work #[test] -fn reserve_transfer_native_asset_from_system_para_to_para() { - // Init values for System Parachain +fn reserve_transfer_native_asset_from_asset_hub_to_para() { + // Init values for Asset Hub let destination = AssetHubWestend::sibling_location_of(PenpalA::para_id()); let sender = AssetHubWestendSender::get(); let amount_to_send: Balance = ASSET_HUB_WESTEND_ED * 2000; @@ -749,9 +749,9 @@ fn reserve_transfer_native_asset_from_system_para_to_para() { assert!(receiver_assets_after < receiver_assets_before + amount_to_send); } -/// Reserve Transfers of native asset from Parachain to System Parachain should work +/// Reserve Transfers of native asset from Parachain to Asset Hub should work #[test] -fn reserve_transfer_native_asset_from_para_to_system_para() { +fn reserve_transfer_native_asset_from_para_to_asset_hub() { // Init values for Parachain let destination = PenpalA::sibling_location_of(AssetHubWestend::para_id()); let sender = PenpalASender::get(); @@ -768,13 +768,13 @@ fn reserve_transfer_native_asset_from_para_to_system_para() { amount_to_send * 2, ); - // Init values for System Parachain + // Init values for Asset Hub let receiver = AssetHubWestendReceiver::get(); let penpal_location_as_seen_by_ahr = AssetHubWestend::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubWestend::sovereign_account_id_of(penpal_location_as_seen_by_ahr); - // fund Parachain's SA on System Parachain with the native tokens held in reserve + // fund Parachain's SA on Asset Hub with the native tokens held in reserve AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahr.into(), amount_to_send * 2)]); // Init Test @@ -825,11 +825,11 @@ fn reserve_transfer_native_asset_from_para_to_system_para() { // ========================================================================= // ======= Reserve Transfers - Non-system Asset - AssetHub<>Parachain ====== // ========================================================================= -/// Reserve Transfers of a local asset and native asset from System Parachain to Parachain should +/// Reserve Transfers of a local asset and native asset from Asset Hub to Parachain should /// work #[test] -fn reserve_transfer_assets_from_system_para_to_para() { - // Init values for System Parachain +fn reserve_transfer_multiple_assets_from_asset_hub_to_para() { + // Init values for Asset Hub let destination = AssetHubWestend::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubWestend::sovereign_account_id_of(destination.clone()); let sender = AssetHubWestendSender::get(); @@ -940,10 +940,12 @@ fn reserve_transfer_assets_from_system_para_to_para() { ); } -/// Reserve Transfers of a foreign asset and native asset from Parachain to System Para should -/// work +/// Reserve Transfers of a random asset and native asset from Parachain to Asset Hub should work +/// Receiver is empty account to show deposit works as long as transfer includes enough DOT for ED. +/// Once we have https://github.com/paritytech/polkadot-sdk/issues/5298, +/// we should do equivalent test with USDT instead of DOT. #[test] -fn reserve_transfer_assets_from_para_to_system_para() { +fn reserve_transfer_multiple_assets_from_para_to_asset_hub() { // Init values for Parachain let destination = PenpalA::sibling_location_of(AssetHubWestend::para_id()); let sender = PenpalASender::get(); @@ -966,25 +968,24 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Fund Parachain's sender account with some foreign assets PenpalA::mint_foreign_asset( penpal_asset_owner_signer.clone(), - asset_location_on_penpal, + asset_location_on_penpal.clone(), sender.clone(), asset_amount_to_send * 2, ); // Fund Parachain's sender account with some system assets PenpalA::mint_foreign_asset( penpal_asset_owner_signer, - system_asset_location_on_penpal, + system_asset_location_on_penpal.clone(), sender.clone(), fee_amount_to_send * 2, ); - // Init values for System Parachain - let receiver = AssetHubWestendReceiver::get(); + // Beneficiary is a new (empty) account + let receiver = get_account_id_from_seed::(DUMMY_EMPTY); + // Init values for Asset Hub let penpal_location_as_seen_by_ahr = AssetHubWestend::sibling_location_of(PenpalA::para_id()); let sov_penpal_on_ahr = AssetHubWestend::sovereign_account_id_of(penpal_location_as_seen_by_ahr); - let system_para_native_asset_location = RelayLocation::get(); - let system_para_foreign_asset_location = PenpalLocalReservableFromAssetHub::get(); let ah_asset_owner = AssetHubWestendAssetOwner::get(); let ah_asset_owner_signer = ::RuntimeOrigin::signed(ah_asset_owner); @@ -1019,11 +1020,11 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Query initial balances let sender_system_assets_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_native_asset_location.clone(), &sender) + >::balance(system_asset_location_on_penpal.clone(), &sender) }); let sender_foreign_assets_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_foreign_asset_location.clone(), &sender) + >::balance(asset_location_on_penpal.clone(), &sender) }); let receiver_balance_before = test.receiver.balance; let receiver_assets_before = AssetHubWestend::execute_with(|| { @@ -1040,11 +1041,11 @@ fn reserve_transfer_assets_from_para_to_system_para() { // Query final balances let sender_system_assets_after = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_native_asset_location, &sender) + >::balance(system_asset_location_on_penpal, &sender) }); let sender_foreign_assets_after = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(system_para_foreign_asset_location, &sender) + >::balance(asset_location_on_penpal, &sender) }); let receiver_balance_after = test.receiver.balance; let receiver_assets_after = AssetHubWestend::execute_with(|| { diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/send.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/send.rs index eb0e985cc0ce6f84318f763cb37e707beaeca718..761c7c12255c5890fd99e53a20b81060e2e2b8c2 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/send.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/send.rs @@ -18,7 +18,7 @@ use crate::imports::*; /// Relay Chain should be able to execute `Transact` instructions in System Parachain /// when `OriginKind::Superuser`. #[test] -fn send_transact_as_superuser_from_relay_to_system_para_works() { +fn send_transact_as_superuser_from_relay_to_asset_hub_works() { AssetHubWestend::force_create_asset_from_relay_as_root( ASSET_ID, ASSET_MIN_BALANCE, @@ -29,28 +29,25 @@ fn send_transact_as_superuser_from_relay_to_system_para_works() { } /// We tests two things here: -/// - Parachain should be able to send XCM paying its fee with system asset in the System Parachain -/// - Parachain should be able to create a new Foreign Asset in the System Parachain +/// - Parachain should be able to send XCM paying its fee at Asset Hub using system asset +/// - Parachain should be able to create a new Foreign Asset at Asset Hub #[test] -fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { +fn send_xcm_from_para_to_asset_hub_paying_fee_with_system_asset() { let para_sovereign_account = AssetHubWestend::sovereign_account_id_of( AssetHubWestend::sibling_location_of(PenpalA::para_id()), ); - let asset_location_on_penpal = v3::Location::new( + let asset_location_on_penpal = Location::new( 0, - [ - v3::Junction::PalletInstance(ASSETS_PALLET_ID), - v3::Junction::GeneralIndex(ASSET_ID.into()), - ], + [Junction::PalletInstance(ASSETS_PALLET_ID), Junction::GeneralIndex(ASSET_ID.into())], ); let foreign_asset_at_asset_hub = - v3::Location::new(1, [v3::Junction::Parachain(PenpalA::para_id().into())]) + Location::new(1, [Junction::Parachain(PenpalA::para_id().into())]) .appended_with(asset_location_on_penpal) .unwrap(); // Encoded `create_asset` call to be executed in AssetHub let call = AssetHubWestend::create_foreign_asset_call( - foreign_asset_at_asset_hub, + foreign_asset_at_asset_hub.clone(), ASSET_MIN_BALANCE, para_sovereign_account.clone(), ); @@ -86,12 +83,7 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { AssetHubWestend::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; - - AssetHubWestend::assert_xcmp_queue_success(Some(Weight::from_parts( - 15_594_564_000, - 562_893, - ))); - + AssetHubWestend::assert_xcmp_queue_success(None); assert_expected_events!( AssetHubWestend, vec![ @@ -115,15 +107,15 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_system_assets_works() { } /// We tests two things here: -/// - Parachain should be able to send XCM paying its fee with system assets in the System Parachain -/// - Parachain should be able to create a new Asset in the System Parachain +/// - Parachain should be able to send XCM paying its fee at Asset Hub using sufficient asset +/// - Parachain should be able to create a new Asset at Asset Hub #[test] -fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() { +fn send_xcm_from_para_to_asset_hub_paying_fee_with_sufficient_asset() { let para_sovereign_account = AssetHubWestend::sovereign_account_id_of( AssetHubWestend::sibling_location_of(PenpalA::para_id()), ); - // Force create and mint assets for Parachain's sovereign account + // Force create and mint sufficient assets for Parachain's sovereign account AssetHubWestend::force_create_and_mint_asset( ASSET_ID, ASSET_MIN_BALANCE, @@ -170,12 +162,7 @@ fn send_xcm_from_para_to_system_para_paying_fee_with_assets_works() { AssetHubWestend::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; - - AssetHubWestend::assert_xcmp_queue_success(Some(Weight::from_parts( - 15_594_564_000, - 562_893, - ))); - + AssetHubWestend::assert_xcmp_queue_success(None); assert_expected_events!( AssetHubWestend, vec![ diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/swap.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/swap.rs index f6b6580988658f5fadead0250a6bcc886c9f125d..1a2821452155db77eca049f490a7ce6cacd873d0 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/swap.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/swap.rs @@ -17,15 +17,13 @@ use crate::imports::*; #[test] fn swap_locally_on_chain_using_local_assets() { - let asset_native = Box::new( - v3::Location::try_from(asset_hub_westend_runtime::xcm_config::WestendLocation::get()) - .expect("conversion works"), - ); - let asset_one = Box::new(v3::Location { + let asset_native = + Box::new(Location::try_from(RelayLocation::get()).expect("conversion works")); + let asset_one = Box::new(Location { parents: 0, interior: [ - v3::Junction::PalletInstance(ASSETS_PALLET_ID), - v3::Junction::GeneralIndex(ASSET_ID.into()), + Junction::PalletInstance(ASSETS_PALLET_ID), + Junction::GeneralIndex(ASSET_ID.into()), ] .into(), }); @@ -114,11 +112,11 @@ fn swap_locally_on_chain_using_local_assets() { #[test] fn swap_locally_on_chain_using_foreign_assets() { - let asset_native = Box::new(v3::Location::try_from(RelayLocation::get()).unwrap()); + let asset_native = Box::new(Location::try_from(RelayLocation::get()).unwrap()); let asset_location_on_penpal = - v3::Location::try_from(PenpalLocalTeleportableToAssetHub::get()).expect("conversion_works"); + Location::try_from(PenpalLocalTeleportableToAssetHub::get()).expect("conversion_works"); let foreign_asset_at_asset_hub_westend = - v3::Location::new(1, [v3::Junction::Parachain(PenpalA::para_id().into())]) + Location::new(1, [Junction::Parachain(PenpalA::para_id().into())]) .appended_with(asset_location_on_penpal) .unwrap(); @@ -143,7 +141,7 @@ fn swap_locally_on_chain_using_foreign_assets() { // 1. Mint foreign asset (in reality this should be a teleport or some such) assert_ok!(::ForeignAssets::mint( ::RuntimeOrigin::signed(sov_penpal_on_ahr.clone().into()), - foreign_asset_at_asset_hub_westend, + foreign_asset_at_asset_hub_westend.clone(), sov_penpal_on_ahr.clone().into(), ASSET_HUB_WESTEND_ED * 3_000_000_000_000, )); @@ -159,7 +157,7 @@ fn swap_locally_on_chain_using_foreign_assets() { assert_ok!(::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubWestendSender::get()), asset_native.clone(), - Box::new(foreign_asset_at_asset_hub_westend), + Box::new(foreign_asset_at_asset_hub_westend.clone()), )); assert_expected_events!( @@ -173,7 +171,7 @@ fn swap_locally_on_chain_using_foreign_assets() { assert_ok!(::AssetConversion::add_liquidity( ::RuntimeOrigin::signed(sov_penpal_on_ahr.clone()), asset_native.clone(), - Box::new(foreign_asset_at_asset_hub_westend), + Box::new(foreign_asset_at_asset_hub_westend.clone()), 1_000_000_000_000_000, 2_000_000_000_000_000, 0, @@ -191,7 +189,7 @@ fn swap_locally_on_chain_using_foreign_assets() { ); // 4. Swap! - let path = vec![asset_native.clone(), Box::new(foreign_asset_at_asset_hub_westend)]; + let path = vec![asset_native.clone(), Box::new(foreign_asset_at_asset_hub_westend.clone())]; assert_ok!( ::AssetConversion::swap_exact_tokens_for_tokens( @@ -229,12 +227,12 @@ fn swap_locally_on_chain_using_foreign_assets() { #[test] fn cannot_create_pool_from_pool_assets() { - let asset_native = asset_hub_westend_runtime::xcm_config::WestendLocation::get(); - let mut asset_one = asset_hub_westend_runtime::xcm_config::PoolAssetsPalletLocation::get(); + let asset_native = RelayLocation::get(); + let mut asset_one = ahw_xcm_config::PoolAssetsPalletLocation::get(); asset_one.append_with(GeneralIndex(ASSET_ID.into())).expect("pool assets"); AssetHubWestend::execute_with(|| { - let pool_owner_account_id = asset_hub_westend_runtime::AssetConversionOrigin::get(); + let pool_owner_account_id = AssetHubWestendAssetConversionOrigin::get(); assert_ok!(::PoolAssets::create( ::RuntimeOrigin::signed(pool_owner_account_id.clone()), @@ -254,8 +252,8 @@ fn cannot_create_pool_from_pool_assets() { assert_matches::assert_matches!( ::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubWestendSender::get()), - Box::new(v3::Location::try_from(asset_native).expect("conversion works")), - Box::new(v3::Location::try_from(asset_one).expect("conversion works")), + Box::new(Location::try_from(asset_native).expect("conversion works")), + Box::new(Location::try_from(asset_one).expect("conversion works")), ), Err(DispatchError::Module(ModuleError{index: _, error: _, message})) => assert_eq!(message, Some("Unknown")) ); @@ -264,14 +262,12 @@ fn cannot_create_pool_from_pool_assets() { #[test] fn pay_xcm_fee_with_some_asset_swapped_for_native() { - let asset_native = - v3::Location::try_from(asset_hub_westend_runtime::xcm_config::WestendLocation::get()) - .expect("conversion works"); - let asset_one = xcm::v3::Location { + let asset_native = Location::try_from(RelayLocation::get()).expect("conversion works"); + let asset_one = Location { parents: 0, interior: [ - xcm::v3::Junction::PalletInstance(ASSETS_PALLET_ID), - xcm::v3::Junction::GeneralIndex(ASSET_ID.into()), + Junction::PalletInstance(ASSETS_PALLET_ID), + Junction::GeneralIndex(ASSET_ID.into()), ] .into(), }; @@ -300,8 +296,8 @@ fn pay_xcm_fee_with_some_asset_swapped_for_native() { assert_ok!(::AssetConversion::create_pool( ::RuntimeOrigin::signed(AssetHubWestendSender::get()), - Box::new(asset_native), - Box::new(asset_one), + Box::new(asset_native.clone()), + Box::new(asset_one.clone()), )); assert_expected_events!( diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/teleport.rs index a524b87b2daf3a1352af1ea33b64282c2f4a8137..15d39858acca4b099cd0215a55d017b42a695dda 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/teleport.rs @@ -15,53 +15,6 @@ use crate::imports::*; -fn relay_origin_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - Westend::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(631_531_000, 7_186))); - - assert_expected_events!( - Westend, - vec![ - // Amount to teleport is withdrawn from Sender - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == t.sender.account_id, - amount: *amount == t.args.amount, - }, - // Amount to teleport is deposited in Relay's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - ] - ); -} - -fn relay_dest_assertions(t: SystemParaToRelayTest) { - type RuntimeEvent = ::RuntimeEvent; - - Westend::assert_ump_queue_processed( - true, - Some(AssetHubWestend::para_id()), - Some(Weight::from_parts(307_225_000, 7_186)), - ); - - assert_expected_events!( - Westend, - vec![ - // Amount is withdrawn from Relay Chain's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - fn relay_dest_assertions_fail(_t: SystemParaToRelayTest) { Westend::assert_ump_queue_processed( false, @@ -92,22 +45,6 @@ fn para_origin_assertions(t: SystemParaToRelayTest) { ); } -fn para_dest_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - AssetHubWestend::assert_dmp_queue_complete(Some(Weight::from_parts(157_718_000, 3593))); - - assert_expected_events!( - AssetHubWestend, - vec![ - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - fn penpal_to_ah_foreign_assets_sender_assertions(t: ParaToSystemParaTest) { type RuntimeEvent = ::RuntimeEvent; let system_para_native_asset_location = RelayLocation::get(); @@ -141,7 +78,6 @@ fn penpal_to_ah_foreign_assets_receiver_assertions(t: ParaToSystemParaTest) { ); let (expected_foreign_asset_id, expected_foreign_asset_amount) = non_fee_asset(&t.args.assets, t.args.fee_asset_item as usize).unwrap(); - let expected_foreign_asset_id_v3: v3::Location = expected_foreign_asset_id.try_into().unwrap(); AssetHubWestend::assert_xcmp_queue_success(None); @@ -159,7 +95,7 @@ fn penpal_to_ah_foreign_assets_receiver_assertions(t: ParaToSystemParaTest) { who: *who == t.receiver.account_id, }, RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, amount }) => { - asset_id: *asset_id == expected_foreign_asset_id_v3, + asset_id: *asset_id == expected_foreign_asset_id, owner: *owner == t.receiver.account_id, amount: *amount == expected_foreign_asset_amount, }, @@ -173,7 +109,6 @@ fn ah_to_penpal_foreign_assets_sender_assertions(t: SystemParaToParaTest) { AssetHubWestend::assert_xcm_pallet_attempted_complete(None); let (expected_foreign_asset_id, expected_foreign_asset_amount) = non_fee_asset(&t.args.assets, t.args.fee_asset_item as usize).unwrap(); - let expected_foreign_asset_id_v3: v3::Location = expected_foreign_asset_id.try_into().unwrap(); assert_expected_events!( AssetHubWestend, vec![ @@ -189,7 +124,7 @@ fn ah_to_penpal_foreign_assets_sender_assertions(t: SystemParaToParaTest) { }, // foreign asset is burned locally as part of teleportation RuntimeEvent::ForeignAssets(pallet_assets::Event::Burned { asset_id, owner, balance }) => { - asset_id: *asset_id == expected_foreign_asset_id_v3, + asset_id: *asset_id == expected_foreign_asset_id, owner: *owner == t.sender.account_id, balance: *balance == expected_foreign_asset_amount, }, @@ -232,17 +167,6 @@ fn ah_to_penpal_foreign_assets_receiver_assertions(t: SystemParaToParaTest) { ); } -fn relay_limited_teleport_assets(t: RelayToSystemParaTest) -> DispatchResult { - ::XcmPallet::limited_teleport_assets( - t.signed_origin, - bx!(t.args.dest.into()), - bx!(t.args.beneficiary.into()), - bx!(t.args.assets.into()), - t.args.fee_asset_item, - t.args.weight_limit, - ) -} - fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResult { ::PolkadotXcm::limited_teleport_assets( t.signed_origin, @@ -276,90 +200,41 @@ fn system_para_to_para_transfer_assets(t: SystemParaToParaTest) -> DispatchResul ) } -/// Limited Teleport of native asset from Relay Chain to the System Parachain should work #[test] -fn limited_teleport_native_assets_from_relay_to_system_para_works() { - // Init values for Relay Chain - let amount_to_send: Balance = WESTEND_ED * 1000; - let dest = Westend::child_location_of(AssetHubWestend::para_id()); - let beneficiary_id = AssetHubWestendReceiver::get(); - let test_args = TestContext { - sender: WestendSender::get(), - receiver: AssetHubWestendReceiver::get(), - args: TestArgs::new_relay(dest, beneficiary_id, amount_to_send), - }; - - let mut test = RelayToSystemParaTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(relay_origin_assertions); - test.set_assertion::(para_dest_assertions); - test.set_dispatchable::(relay_limited_teleport_assets); - test.assert(); - - let delivery_fees = Westend::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; +fn teleport_to_other_system_parachains_works() { + let amount = ASSET_HUB_WESTEND_ED * 100; + let native_asset: Assets = (Parent, amount).into(); - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); + test_parachain_is_trusted_teleporter!( + AssetHubWestend, // Origin + AssetHubWestendXcmConfig, // XCM Configuration + vec![BridgeHubWestend], // Destinations + (native_asset, amount) + ); } -/// Limited Teleport of native asset from System Parachain to Relay Chain -/// should work when there is enough balance in Relay Chain's `CheckAccount` #[test] -fn limited_teleport_native_assets_back_from_system_para_to_relay_works() { - // Dependency - Relay Chain's `CheckAccount` should have enough balance - limited_teleport_native_assets_from_relay_to_system_para_works(); - - // Init values for Relay Chain - let amount_to_send: Balance = ASSET_HUB_WESTEND_ED * 1000; - let destination = AssetHubWestend::parent_location(); - let beneficiary_id = WestendReceiver::get(); - let assets = (Parent, amount_to_send).into(); - - let test_args = TestContext { - sender: AssetHubWestendSender::get(), - receiver: WestendReceiver::get(), - args: TestArgs::new_para(destination, beneficiary_id, amount_to_send, assets, None, 0), - }; - - let mut test = SystemParaToRelayTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(para_origin_assertions); - test.set_assertion::(relay_dest_assertions); - test.set_dispatchable::(system_para_limited_teleport_assets); - test.assert(); +fn teleport_from_and_to_relay() { + let amount = WESTEND_ED * 100; + let native_asset: Assets = (Here, amount).into(); - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - let delivery_fees = AssetHubWestend::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); + test_relay_is_trusted_teleporter!( + Westend, + WestendXcmConfig, + vec![AssetHubWestend], + (native_asset, amount) + ); - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); + test_parachain_is_trusted_teleporter_for_relay!( + AssetHubWestend, + AssetHubWestendXcmConfig, + Westend, + amount + ); } /// Limited Teleport of native asset from System Parachain to Relay Chain -/// should't work when there is not enough balance in Relay Chain's `CheckAccount` +/// shouldn't work when there is not enough balance in Relay Chain's `CheckAccount` #[test] fn limited_teleport_native_assets_from_system_para_to_relay_fails() { // Init values for Relay Chain @@ -399,19 +274,6 @@ fn limited_teleport_native_assets_from_system_para_to_relay_fails() { assert_eq!(receiver_balance_after, receiver_balance_before); } -#[test] -fn teleport_to_other_system_parachains_works() { - let amount = ASSET_HUB_WESTEND_ED * 100; - let native_asset: Assets = (Parent, amount).into(); - - test_parachain_is_trusted_teleporter!( - AssetHubWestend, // Origin - AssetHubWestendXcmConfig, // XCM Configuration - vec![BridgeHubWestend], // Destinations - (native_asset, amount) - ); -} - /// Bidirectional teleports of local Penpal assets to Asset Hub as foreign assets while paying /// fees using (reserve transferred) native asset. pub fn do_bidirectional_teleport_foreign_assets_between_para_and_asset_hub_using_xt( diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/treasury.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/treasury.rs index 6d8c0f5e5de6ae70559f5d60545959db5e74f735..b70967184387a868b4bd2b49970f8e16d418d62d 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/treasury.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/treasury.rs @@ -14,29 +14,28 @@ // limitations under the License. use crate::imports::*; -use emulated_integration_tests_common::accounts::{ALICE, BOB}; -use frame_support::traits::fungibles::{Create, Inspect, Mutate}; +use emulated_integration_tests_common::{ + accounts::{ALICE, BOB}, + USDT_ID, +}; +use frame_support::traits::fungibles::{Inspect, Mutate}; use polkadot_runtime_common::impls::VersionedLocatableAsset; use xcm_executor::traits::ConvertLocation; #[test] fn create_and_claim_treasury_spend() { - const ASSET_ID: u32 = 1984; - const SPEND_AMOUNT: u128 = 1_000_000; + const SPEND_AMOUNT: u128 = 1_000_000_000; // treasury location from a sibling parachain. let treasury_location: Location = Location::new(1, PalletInstance(37)); // treasury account on a sibling parachain. let treasury_account = - asset_hub_westend_runtime::xcm_config::LocationToAccountId::convert_location( - &treasury_location, - ) - .unwrap(); + ahw_xcm_config::LocationToAccountId::convert_location(&treasury_location).unwrap(); let asset_hub_location = Location::new(0, Parachain(AssetHubWestend::para_id().into())); let root = ::RuntimeOrigin::root(); // asset kind to be spend from the treasury. let asset_kind = VersionedLocatableAsset::V4 { location: asset_hub_location, - asset_id: AssetId([PalletInstance(50), GeneralIndex(ASSET_ID.into())].into()), + asset_id: AssetId([PalletInstance(50), GeneralIndex(USDT_ID.into())].into()), }; // treasury spend beneficiary. let alice: AccountId = Westend::account_id_of(ALICE); @@ -46,16 +45,10 @@ fn create_and_claim_treasury_spend() { AssetHubWestend::execute_with(|| { type Assets = ::Assets; - // create an asset class and mint some assets to the treasury account. - assert_ok!(>::create( - ASSET_ID, - treasury_account.clone(), - true, - SPEND_AMOUNT / 2 - )); - assert_ok!(>::mint_into(ASSET_ID, &treasury_account, SPEND_AMOUNT * 4)); + // USDT created at genesis, mint some assets to the treasury account. + assert_ok!(>::mint_into(USDT_ID, &treasury_account, SPEND_AMOUNT * 4)); // beneficiary has zero balance. - assert_eq!(>::balance(ASSET_ID, &alice,), 0u128,); + assert_eq!(>::balance(USDT_ID, &alice,), 0u128,); }); Westend::execute_with(|| { @@ -97,7 +90,7 @@ fn create_and_claim_treasury_spend() { AssetHubWestend, vec![ RuntimeEvent::Assets(pallet_assets::Event::Transferred { asset_id: id, from, to, amount }) => { - id: id == &ASSET_ID, + id: id == &USDT_ID, from: from == &treasury_account, to: to == &alice, amount: amount == &SPEND_AMOUNT, @@ -107,7 +100,7 @@ fn create_and_claim_treasury_spend() { ] ); // beneficiary received the assets from the treasury. - assert_eq!(>::balance(ASSET_ID, &alice,), SPEND_AMOUNT,); + assert_eq!(>::balance(USDT_ID, &alice,), SPEND_AMOUNT,); }); Westend::execute_with(|| { diff --git a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs index aeec9b44dab4ce7648e609e13136c381a5a50695..037d6604ea4d5e665928b5629dce3a52abb30a8a 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/assets/asset-hub-westend/src/tests/xcm_fee_estimation.rs @@ -17,105 +17,111 @@ use crate::imports::*; -use sp_keyring::AccountKeyring::Alice; -use sp_runtime::{generic, MultiSignature}; -use xcm_fee_payment_runtime_api::{ - dry_run::runtime_decl_for_xcm_dry_run_api::XcmDryRunApiV1, +use frame_support::{ + dispatch::RawOrigin, + sp_runtime::{traits::Dispatchable, DispatchResult}, +}; +use xcm_runtime_apis::{ + dry_run::runtime_decl_for_dry_run_api::DryRunApiV1, fees::runtime_decl_for_xcm_payment_api::XcmPaymentApiV1, }; -/// We are able to dry-run and estimate the fees for a teleport between relay and system para. -/// Scenario: Alice on Westend relay chain wants to teleport WND to Asset Hub. -/// We want to know the fees using the `XcmDryRunApi` and `XcmPaymentApi`. -#[test] -fn teleport_relay_system_para_works() { - let destination: Location = Parachain(1000).into(); // Asset Hub. - let beneficiary_id = AssetHubWestendReceiver::get(); - let beneficiary: Location = AccountId32 { id: beneficiary_id.clone().into(), network: None } // Test doesn't allow specifying a network here. - .into(); // Beneficiary in Asset Hub. - let teleport_amount = 1_000_000_000_000; // One WND (12 decimals). - let assets: Assets = vec![(Here, teleport_amount).into()].into(); - - // We get them from the Westend closure. - let mut delivery_fees_amount = 0; - let mut remote_message = VersionedXcm::V4(Xcm(Vec::new())); - ::new_ext().execute_with(|| { - type Runtime = ::Runtime; - type RuntimeCall = ::RuntimeCall; - - let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets { - dest: Box::new(VersionedLocation::V4(destination.clone())), - beneficiary: Box::new(VersionedLocation::V4(beneficiary)), - assets: Box::new(VersionedAssets::V4(assets)), - fee_asset_item: 0, - weight_limit: Unlimited, - }); - let sender = Alice; // Is the same as `WestendSender`. - let extrinsic = construct_extrinsic_westend(sender, call); - let result = Runtime::dry_run_extrinsic(extrinsic).unwrap(); - assert_eq!(result.forwarded_xcms.len(), 1); - let (destination_to_query, messages_to_query) = &result.forwarded_xcms[0]; - assert_eq!(messages_to_query.len(), 1); - remote_message = messages_to_query[0].clone(); - let delivery_fees = - Runtime::query_delivery_fees(destination_to_query.clone(), remote_message.clone()) - .unwrap(); - delivery_fees_amount = get_amount_from_versioned_assets(delivery_fees); - }); - - // This is set in the AssetHubWestend closure. - let mut remote_execution_fees = 0; - ::execute_with(|| { - type Runtime = ::Runtime; - - let weight = Runtime::query_xcm_weight(remote_message.clone()).unwrap(); - remote_execution_fees = - Runtime::query_weight_to_asset_fee(weight, VersionedAssetId::V4(Parent.into())) - .unwrap(); - }); - - let test_args = TestContext { - sender: WestendSender::get(), // Alice. - receiver: AssetHubWestendReceiver::get(), // Bob in Asset Hub. - args: TestArgs::new_relay(destination, beneficiary_id, teleport_amount), - }; - let mut test = RelayToSystemParaTest::new(test_args); +fn sender_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + PenpalA::assert_xcm_pallet_attempted_complete(None); + + assert_expected_events!( + PenpalA, + vec![ + RuntimeEvent::ForeignAssets( + pallet_assets::Event::Burned { asset_id, owner, balance } + ) => { + asset_id: *asset_id == Location::new(1, []), + owner: *owner == test.sender.account_id, + balance: *balance == test.args.amount, + }, + ] + ); +} - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - assert_eq!(sender_balance_before, 1_000_000_000_000_000_000); - assert_eq!(receiver_balance_before, 4_096_000_000_000); +fn hop_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + AssetHubWestend::assert_xcmp_queue_success(None); + + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::Balances( + pallet_balances::Event::Burned { amount, .. } + ) => { + amount: *amount == test.args.amount, + }, + ] + ); +} - test.set_dispatchable::(transfer_assets); - test.assert(); +fn receiver_assertions(test: ParaToParaThroughAHTest) { + type RuntimeEvent = ::RuntimeEvent; + PenpalB::assert_xcmp_queue_success(None); + + assert_expected_events!( + PenpalB, + vec![ + RuntimeEvent::ForeignAssets( + pallet_assets::Event::Issued { asset_id, owner, .. } + ) => { + asset_id: *asset_id == Location::new(1, []), + owner: *owner == test.receiver.account_id, + }, + ] + ); +} - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; +fn transfer_assets_para_to_para_through_ah_dispatchable( + test: ParaToParaThroughAHTest, +) -> DispatchResult { + let call = transfer_assets_para_to_para_through_ah_call(test.clone()); + match call.dispatch(test.signed_origin) { + Ok(_) => Ok(()), + Err(error_with_post_info) => Err(error_with_post_info.error), + } +} - // We now know the exact fees. - assert_eq!( - sender_balance_after, - sender_balance_before - delivery_fees_amount - teleport_amount - ); - assert_eq!( - receiver_balance_after, - receiver_balance_before + teleport_amount - remote_execution_fees - ); +fn transfer_assets_para_to_para_through_ah_call( + test: ParaToParaThroughAHTest, +) -> ::RuntimeCall { + type RuntimeCall = ::RuntimeCall; + + let asset_hub_location: Location = PenpalB::sibling_location_of(AssetHubWestend::para_id()); + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(test.args.assets.len() as u32)), + beneficiary: test.args.beneficiary, + }]); + RuntimeCall::PolkadotXcm(pallet_xcm::Call::transfer_assets_using_type_and_then { + dest: bx!(test.args.dest.into()), + assets: bx!(test.args.assets.clone().into()), + assets_transfer_type: bx!(TransferType::RemoteReserve(asset_hub_location.clone().into())), + remote_fees_id: bx!(VersionedAssetId::V4(AssetId(Location::new(1, [])))), + fees_transfer_type: bx!(TransferType::RemoteReserve(asset_hub_location.into())), + custom_xcm_on_dest: bx!(VersionedXcm::from(custom_xcm_on_dest)), + weight_limit: test.args.weight_limit, + }) } /// We are able to dry-run and estimate the fees for a multi-hop XCM journey. /// Scenario: Alice on PenpalA has some WND and wants to send them to PenpalB. -/// We want to know the fees using the `XcmDryRunApi` and `XcmPaymentApi`. +/// We want to know the fees using the `DryRunApi` and `XcmPaymentApi`. #[test] fn multi_hop_works() { let destination = PenpalA::sibling_location_of(PenpalB::para_id()); let sender = PenpalASender::get(); - let amount_to_send = 1_000_000_000_000; // One WND (12 decimals). + let amount_to_send = 1_000_000_000_000; let asset_owner = PenpalAssetOwner::get(); let assets: Assets = (Parent, amount_to_send).into(); - let relay_native_asset_location = RelayLocation::get(); - let sender_as_seen_by_relay = Westend::child_location_of(PenpalA::para_id()); - let sov_of_sender_on_relay = Westend::sovereign_account_id_of(sender_as_seen_by_relay.clone()); + let relay_native_asset_location = Location::parent(); + let sender_as_seen_by_ah = AssetHubWestend::sibling_location_of(PenpalA::para_id()); + let sov_of_sender_on_ah = + AssetHubWestend::sovereign_account_id_of(sender_as_seen_by_ah.clone()); // fund Parachain's sender account PenpalA::mint_foreign_asset( @@ -125,36 +131,44 @@ fn multi_hop_works() { amount_to_send * 2, ); - // fund the Parachain Origin's SA on Relay Chain with the native tokens held in reserve - Westend::fund_accounts(vec![(sov_of_sender_on_relay.clone().into(), amount_to_send * 2)]); + // fund the Parachain Origin's SA on AssetHub with the native tokens held in reserve. + AssetHubWestend::fund_accounts(vec![(sov_of_sender_on_ah.clone(), amount_to_send * 2)]); // Init values for Parachain Destination let beneficiary_id = PenpalBReceiver::get(); - let beneficiary: Location = AccountId32 { - id: beneficiary_id.clone().into(), - network: None, // Test doesn't allow specifying a network here. - } - .into(); + + let test_args = TestContext { + sender: PenpalASender::get(), // Bob in PenpalB. + receiver: PenpalBReceiver::get(), // Alice. + args: TestArgs::new_para( + destination, + beneficiary_id.clone(), + amount_to_send, + assets, + None, + 0, + ), + }; + let mut test = ParaToParaThroughAHTest::new(test_args); // We get them from the PenpalA closure. let mut delivery_fees_amount = 0; let mut remote_message = VersionedXcm::V4(Xcm(Vec::new())); ::execute_with(|| { type Runtime = ::Runtime; - type RuntimeCall = ::RuntimeCall; - - let call = RuntimeCall::PolkadotXcm(pallet_xcm::Call::transfer_assets { - dest: Box::new(VersionedLocation::V4(destination.clone())), - beneficiary: Box::new(VersionedLocation::V4(beneficiary)), - assets: Box::new(VersionedAssets::V4(assets.clone())), - fee_asset_item: 0, - weight_limit: Unlimited, - }); - let sender = Alice; // Same as `PenpalASender`. - let extrinsic = construct_extrinsic_penpal(sender, call); - let result = Runtime::dry_run_extrinsic(extrinsic).unwrap(); - assert_eq!(result.forwarded_xcms.len(), 1); - let (destination_to_query, messages_to_query) = &result.forwarded_xcms[0]; + type OriginCaller = ::OriginCaller; + + let call = transfer_assets_para_to_para_through_ah_call(test.clone()); + let origin = OriginCaller::system(RawOrigin::Signed(sender.clone())); + let result = Runtime::dry_run_call(origin, call).unwrap(); + // We filter the result to get only the messages we are interested in. + let (destination_to_query, messages_to_query) = &result + .forwarded_xcms + .iter() + .find(|(destination, _)| { + *destination == VersionedLocation::V4(Location::new(1, [Parachain(1000)])) + }) + .unwrap(); assert_eq!(messages_to_query.len(), 1); remote_message = messages_to_query[0].clone(); let delivery_fees = @@ -163,18 +177,21 @@ fn multi_hop_works() { delivery_fees_amount = get_amount_from_versioned_assets(delivery_fees); }); - // This is set in the Westend closure. + // These are set in the AssetHub closure. let mut intermediate_execution_fees = 0; let mut intermediate_delivery_fees_amount = 0; let mut intermediate_remote_message = VersionedXcm::V4(Xcm::<()>(Vec::new())); - ::execute_with(|| { - type Runtime = ::Runtime; - type RuntimeCall = ::RuntimeCall; + ::execute_with(|| { + type Runtime = ::Runtime; + type RuntimeCall = ::RuntimeCall; // First we get the execution fees. let weight = Runtime::query_xcm_weight(remote_message.clone()).unwrap(); - intermediate_execution_fees = - Runtime::query_weight_to_asset_fee(weight, VersionedAssetId::V4(Here.into())).unwrap(); + intermediate_execution_fees = Runtime::query_weight_to_asset_fee( + weight, + VersionedAssetId::V4(Location::new(1, []).into()), + ) + .unwrap(); // We have to do this to turn `VersionedXcm<()>` into `VersionedXcm`. let xcm_program = @@ -182,8 +199,14 @@ fn multi_hop_works() { // Now we get the delivery fees to the final destination. let result = - Runtime::dry_run_xcm(sender_as_seen_by_relay.clone().into(), xcm_program).unwrap(); - let (destination_to_query, messages_to_query) = &result.forwarded_xcms[0]; + Runtime::dry_run_xcm(sender_as_seen_by_ah.clone().into(), xcm_program).unwrap(); + let (destination_to_query, messages_to_query) = &result + .forwarded_xcms + .iter() + .find(|(destination, _)| { + *destination == VersionedLocation::V4(Location::new(1, [Parachain(2001)])) + }) + .unwrap(); // There's actually two messages here. // One created when the message we sent from PenpalA arrived and was executed. // The second one when we dry-run the xcm. @@ -201,7 +224,7 @@ fn multi_hop_works() { // Get the final execution fees in the destination. let mut final_execution_fees = 0; ::execute_with(|| { - type Runtime = ::Runtime; + type Runtime = ::Runtime; let weight = Runtime::query_xcm_weight(intermediate_remote_message.clone()).unwrap(); final_execution_fees = @@ -211,7 +234,7 @@ fn multi_hop_works() { // Dry-running is done. PenpalA::reset_ext(); - Westend::reset_ext(); + AssetHubWestend::reset_ext(); PenpalB::reset_ext(); // Fund accounts again. @@ -221,23 +244,9 @@ fn multi_hop_works() { sender.clone(), amount_to_send * 2, ); - Westend::fund_accounts(vec![(sov_of_sender_on_relay.into(), amount_to_send * 2)]); + AssetHubWestend::fund_accounts(vec![(sov_of_sender_on_ah, amount_to_send * 2)]); // Actually run the extrinsic. - let test_args = TestContext { - sender: PenpalASender::get(), // Alice. - receiver: PenpalBReceiver::get(), // Bob in PenpalB. - args: TestArgs::new_para( - destination, - beneficiary_id.clone(), - amount_to_send, - assets, - None, - 0, - ), - }; - let mut test = ParaToParaThroughRelayTest::new(test_args); - let sender_assets_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; >::balance(relay_native_asset_location.clone(), &sender) @@ -247,7 +256,10 @@ fn multi_hop_works() { >::balance(relay_native_asset_location.clone(), &beneficiary_id) }); - test.set_dispatchable::(transfer_assets_para_to_para); + test.set_assertion::(sender_assertions); + test.set_assertion::(hop_assertions); + test.set_assertion::(receiver_assertions); + test.set_dispatchable::(transfer_assets_para_to_para_through_ah_dispatchable); test.assert(); let sender_assets_after = PenpalA::execute_with(|| { @@ -274,97 +286,3 @@ fn multi_hop_works() { final_execution_fees ); } - -fn get_amount_from_versioned_assets(assets: VersionedAssets) -> u128 { - let latest_assets: Assets = assets.try_into().unwrap(); - let Fungible(amount) = latest_assets.inner()[0].fun else { - unreachable!("asset is fungible"); - }; - amount -} - -fn transfer_assets(test: RelayToSystemParaTest) -> DispatchResult { - ::XcmPallet::transfer_assets( - test.signed_origin, - bx!(test.args.dest.into()), - bx!(test.args.beneficiary.into()), - bx!(test.args.assets.into()), - test.args.fee_asset_item, - test.args.weight_limit, - ) -} - -fn transfer_assets_para_to_para(test: ParaToParaThroughRelayTest) -> DispatchResult { - ::PolkadotXcm::transfer_assets( - test.signed_origin, - bx!(test.args.dest.into()), - bx!(test.args.beneficiary.into()), - bx!(test.args.assets.into()), - test.args.fee_asset_item, - test.args.weight_limit, - ) -} - -// Constructs the SignedExtra component of an extrinsic for the Westend runtime. -fn construct_extrinsic_westend( - sender: sp_keyring::AccountKeyring, - call: westend_runtime::RuntimeCall, -) -> westend_runtime::UncheckedExtrinsic { - type Runtime = ::Runtime; - let account_id = ::AccountId::from(sender.public()); - let tip = 0; - let extra: westend_runtime::SignedExtra = ( - frame_system::CheckNonZeroSender::::new(), - frame_system::CheckSpecVersion::::new(), - frame_system::CheckTxVersion::::new(), - frame_system::CheckGenesis::::new(), - frame_system::CheckMortality::::from(sp_runtime::generic::Era::immortal()), - frame_system::CheckNonce::::from( - frame_system::Pallet::::account(&account_id).nonce, - ), - frame_system::CheckWeight::::new(), - pallet_transaction_payment::ChargeTransactionPayment::::from(tip), - ); - let raw_payload = westend_runtime::SignedPayload::new(call, extra).unwrap(); - let signature = raw_payload.using_encoded(|payload| sender.sign(payload)); - let (call, extra, _) = raw_payload.deconstruct(); - westend_runtime::UncheckedExtrinsic::new_signed( - call, - account_id.into(), - MultiSignature::Sr25519(signature), - extra, - ) -} - -// Constructs the SignedExtra component of an extrinsic for the Westend runtime. -fn construct_extrinsic_penpal( - sender: sp_keyring::AccountKeyring, - call: penpal_runtime::RuntimeCall, -) -> penpal_runtime::UncheckedExtrinsic { - type Runtime = ::Runtime; - let account_id = ::AccountId::from(sender.public()); - let tip = 0; - let extra: penpal_runtime::SignedExtra = ( - frame_system::CheckNonZeroSender::::new(), - frame_system::CheckSpecVersion::::new(), - frame_system::CheckTxVersion::::new(), - frame_system::CheckGenesis::::new(), - frame_system::CheckEra::::from(generic::Era::immortal()), - frame_system::CheckNonce::::from( - frame_system::Pallet::::account(&account_id).nonce, - ), - frame_system::CheckWeight::::new(), - pallet_asset_tx_payment::ChargeAssetTxPayment::::from(tip, None), - ); - type SignedPayload = - generic::SignedPayload; - let raw_payload = SignedPayload::new(call, extra).unwrap(); - let signature = raw_payload.using_encoded(|payload| sender.sign(payload)); - let (call, extra, _) = raw_payload.deconstruct(); - penpal_runtime::UncheckedExtrinsic::new_signed( - call, - account_id.into(), - MultiSignature::Sr25519(signature), - extra, - ) -} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/Cargo.toml index bbe54c367baf41d183dd60f976a7951d20d8a6f2..a5787885329d75a05fe50ce18690fd6d4076db51 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/Cargo.toml @@ -11,40 +11,38 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -hex-literal = "0.4.1" +codec = { workspace = true } +scale-info = { features = ["derive"], workspace = true } +hex-literal = { workspace = true, default-features = true } # Substrate -sp-core = { path = "../../../../../../../substrate/primitives/core", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion = { path = "../../../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue" } -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } +sp-core = { workspace = true } +frame-support = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true, default-features = true } +sp-runtime = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -pallet-xcm = { path = "../../../../../../../polkadot/xcm/pallet-xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +pallet-xcm = { workspace = true } +xcm-executor = { workspace = true } # Bridges -pallet-bridge-messages = { path = "../../../../../../../bridges/modules/messages", default-features = false } +pallet-bridge-messages = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../common" } -testnet-parachains-constants = { path = "../../../../../runtimes/constants", features = ["rococo"] } -cumulus-pallet-xcmp-queue = { path = "../../../../../../pallets/xcmp-queue", default-features = false } -bridge-hub-rococo-runtime = { path = "../../../../../runtimes/bridge-hubs/bridge-hub-rococo", default-features = false } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -rococo-westend-system-emulated-network = { path = "../../../networks/rococo-westend-system" } -rococo-system-emulated-network = { path = "../../../networks/rococo-system" } -asset-hub-rococo-runtime = { path = "../../../../../runtimes/assets/asset-hub-rococo", default-features = false } +cumulus-pallet-xcmp-queue = { workspace = true } +emulated-integration-tests-common = { workspace = true } +parachains-common = { workspace = true, default-features = true } +rococo-system-emulated-network = { workspace = true } +rococo-westend-system-emulated-network = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true, default-features = true } # Snowbridge -snowbridge-core = { path = "../../../../../../../bridges/snowbridge/primitives/core", default-features = false } -snowbridge-router-primitives = { path = "../../../../../../../bridges/snowbridge/primitives/router", default-features = false } -snowbridge-pallet-system = { path = "../../../../../../../bridges/snowbridge/pallets/system", default-features = false } -snowbridge-pallet-outbound-queue = { path = "../../../../../../../bridges/snowbridge/pallets/outbound-queue", default-features = false } -snowbridge-pallet-inbound-queue-fixtures = { path = "../../../../../../../bridges/snowbridge/pallets/inbound-queue/fixtures" } +snowbridge-core = { workspace = true } +snowbridge-router-primitives = { workspace = true } +snowbridge-pallet-system = { workspace = true } +snowbridge-pallet-outbound-queue = { workspace = true } +snowbridge-pallet-inbound-queue-fixtures = { workspace = true, default-features = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/lib.rs index 0415af580ef8add90c92620e93052e356abe2de9..ac08e48ded68dacad27756ff62b55caf6a1a7f32 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/lib.rs @@ -23,7 +23,8 @@ mod imports { pub use xcm::{ latest::ParentThen, prelude::{AccountId32 as AccountId32Junction, *}, - v3::{self, NetworkId::Westend as WestendId}, + v4, + v4::NetworkId::Westend as WestendId, }; pub use xcm_executor::traits::TransferType; @@ -31,32 +32,49 @@ mod imports { pub use emulated_integration_tests_common::{ accounts::ALICE, impls::Inspect, - test_parachain_is_trusted_teleporter, + test_parachain_is_trusted_teleporter, test_parachain_is_trusted_teleporter_for_relay, + test_relay_is_trusted_teleporter, xcm_emulator::{ assert_expected_events, bx, Chain, Parachain as Para, RelayChain as Relay, TestExt, }, + ASSETS_PALLET_ID, USDT_ID, }; pub use parachains_common::AccountId; pub use rococo_westend_system_emulated_network::{ asset_hub_rococo_emulated_chain::{ - genesis::ED as ASSET_HUB_ROCOCO_ED, AssetHubRococoParaPallet as AssetHubRococoPallet, + asset_hub_rococo_runtime::xcm_config as ahr_xcm_config, + genesis::{AssetHubRococoAssetOwner, ED as ASSET_HUB_ROCOCO_ED}, + AssetHubRococoParaPallet as AssetHubRococoPallet, }, asset_hub_westend_emulated_chain::{ genesis::ED as ASSET_HUB_WESTEND_ED, AssetHubWestendParaPallet as AssetHubWestendPallet, }, bridge_hub_rococo_emulated_chain::{ - genesis::ED as BRIDGE_HUB_ROCOCO_ED, BridgeHubRococoParaPallet as BridgeHubRococoPallet, + genesis::ED as BRIDGE_HUB_ROCOCO_ED, BridgeHubRococoExistentialDeposit, + BridgeHubRococoParaPallet as BridgeHubRococoPallet, BridgeHubRococoRuntimeOrigin, + BridgeHubRococoXcmConfig, EthereumBeaconClient, EthereumInboundQueue, + }, + penpal_emulated_chain::{ + penpal_runtime::xcm_config::{ + CustomizableAssetFromSystemAssetHub as PenpalCustomizableAssetFromSystemAssetHub, + UniversalLocation as PenpalUniversalLocation, + }, + PenpalAParaPallet as PenpalAPallet, PenpalAssetOwner, + }, + rococo_emulated_chain::{ + genesis::ED as ROCOCO_ED, rococo_runtime::xcm_config::XcmConfig as RococoXcmConfig, + RococoRelayPallet as RococoPallet, }, - penpal_emulated_chain::{PenpalAParaPallet as PenpalAPallet, PenpalAssetOwner}, - rococo_emulated_chain::{genesis::ED as ROCOCO_ED, RococoRelayPallet as RococoPallet}, AssetHubRococoPara as AssetHubRococo, AssetHubRococoParaReceiver as AssetHubRococoReceiver, AssetHubRococoParaSender as AssetHubRococoSender, AssetHubWestendPara as AssetHubWestend, AssetHubWestendParaReceiver as AssetHubWestendReceiver, AssetHubWestendParaSender as AssetHubWestendSender, BridgeHubRococoPara as BridgeHubRococo, + BridgeHubRococoParaReceiver as BridgeHubRococoReceiver, BridgeHubRococoParaSender as BridgeHubRococoSender, BridgeHubWestendPara as BridgeHubWestend, PenpalAPara as PenpalA, PenpalAParaReceiver as PenpalAReceiver, PenpalAParaSender as PenpalASender, - RococoRelay as Rococo, + RococoRelay as Rococo, RococoRelayReceiver as RococoReceiver, + RococoRelaySender as RococoSender, }; pub const ASSET_MIN_BALANCE: u128 = 1000; diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/asset_transfers.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/asset_transfers.rs index 87fb70e4de23857bf929ed1a663fd2dcc3120e93..8a674f89c9ef9cdc6c5c6512d93196f96144f6a8 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/asset_transfers.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/asset_transfers.rs @@ -15,168 +15,141 @@ use crate::tests::*; -fn send_asset_from_asset_hub_rococo_to_asset_hub_westend(id: Location, amount: u128) { - let destination = asset_hub_westend_location(); - +fn send_assets_over_bridge(send_fn: F) { // fund the AHR's SA on BHR for paying bridge transport fees BridgeHubRococo::fund_para_sovereign(AssetHubRococo::para_id(), 10_000_000_000_000u128); // set XCM versions - AssetHubRococo::force_xcm_version(destination.clone(), XCM_VERSION); + let local_asset_hub = PenpalA::sibling_location_of(AssetHubRococo::para_id()); + PenpalA::force_xcm_version(local_asset_hub.clone(), XCM_VERSION); + AssetHubRococo::force_xcm_version(asset_hub_westend_location(), XCM_VERSION); BridgeHubRococo::force_xcm_version(bridge_hub_westend_location(), XCM_VERSION); // send message over bridge - assert_ok!(send_asset_from_asset_hub_rococo(destination, (id, amount))); + send_fn(); + + // process and verify intermediary hops assert_bridge_hub_rococo_message_accepted(true); assert_bridge_hub_westend_message_received(); } -fn send_asset_from_penpal_rococo_through_local_asset_hub_to_westend_asset_hub( - id: Location, - transfer_amount: u128, -) { - let destination = asset_hub_westend_location(); - let local_asset_hub: Location = PenpalA::sibling_location_of(AssetHubRococo::para_id()); - let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of( - AssetHubRococo::sibling_location_of(PenpalA::para_id()), - ); - let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( - Westend, - AssetHubWestend::para_id(), - ); - - // fund the AHR's SA on BHR for paying bridge transport fees - BridgeHubRococo::fund_para_sovereign(AssetHubRococo::para_id(), 10_000_000_000_000u128); +fn set_up_rocs_for_penpal_rococo_through_ahr_to_ahw( + sender: &AccountId, + amount: u128, +) -> (Location, v4::Location) { + let roc_at_rococo_parachains = roc_at_ah_rococo(); + let roc_at_asset_hub_westend = bridged_roc_at_ah_westend(); + create_foreign_on_ah_westend(roc_at_asset_hub_westend.clone(), true); - // set XCM versions - PenpalA::force_xcm_version(local_asset_hub.clone(), XCM_VERSION); - AssetHubRococo::force_xcm_version(destination.clone(), XCM_VERSION); - BridgeHubRococo::force_xcm_version(bridge_hub_westend_location(), XCM_VERSION); - - // send message over bridge - assert_ok!(PenpalA::execute_with(|| { - let signed_origin = ::RuntimeOrigin::signed(PenpalASender::get()); - let beneficiary: Location = - AccountId32Junction { network: None, id: AssetHubWestendReceiver::get().into() }.into(); - let assets: Assets = (id.clone(), transfer_amount).into(); - let fees_id: AssetId = id.into(); - let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { - assets: Wild(AllCounted(assets.len() as u32)), - beneficiary, - }]); + let penpal_location = AssetHubRococo::sibling_location_of(PenpalA::para_id()); + let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(penpal_location); + // fund Penpal's sovereign account on AssetHub + AssetHubRococo::fund_accounts(vec![(sov_penpal_on_ahr.into(), amount * 2)]); + // fund Penpal's sender account + PenpalA::mint_foreign_asset( + ::RuntimeOrigin::signed(PenpalAssetOwner::get()), + roc_at_rococo_parachains.clone(), + sender.clone(), + amount * 2, + ); + (roc_at_rococo_parachains, roc_at_asset_hub_westend) +} - ::PolkadotXcm::transfer_assets_using_type_and_then( - signed_origin, - bx!(destination.into()), - bx!(assets.clone().into()), - bx!(TransferType::RemoteReserve(local_asset_hub.clone().into())), - bx!(fees_id.into()), - bx!(TransferType::RemoteReserve(local_asset_hub.into())), - bx!(VersionedXcm::from(custom_xcm_on_dest)), - WeightLimit::Unlimited, - ) - })); - AssetHubRococo::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - assert_expected_events!( - AssetHubRococo, - vec![ - // Amount to reserve transfer is withdrawn from Penpal's sovereign account - RuntimeEvent::Balances( - pallet_balances::Event::Burned { who, amount } - ) => { - who: *who == sov_penpal_on_ahr.clone().into(), - amount: *amount == transfer_amount, - }, - // Amount deposited in AHW's sovereign account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == sov_ahw_on_ahr.clone().into(), - }, - RuntimeEvent::XcmpQueue( - cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. } - ) => {}, - ] +fn send_assets_from_penpal_rococo_through_rococo_ah_to_westend_ah( + destination: Location, + assets: (Assets, TransferType), + fees: (AssetId, TransferType), + custom_xcm_on_dest: Xcm<()>, +) { + send_assets_over_bridge(|| { + let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of( + AssetHubRococo::sibling_location_of(PenpalA::para_id()), ); + let sov_ahw_on_ahr = + AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( + Westend, + AssetHubWestend::para_id(), + ); + // send message over bridge + assert_ok!(PenpalA::execute_with(|| { + let signed_origin = ::RuntimeOrigin::signed(PenpalASender::get()); + ::PolkadotXcm::transfer_assets_using_type_and_then( + signed_origin, + bx!(destination.into()), + bx!(assets.0.into()), + bx!(assets.1), + bx!(fees.0.into()), + bx!(fees.1), + bx!(VersionedXcm::from(custom_xcm_on_dest)), + WeightLimit::Unlimited, + ) + })); + // verify intermediary AH Rococo hop + AssetHubRococo::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + assert_expected_events!( + AssetHubRococo, + vec![ + // Amount to reserve transfer is withdrawn from Penpal's sovereign account + RuntimeEvent::Balances( + pallet_balances::Event::Burned { who, .. } + ) => { + who: *who == sov_penpal_on_ahr.clone().into(), + }, + // Amount deposited in AHW's sovereign account + RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { + who: *who == sov_ahw_on_ahr.clone().into(), + }, + RuntimeEvent::XcmpQueue( + cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. } + ) => {}, + ] + ); + }); }); - assert_bridge_hub_rococo_message_accepted(true); - assert_bridge_hub_westend_message_received(); } #[test] -fn send_rocs_from_asset_hub_rococo_to_asset_hub_westend() { - let roc_at_asset_hub_rococo: v3::Location = v3::Parent.into(); - let roc_at_asset_hub_westend = - v3::Location::new(2, [v3::Junction::GlobalConsensus(v3::NetworkId::Rococo)]); - let owner: AccountId = AssetHubWestend::account_id_of(ALICE); - AssetHubWestend::force_create_foreign_asset( - roc_at_asset_hub_westend, - owner, - true, - ASSET_MIN_BALANCE, - vec![], - ); +/// Test transfer of ROC, USDT and wETH from AssetHub Rococo to AssetHub Westend. +/// +/// This mix of assets should cover the whole range: +/// - native assets: ROC, +/// - trust-based assets: USDT (exists only on Rococo, Westend gets it from Rococo over bridge), +/// - foreign asset / bridged asset (other bridge / Snowfork): wETH (bridged from Ethereum to Rococo +/// over Snowbridge, then bridged over to Westend through this bridge). +fn send_roc_usdt_and_weth_from_asset_hub_rococo_to_asset_hub_westend() { + let amount = ASSET_HUB_ROCOCO_ED * 1_000_000; + let sender = AssetHubRococoSender::get(); + let receiver = AssetHubWestendReceiver::get(); + let roc_at_asset_hub_rococo = roc_at_ah_rococo(); + let bridged_roc_at_asset_hub_westend = bridged_roc_at_ah_westend(); + + create_foreign_on_ah_westend(bridged_roc_at_asset_hub_westend.clone(), true); + set_up_pool_with_wnd_on_ah_westend(bridged_roc_at_asset_hub_westend.clone()); + + //////////////////////////////////////////////////////////// + // Let's first send over just some ROCs as a simple example + //////////////////////////////////////////////////////////// let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( Westend, AssetHubWestend::para_id(), ); - - AssetHubWestend::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - - // setup a pool to pay xcm fees with `roc_at_asset_hub_westend` tokens - assert_ok!(::ForeignAssets::mint( - ::RuntimeOrigin::signed(AssetHubWestendSender::get()), - roc_at_asset_hub_westend.into(), - AssetHubWestendSender::get().into(), - 3_000_000_000_000, - )); - - assert_ok!(::AssetConversion::create_pool( - ::RuntimeOrigin::signed(AssetHubWestendSender::get()), - Box::new(xcm::v3::Parent.into()), - Box::new(roc_at_asset_hub_westend), - )); - - assert_expected_events!( - AssetHubWestend, - vec![ - RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::PoolCreated { .. }) => {}, - ] - ); - - assert_ok!(::AssetConversion::add_liquidity( - ::RuntimeOrigin::signed(AssetHubWestendSender::get()), - Box::new(xcm::v3::Parent.into()), - Box::new(roc_at_asset_hub_westend), - 1_000_000_000_000, - 2_000_000_000_000, - 1, - 1, - AssetHubWestendSender::get().into() - )); - - assert_expected_events!( - AssetHubWestend, - vec![ - RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::LiquidityAdded {..}) => {}, - ] - ); - }); - let rocs_in_reserve_on_ahr_before = ::account_data_of(sov_ahw_on_ahr.clone()).free; - let sender_rocs_before = - ::account_data_of(AssetHubRococoSender::get()).free; - let receiver_rocs_before = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(roc_at_asset_hub_westend, &AssetHubWestendReceiver::get()) + let sender_rocs_before = ::account_data_of(sender.clone()).free; + let receiver_rocs_before = + foreign_balance_on_ah_westend(bridged_roc_at_asset_hub_westend.clone(), &receiver); + + // send ROCs, use them for fees + send_assets_over_bridge(|| { + let destination = asset_hub_westend_location(); + let assets: Assets = + (Location::try_from(roc_at_asset_hub_rococo.clone()).unwrap(), amount).into(); + let fee_idx = 0; + assert_ok!(send_assets_from_asset_hub_rococo(destination, assets, fee_idx)); }); - let amount = ASSET_HUB_ROCOCO_ED * 1_000_000; - send_asset_from_asset_hub_rococo_to_asset_hub_westend( - roc_at_asset_hub_rococo.try_into().unwrap(), - amount, - ); + // verify expected events on final destination AssetHubWestend::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -185,7 +158,7 @@ fn send_rocs_from_asset_hub_rococo_to_asset_hub_westend() { // issue ROCs on AHW RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, .. }) => { asset_id: *asset_id == roc_at_asset_hub_rococo, - owner: *owner == AssetHubWestendReceiver::get(), + owner: owner == &receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -195,36 +168,103 @@ fn send_rocs_from_asset_hub_rococo_to_asset_hub_westend() { ); }); - let sender_rocs_after = - ::account_data_of(AssetHubRococoSender::get()).free; - let receiver_rocs_after = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(roc_at_asset_hub_westend, &AssetHubWestendReceiver::get()) - }); + let sender_rocs_after = ::account_data_of(sender.clone()).free; + let receiver_rocs_after = + foreign_balance_on_ah_westend(bridged_roc_at_asset_hub_westend, &receiver); let rocs_in_reserve_on_ahr_after = ::account_data_of(sov_ahw_on_ahr.clone()).free; - // Sender's balance is reduced + // Sender's ROC balance is reduced assert!(sender_rocs_before > sender_rocs_after); - // Receiver's balance is increased + // Receiver's ROC balance is increased assert!(receiver_rocs_after > receiver_rocs_before); - // Reserve balance is increased by sent amount + // Reserve ROC balance is increased by sent amount assert_eq!(rocs_in_reserve_on_ahr_after, rocs_in_reserve_on_ahr_before + amount); + + ///////////////////////////////////////////////////////////// + // Now let's send over USDTs + wETH (and pay fees with USDT) + ///////////////////////////////////////////////////////////// + + let usdt_at_asset_hub_rococo = usdt_at_ah_rococo(); + let bridged_usdt_at_asset_hub_westend = bridged_usdt_at_ah_westend(); + // wETH has same relative location on both Rococo and Westend AssetHubs + let bridged_weth_at_ah = weth_at_asset_hubs(); + + // mint USDT in sender's account (USDT already created in genesis) + AssetHubRococo::mint_asset( + ::RuntimeOrigin::signed(AssetHubRococoAssetOwner::get()), + USDT_ID, + sender.clone(), + amount * 2, + ); + // create wETH at src and dest and prefund sender's account + create_foreign_on_ah_rococo( + bridged_weth_at_ah.clone(), + true, + vec![(sender.clone(), amount * 2)], + ); + create_foreign_on_ah_westend(bridged_weth_at_ah.clone(), true); + create_foreign_on_ah_westend(bridged_usdt_at_asset_hub_westend.clone(), true); + set_up_pool_with_wnd_on_ah_westend(bridged_usdt_at_asset_hub_westend.clone()); + + let receiver_usdts_before = + foreign_balance_on_ah_westend(bridged_usdt_at_asset_hub_westend.clone(), &receiver); + let receiver_weth_before = foreign_balance_on_ah_westend(bridged_weth_at_ah.clone(), &receiver); + + // send USDTs and wETHs + let assets: Assets = vec![ + (usdt_at_asset_hub_rococo.clone(), amount).into(), + (Location::try_from(bridged_weth_at_ah.clone()).unwrap(), amount).into(), + ] + .into(); + // use USDT for fees + let fee: AssetId = usdt_at_asset_hub_rococo.into(); + + // use the more involved transfer extrinsic + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(assets.len() as u32)), + beneficiary: AccountId32Junction { network: None, id: receiver.clone().into() }.into(), + }]); + assert_ok!(AssetHubRococo::execute_with(|| { + ::PolkadotXcm::transfer_assets_using_type_and_then( + ::RuntimeOrigin::signed(sender.into()), + bx!(asset_hub_westend_location().into()), + bx!(assets.into()), + bx!(TransferType::LocalReserve), + bx!(fee.into()), + bx!(TransferType::LocalReserve), + bx!(VersionedXcm::from(custom_xcm_on_dest)), + WeightLimit::Unlimited, + ) + })); + // verify hops (also advances the message through the hops) + assert_bridge_hub_rococo_message_accepted(true); + assert_bridge_hub_westend_message_received(); + AssetHubWestend::execute_with(|| { + AssetHubWestend::assert_xcmp_queue_success(None); + }); + + let receiver_usdts_after = + foreign_balance_on_ah_westend(bridged_usdt_at_asset_hub_westend, &receiver); + let receiver_weth_after = foreign_balance_on_ah_westend(bridged_weth_at_ah, &receiver); + + // Receiver's USDT balance is increased by almost `amount` (minus fees) + assert!(receiver_usdts_after > receiver_usdts_before); + assert!(receiver_usdts_after < receiver_usdts_before + amount); + // Receiver's wETH balance is increased by sent amount + assert_eq!(receiver_weth_after, receiver_weth_before + amount); } #[test] -fn send_wnds_from_asset_hub_rococo_to_asset_hub_westend() { +/// Send bridged WNDs "back" from AssetHub Rococo to AssetHub Westend. +fn send_back_wnds_from_asset_hub_rococo_to_asset_hub_westend() { let prefund_amount = 10_000_000_000_000u128; - let wnd_at_asset_hub_rococo = - v3::Location::new(2, [v3::Junction::GlobalConsensus(v3::NetworkId::Westend)]); - let owner: AccountId = AssetHubRococo::account_id_of(ALICE); - AssetHubRococo::force_create_foreign_asset( - wnd_at_asset_hub_rococo, - owner, - true, - ASSET_MIN_BALANCE, - vec![(AssetHubRococoSender::get(), prefund_amount)], - ); + let amount_to_send = ASSET_HUB_WESTEND_ED * 1_000; + let sender = AssetHubRococoSender::get(); + let receiver = AssetHubWestendReceiver::get(); + let wnd_at_asset_hub_rococo = bridged_wnd_at_ah_rococo(); + let prefund_accounts = vec![(sender.clone(), prefund_amount)]; + create_foreign_on_ah_rococo(wnd_at_asset_hub_rococo.clone(), true, prefund_accounts); // fund the AHR's SA on AHW with the WND tokens held in reserve let sov_ahr_on_ahw = AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( @@ -236,19 +276,19 @@ fn send_wnds_from_asset_hub_rococo_to_asset_hub_westend() { let wnds_in_reserve_on_ahw_before = ::account_data_of(sov_ahr_on_ahw.clone()).free; assert_eq!(wnds_in_reserve_on_ahw_before, prefund_amount); - let sender_wnds_before = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(wnd_at_asset_hub_rococo, &AssetHubRococoSender::get()) - }); + + let sender_wnds_before = foreign_balance_on_ah_rococo(wnd_at_asset_hub_rococo.clone(), &sender); assert_eq!(sender_wnds_before, prefund_amount); - let receiver_wnds_before = - ::account_data_of(AssetHubWestendReceiver::get()).free; + let receiver_wnds_before = ::account_data_of(receiver.clone()).free; + + // send back WNDs, use them for fees + send_assets_over_bridge(|| { + let destination = asset_hub_westend_location(); + let assets: Assets = (wnd_at_asset_hub_rococo.clone(), amount_to_send).into(); + let fee_idx = 0; + assert_ok!(send_assets_from_asset_hub_rococo(destination, assets, fee_idx)); + }); - let amount_to_send = ASSET_HUB_WESTEND_ED * 1_000; - send_asset_from_asset_hub_rococo_to_asset_hub_westend( - Location::try_from(wnd_at_asset_hub_rococo).unwrap(), - amount_to_send, - ); AssetHubWestend::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -263,7 +303,7 @@ fn send_wnds_from_asset_hub_rococo_to_asset_hub_westend() { }, // WNDs deposited to beneficiary RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == AssetHubWestendReceiver::get(), + who: who == &receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -273,12 +313,8 @@ fn send_wnds_from_asset_hub_rococo_to_asset_hub_westend() { ); }); - let sender_wnds_after = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(wnd_at_asset_hub_rococo, &AssetHubRococoSender::get()) - }); - let receiver_wnds_after = - ::account_data_of(AssetHubWestendReceiver::get()).free; + let sender_wnds_after = foreign_balance_on_ah_rococo(wnd_at_asset_hub_rococo, &sender); + let receiver_wnds_after = ::account_data_of(receiver).free; let wnds_in_reserve_on_ahw_after = ::account_data_of(sov_ahr_on_ahw).free; @@ -292,55 +328,48 @@ fn send_wnds_from_asset_hub_rococo_to_asset_hub_westend() { #[test] fn send_rocs_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_westend() { - let roc_at_rococo_parachains: Location = Parent.into(); - let roc_at_asset_hub_westend = Location::new(2, [Junction::GlobalConsensus(NetworkId::Rococo)]); - let owner: AccountId = AssetHubWestend::account_id_of(ALICE); - AssetHubWestend::force_create_foreign_asset( - roc_at_asset_hub_westend.clone().try_into().unwrap(), - owner, - true, - ASSET_MIN_BALANCE, - vec![], - ); + let amount = ASSET_HUB_ROCOCO_ED * 10_000_000; + let sender = PenpalASender::get(); + let receiver = AssetHubWestendReceiver::get(); + let local_asset_hub = PenpalA::sibling_location_of(AssetHubRococo::para_id()); + let (roc_at_rococo_parachains, roc_at_asset_hub_westend) = + set_up_rocs_for_penpal_rococo_through_ahr_to_ahw(&sender, amount); + let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( Westend, AssetHubWestend::para_id(), ); - - let amount = ASSET_HUB_ROCOCO_ED * 10_000_000; - let penpal_location = AssetHubRococo::sibling_location_of(PenpalA::para_id()); - let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(penpal_location); - // fund Penpal's sovereign account on AssetHub - AssetHubRococo::fund_accounts(vec![(sov_penpal_on_ahr.into(), amount * 2)]); - // fund Penpal's sender account - PenpalA::mint_foreign_asset( - ::RuntimeOrigin::signed(PenpalAssetOwner::get()), - roc_at_rococo_parachains.clone(), - PenpalASender::get(), - amount * 2, - ); - let rocs_in_reserve_on_ahr_before = ::account_data_of(sov_ahw_on_ahr.clone()).free; let sender_rocs_before = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance( - roc_at_rococo_parachains.clone(), - &PenpalASender::get(), - ) + >::balance(roc_at_rococo_parachains.clone(), &sender) }); - let receiver_rocs_before = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance( - roc_at_asset_hub_westend.clone().try_into().unwrap(), - &AssetHubWestendReceiver::get(), - ) - }); - send_asset_from_penpal_rococo_through_local_asset_hub_to_westend_asset_hub( - roc_at_rococo_parachains.clone(), - amount, - ); + let receiver_rocs_before = + foreign_balance_on_ah_westend(roc_at_asset_hub_westend.clone(), &receiver); + + // Send ROCs over bridge + { + let destination = asset_hub_westend_location(); + let assets: Assets = (roc_at_rococo_parachains.clone(), amount).into(); + let asset_transfer_type = TransferType::RemoteReserve(local_asset_hub.clone().into()); + let fees_id: AssetId = roc_at_rococo_parachains.clone().into(); + let fees_transfer_type = TransferType::RemoteReserve(local_asset_hub.into()); + let beneficiary: Location = + AccountId32Junction { network: None, id: receiver.clone().into() }.into(); + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(assets.len() as u32)), + beneficiary, + }]); + send_assets_from_penpal_rococo_through_rococo_ah_to_westend_ah( + destination, + (assets, asset_transfer_type), + (fees_id, fees_transfer_type), + custom_xcm_on_dest, + ); + } + // process AHW incoming message and check events AssetHubWestend::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -348,8 +377,8 @@ fn send_rocs_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_westend() vec![ // issue ROCs on AHW RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, .. }) => { - asset_id: *asset_id == roc_at_rococo_parachains.clone().try_into().unwrap(), - owner: *owner == AssetHubWestendReceiver::get(), + asset_id: *asset_id == roc_at_rococo_parachains.clone(), + owner: owner == &receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -361,15 +390,9 @@ fn send_rocs_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_westend() let sender_rocs_after = PenpalA::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(roc_at_rococo_parachains, &PenpalASender::get()) - }); - let receiver_rocs_after = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance( - roc_at_asset_hub_westend.try_into().unwrap(), - &AssetHubWestendReceiver::get(), - ) + >::balance(roc_at_rococo_parachains, &sender) }); + let receiver_rocs_after = foreign_balance_on_ah_westend(roc_at_asset_hub_westend, &receiver); let rocs_in_reserve_on_ahr_after = ::account_data_of(sov_ahw_on_ahr.clone()).free; @@ -381,3 +404,120 @@ fn send_rocs_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_westend() assert!(rocs_in_reserve_on_ahr_after > rocs_in_reserve_on_ahr_before); assert!(rocs_in_reserve_on_ahr_after <= rocs_in_reserve_on_ahr_before + amount); } + +#[test] +fn send_back_wnds_from_penpal_rococo_through_asset_hub_rococo_to_asset_hub_westend() { + let wnd_at_rococo_parachains = bridged_wnd_at_ah_rococo(); + let amount = ASSET_HUB_ROCOCO_ED * 10_000_000; + let sender = PenpalASender::get(); + let receiver = AssetHubWestendReceiver::get(); + + // set up ROCs for transfer + let (roc_at_rococo_parachains, _) = + set_up_rocs_for_penpal_rococo_through_ahr_to_ahw(&sender, amount); + + // set up WNDs for transfer + let penpal_location = AssetHubRococo::sibling_location_of(PenpalA::para_id()); + let sov_penpal_on_ahr = AssetHubRococo::sovereign_account_id_of(penpal_location); + let prefund_accounts = vec![(sov_penpal_on_ahr, amount * 2)]; + create_foreign_on_ah_rococo(wnd_at_rococo_parachains.clone(), true, prefund_accounts); + let asset_owner: AccountId = AssetHubRococo::account_id_of(ALICE); + PenpalA::force_create_foreign_asset( + wnd_at_rococo_parachains.clone(), + asset_owner.clone(), + true, + ASSET_MIN_BALANCE, + vec![(sender.clone(), amount * 2)], + ); + + // fund the AHR's SA on AHW with the WND tokens held in reserve + let sov_ahr_on_ahw = AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( + NetworkId::Rococo, + AssetHubRococo::para_id(), + ); + AssetHubWestend::fund_accounts(vec![(sov_ahr_on_ahw.clone(), amount * 2)]); + + // balances before + let sender_wnds_before = PenpalA::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(wnd_at_rococo_parachains.clone().into(), &sender) + }); + let receiver_wnds_before = ::account_data_of(receiver.clone()).free; + + // send WNDs over the bridge, ROCs only used to pay fees on local AH, pay with WND on remote AH + { + let final_destination = asset_hub_westend_location(); + let intermediary_hop = PenpalA::sibling_location_of(AssetHubRococo::para_id()); + let context = PenpalA::execute_with(|| PenpalUniversalLocation::get()); + + // what happens at final destination + let beneficiary = AccountId32Junction { network: None, id: receiver.clone().into() }.into(); + // use WND as fees on the final destination (AHW) + let remote_fees: Asset = (wnd_at_rococo_parachains.clone(), amount).into(); + let remote_fees = remote_fees.reanchored(&final_destination, &context).unwrap(); + // buy execution using WNDs, then deposit all remaining WNDs + let xcm_on_final_dest = Xcm::<()>(vec![ + BuyExecution { fees: remote_fees, weight_limit: WeightLimit::Unlimited }, + DepositAsset { assets: Wild(AllCounted(1)), beneficiary }, + ]); + + // what happens at intermediary hop + // reanchor final dest (Asset Hub Westend) to the view of hop (Asset Hub Rococo) + let mut final_destination = final_destination.clone(); + final_destination.reanchor(&intermediary_hop, &context).unwrap(); + // reanchor WNDs to the view of hop (Asset Hub Rococo) + let asset: Asset = (wnd_at_rococo_parachains.clone(), amount).into(); + let asset = asset.reanchored(&intermediary_hop, &context).unwrap(); + // on Asset Hub Rococo, forward a request to withdraw WNDs from reserve on Asset Hub Westend + let xcm_on_hop = Xcm::<()>(vec![InitiateReserveWithdraw { + assets: Definite(asset.into()), // WNDs + reserve: final_destination, // AHW + xcm: xcm_on_final_dest, // XCM to execute on AHW + }]); + // assets to send from Penpal and how they reach the intermediary hop + let assets: Assets = vec![ + (wnd_at_rococo_parachains.clone(), amount).into(), + (roc_at_rococo_parachains.clone(), amount).into(), + ] + .into(); + let asset_transfer_type = TransferType::DestinationReserve; + let fees_id: AssetId = roc_at_rococo_parachains.into(); + let fees_transfer_type = TransferType::DestinationReserve; + + // initiate the transfer + send_assets_from_penpal_rococo_through_rococo_ah_to_westend_ah( + intermediary_hop, + (assets, asset_transfer_type), + (fees_id, fees_transfer_type), + xcm_on_hop, + ); + } + + // process AHW incoming message and check events + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + assert_expected_events!( + AssetHubWestend, + vec![ + // issue ROCs on AHW + RuntimeEvent::Balances(pallet_balances::Event::Issued { .. }) => {}, + // message processed successfully + RuntimeEvent::MessageQueue( + pallet_message_queue::Event::Processed { success: true, .. } + ) => {}, + ] + ); + }); + + let sender_wnds_after = PenpalA::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(wnd_at_rococo_parachains.into(), &sender) + }); + let receiver_wnds_after = ::account_data_of(receiver).free; + + // Sender's balance is reduced by sent "amount" + assert_eq!(sender_wnds_after, sender_wnds_before - amount); + // Receiver's balance is increased by no more than "amount" + assert!(receiver_wnds_after > receiver_wnds_before); + assert!(receiver_wnds_after <= receiver_wnds_before + amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..e61dc35bdf8a3cecbaa1cb42582582b1b7c1183f --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = BridgeHubRococoExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(AssetHubRococo, RuntimeCall, NetworkId::Rococo, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/mod.rs index 88dad06434b0d4a28295708c303907e02e70927b..6ce8ecef0df3ff66f0a39d26899aa47202e8a121 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/mod.rs @@ -16,44 +16,147 @@ use crate::imports::*; mod asset_transfers; +mod claim_assets; mod send_xcm; mod snowbridge; mod teleport; pub(crate) fn asset_hub_westend_location() -> Location { + Location::new(2, [GlobalConsensus(Westend), Parachain(AssetHubWestend::para_id().into())]) +} +pub(crate) fn bridge_hub_westend_location() -> Location { + Location::new(2, [GlobalConsensus(Westend), Parachain(BridgeHubWestend::para_id().into())]) +} + +// ROC and wROC +pub(crate) fn roc_at_ah_rococo() -> Location { + Parent.into() +} +pub(crate) fn bridged_roc_at_ah_westend() -> Location { + Location::new(2, [GlobalConsensus(Rococo)]) +} + +// wWND +pub(crate) fn bridged_wnd_at_ah_rococo() -> Location { + Location::new(2, [GlobalConsensus(Westend)]) +} + +// USDT and wUSDT +pub(crate) fn usdt_at_ah_rococo() -> Location { + Location::new(0, [PalletInstance(ASSETS_PALLET_ID), GeneralIndex(USDT_ID.into())]) +} +pub(crate) fn bridged_usdt_at_ah_westend() -> Location { Location::new( 2, - [GlobalConsensus(NetworkId::Westend), Parachain(AssetHubWestend::para_id().into())], + [ + GlobalConsensus(Rococo), + Parachain(AssetHubRococo::para_id().into()), + PalletInstance(ASSETS_PALLET_ID), + GeneralIndex(USDT_ID.into()), + ], ) } -pub(crate) fn bridge_hub_westend_location() -> Location { +// wETH has same relative location on both Rococo and Westend AssetHubs +pub(crate) fn weth_at_asset_hubs() -> Location { Location::new( 2, - [GlobalConsensus(NetworkId::Westend), Parachain(BridgeHubWestend::para_id().into())], + [ + GlobalConsensus(Ethereum { chain_id: snowbridge::CHAIN_ID }), + AccountKey20 { network: None, key: snowbridge::WETH }, + ], ) } -pub(crate) fn send_asset_from_asset_hub_rococo( +pub(crate) fn create_foreign_on_ah_rococo( + id: v4::Location, + sufficient: bool, + prefund_accounts: Vec<(AccountId, u128)>, +) { + let owner = AssetHubRococo::account_id_of(ALICE); + let min = ASSET_MIN_BALANCE; + AssetHubRococo::force_create_foreign_asset(id, owner, sufficient, min, prefund_accounts); +} + +pub(crate) fn create_foreign_on_ah_westend(id: v4::Location, sufficient: bool) { + let owner = AssetHubWestend::account_id_of(ALICE); + AssetHubWestend::force_create_foreign_asset(id, owner, sufficient, ASSET_MIN_BALANCE, vec![]); +} + +pub(crate) fn foreign_balance_on_ah_rococo(id: v4::Location, who: &AccountId) -> u128 { + AssetHubRococo::execute_with(|| { + type Assets = ::ForeignAssets; + >::balance(id, who) + }) +} +pub(crate) fn foreign_balance_on_ah_westend(id: v4::Location, who: &AccountId) -> u128 { + AssetHubWestend::execute_with(|| { + type Assets = ::ForeignAssets; + >::balance(id, who) + }) +} + +// set up pool +pub(crate) fn set_up_pool_with_wnd_on_ah_westend(foreign_asset: v4::Location) { + let wnd: v4::Location = v4::Parent.into(); + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + let owner = AssetHubWestendSender::get(); + let signed_owner = ::RuntimeOrigin::signed(owner.clone()); + + assert_ok!(::ForeignAssets::mint( + signed_owner.clone(), + foreign_asset.clone().into(), + owner.clone().into(), + 3_000_000_000_000, + )); + assert_ok!(::AssetConversion::create_pool( + signed_owner.clone(), + Box::new(wnd.clone()), + Box::new(foreign_asset.clone()), + )); + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::PoolCreated { .. }) => {}, + ] + ); + assert_ok!(::AssetConversion::add_liquidity( + signed_owner.clone(), + Box::new(wnd), + Box::new(foreign_asset), + 1_000_000_000_000, + 2_000_000_000_000, + 1, + 1, + owner.into() + )); + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::LiquidityAdded {..}) => {}, + ] + ); + }); +} + +pub(crate) fn send_assets_from_asset_hub_rococo( destination: Location, - (id, amount): (Location, u128), + assets: Assets, + fee_idx: u32, ) -> DispatchResult { let signed_origin = ::RuntimeOrigin::signed(AssetHubRococoSender::get().into()); - let beneficiary: Location = AccountId32Junction { network: None, id: AssetHubWestendReceiver::get().into() }.into(); - let assets: Assets = (id, amount).into(); - let fee_asset_item = 0; - AssetHubRococo::execute_with(|| { ::PolkadotXcm::limited_reserve_transfer_assets( signed_origin, bx!(destination.into()), bx!(beneficiary.into()), bx!(assets.into()), - fee_asset_item, + fee_idx, WeightLimit::Unlimited, ) }) diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs index a1d871cdb618fdddfbbbc3e7812d0ec7f7ae7866..3f2038b4bdd1b510305eb27b7564aa9bbd778c40 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/send_xcm.rs @@ -29,7 +29,7 @@ fn send_xcm_from_rococo_relay_to_westend_asset_hub_should_fail_on_not_applicable let xcm = VersionedXcm::from(Xcm(vec![ UnpaidExecution { weight_limit, check_origin }, ExportMessage { - network: WestendId.into(), + network: WestendId, destination: [Parachain(AssetHubWestend::para_id().into())].into(), xcm: remote_xcm, }, @@ -61,10 +61,13 @@ fn send_xcm_from_rococo_relay_to_westend_asset_hub_should_fail_on_not_applicable #[test] fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { // Initially set only default version on all runtimes - AssetHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - BridgeHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - BridgeHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - AssetHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + + AssetHubRococo::force_default_xcm_version(Some(older_xcm_version)); + BridgeHubRococo::force_default_xcm_version(Some(older_xcm_version)); + BridgeHubWestend::force_default_xcm_version(Some(older_xcm_version)); + AssetHubWestend::force_default_xcm_version(Some(older_xcm_version)); // prepare data let destination = asset_hub_westend_location(); @@ -78,7 +81,11 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { // send XCM from AssetHubRococo - fails - destination version not known assert_err!( - send_asset_from_asset_hub_rococo(destination.clone(), (native_token.clone(), amount)), + send_assets_from_asset_hub_rococo( + destination.clone(), + (native_token.clone(), amount).into(), + 0 + ), DispatchError::Module(sp_runtime::ModuleError { index: 31, error: [1, 0, 0, 0], @@ -87,67 +94,36 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { ); // set destination version - AssetHubRococo::force_xcm_version(destination.clone(), xcm::v3::prelude::XCM_VERSION); - - // TODO: remove this block, when removing `xcm:v2` - { - // send XCM from AssetHubRococo - fails - AssetHubRococo is set to the default/safe `2` - // version, which does not have the `ExportMessage` instruction. If the default `2` is - // changed to `3`, then this assert can go away" - assert_err!( - send_asset_from_asset_hub_rococo(destination.clone(), (native_token.clone(), amount)), - DispatchError::Module(sp_runtime::ModuleError { - index: 31, - error: [1, 0, 0, 0], - message: Some("SendFailure") - }) - ); - - // set exact version for BridgeHubWestend to `2` without `ExportMessage` instruction - AssetHubRococo::force_xcm_version( - ParentThen(Parachain(BridgeHubRococo::para_id().into()).into()).into(), - xcm::v2::prelude::XCM_VERSION, - ); - // send XCM from AssetHubRococo - fails - `ExportMessage` is not in `2` - assert_err!( - send_asset_from_asset_hub_rococo(destination.clone(), (native_token.clone(), amount)), - DispatchError::Module(sp_runtime::ModuleError { - index: 31, - error: [1, 0, 0, 0], - message: Some("SendFailure") - }) - ); - } + AssetHubRococo::force_xcm_version(destination.clone(), newer_xcm_version); // set version with `ExportMessage` for BridgeHubRococo AssetHubRococo::force_xcm_version( ParentThen(Parachain(BridgeHubRococo::para_id().into()).into()).into(), - xcm::v3::prelude::XCM_VERSION, + newer_xcm_version, ); // send XCM from AssetHubRococo - ok - assert_ok!(send_asset_from_asset_hub_rococo( + assert_ok!(send_assets_from_asset_hub_rococo( destination.clone(), - (native_token.clone(), amount) + (native_token.clone(), amount).into(), + 0, )); // `ExportMessage` on local BridgeHub - fails - remote BridgeHub version not known assert_bridge_hub_rococo_message_accepted(false); // set version for remote BridgeHub on BridgeHubRococo - BridgeHubRococo::force_xcm_version( - bridge_hub_westend_location(), - xcm::v3::prelude::XCM_VERSION, - ); + BridgeHubRococo::force_xcm_version(bridge_hub_westend_location(), newer_xcm_version); // set version for AssetHubWestend on BridgeHubWestend BridgeHubWestend::force_xcm_version( ParentThen(Parachain(AssetHubWestend::para_id().into()).into()).into(), - xcm::v3::prelude::XCM_VERSION, + newer_xcm_version, ); // send XCM from AssetHubRococo - ok - assert_ok!(send_asset_from_asset_hub_rococo( + assert_ok!(send_assets_from_asset_hub_rococo( destination.clone(), - (native_token.clone(), amount) + (native_token.clone(), amount).into(), + 0, )); assert_bridge_hub_rococo_message_accepted(true); assert_bridge_hub_westend_message_received(); @@ -164,20 +140,4 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { ] ); }); - - // TODO: remove this block, when removing `xcm:v2` - { - // set `2` version for remote BridgeHub on BridgeHubRococo, which does not have - // `UniversalOrigin` and `DescendOrigin` - BridgeHubRococo::force_xcm_version( - bridge_hub_westend_location(), - xcm::v2::prelude::XCM_VERSION, - ); - - // send XCM from AssetHubRococo - ok - assert_ok!(send_asset_from_asset_hub_rococo(destination, (native_token, amount))); - // message is not accepted on the local BridgeHub (`DestinationUnsupported`) because we - // cannot add `UniversalOrigin` and `DescendOrigin` - assert_bridge_hub_rococo_message_accepted(false); - } } diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs index 1c1c51404aa48a78d110dbcc2e28fefa01ee94bb..84328fb7c6d201b86edf9aba954d84b7598e3005 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/snowbridge.rs @@ -13,12 +13,10 @@ // See the License for the specific language governing permissions and // limitations under the License. use crate::imports::*; -use bridge_hub_rococo_runtime::{EthereumBeaconClient, EthereumInboundQueue, RuntimeOrigin}; use codec::{Decode, Encode}; use emulated_integration_tests_common::xcm_emulator::ConvertLocation; use frame_support::pallet_prelude::TypeInfo; use hex_literal::hex; -use rococo_system_emulated_network::penpal_emulated_chain::CustomizableAssetFromSystemAssetHub; use rococo_westend_system_emulated_network::BridgeHubRococoParaSender as BridgeHubRococoSender; use snowbridge_core::{inbound::InboundQueueFixture, outbound::OperatingMode}; use snowbridge_pallet_inbound_queue_fixtures::{ @@ -34,10 +32,10 @@ use sp_runtime::{DispatchError::Token, TokenError::FundsUnavailable}; use testnet_parachains_constants::rococo::snowbridge::EthereumNetwork; const INITIAL_FUND: u128 = 5_000_000_000 * ROCOCO_ED; -const CHAIN_ID: u64 = 11155111; +pub const CHAIN_ID: u64 = 11155111; const TREASURY_ACCOUNT: [u8; 32] = hex!("6d6f646c70792f74727372790000000000000000000000000000000000000000"); -const WETH: [u8; 20] = hex!("87d1f7fdfEe7f651FaBc8bFCB6E086C278b77A7d"); +pub const WETH: [u8; 20] = hex!("87d1f7fdfEe7f651FaBc8bFCB6E086C278b77A7d"); const ETHEREUM_DESTINATION_ADDRESS: [u8; 20] = hex!("44a57ee2f2FCcb85FDa2B0B18EBD0D8D2333700e"); const INSUFFICIENT_XCM_FEE: u128 = 1000; const XCM_FEE: u128 = 4_000_000_000; @@ -64,7 +62,7 @@ pub fn send_inbound_message(fixture: InboundQueueFixture) -> DispatchResult { ) .unwrap(); EthereumInboundQueue::submit( - RuntimeOrigin::signed(BridgeHubRococoSender::get()), + BridgeHubRococoRuntimeOrigin::signed(BridgeHubRococoSender::get()), fixture.message, ) } @@ -215,7 +213,7 @@ fn register_weth_token_from_ethereum_to_asset_hub() { // Construct RegisterToken message and sent to inbound queue let register_token_message = make_register_token_message(); - send_inbound_message(register_token_message.clone()).unwrap(); + assert_ok!(send_inbound_message(register_token_message.clone())); assert_expected_events!( BridgeHubRococo, @@ -250,10 +248,10 @@ fn send_token_from_ethereum_to_asset_hub() { type RuntimeEvent = ::RuntimeEvent; // Construct RegisterToken message and sent to inbound queue - send_inbound_message(make_register_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_register_token_message())); // Construct SendToken message and sent to inbound queue - send_inbound_message(make_send_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_send_token_message())); // Check that the message was sent assert_expected_events!( @@ -298,7 +296,7 @@ fn send_token_from_ethereum_to_penpal() { assert_ok!(::System::set_storage( ::RuntimeOrigin::root(), vec![( - CustomizableAssetFromSystemAssetHub::key().to_vec(), + PenpalCustomizableAssetFromSystemAssetHub::key().to_vec(), Location::new(2, [GlobalConsensus(Ethereum { chain_id: CHAIN_ID })]).encode(), )], )); @@ -332,14 +330,14 @@ fn send_token_from_ethereum_to_penpal() { type RuntimeEvent = ::RuntimeEvent; // Construct RegisterToken message and sent to inbound queue - send_inbound_message(make_register_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_register_token_message())); // Construct SendToken message to AssetHub(only for increase the nonce as the same order in // smoke test) - send_inbound_message(make_send_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_send_token_message())); // Construct SendToken message and sent to inbound queue - send_inbound_message(make_send_token_to_penpal_message()).unwrap(); + assert_ok!(send_inbound_message(make_send_token_to_penpal_message())); assert_expected_events!( BridgeHubRococo, @@ -379,7 +377,7 @@ fn send_token_from_ethereum_to_penpal() { /// - returning the token to Ethereum #[test] fn send_weth_asset_from_asset_hub_to_ethereum() { - use asset_hub_rococo_runtime::xcm_config::bridging::to_ethereum::DefaultBridgeHubEthereumBaseFee; + use ahr_xcm_config::bridging::to_ethereum::DefaultBridgeHubEthereumBaseFee; let assethub_location = BridgeHubRococo::sibling_location_of(AssetHubRococo::para_id()); let assethub_sovereign = BridgeHubRococo::sovereign_account_id_of(assethub_location); @@ -399,7 +397,7 @@ fn send_weth_asset_from_asset_hub_to_ethereum() { type RuntimeEvent = ::RuntimeEvent; // Construct RegisterToken message and sent to inbound queue - send_inbound_message(make_register_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_register_token_message())); // Check that the register token message was sent using xcm assert_expected_events!( @@ -410,7 +408,7 @@ fn send_weth_asset_from_asset_hub_to_ethereum() { ); // Construct SendToken message and sent to inbound queue - send_inbound_message(make_send_token_message()).unwrap(); + assert_ok!(send_inbound_message(make_send_token_message())); // Check that the send token message was sent using xcm assert_expected_events!( @@ -562,7 +560,6 @@ fn send_token_from_ethereum_to_asset_hub_with_fee(account_id: [u8; 32], fee: u12 2, [EthereumNetwork::get().into(), AccountKey20 { network: None, key: WETH }], ); - // (Parent, Parent, EthereumNetwork::get(), AccountKey20 { network: None, key: WETH }) // Fund asset hub sovereign on bridge hub let asset_hub_sovereign = BridgeHubRococo::sovereign_account_id_of(Location::new( 1, @@ -671,8 +668,8 @@ fn send_token_from_ethereum_to_non_existent_account_on_asset_hub_with_insufficie #[test] fn send_token_from_ethereum_to_non_existent_account_on_asset_hub_with_sufficient_fee_but_do_not_satisfy_ed( ) { - // On AH the xcm fee is 33_873_024 and the ED is 3_300_000 - send_token_from_ethereum_to_asset_hub_with_fee([1; 32], 36_000_000); + // On AH the xcm fee is 26_789_690 and the ED is 3_300_000 + send_token_from_ethereum_to_asset_hub_with_fee([1; 32], 30_000_000); AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/teleport.rs index 8f51f5b180004d3f694cc68ba6d3c11ab46df95a..8cdd9613dc52126ea134ed69ced701dbb0e5f744 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-rococo/src/tests/teleport.rs @@ -13,8 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::tests::*; -use bridge_hub_rococo_runtime::xcm_config::XcmConfig; +use crate::imports::*; #[test] fn teleport_to_other_system_parachains_works() { @@ -22,9 +21,29 @@ fn teleport_to_other_system_parachains_works() { let native_asset: Assets = (Parent, amount).into(); test_parachain_is_trusted_teleporter!( - BridgeHubRococo, // Origin - XcmConfig, // XCM configuration - vec![AssetHubRococo], // Destinations + BridgeHubRococo, // Origin + BridgeHubRococoXcmConfig, // XCM configuration + vec![AssetHubRococo], // Destinations (native_asset, amount) ); } + +#[test] +fn teleport_from_and_to_relay() { + let amount = ROCOCO_ED * 100; + let native_asset: Assets = (Here, amount).into(); + + test_relay_is_trusted_teleporter!( + Rococo, + RococoXcmConfig, + vec![BridgeHubRococo], + (native_asset, amount) + ); + + test_parachain_is_trusted_teleporter_for_relay!( + BridgeHubRococo, + BridgeHubRococoXcmConfig, + Rococo, + amount + ); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/Cargo.toml index 6aebf8862d62e794a24e6926ff487d1956ed792b..1f2d2c8ece2437fee863a888713ae8d868359b84 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/Cargo.toml @@ -11,26 +11,41 @@ publish = false workspace = true [dependencies] +hex-literal = { workspace = true, default-features = true } +codec = { workspace = true } +log = { workspace = true } +scale-info = { workspace = true } # Substrate -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion = { path = "../../../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue" } -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } +frame-support = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true, default-features = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -pallet-xcm = { path = "../../../../../../../polkadot/xcm/pallet-xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +pallet-xcm = { workspace = true } +xcm-executor = { workspace = true } # Bridges -pallet-bridge-messages = { path = "../../../../../../../bridges/modules/messages", default-features = false } +pallet-bridge-messages = { workspace = true } # Cumulus -parachains-common = { path = "../../../../../common" } -cumulus-pallet-xcmp-queue = { path = "../../../../../../pallets/xcmp-queue", default-features = false } -bridge-hub-westend-runtime = { path = "../../../../../runtimes/bridge-hubs/bridge-hub-westend", default-features = false } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -rococo-westend-system-emulated-network = { path = "../../../networks/rococo-westend-system" } +cumulus-pallet-xcmp-queue = { workspace = true } +emulated-integration-tests-common = { workspace = true } +parachains-common = { workspace = true, default-features = true } +rococo-westend-system-emulated-network = { workspace = true } +testnet-parachains-constants = { workspace = true, features = ["westend"] } +asset-hub-westend-runtime = { workspace = true } +bridge-hub-westend-runtime = { workspace = true } + +# Snowbridge +snowbridge-core = { workspace = true } +snowbridge-router-primitives = { workspace = true } +snowbridge-pallet-system = { workspace = true } +snowbridge-pallet-outbound-queue = { workspace = true } +snowbridge-pallet-inbound-queue = { workspace = true } +snowbridge-pallet-inbound-queue-fixtures = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/lib.rs index 36b846e103131882e36b899bdb323d9b969cddde..5e0462d14882a9922c8d6232dd7ebe781ca5c88a 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/lib.rs @@ -23,8 +23,7 @@ mod imports { pub use xcm::{ latest::ParentThen, prelude::{AccountId32 as AccountId32Junction, *}, - v3, - v4::NetworkId::Rococo as RococoId, + v4::{self, NetworkId::Rococo as RococoId}, }; pub use xcm_executor::traits::TransferType; @@ -32,32 +31,43 @@ mod imports { pub use emulated_integration_tests_common::{ accounts::ALICE, impls::Inspect, - test_parachain_is_trusted_teleporter, + test_parachain_is_trusted_teleporter, test_parachain_is_trusted_teleporter_for_relay, + test_relay_is_trusted_teleporter, xcm_emulator::{ assert_expected_events, bx, Chain, Parachain as Para, RelayChain as Relay, TestExt, }, + ASSETS_PALLET_ID, USDT_ID, }; pub use parachains_common::AccountId; pub use rococo_westend_system_emulated_network::{ asset_hub_rococo_emulated_chain::{ - genesis::ED as ASSET_HUB_ROCOCO_ED, AssetHubRococoParaPallet as AssetHubRococoPallet, + genesis::{AssetHubRococoAssetOwner, ED as ASSET_HUB_ROCOCO_ED}, + AssetHubRococoParaPallet as AssetHubRococoPallet, }, asset_hub_westend_emulated_chain::{ genesis::ED as ASSET_HUB_WESTEND_ED, AssetHubWestendParaPallet as AssetHubWestendPallet, }, bridge_hub_westend_emulated_chain::{ - genesis::ED as BRIDGE_HUB_WESTEND_ED, - BridgeHubWestendParaPallet as BridgeHubWestendPallet, + genesis::ED as BRIDGE_HUB_WESTEND_ED, BridgeHubWestendExistentialDeposit, + BridgeHubWestendParaPallet as BridgeHubWestendPallet, BridgeHubWestendXcmConfig, + }, + penpal_emulated_chain::{ + penpal_runtime::xcm_config::UniversalLocation as PenpalUniversalLocation, + PenpalAssetOwner, PenpalBParaPallet as PenpalBPallet, + }, + westend_emulated_chain::{ + genesis::ED as WESTEND_ED, westend_runtime::xcm_config::XcmConfig as WestendXcmConfig, + WestendRelayPallet as WestendPallet, }, - penpal_emulated_chain::{PenpalAssetOwner, PenpalBParaPallet as PenpalBPallet}, - westend_emulated_chain::WestendRelayPallet as WestendPallet, AssetHubRococoPara as AssetHubRococo, AssetHubRococoParaReceiver as AssetHubRococoReceiver, AssetHubRococoParaSender as AssetHubRococoSender, AssetHubWestendPara as AssetHubWestend, AssetHubWestendParaReceiver as AssetHubWestendReceiver, AssetHubWestendParaSender as AssetHubWestendSender, BridgeHubRococoPara as BridgeHubRococo, BridgeHubWestendPara as BridgeHubWestend, + BridgeHubWestendParaReceiver as BridgeHubWestendReceiver, BridgeHubWestendParaSender as BridgeHubWestendSender, PenpalBPara as PenpalB, PenpalBParaSender as PenpalBSender, WestendRelay as Westend, + WestendRelayReceiver as WestendReceiver, WestendRelaySender as WestendSender, }; pub const ASSET_MIN_BALANCE: u128 = 1000; diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/asset_transfers.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/asset_transfers.rs index 597e77d9049cf030fc2b0f0d8e986da53f1f08e2..fc8b772a9c7e02e9937d78607ceb2b106b16fd24 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/asset_transfers.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/asset_transfers.rs @@ -14,165 +14,132 @@ // limitations under the License. use crate::tests::*; -fn send_asset_from_asset_hub_westend_to_asset_hub_rococo(id: Location, amount: u128) { - let destination = asset_hub_rococo_location(); - +fn send_assets_over_bridge(send_fn: F) { // fund the AHW's SA on BHW for paying bridge transport fees BridgeHubWestend::fund_para_sovereign(AssetHubWestend::para_id(), 10_000_000_000_000u128); // set XCM versions - AssetHubWestend::force_xcm_version(destination.clone(), XCM_VERSION); + let local_asset_hub = PenpalB::sibling_location_of(AssetHubWestend::para_id()); + PenpalB::force_xcm_version(local_asset_hub.clone(), XCM_VERSION); + AssetHubWestend::force_xcm_version(asset_hub_rococo_location(), XCM_VERSION); BridgeHubWestend::force_xcm_version(bridge_hub_rococo_location(), XCM_VERSION); // send message over bridge - assert_ok!(send_asset_from_asset_hub_westend(destination, (id, amount))); + send_fn(); + + // process and verify intermediary hops assert_bridge_hub_westend_message_accepted(true); assert_bridge_hub_rococo_message_received(); } -fn send_asset_from_penpal_westend_through_local_asset_hub_to_rococo_asset_hub( - id: Location, - transfer_amount: u128, -) { - let destination = asset_hub_rococo_location(); - let local_asset_hub: Location = PenpalB::sibling_location_of(AssetHubWestend::para_id()); - let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of( - AssetHubWestend::sibling_location_of(PenpalB::para_id()), - ); - let sov_ahr_on_ahw = AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( - Rococo, - AssetHubRococo::para_id(), - ); - - // fund the AHW's SA on BHW for paying bridge transport fees - BridgeHubWestend::fund_para_sovereign(AssetHubWestend::para_id(), 10_000_000_000_000u128); - - // set XCM versions - PenpalB::force_xcm_version(local_asset_hub.clone(), XCM_VERSION); - AssetHubWestend::force_xcm_version(destination.clone(), XCM_VERSION); - BridgeHubWestend::force_xcm_version(bridge_hub_rococo_location(), XCM_VERSION); +fn set_up_wnds_for_penpal_westend_through_ahw_to_ahr( + sender: &AccountId, + amount: u128, +) -> (Location, v4::Location) { + let wnd_at_westend_parachains = wnd_at_ah_westend(); + let wnd_at_asset_hub_rococo = bridged_wnd_at_ah_rococo(); + create_foreign_on_ah_rococo(wnd_at_asset_hub_rococo.clone(), true); - // send message over bridge - assert_ok!(PenpalB::execute_with(|| { - let signed_origin = ::RuntimeOrigin::signed(PenpalBSender::get()); - let beneficiary: Location = - AccountId32Junction { network: None, id: AssetHubRococoReceiver::get().into() }.into(); - let assets: Assets = (id.clone(), transfer_amount).into(); - let fees_id: AssetId = id.into(); - let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { - assets: Wild(AllCounted(assets.len() as u32)), - beneficiary, - }]); + let penpal_location = AssetHubWestend::sibling_location_of(PenpalB::para_id()); + let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of(penpal_location); + // fund Penpal's sovereign account on AssetHub + AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahw.into(), amount * 2)]); + // fund Penpal's sender account + PenpalB::mint_foreign_asset( + ::RuntimeOrigin::signed(PenpalAssetOwner::get()), + wnd_at_westend_parachains.clone(), + sender.clone(), + amount * 2, + ); + (wnd_at_westend_parachains, wnd_at_asset_hub_rococo) +} - ::PolkadotXcm::transfer_assets_using_type_and_then( - signed_origin, - bx!(destination.into()), - bx!(assets.into()), - bx!(TransferType::RemoteReserve(local_asset_hub.clone().into())), - bx!(fees_id.into()), - bx!(TransferType::RemoteReserve(local_asset_hub.into())), - bx!(VersionedXcm::from(custom_xcm_on_dest)), - WeightLimit::Unlimited, - ) - })); - AssetHubWestend::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - assert_expected_events!( - AssetHubWestend, - vec![ - // Amount to reserve transfer is withdrawn from Penpal's sovereign account - RuntimeEvent::Balances( - pallet_balances::Event::Burned { who, amount } - ) => { - who: *who == sov_penpal_on_ahw.clone().into(), - amount: *amount == transfer_amount, - }, - // Amount deposited in AHR's sovereign account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == sov_ahr_on_ahw.clone().into(), - }, - RuntimeEvent::XcmpQueue( - cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. } - ) => {}, - ] +fn send_assets_from_penpal_westend_through_westend_ah_to_rococo_ah( + destination: Location, + assets: (Assets, TransferType), + fees: (AssetId, TransferType), + custom_xcm_on_dest: Xcm<()>, +) { + send_assets_over_bridge(|| { + let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of( + AssetHubWestend::sibling_location_of(PenpalB::para_id()), ); + let sov_ahr_on_ahw = + AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( + Rococo, + AssetHubRococo::para_id(), + ); + + // send message over bridge + assert_ok!(PenpalB::execute_with(|| { + let signed_origin = ::RuntimeOrigin::signed(PenpalBSender::get()); + ::PolkadotXcm::transfer_assets_using_type_and_then( + signed_origin, + bx!(destination.into()), + bx!(assets.0.into()), + bx!(assets.1), + bx!(fees.0.into()), + bx!(fees.1), + bx!(VersionedXcm::from(custom_xcm_on_dest)), + WeightLimit::Unlimited, + ) + })); + // verify intermediary AH Westend hop + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + assert_expected_events!( + AssetHubWestend, + vec![ + // Amount to reserve transfer is withdrawn from Penpal's sovereign account + RuntimeEvent::Balances( + pallet_balances::Event::Burned { who, .. } + ) => { + who: *who == sov_penpal_on_ahw.clone().into(), + }, + // Amount deposited in AHR's sovereign account + RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { + who: *who == sov_ahr_on_ahw.clone().into(), + }, + RuntimeEvent::XcmpQueue( + cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. } + ) => {}, + ] + ); + }); }); - assert_bridge_hub_westend_message_accepted(true); - assert_bridge_hub_rococo_message_received(); } #[test] +/// Test transfer of WND from AssetHub Westend to AssetHub Rococo. fn send_wnds_from_asset_hub_westend_to_asset_hub_rococo() { - let wnd_at_asset_hub_westend: Location = Parent.into(); - let wnd_at_asset_hub_rococo = - v3::Location::new(2, [v3::Junction::GlobalConsensus(v3::NetworkId::Westend)]); - let owner: AccountId = AssetHubRococo::account_id_of(ALICE); - AssetHubRococo::force_create_foreign_asset( - wnd_at_asset_hub_rococo, - owner, - true, - ASSET_MIN_BALANCE, - vec![], - ); + let amount = ASSET_HUB_WESTEND_ED * 1_000; + let sender = AssetHubWestendSender::get(); + let receiver = AssetHubRococoReceiver::get(); + let wnd_at_asset_hub_westend = wnd_at_ah_westend(); + let bridged_wnd_at_asset_hub_rococo = bridged_wnd_at_ah_rococo(); + create_foreign_on_ah_rococo(bridged_wnd_at_asset_hub_rococo.clone(), true); + + set_up_pool_with_roc_on_ah_rococo(bridged_wnd_at_asset_hub_rococo.clone(), true); + let sov_ahr_on_ahw = AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( Rococo, AssetHubRococo::para_id(), ); - - AssetHubRococo::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - - // setup a pool to pay xcm fees with `wnd_at_asset_hub_rococo` tokens - assert_ok!(::ForeignAssets::mint( - ::RuntimeOrigin::signed(AssetHubRococoSender::get()), - wnd_at_asset_hub_rococo.into(), - AssetHubRococoSender::get().into(), - 3_000_000_000_000, - )); - - assert_ok!(::AssetConversion::create_pool( - ::RuntimeOrigin::signed(AssetHubRococoSender::get()), - Box::new(xcm::v3::Parent.into()), - Box::new(wnd_at_asset_hub_rococo), - )); - - assert_expected_events!( - AssetHubRococo, - vec![ - RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::PoolCreated { .. }) => {}, - ] - ); - - assert_ok!(::AssetConversion::add_liquidity( - ::RuntimeOrigin::signed(AssetHubRococoSender::get()), - Box::new(xcm::v3::Parent.into()), - Box::new(wnd_at_asset_hub_rococo), - 1_000_000_000_000, - 2_000_000_000_000, - 1, - 1, - AssetHubRococoSender::get().into() - )); - - assert_expected_events!( - AssetHubRococo, - vec![ - RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::LiquidityAdded {..}) => {}, - ] - ); - }); - let wnds_in_reserve_on_ahw_before = ::account_data_of(sov_ahr_on_ahw.clone()).free; - let sender_wnds_before = - ::account_data_of(AssetHubWestendSender::get()).free; - let receiver_wnds_before = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(wnd_at_asset_hub_rococo, &AssetHubRococoReceiver::get()) + let sender_wnds_before = ::account_data_of(sender.clone()).free; + let receiver_wnds_before = + foreign_balance_on_ah_rococo(bridged_wnd_at_asset_hub_rococo.clone(), &receiver); + + // send WNDs, use them for fees + send_assets_over_bridge(|| { + let destination = asset_hub_rococo_location(); + let assets: Assets = (wnd_at_asset_hub_westend, amount).into(); + let fee_idx = 0; + assert_ok!(send_assets_from_asset_hub_westend(destination, assets, fee_idx)); }); - let amount = ASSET_HUB_WESTEND_ED * 1_000; - send_asset_from_asset_hub_westend_to_asset_hub_rococo(wnd_at_asset_hub_westend, amount); + // verify expected events on final destination AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -180,8 +147,8 @@ fn send_wnds_from_asset_hub_westend_to_asset_hub_rococo() { vec![ // issue WNDs on AHR RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, .. }) => { - asset_id: *asset_id == wnd_at_asset_hub_rococo, - owner: *owner == AssetHubRococoReceiver::get(), + asset_id: *asset_id == bridged_wnd_at_asset_hub_rococo, + owner: *owner == receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -191,12 +158,9 @@ fn send_wnds_from_asset_hub_westend_to_asset_hub_rococo() { ); }); - let sender_wnds_after = - ::account_data_of(AssetHubWestendSender::get()).free; - let receiver_wnds_after = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(wnd_at_asset_hub_rococo, &AssetHubRococoReceiver::get()) - }); + let sender_wnds_after = ::account_data_of(sender).free; + let receiver_wnds_after = + foreign_balance_on_ah_rococo(bridged_wnd_at_asset_hub_rococo, &receiver); let wnds_in_reserve_on_ahw_after = ::account_data_of(sov_ahr_on_ahw).free; @@ -209,18 +173,26 @@ fn send_wnds_from_asset_hub_westend_to_asset_hub_rococo() { } #[test] -fn send_rocs_from_asset_hub_westend_to_asset_hub_rococo() { +/// Send bridged assets "back" from AssetHub Rococo to AssetHub Westend. +/// +/// This mix of assets should cover the whole range: +/// - bridged native assets: ROC, +/// - bridged trust-based assets: USDT (exists only on Rococo, Westend gets it from Rococo over +/// bridge), +/// - bridged foreign asset / double-bridged asset (other bridge / Snowfork): wETH (bridged from +/// Ethereum to Rococo over Snowbridge, then bridged over to Westend through this bridge). +fn send_back_rocs_usdt_and_weth_from_asset_hub_westend_to_asset_hub_rococo() { let prefund_amount = 10_000_000_000_000u128; - let roc_at_asset_hub_westend = - v3::Location::new(2, [v3::Junction::GlobalConsensus(v3::NetworkId::Rococo)]); - let owner: AccountId = AssetHubWestend::account_id_of(ALICE); - AssetHubWestend::force_create_foreign_asset( - roc_at_asset_hub_westend, - owner, - true, - ASSET_MIN_BALANCE, - vec![(AssetHubWestendSender::get(), prefund_amount)], - ); + let amount_to_send = ASSET_HUB_ROCOCO_ED * 1_000; + let sender = AssetHubWestendSender::get(); + let receiver = AssetHubRococoReceiver::get(); + let bridged_roc_at_asset_hub_westend = bridged_roc_at_ah_westend(); + let prefund_accounts = vec![(sender.clone(), prefund_amount)]; + create_foreign_on_ah_westend(bridged_roc_at_asset_hub_westend.clone(), true, prefund_accounts); + + //////////////////////////////////////////////////////////// + // Let's first send back just some ROCs as a simple example + //////////////////////////////////////////////////////////// // fund the AHW's SA on AHR with the ROC tokens held in reserve let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( @@ -232,19 +204,20 @@ fn send_rocs_from_asset_hub_westend_to_asset_hub_rococo() { let rocs_in_reserve_on_ahr_before = ::account_data_of(sov_ahw_on_ahr.clone()).free; assert_eq!(rocs_in_reserve_on_ahr_before, prefund_amount); - let sender_rocs_before = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(roc_at_asset_hub_westend, &AssetHubWestendSender::get()) - }); + + let sender_rocs_before = + foreign_balance_on_ah_westend(bridged_roc_at_asset_hub_westend.clone(), &sender); assert_eq!(sender_rocs_before, prefund_amount); - let receiver_rocs_before = - ::account_data_of(AssetHubRococoReceiver::get()).free; + let receiver_rocs_before = ::account_data_of(receiver.clone()).free; + + // send back ROCs, use them for fees + send_assets_over_bridge(|| { + let destination = asset_hub_rococo_location(); + let assets: Assets = (bridged_roc_at_asset_hub_westend.clone(), amount_to_send).into(); + let fee_idx = 0; + assert_ok!(send_assets_from_asset_hub_westend(destination, assets, fee_idx)); + }); - let amount_to_send = ASSET_HUB_ROCOCO_ED * 1_000; - send_asset_from_asset_hub_westend_to_asset_hub_rococo( - roc_at_asset_hub_westend.try_into().unwrap(), - amount_to_send, - ); AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -259,7 +232,7 @@ fn send_rocs_from_asset_hub_westend_to_asset_hub_rococo() { }, // ROCs deposited to beneficiary RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == AssetHubRococoReceiver::get(), + who: *who == receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -269,12 +242,9 @@ fn send_rocs_from_asset_hub_westend_to_asset_hub_rococo() { ); }); - let sender_rocs_after = AssetHubWestend::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance(roc_at_asset_hub_westend, &AssetHubWestendSender::get()) - }); - let receiver_rocs_after = - ::account_data_of(AssetHubRococoReceiver::get()).free; + let sender_rocs_after = + foreign_balance_on_ah_westend(bridged_roc_at_asset_hub_westend, &sender); + let receiver_rocs_after = ::account_data_of(receiver.clone()).free; let rocs_in_reserve_on_ahr_after = ::account_data_of(sov_ahw_on_ahr.clone()).free; @@ -284,59 +254,142 @@ fn send_rocs_from_asset_hub_westend_to_asset_hub_rococo() { assert!(receiver_rocs_after > receiver_rocs_before); // Reserve balance is reduced by sent amount assert_eq!(rocs_in_reserve_on_ahr_after, rocs_in_reserve_on_ahr_before - amount_to_send); + + ////////////////////////////////////////////////////////////////// + // Now let's send back over USDTs + wETH (and pay fees with USDT) + ////////////////////////////////////////////////////////////////// + + // wETH has same relative location on both Rococo and Westend AssetHubs + let bridged_weth_at_ah = weth_at_asset_hubs(); + let bridged_usdt_at_asset_hub_westend = bridged_usdt_at_ah_westend(); + + // set up destination chain AH Rococo: + // create a ROC/USDT pool to be able to pay fees with USDT (USDT created in genesis) + set_up_pool_with_roc_on_ah_rococo(usdt_at_ah_rococo(), false); + // create wETH on Rococo (IRL it's already created by Snowbridge) + create_foreign_on_ah_rococo(bridged_weth_at_ah.clone(), true); + // prefund AHW's sovereign account on AHR to be able to withdraw USDT and wETH from reserves + let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( + Westend, + AssetHubWestend::para_id(), + ); + AssetHubRococo::mint_asset( + ::RuntimeOrigin::signed(AssetHubRococoAssetOwner::get()), + USDT_ID, + sov_ahw_on_ahr.clone(), + amount_to_send * 2, + ); + AssetHubRococo::mint_foreign_asset( + ::RuntimeOrigin::signed(AssetHubRococo::account_id_of(ALICE)), + bridged_weth_at_ah.clone(), + sov_ahw_on_ahr, + amount_to_send * 2, + ); + + // set up source chain AH Westend: + // create wETH and USDT foreign assets on Westend and prefund sender's account + let prefund_accounts = vec![(sender.clone(), amount_to_send * 2)]; + create_foreign_on_ah_westend(bridged_weth_at_ah.clone(), true, prefund_accounts.clone()); + create_foreign_on_ah_westend(bridged_usdt_at_asset_hub_westend.clone(), true, prefund_accounts); + + // check balances before + let receiver_usdts_before = AssetHubRococo::execute_with(|| { + type Assets = ::Assets; + >::balance(USDT_ID, &receiver) + }); + let receiver_weth_before = foreign_balance_on_ah_rococo(bridged_weth_at_ah.clone(), &receiver); + + let usdt_id: AssetId = Location::try_from(bridged_usdt_at_asset_hub_westend).unwrap().into(); + // send USDTs and wETHs + let assets: Assets = vec![ + (usdt_id.clone(), amount_to_send).into(), + (Location::try_from(bridged_weth_at_ah.clone()).unwrap(), amount_to_send).into(), + ] + .into(); + // use USDT for fees + let fee = usdt_id; + + // use the more involved transfer extrinsic + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(assets.len() as u32)), + beneficiary: AccountId32Junction { network: None, id: receiver.clone().into() }.into(), + }]); + assert_ok!(AssetHubWestend::execute_with(|| { + ::PolkadotXcm::transfer_assets_using_type_and_then( + ::RuntimeOrigin::signed(sender.into()), + bx!(asset_hub_rococo_location().into()), + bx!(assets.into()), + bx!(TransferType::DestinationReserve), + bx!(fee.into()), + bx!(TransferType::DestinationReserve), + bx!(VersionedXcm::from(custom_xcm_on_dest)), + WeightLimit::Unlimited, + ) + })); + // verify hops (also advances the message through the hops) + assert_bridge_hub_westend_message_accepted(true); + assert_bridge_hub_rococo_message_received(); + AssetHubRococo::execute_with(|| { + AssetHubRococo::assert_xcmp_queue_success(None); + }); + + let receiver_usdts_after = AssetHubRococo::execute_with(|| { + type Assets = ::Assets; + >::balance(USDT_ID, &receiver) + }); + let receiver_weth_after = foreign_balance_on_ah_rococo(bridged_weth_at_ah, &receiver); + + // Receiver's USDT balance is increased by almost `amount_to_send` (minus fees) + assert!(receiver_usdts_after > receiver_usdts_before); + assert!(receiver_usdts_after < receiver_usdts_before + amount_to_send); + // Receiver's wETH balance is increased by `amount_to_send` + assert_eq!(receiver_weth_after, receiver_weth_before + amount_to_send); } #[test] fn send_wnds_from_penpal_westend_through_asset_hub_westend_to_asset_hub_rococo() { - let wnd_at_westend_parachains: Location = Parent.into(); - let wnd_at_asset_hub_rococo = Location::new(2, [Junction::GlobalConsensus(NetworkId::Westend)]); - let owner: AccountId = AssetHubRococo::account_id_of(ALICE); - AssetHubRococo::force_create_foreign_asset( - wnd_at_asset_hub_rococo.clone().try_into().unwrap(), - owner, - true, - ASSET_MIN_BALANCE, - vec![], - ); + let amount = ASSET_HUB_WESTEND_ED * 10_000_000; + let sender = PenpalBSender::get(); + let receiver = AssetHubRococoReceiver::get(); + let local_asset_hub = PenpalB::sibling_location_of(AssetHubWestend::para_id()); + let (wnd_at_westend_parachains, wnd_at_asset_hub_rococo) = + set_up_wnds_for_penpal_westend_through_ahw_to_ahr(&sender, amount); + let sov_ahr_on_ahw = AssetHubWestend::sovereign_account_of_parachain_on_other_global_consensus( Rococo, AssetHubRococo::para_id(), ); - - let amount = ASSET_HUB_WESTEND_ED * 10_000_000; - let penpal_location = AssetHubWestend::sibling_location_of(PenpalB::para_id()); - let sov_penpal_on_ahw = AssetHubWestend::sovereign_account_id_of(penpal_location); - // fund Penpal's sovereign account on AssetHub - AssetHubWestend::fund_accounts(vec![(sov_penpal_on_ahw.into(), amount * 2)]); - // fund Penpal's sender account - PenpalB::mint_foreign_asset( - ::RuntimeOrigin::signed(PenpalAssetOwner::get()), - wnd_at_westend_parachains.clone(), - PenpalBSender::get(), - amount * 2, - ); - let wnds_in_reserve_on_ahw_before = ::account_data_of(sov_ahr_on_ahw.clone()).free; let sender_wnds_before = PenpalB::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance( - wnd_at_westend_parachains.clone(), - &PenpalBSender::get(), - ) + >::balance(wnd_at_westend_parachains.clone(), &sender) }); - let receiver_wnds_before = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance( - wnd_at_asset_hub_rococo.clone().try_into().unwrap(), - &AssetHubRococoReceiver::get(), - ) - }); - send_asset_from_penpal_westend_through_local_asset_hub_to_rococo_asset_hub( - wnd_at_westend_parachains.clone(), - amount, - ); + let receiver_wnds_before = + foreign_balance_on_ah_rococo(wnd_at_asset_hub_rococo.clone(), &receiver); + + // Send WNDs over bridge + { + let destination = asset_hub_rococo_location(); + let assets: Assets = (wnd_at_westend_parachains.clone(), amount).into(); + let asset_transfer_type = TransferType::RemoteReserve(local_asset_hub.clone().into()); + let fees_id: AssetId = wnd_at_westend_parachains.clone().into(); + let fees_transfer_type = TransferType::RemoteReserve(local_asset_hub.into()); + let beneficiary: Location = + AccountId32Junction { network: None, id: receiver.clone().into() }.into(); + let custom_xcm_on_dest = Xcm::<()>(vec![DepositAsset { + assets: Wild(AllCounted(assets.len() as u32)), + beneficiary, + }]); + send_assets_from_penpal_westend_through_westend_ah_to_rococo_ah( + destination, + (assets, asset_transfer_type), + (fees_id, fees_transfer_type), + custom_xcm_on_dest, + ); + } + // process AHR incoming message and check events AssetHubRococo::execute_with(|| { type RuntimeEvent = ::RuntimeEvent; assert_expected_events!( @@ -344,8 +397,8 @@ fn send_wnds_from_penpal_westend_through_asset_hub_westend_to_asset_hub_rococo() vec![ // issue WNDs on AHR RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { asset_id, owner, .. }) => { - asset_id: *asset_id == wnd_at_westend_parachains.clone().try_into().unwrap(), - owner: *owner == AssetHubRococoReceiver::get(), + asset_id: *asset_id == wnd_at_westend_parachains.clone(), + owner: owner == &receiver, }, // message processed successfully RuntimeEvent::MessageQueue( @@ -357,15 +410,9 @@ fn send_wnds_from_penpal_westend_through_asset_hub_westend_to_asset_hub_rococo() let sender_wnds_after = PenpalB::execute_with(|| { type ForeignAssets = ::ForeignAssets; - >::balance(wnd_at_westend_parachains, &PenpalBSender::get()) - }); - let receiver_wnds_after = AssetHubRococo::execute_with(|| { - type Assets = ::ForeignAssets; - >::balance( - wnd_at_asset_hub_rococo.try_into().unwrap(), - &AssetHubRococoReceiver::get(), - ) + >::balance(wnd_at_westend_parachains, &sender) }); + let receiver_wnds_after = foreign_balance_on_ah_rococo(wnd_at_asset_hub_rococo, &receiver); let wnds_in_reserve_on_ahw_after = ::account_data_of(sov_ahr_on_ahw.clone()).free; @@ -377,3 +424,120 @@ fn send_wnds_from_penpal_westend_through_asset_hub_westend_to_asset_hub_rococo() assert!(wnds_in_reserve_on_ahw_after > wnds_in_reserve_on_ahw_before); assert!(wnds_in_reserve_on_ahw_after <= wnds_in_reserve_on_ahw_before + amount); } + +#[test] +fn send_back_rocs_from_penpal_westend_through_asset_hub_westend_to_asset_hub_rococo() { + let roc_at_westend_parachains = bridged_roc_at_ah_westend(); + let amount = ASSET_HUB_WESTEND_ED * 10_000_000; + let sender = PenpalBSender::get(); + let receiver = AssetHubRococoReceiver::get(); + + // set up WNDs for transfer + let (wnd_at_westend_parachains, _) = + set_up_wnds_for_penpal_westend_through_ahw_to_ahr(&sender, amount); + + // set up ROCs for transfer + let penpal_location = AssetHubWestend::sibling_location_of(PenpalB::para_id()); + let sov_penpal_on_ahr = AssetHubWestend::sovereign_account_id_of(penpal_location); + let prefund_accounts = vec![(sov_penpal_on_ahr, amount * 2)]; + create_foreign_on_ah_westend(roc_at_westend_parachains.clone(), true, prefund_accounts); + let asset_owner: AccountId = AssetHubWestend::account_id_of(ALICE); + PenpalB::force_create_foreign_asset( + roc_at_westend_parachains.clone(), + asset_owner.clone(), + true, + ASSET_MIN_BALANCE, + vec![(sender.clone(), amount * 2)], + ); + + // fund the AHW's SA on AHR with the ROC tokens held in reserve + let sov_ahw_on_ahr = AssetHubRococo::sovereign_account_of_parachain_on_other_global_consensus( + Westend, + AssetHubWestend::para_id(), + ); + AssetHubRococo::fund_accounts(vec![(sov_ahw_on_ahr.clone(), amount * 2)]); + + // balances before + let sender_rocs_before = PenpalB::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(roc_at_westend_parachains.clone().into(), &sender) + }); + let receiver_rocs_before = ::account_data_of(receiver.clone()).free; + + // send ROCs over the bridge, WNDs only used to pay fees on local AH, pay with ROC on remote AH + { + let final_destination = asset_hub_rococo_location(); + let intermediary_hop = PenpalB::sibling_location_of(AssetHubWestend::para_id()); + let context = PenpalB::execute_with(|| PenpalUniversalLocation::get()); + + // what happens at final destination + let beneficiary = AccountId32Junction { network: None, id: receiver.clone().into() }.into(); + // use ROC as fees on the final destination (AHW) + let remote_fees: Asset = (roc_at_westend_parachains.clone(), amount).into(); + let remote_fees = remote_fees.reanchored(&final_destination, &context).unwrap(); + // buy execution using ROCs, then deposit all remaining ROCs + let xcm_on_final_dest = Xcm::<()>(vec![ + BuyExecution { fees: remote_fees, weight_limit: WeightLimit::Unlimited }, + DepositAsset { assets: Wild(AllCounted(1)), beneficiary }, + ]); + + // what happens at intermediary hop + // reanchor final dest (Asset Hub Rococo) to the view of hop (Asset Hub Westend) + let mut final_destination = final_destination.clone(); + final_destination.reanchor(&intermediary_hop, &context).unwrap(); + // reanchor ROCs to the view of hop (Asset Hub Westend) + let asset: Asset = (roc_at_westend_parachains.clone(), amount).into(); + let asset = asset.reanchored(&intermediary_hop, &context).unwrap(); + // on Asset Hub Westend, forward a request to withdraw ROCs from reserve on Asset Hub Rococo + let xcm_on_hop = Xcm::<()>(vec![InitiateReserveWithdraw { + assets: Definite(asset.into()), // ROCs + reserve: final_destination, // AHR + xcm: xcm_on_final_dest, // XCM to execute on AHR + }]); + // assets to send from Penpal and how they reach the intermediary hop + let assets: Assets = vec![ + (roc_at_westend_parachains.clone(), amount).into(), + (wnd_at_westend_parachains.clone(), amount).into(), + ] + .into(); + let asset_transfer_type = TransferType::DestinationReserve; + let fees_id: AssetId = wnd_at_westend_parachains.into(); + let fees_transfer_type = TransferType::DestinationReserve; + + // initiate the transfer + send_assets_from_penpal_westend_through_westend_ah_to_rococo_ah( + intermediary_hop, + (assets, asset_transfer_type), + (fees_id, fees_transfer_type), + xcm_on_hop, + ); + } + + // process AHR incoming message and check events + AssetHubRococo::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + assert_expected_events!( + AssetHubRococo, + vec![ + // issue WNDs on AHR + RuntimeEvent::Balances(pallet_balances::Event::Issued { .. }) => {}, + // message processed successfully + RuntimeEvent::MessageQueue( + pallet_message_queue::Event::Processed { success: true, .. } + ) => {}, + ] + ); + }); + + let sender_rocs_after = PenpalB::execute_with(|| { + type ForeignAssets = ::ForeignAssets; + >::balance(roc_at_westend_parachains.into(), &sender) + }); + let receiver_rocs_after = ::account_data_of(receiver).free; + + // Sender's balance is reduced by sent "amount" + assert_eq!(sender_rocs_after, sender_rocs_before - amount); + // Receiver's balance is increased by no more than "amount" + assert!(receiver_rocs_after > receiver_rocs_before); + assert!(receiver_rocs_after <= receiver_rocs_before + amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..e62ce6843258e641ddd1e86dc0c5b006db31e4df --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = BridgeHubWestendExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(AssetHubWestend, RuntimeCall, NetworkId::Westend, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/mod.rs index b781d6e987ca1fc7f2a64710263f432c1cc8b3c6..bf894a3baf585da518287b3a30527b403c55aa3a 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/mod.rs @@ -16,43 +16,161 @@ use crate::imports::*; mod asset_transfers; +mod claim_assets; mod send_xcm; +mod snowbridge; mod teleport; pub(crate) fn asset_hub_rococo_location() -> Location { + Location::new(2, [GlobalConsensus(Rococo), Parachain(AssetHubRococo::para_id().into())]) +} + +pub(crate) fn bridge_hub_rococo_location() -> Location { + Location::new(2, [GlobalConsensus(Rococo), Parachain(BridgeHubRococo::para_id().into())]) +} + +// WND and wWND +pub(crate) fn wnd_at_ah_westend() -> Location { + Parent.into() +} +pub(crate) fn bridged_wnd_at_ah_rococo() -> Location { + Location::new(2, [GlobalConsensus(Westend)]) +} + +// wROC +pub(crate) fn bridged_roc_at_ah_westend() -> Location { + Location::new(2, [GlobalConsensus(Rococo)]) +} + +// USDT and wUSDT +pub(crate) fn usdt_at_ah_rococo() -> Location { + Location::new(0, [PalletInstance(ASSETS_PALLET_ID), GeneralIndex(USDT_ID.into())]) +} +pub(crate) fn bridged_usdt_at_ah_westend() -> Location { Location::new( 2, - [GlobalConsensus(NetworkId::Rococo), Parachain(AssetHubRococo::para_id().into())], + [ + GlobalConsensus(Rococo), + Parachain(AssetHubRococo::para_id().into()), + PalletInstance(ASSETS_PALLET_ID), + GeneralIndex(USDT_ID.into()), + ], ) } -pub(crate) fn bridge_hub_rococo_location() -> Location { +// wETH has same relative location on both Rococo and Westend AssetHubs +pub(crate) fn weth_at_asset_hubs() -> Location { Location::new( 2, - [GlobalConsensus(NetworkId::Rococo), Parachain(BridgeHubRococo::para_id().into())], + [ + GlobalConsensus(Ethereum { chain_id: snowbridge::CHAIN_ID }), + AccountKey20 { network: None, key: snowbridge::WETH }, + ], ) } -pub(crate) fn send_asset_from_asset_hub_westend( +pub(crate) fn create_foreign_on_ah_rococo(id: v4::Location, sufficient: bool) { + let owner = AssetHubRococo::account_id_of(ALICE); + AssetHubRococo::force_create_foreign_asset(id, owner, sufficient, ASSET_MIN_BALANCE, vec![]); +} + +pub(crate) fn create_foreign_on_ah_westend( + id: v4::Location, + sufficient: bool, + prefund_accounts: Vec<(AccountId, u128)>, +) { + let owner = AssetHubWestend::account_id_of(ALICE); + let min = ASSET_MIN_BALANCE; + AssetHubWestend::force_create_foreign_asset(id, owner, sufficient, min, prefund_accounts); +} + +pub(crate) fn foreign_balance_on_ah_rococo(id: v4::Location, who: &AccountId) -> u128 { + AssetHubRococo::execute_with(|| { + type Assets = ::ForeignAssets; + >::balance(id, who) + }) +} +pub(crate) fn foreign_balance_on_ah_westend(id: v4::Location, who: &AccountId) -> u128 { + AssetHubWestend::execute_with(|| { + type Assets = ::ForeignAssets; + >::balance(id, who) + }) +} + +// set up pool +pub(crate) fn set_up_pool_with_roc_on_ah_rococo(asset: v4::Location, is_foreign: bool) { + let roc: v4::Location = v4::Parent.into(); + AssetHubRococo::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + let owner = AssetHubRococoSender::get(); + let signed_owner = ::RuntimeOrigin::signed(owner.clone()); + + if is_foreign { + assert_ok!(::ForeignAssets::mint( + signed_owner.clone(), + asset.clone().into(), + owner.clone().into(), + 3_000_000_000_000, + )); + } else { + let asset_id = match asset.interior.last() { + Some(v4::Junction::GeneralIndex(id)) => *id as u32, + _ => unreachable!(), + }; + assert_ok!(::Assets::mint( + signed_owner.clone(), + asset_id.into(), + owner.clone().into(), + 3_000_000_000_000, + )); + } + assert_ok!(::AssetConversion::create_pool( + signed_owner.clone(), + Box::new(roc.clone()), + Box::new(asset.clone()), + )); + assert_expected_events!( + AssetHubRococo, + vec![ + RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::PoolCreated { .. }) => {}, + ] + ); + assert_ok!(::AssetConversion::add_liquidity( + signed_owner.clone(), + Box::new(roc), + Box::new(asset), + 1_000_000_000_000, + 2_000_000_000_000, + 1, + 1, + owner.into() + )); + assert_expected_events!( + AssetHubRococo, + vec![ + RuntimeEvent::AssetConversion(pallet_asset_conversion::Event::LiquidityAdded {..}) => {}, + ] + ); + }); +} + +pub(crate) fn send_assets_from_asset_hub_westend( destination: Location, - (id, amount): (Location, u128), + assets: Assets, + fee_idx: u32, ) -> DispatchResult { let signed_origin = ::RuntimeOrigin::signed(AssetHubWestendSender::get().into()); - let beneficiary: Location = AccountId32Junction { network: None, id: AssetHubRococoReceiver::get().into() }.into(); - let assets: Assets = (id, amount).into(); - let fee_asset_item = 0; - AssetHubWestend::execute_with(|| { ::PolkadotXcm::limited_reserve_transfer_assets( signed_origin, bx!(destination.into()), bx!(beneficiary.into()), bx!(assets.into()), - fee_asset_item, + fee_idx, WeightLimit::Unlimited, ) }) diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs index b01be5e8dc84b4edf35651d0388baa1462b54c9b..dee411bea8b7353f07b5542b1a81f08ed2dbd966 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/send_xcm.rs @@ -61,10 +61,13 @@ fn send_xcm_from_westend_relay_to_rococo_asset_hub_should_fail_on_not_applicable #[test] fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { // Initially set only default version on all runtimes - AssetHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - BridgeHubRococo::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - BridgeHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); - AssetHubWestend::force_default_xcm_version(Some(xcm::v2::prelude::XCM_VERSION)); + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + + AssetHubRococo::force_default_xcm_version(Some(older_xcm_version)); + BridgeHubRococo::force_default_xcm_version(Some(older_xcm_version)); + BridgeHubWestend::force_default_xcm_version(Some(older_xcm_version)); + AssetHubWestend::force_default_xcm_version(Some(older_xcm_version)); // prepare data let destination = asset_hub_rococo_location(); @@ -78,7 +81,11 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { // send XCM from AssetHubWestend - fails - destination version not known assert_err!( - send_asset_from_asset_hub_westend(destination.clone(), (native_token.clone(), amount)), + send_assets_from_asset_hub_westend( + destination.clone(), + (native_token.clone(), amount).into(), + 0 + ), DispatchError::Module(sp_runtime::ModuleError { index: 31, error: [1, 0, 0, 0], @@ -87,67 +94,36 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { ); // set destination version - AssetHubWestend::force_xcm_version(destination.clone(), xcm::v3::prelude::XCM_VERSION); - - // TODO: remove this block, when removing `xcm:v2` - { - // send XCM from AssetHubRococo - fails - AssetHubRococo is set to the default/safe `2` - // version, which does not have the `ExportMessage` instruction. If the default `2` is - // changed to `3`, then this assert can go away" - assert_err!( - send_asset_from_asset_hub_westend(destination.clone(), (native_token.clone(), amount)), - DispatchError::Module(sp_runtime::ModuleError { - index: 31, - error: [1, 0, 0, 0], - message: Some("SendFailure") - }) - ); - - // set exact version for BridgeHubWestend to `2` without `ExportMessage` instruction - AssetHubWestend::force_xcm_version( - ParentThen(Parachain(BridgeHubWestend::para_id().into()).into()).into(), - xcm::v2::prelude::XCM_VERSION, - ); - // send XCM from AssetHubWestend - fails - `ExportMessage` is not in `2` - assert_err!( - send_asset_from_asset_hub_westend(destination.clone(), (native_token.clone(), amount)), - DispatchError::Module(sp_runtime::ModuleError { - index: 31, - error: [1, 0, 0, 0], - message: Some("SendFailure") - }) - ); - } + AssetHubWestend::force_xcm_version(destination.clone(), newer_xcm_version); // set version with `ExportMessage` for BridgeHubWestend AssetHubWestend::force_xcm_version( ParentThen(Parachain(BridgeHubWestend::para_id().into()).into()).into(), - xcm::v3::prelude::XCM_VERSION, + newer_xcm_version, ); // send XCM from AssetHubWestend - ok - assert_ok!(send_asset_from_asset_hub_westend( + assert_ok!(send_assets_from_asset_hub_westend( destination.clone(), - (native_token.clone(), amount) + (native_token.clone(), amount).into(), + 0 )); // `ExportMessage` on local BridgeHub - fails - remote BridgeHub version not known assert_bridge_hub_westend_message_accepted(false); // set version for remote BridgeHub on BridgeHubWestend - BridgeHubWestend::force_xcm_version( - bridge_hub_rococo_location(), - xcm::v3::prelude::XCM_VERSION, - ); + BridgeHubWestend::force_xcm_version(bridge_hub_rococo_location(), newer_xcm_version); // set version for AssetHubRococo on BridgeHubRococo BridgeHubRococo::force_xcm_version( ParentThen(Parachain(AssetHubRococo::para_id().into()).into()).into(), - xcm::v3::prelude::XCM_VERSION, + newer_xcm_version, ); // send XCM from AssetHubWestend - ok - assert_ok!(send_asset_from_asset_hub_westend( + assert_ok!(send_assets_from_asset_hub_westend( destination.clone(), - (native_token.clone(), amount) + (native_token.clone(), amount).into(), + 0 )); assert_bridge_hub_westend_message_accepted(true); assert_bridge_hub_rococo_message_received(); @@ -164,20 +140,4 @@ fn send_xcm_through_opened_lane_with_different_xcm_version_on_hops_works() { ] ); }); - - // TODO: remove this block, when removing `xcm:v2` - { - // set `2` version for remote BridgeHub on BridgeHubRococo, which does not have - // `UniversalOrigin` and `DescendOrigin` - BridgeHubWestend::force_xcm_version( - bridge_hub_rococo_location(), - xcm::v2::prelude::XCM_VERSION, - ); - - // send XCM from AssetHubWestend - ok - assert_ok!(send_asset_from_asset_hub_westend(destination, (native_token, amount))); - // message is not accepted on the local BridgeHub (`DestinationUnsupported`) because we - // cannot add `UniversalOrigin` and `DescendOrigin` - assert_bridge_hub_westend_message_accepted(false); - } } diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/snowbridge.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/snowbridge.rs new file mode 100644 index 0000000000000000000000000000000000000000..b4db9b365f390c820b83ca069912a5fa09e2a069 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/snowbridge.rs @@ -0,0 +1,307 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +use crate::imports::*; +use asset_hub_westend_runtime::xcm_config::bridging::to_ethereum::DefaultBridgeHubEthereumBaseFee; +use bridge_hub_westend_runtime::EthereumInboundQueue; +use codec::{Decode, Encode}; +use frame_support::pallet_prelude::TypeInfo; +use hex_literal::hex; +use snowbridge_core::outbound::OperatingMode; +use snowbridge_router_primitives::inbound::{ + Command, ConvertMessage, Destination, MessageV1, VersionedMessage, +}; +use testnet_parachains_constants::westend::snowbridge::EthereumNetwork; + +const INITIAL_FUND: u128 = 5_000_000_000_000_000_000; +pub const CHAIN_ID: u64 = 11155111; +pub const WETH: [u8; 20] = hex!("87d1f7fdfEe7f651FaBc8bFCB6E086C278b77A7d"); +const ETHEREUM_DESTINATION_ADDRESS: [u8; 20] = hex!("44a57ee2f2FCcb85FDa2B0B18EBD0D8D2333700e"); +const XCM_FEE: u128 = 100_000_000_000; +const WETH_AMOUNT: u128 = 1_000_000_000; + +#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)] +pub enum ControlCall { + #[codec(index = 3)] + CreateAgent, + #[codec(index = 4)] + CreateChannel { mode: OperatingMode }, +} + +#[allow(clippy::large_enum_variant)] +#[derive(Encode, Decode, Debug, PartialEq, Eq, Clone, TypeInfo)] +pub enum SnowbridgeControl { + #[codec(index = 83)] + Control(ControlCall), +} + +/// Tests the registering of a token as an asset on AssetHub. +#[test] +fn register_weth_token_from_ethereum_to_asset_hub() { + // Fund AssetHub sovereign account so that it can pay execution fees. + BridgeHubWestend::fund_para_sovereign(AssetHubWestend::para_id().into(), INITIAL_FUND); + + BridgeHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + type Converter = ::MessageConverter; + + let message = VersionedMessage::V1(MessageV1 { + chain_id: CHAIN_ID, + command: Command::RegisterToken { token: WETH.into(), fee: XCM_FEE }, + }); + let (xcm, _) = Converter::convert(message).unwrap(); + let _ = EthereumInboundQueue::send_xcm(xcm, AssetHubRococo::para_id().into()).unwrap(); + + assert_expected_events!( + BridgeHubWestend, + vec![ + RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {}, + ] + ); + }); + + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::ForeignAssets(pallet_assets::Event::Created { .. }) => {}, + ] + ); + }); +} + +/// Tests the registering of a token as an asset on AssetHub, and then subsequently sending +/// a token from Ethereum to AssetHub. +#[test] +fn send_token_from_ethereum_to_asset_hub() { + let asset_hub_sovereign = BridgeHubWestend::sovereign_account_id_of(Location::new( + 1, + [Parachain(AssetHubWestend::para_id().into())], + )); + // Fund AssetHub sovereign account so it can pay execution fees for the asset transfer + BridgeHubWestend::fund_accounts(vec![(asset_hub_sovereign.clone(), INITIAL_FUND)]); + + // Fund ethereum sovereign on AssetHub + AssetHubWestend::fund_accounts(vec![(AssetHubWestendReceiver::get(), INITIAL_FUND)]); + + let weth_asset_location: Location = + (Parent, Parent, EthereumNetwork::get(), AccountKey20 { network: None, key: WETH }).into(); + + AssetHubWestend::execute_with(|| { + type RuntimeOrigin = ::RuntimeOrigin; + + assert_ok!(::ForeignAssets::force_create( + RuntimeOrigin::root(), + weth_asset_location.clone().try_into().unwrap(), + asset_hub_sovereign.into(), + false, + 1, + )); + + assert!(::ForeignAssets::asset_exists( + weth_asset_location.clone().try_into().unwrap(), + )); + }); + + BridgeHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + type Converter = ::MessageConverter; + + let message = VersionedMessage::V1(MessageV1 { + chain_id: CHAIN_ID, + command: Command::SendToken { + token: WETH.into(), + destination: Destination::AccountId32 { id: AssetHubWestendReceiver::get().into() }, + amount: WETH_AMOUNT, + fee: XCM_FEE, + }, + }); + let (xcm, _) = Converter::convert(message).unwrap(); + let _ = EthereumInboundQueue::send_xcm(xcm, AssetHubWestend::para_id().into()).unwrap(); + + // Check that the message was sent + assert_expected_events!( + BridgeHubWestend, + vec![ + RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {}, + ] + ); + }); + + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + // Check that the token was received and issued as a foreign asset on AssetHub + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { .. }) => {}, + ] + ); + }); +} + +/// Tests the full cycle of token transfers: +/// - registering a token on AssetHub +/// - sending a token to AssetHub +/// - returning the token to Ethereum +#[test] +fn send_weth_asset_from_asset_hub_to_ethereum() { + let assethub_location = BridgeHubWestend::sibling_location_of(AssetHubWestend::para_id()); + let assethub_sovereign = BridgeHubWestend::sovereign_account_id_of(assethub_location); + let weth_asset_location: Location = + (Parent, Parent, EthereumNetwork::get(), AccountKey20 { network: None, key: WETH }).into(); + + AssetHubWestend::force_default_xcm_version(Some(XCM_VERSION)); + BridgeHubWestend::force_default_xcm_version(Some(XCM_VERSION)); + AssetHubWestend::force_xcm_version( + Location::new(2, [GlobalConsensus(Ethereum { chain_id: CHAIN_ID })]), + XCM_VERSION, + ); + + BridgeHubWestend::fund_accounts(vec![(assethub_sovereign.clone(), INITIAL_FUND)]); + + AssetHubWestend::execute_with(|| { + type RuntimeOrigin = ::RuntimeOrigin; + + assert_ok!(::ForeignAssets::force_create( + RuntimeOrigin::root(), + weth_asset_location.clone().try_into().unwrap(), + assethub_sovereign.clone().into(), + false, + 1, + )); + + assert!(::ForeignAssets::asset_exists( + weth_asset_location.clone().try_into().unwrap(), + )); + }); + + BridgeHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + type Converter = ::MessageConverter; + + let message = VersionedMessage::V1(MessageV1 { + chain_id: CHAIN_ID, + command: Command::SendToken { + token: WETH.into(), + destination: Destination::AccountId32 { id: AssetHubWestendReceiver::get().into() }, + amount: WETH_AMOUNT, + fee: XCM_FEE, + }, + }); + let (xcm, _) = Converter::convert(message).unwrap(); + let _ = EthereumInboundQueue::send_xcm(xcm, AssetHubWestend::para_id().into()).unwrap(); + + // Check that the send token message was sent using xcm + assert_expected_events!( + BridgeHubWestend, + vec![ + RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) =>{},] + ); + }); + + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + type RuntimeOrigin = ::RuntimeOrigin; + + // Check that AssetHub has issued the foreign asset + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::ForeignAssets(pallet_assets::Event::Issued { .. }) => {}, + ] + ); + let assets = vec![Asset { + id: AssetId(Location::new( + 2, + [ + GlobalConsensus(Ethereum { chain_id: CHAIN_ID }), + AccountKey20 { network: None, key: WETH }, + ], + )), + fun: Fungible(WETH_AMOUNT), + }]; + let multi_assets = VersionedAssets::V4(Assets::from(assets)); + + let destination = VersionedLocation::V4(Location::new( + 2, + [GlobalConsensus(Ethereum { chain_id: CHAIN_ID })], + )); + + let beneficiary = VersionedLocation::V4(Location::new( + 0, + [AccountKey20 { network: None, key: ETHEREUM_DESTINATION_ADDRESS.into() }], + )); + + let free_balance_before = + ::Balances::free_balance( + AssetHubWestendReceiver::get(), + ); + // Send the Weth back to Ethereum + ::PolkadotXcm::limited_reserve_transfer_assets( + RuntimeOrigin::signed(AssetHubWestendReceiver::get()), + Box::new(destination), + Box::new(beneficiary), + Box::new(multi_assets), + 0, + Unlimited, + ) + .unwrap(); + let free_balance_after = ::Balances::free_balance( + AssetHubWestendReceiver::get(), + ); + // Assert at least DefaultBridgeHubEthereumBaseFee charged from the sender + let free_balance_diff = free_balance_before - free_balance_after; + assert!(free_balance_diff > DefaultBridgeHubEthereumBaseFee::get()); + }); + + BridgeHubWestend::execute_with(|| { + use bridge_hub_westend_runtime::xcm_config::TreasuryAccount; + type RuntimeEvent = ::RuntimeEvent; + // Check that the transfer token back to Ethereum message was queue in the Ethereum + // Outbound Queue + assert_expected_events!( + BridgeHubWestend, + vec![ + + RuntimeEvent::EthereumOutboundQueue(snowbridge_pallet_outbound_queue::Event::MessageQueued + {..}) => {}, ] + ); + let events = BridgeHubWestend::events(); + // Check that the local fee was credited to the Snowbridge sovereign account + assert!( + events.iter().any(|event| matches!( + event, + RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) + if *who == TreasuryAccount::get().into() && *amount == 5071000000 + )), + "Snowbridge sovereign takes local fee." + ); + // Check that the remote fee was credited to the AssetHub sovereign account + assert!( + events.iter().any(|event| matches!( + event, + RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) + if *who == assethub_sovereign && *amount == 2680000000000, + )), + "AssetHub sovereign takes remote fee." + ); + }); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/teleport.rs index c960233c08b73df30b2f873f2ef5333ea15bf428..a5add3b82957cf83a3d49dc04e32ace90e9bf099 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/bridges/bridge-hub-westend/src/tests/teleport.rs @@ -13,8 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use crate::tests::*; -use bridge_hub_westend_runtime::xcm_config::XcmConfig; +use crate::imports::*; #[test] fn teleport_to_other_system_parachains_works() { @@ -22,9 +21,29 @@ fn teleport_to_other_system_parachains_works() { let native_asset: Assets = (Parent, amount).into(); test_parachain_is_trusted_teleporter!( - BridgeHubWestend, // Origin - XcmConfig, // XCM configuration - vec![AssetHubWestend], // Destinations + BridgeHubWestend, // Origin + BridgeHubWestendXcmConfig, // XCM configuration + vec![AssetHubWestend], // Destinations (native_asset, amount) ); } + +#[test] +fn teleport_from_and_to_relay() { + let amount = WESTEND_ED * 100; + let native_asset: Assets = (Here, amount).into(); + + test_relay_is_trusted_teleporter!( + Westend, + WestendXcmConfig, + vec![BridgeHubWestend], + (native_asset, amount) + ); + + test_parachain_is_trusted_teleporter_for_relay!( + BridgeHubWestend, + BridgeHubWestendXcmConfig, + Westend, + amount + ); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/Cargo.toml index d1dbef9fc4156c08b2c52f54a3759de763c959e0..c4d281b75a77b32a9772ade66e2dbb0837cc8fcf 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/Cargo.toml @@ -11,33 +11,31 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } -assert_matches = "1.5.0" +codec = { workspace = true } +assert_matches = { workspace = true } # Substrate -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-asset-rate = { path = "../../../../../../../substrate/frame/asset-rate", default-features = false } -pallet-assets = { path = "../../../../../../../substrate/frame/assets", default-features = false } -pallet-treasury = { path = "../../../../../../../substrate/frame/treasury", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue", default-features = false } -pallet-utility = { path = "../../../../../../../substrate/frame/utility", default-features = false } +sp-runtime = { workspace = true } +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-asset-rate = { workspace = true } +pallet-assets = { workspace = true } +pallet-treasury = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-utility = { workspace = true } +pallet-whitelist = { workspace = true } # Polkadot -polkadot-runtime-common = { path = "../../../../../../../polkadot/runtime/common" } -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } -pallet-xcm = { path = "../../../../../../../polkadot/xcm/pallet-xcm", default-features = false } -westend-runtime = { path = "../../../../../../../polkadot/runtime/westend" } -westend-runtime-constants = { path = "../../../../../../../polkadot/runtime/westend/constants" } +polkadot-runtime-common = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } +pallet-xcm = { workspace = true } +westend-runtime-constants = { workspace = true, default-features = true } # Cumulus -parachains-common = { path = "../../../../../../parachains/common" } -testnet-parachains-constants = { path = "../../../../../runtimes/constants", features = ["westend"] } -asset-hub-westend-runtime = { path = "../../../../../runtimes/assets/asset-hub-westend" } -collectives-westend-runtime = { path = "../../../../../runtimes/collectives/collectives-westend" } -cumulus-pallet-xcmp-queue = { default-features = false, path = "../../../../../../pallets/xcmp-queue" } -cumulus-pallet-parachain-system = { default-features = false, path = "../../../../../../pallets/parachain-system" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -westend-system-emulated-network = { path = "../../../networks/westend-system" } +parachains-common = { workspace = true, default-features = true } +testnet-parachains-constants = { features = ["westend"], workspace = true, default-features = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +emulated-integration-tests-common = { workspace = true } +westend-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/lib.rs index 97239330216ac8f66a7684811d1de30b13f56f7e..e2048b62c311254ab474172ee49494aa87166c85 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/lib.rs @@ -15,15 +15,42 @@ pub use xcm::{prelude::*, v3}; -pub use emulated_integration_tests_common::xcm_emulator::{ - assert_expected_events, bx, Chain, RelayChain as Relay, TestExt, +pub use emulated_integration_tests_common::{ + accounts::ALICE, + test_parachain_is_trusted_teleporter, + xcm_emulator::{assert_expected_events, bx, Chain, Parachain, RelayChain as Relay, TestExt}, }; pub use westend_system_emulated_network::{ - asset_hub_westend_emulated_chain::AssetHubWestendParaPallet as AssetHubWestendPallet, - collectives_westend_emulated_chain::CollectivesWestendParaPallet as CollectivesWestendPallet, - westend_emulated_chain::WestendRelayPallet as WestendPallet, - AssetHubWestendPara as AssetHubWestend, CollectivesWestendPara as CollectivesWestend, - WestendRelay as Westend, + asset_hub_westend_emulated_chain::{ + asset_hub_westend_runtime::xcm_config::{ + LocationToAccountId as AssetHubLocationToAccountId, + XcmConfig as AssetHubWestendXcmConfig, + }, + genesis::ED as ASSET_HUB_WESTEND_ED, + AssetHubWestendParaPallet as AssetHubWestendPallet, + }, + collectives_westend_emulated_chain::{ + collectives_westend_runtime::{ + fellowship as collectives_fellowship, + xcm_config::XcmConfig as CollectivesWestendXcmConfig, + }, + genesis::ED as COLLECTIVES_WESTEND_ED, + CollectivesWestendParaPallet as CollectivesWestendPallet, + }, + westend_emulated_chain::{ + genesis::ED as WESTEND_ED, + westend_runtime::{ + governance as westend_governance, xcm_config::XcmConfig as WestendXcmConfig, + OriginCaller as WestendOriginCaller, + }, + WestendRelayPallet as WestendPallet, + }, + AssetHubWestendPara as AssetHubWestend, AssetHubWestendParaReceiver as AssetHubWestendReceiver, + AssetHubWestendParaSender as AssetHubWestendSender, + CollectivesWestendPara as CollectivesWestend, + CollectivesWestendParaReceiver as CollectivesWestendReceiver, + CollectivesWestendParaSender as CollectivesWestendSender, WestendRelay as Westend, + WestendRelayReceiver as WestendReceiver, WestendRelaySender as WestendSender, }; #[cfg(test)] diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship.rs new file mode 100644 index 0000000000000000000000000000000000000000..f97599bda7f08be29d3388cd4a0856db77a30858 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship.rs @@ -0,0 +1,72 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::*; +use codec::Encode; +use collectives_fellowship::pallet_fellowship_origins::Origin::Fellows as FellowsOrigin; +use frame_support::{assert_ok, sp_runtime::traits::Dispatchable}; + +#[test] +fn fellows_whitelist_call() { + CollectivesWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + type RuntimeCall = ::RuntimeCall; + type RuntimeOrigin = ::RuntimeOrigin; + type Runtime = ::Runtime; + type WestendCall = ::RuntimeCall; + type WestendRuntime = ::Runtime; + + let call_hash = [1u8; 32].into(); + + let whitelist_call = RuntimeCall::PolkadotXcm(pallet_xcm::Call::::send { + dest: bx!(VersionedLocation::from(Location::parent())), + message: bx!(VersionedXcm::from(Xcm(vec![ + UnpaidExecution { weight_limit: Unlimited, check_origin: None }, + Transact { + origin_kind: OriginKind::Xcm, + require_weight_at_most: Weight::from_parts(5_000_000_000, 500_000), + call: WestendCall::Whitelist( + pallet_whitelist::Call::::whitelist_call { call_hash } + ) + .encode() + .into(), + } + ]))), + }); + + let fellows_origin: RuntimeOrigin = FellowsOrigin.into(); + + assert_ok!(whitelist_call.dispatch(fellows_origin)); + + assert_expected_events!( + CollectivesWestend, + vec![ + RuntimeEvent::PolkadotXcm(pallet_xcm::Event::Sent { .. }) => {}, + ] + ); + }); + + Westend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + assert_expected_events!( + Westend, + vec![ + RuntimeEvent::Whitelist(pallet_whitelist::Event::CallWhitelisted { .. }) => {}, + RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { success: true, .. }) => {}, + ] + ); + }); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_salary.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_salary.rs new file mode 100644 index 0000000000000000000000000000000000000000..840d2da4946306498605853366daf46fb145ca78 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_salary.rs @@ -0,0 +1,66 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::*; +use collectives_fellowship::FellowshipSalaryPaymaster; +use frame_support::{ + assert_ok, + traits::{fungibles::Mutate, tokens::Pay}, +}; +use xcm_executor::traits::ConvertLocation; + +const FELLOWSHIP_SALARY_PALLET_ID: u8 = 64; + +#[test] +fn pay_salary() { + let asset_id: u32 = 1984; + let fellowship_salary = ( + Parent, + Parachain(CollectivesWestend::para_id().into()), + PalletInstance(FELLOWSHIP_SALARY_PALLET_ID), + ); + let pay_from = + AssetHubLocationToAccountId::convert_location(&fellowship_salary.into()).unwrap(); + let pay_to = Westend::account_id_of(ALICE); + let pay_amount = 9_000_000_000; + + AssetHubWestend::execute_with(|| { + type AssetHubAssets = ::Assets; + assert_ok!(>::mint_into(asset_id, &pay_from, pay_amount * 2)); + }); + + CollectivesWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + + assert_ok!(FellowshipSalaryPaymaster::pay(&pay_to, (), pay_amount)); + assert_expected_events!( + CollectivesWestend, + vec![ + RuntimeEvent::XcmpQueue(cumulus_pallet_xcmp_queue::Event::XcmpMessageSent { .. }) => {}, + ] + ); + }); + + AssetHubWestend::execute_with(|| { + type RuntimeEvent = ::RuntimeEvent; + assert_expected_events!( + AssetHubWestend, + vec![ + RuntimeEvent::Assets(pallet_assets::Event::Transferred { .. }) => {}, + RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { success: true ,.. }) => {}, + ] + ); + }); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_treasury.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_treasury.rs index bde1220e2495bc544e507be1a8b40d77fcbde894..943f8965540d5cb0c17c7a0b1aac8797cbd3ed42 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_treasury.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/fellowship_treasury.rs @@ -14,14 +14,11 @@ // limitations under the License. use crate::*; -use asset_hub_westend_runtime::xcm_config::LocationToAccountId as AssetHubLocationToAccountId; -use emulated_integration_tests_common::accounts::ALICE; use frame_support::{ assert_ok, dispatch::RawOrigin, instances::Instance1, sp_runtime::traits::Dispatchable, traits::fungible::Inspect, }; use polkadot_runtime_common::impls::VersionedLocatableAsset; -use westend_runtime::OriginCaller; use westend_runtime_constants::currency::UNITS; use xcm_executor::traits::ConvertLocation; @@ -65,7 +62,7 @@ fn fellowship_treasury_spend() { let treasury_location: Location = (Parent, PalletInstance(37)).into(); let teleport_call = RuntimeCall::Utility(pallet_utility::Call::::dispatch_as { - as_origin: bx!(OriginCaller::system(RawOrigin::Signed(treasury_account))), + as_origin: bx!(WestendOriginCaller::system(RawOrigin::Signed(treasury_account))), call: bx!(RuntimeCall::XcmPallet(pallet_xcm::Call::::teleport_assets { dest: bx!(VersionedLocation::V4(asset_hub_location.clone())), beneficiary: bx!(VersionedLocation::V4(treasury_location)), @@ -97,7 +94,7 @@ fn fellowship_treasury_spend() { // Fund Fellowship Treasury from Westend Treasury. let treasury_origin: RuntimeOrigin = - westend_runtime::governance::pallet_custom_origins::Origin::Treasurer.into(); + westend_governance::pallet_custom_origins::Origin::Treasurer.into(); let fellowship_treasury_location: Location = Location::new(1, [Parachain(1001), PalletInstance(65)]); let asset_hub_location: Location = [Parachain(1000)].into(); @@ -170,8 +167,7 @@ fn fellowship_treasury_spend() { // Fund Alice account from Fellowship Treasury. let fellows_origin: RuntimeOrigin = - collectives_westend_runtime::fellowship::pallet_fellowship_origins::Origin::Fellows - .into(); + collectives_fellowship::pallet_fellowship_origins::Origin::Fellows.into(); let asset_hub_location: Location = (Parent, Parachain(1000)).into(); let native_asset = Location::parent(); diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/mod.rs index a9f65df34b647835b4ce5585be6b53b0489de578..ef4e4885183d092c087329b8ebc414afa105a500 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/mod.rs @@ -13,4 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +mod fellowship; +mod fellowship_salary; mod fellowship_treasury; +mod teleport; diff --git a/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/teleport.rs new file mode 100644 index 0000000000000000000000000000000000000000..32f543406d759da1a5f0d06de851930f8ae2b00f --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/collectives/collectives-westend/src/tests/teleport.rs @@ -0,0 +1,66 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +use crate::*; +use emulated_integration_tests_common::{ + test_parachain_is_trusted_teleporter_for_relay, test_relay_is_trusted_teleporter, +}; +use frame_support::assert_ok; + +#[test] +fn teleport_from_and_to_relay() { + let amount = WESTEND_ED * 10; + let native_asset: Assets = (Here, amount).into(); + + test_relay_is_trusted_teleporter!( + Westend, // Origin + WestendXcmConfig, // XCM Configuration + vec![CollectivesWestend], // Destinations + (native_asset, amount) + ); + + test_parachain_is_trusted_teleporter_for_relay!( + CollectivesWestend, // Origin + CollectivesWestendXcmConfig, // XCM Configuration + Westend, // Destination + amount + ); +} + +#[test] +fn teleport_from_collectives_to_asset_hub() { + let amount = ASSET_HUB_WESTEND_ED * 100; + let native_asset: Assets = (Parent, amount).into(); + + test_parachain_is_trusted_teleporter!( + CollectivesWestend, // Origin + CollectivesWestendXcmConfig, // XCM Configuration + vec![AssetHubWestend], // Destinations + (native_asset, amount) + ); +} + +#[test] +fn teleport_from_asset_hub_to_collectives() { + let amount = COLLECTIVES_WESTEND_ED * 100; + let native_asset: Assets = (Parent, amount).into(); + + test_parachain_is_trusted_teleporter!( + AssetHubWestend, // Origin + AssetHubWestendXcmConfig, // XCM Configuration + vec![CollectivesWestend], // Destinations + (native_asset, amount) + ); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..259be790c3e5f789b8ee180fef068e596b2c1fdd --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "coretime-rococo-integration-tests" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +description = "Coretime Rococo runtime integration tests with xcm-emulator" +publish = false + +[dependencies] + +# Substrate +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-identity = { workspace = true } +sp-runtime = { workspace = true } + +# Polkadot +polkadot-runtime-common = { workspace = true, default-features = true } +rococo-runtime-constants = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } + +# Cumulus +emulated-integration-tests-common = { workspace = true } +rococo-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..ad3c4fd58da991af243db4b611fd1e6279429f5d --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/lib.rs @@ -0,0 +1,40 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#[cfg(test)] +mod imports { + + // Substrate + pub use frame_support::assert_ok; + + // Polkadot + pub use xcm::prelude::*; + + // Cumulus + pub use emulated_integration_tests_common::xcm_emulator::{ + assert_expected_events, bx, TestExt, + }; + pub use rococo_system_emulated_network::{ + coretime_rococo_emulated_chain::{ + coretime_rococo_runtime::ExistentialDeposit as CoretimeRococoExistentialDeposit, + CoretimeRococoParaPallet as CoretimeRococoPallet, + }, + CoretimeRococoPara as CoretimeRococo, CoretimeRococoParaReceiver as CoretimeRococoReceiver, + CoretimeRococoParaSender as CoretimeRococoSender, + }; +} + +#[cfg(test)] +mod tests; diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..e37b915174d36d33d86ce0ff2c7fbef2b3c91024 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = CoretimeRococoExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(CoretimeRococo, RuntimeCall, NetworkId::Rococo, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e78351bce03110a3722cf699c7c70fa9b9a5341 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-rococo/src/tests/mod.rs @@ -0,0 +1,16 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +mod claim_assets; diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..a8fa905d2e5ee4f1905bcf420fa135f8612c7796 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/Cargo.toml @@ -0,0 +1,27 @@ +[package] +name = "coretime-westend-integration-tests" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +description = "Coretime Westend runtime integration tests with xcm-emulator" +publish = false + +[dependencies] + +# Substrate +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-identity = { workspace = true } +sp-runtime = { workspace = true } + +# Polkadot +polkadot-runtime-common = { workspace = true, default-features = true } +westend-runtime-constants = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } + +# Cumulus +emulated-integration-tests-common = { workspace = true } +westend-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..838ca6eeafb67db1c78159f78877a35a207c2a41 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/lib.rs @@ -0,0 +1,41 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#[cfg(test)] +mod imports { + + // Substrate + pub use frame_support::assert_ok; + + // Polkadot + pub use xcm::prelude::*; + + // Cumulus + pub use emulated_integration_tests_common::xcm_emulator::{ + assert_expected_events, bx, TestExt, + }; + pub use westend_system_emulated_network::{ + coretime_westend_emulated_chain::{ + coretime_westend_runtime::ExistentialDeposit as CoretimeWestendExistentialDeposit, + CoretimeWestendParaPallet as CoretimeWestendPallet, + }, + CoretimeWestendPara as CoretimeWestend, + CoretimeWestendParaReceiver as CoretimeWestendReceiver, + CoretimeWestendParaSender as CoretimeWestendSender, + }; +} + +#[cfg(test)] +mod tests; diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..c8d853698444c3dfc047ae1b860eee742efca004 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = CoretimeWestendExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(CoretimeWestend, RuntimeCall, NetworkId::Westend, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e78351bce03110a3722cf699c7c70fa9b9a5341 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/coretime/coretime-westend/src/tests/mod.rs @@ -0,0 +1,16 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +mod claim_assets; diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/Cargo.toml index 1570aa7662fcbbfe1b018251d2700ce2d653d165..011be93ecac73f06a73616802d19a0e871cd8b30 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/Cargo.toml @@ -8,25 +8,23 @@ description = "People Rococo runtime integration tests with xcm-emulator" publish = false [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } +codec = { workspace = true } # Substrate -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue", default-features = false } -pallet-identity = { path = "../../../../../../../substrate/frame/identity", default-features = false } +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-identity = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } -rococo-runtime = { path = "../../../../../../../polkadot/runtime/rococo" } -rococo-runtime-constants = { path = "../../../../../../../polkadot/runtime/rococo/constants" } -polkadot-runtime-common = { path = "../../../../../../../polkadot/runtime/common" } +polkadot-runtime-common = { workspace = true, default-features = true } +rococo-runtime-constants = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -asset-test-utils = { path = "../../../../../runtimes/assets/test-utils" } -parachains-common = { path = "../../../../../common" } -people-rococo-runtime = { path = "../../../../../runtimes/people/people-rococo" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -rococo-system-emulated-network = { path = "../../../networks/rococo-system" } +asset-test-utils = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +parachains-common = { workspace = true, default-features = true } +rococo-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/lib.rs index 38ff08b486d4703513ab74d681ae5f07107931ec..06b0b6ba600534793b83f24e6e8d9b9d730736bd 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/lib.rs @@ -15,15 +15,8 @@ #[cfg(test)] mod imports { - pub use codec::Encode; - // Substrate - pub use frame_support::{ - assert_ok, - pallet_prelude::Weight, - sp_runtime::{AccountId32, DispatchResult}, - traits::fungibles::Inspect, - }; + pub use frame_support::{assert_ok, sp_runtime::DispatchResult, traits::fungibles::Inspect}; // Polkadot pub use xcm::prelude::*; @@ -37,15 +30,21 @@ mod imports { pub use parachains_common::Balance; pub use rococo_system_emulated_network::{ people_rococo_emulated_chain::{ - genesis::ED as PEOPLE_ROCOCO_ED, PeopleRococoParaPallet as PeopleRococoPallet, + people_rococo_runtime::{ + xcm_config::XcmConfig as PeopleRococoXcmConfig, + ExistentialDeposit as PeopleRococoExistentialDeposit, + }, + PeopleRococoParaPallet as PeopleRococoPallet, + }, + rococo_emulated_chain::{ + genesis::ED as ROCOCO_ED, rococo_runtime::xcm_config::XcmConfig as RococoXcmConfig, + RococoRelayPallet as RococoPallet, }, - rococo_emulated_chain::{genesis::ED as ROCOCO_ED, RococoRelayPallet as RococoPallet}, PeopleRococoPara as PeopleRococo, PeopleRococoParaReceiver as PeopleRococoReceiver, PeopleRococoParaSender as PeopleRococoSender, RococoRelay as Rococo, RococoRelayReceiver as RococoReceiver, RococoRelaySender as RococoSender, }; - pub type RelayToSystemParaTest = Test; pub type SystemParaToRelayTest = Test; } diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..793200e1d06b870327942229252d56bcb46405f9 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = PeopleRococoExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(PeopleRococo, RuntimeCall, NetworkId::Rococo, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/mod.rs index 80c00021ca53db3850d6d32c1584ae7ae924933f..08749b295dc21def8feb2c2318bcbed2b258ba9e 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/mod.rs @@ -13,5 +13,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -mod reap_identity; +mod claim_assets; mod teleport; diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/reap_identity.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/reap_identity.rs deleted file mode 100644 index 3f1f8638d6fa1491288cd6bbd60f08c13af566dd..0000000000000000000000000000000000000000 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/reap_identity.rs +++ /dev/null @@ -1,549 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 - -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -//! # OnReapIdentity Tests -//! -//! This file contains the test cases for migrating Identity data away from the Rococo Relay -//! chain and to the PeopleRococo parachain. This migration is part of the broader Minimal Relay -//! effort: -//! https://github.com/polkadot-fellows/RFCs/blob/main/text/0032-minimal-relay.md -//! -//! ## Overview -//! -//! The tests validate the robustness and correctness of the `OnReapIdentityHandler` -//! ensuring that it behaves as expected in various scenarios. Key aspects tested include: -//! -//! - **Deposit Handling**: Confirming that deposits are correctly migrated from the Relay Chain to -//! the People parachain in various scenarios (different `IdentityInfo` fields and different -//! numbers of sub-accounts). -//! -//! ### Test Scenarios -//! -//! The tests are categorized into several scenarios, each resulting in different deposits required -//! on the destination parachain. The tests ensure: -//! -//! - Reserved deposits on the Relay Chain are fully released; -//! - The freed deposit from the Relay Chain is sufficient for the parachain deposit; and -//! - The account will exist on the parachain. - -use crate::imports::*; -use frame_support::BoundedVec; -use pallet_balances::Event as BalancesEvent; -use pallet_identity::{legacy::IdentityInfo, Data, Event as IdentityEvent}; -use people_rococo_runtime::people::{ - BasicDeposit as BasicDepositParachain, ByteDeposit as ByteDepositParachain, - IdentityInfo as IdentityInfoParachain, SubAccountDeposit as SubAccountDepositParachain, -}; -use rococo_runtime::{ - BasicDeposit, ByteDeposit, MaxAdditionalFields, MaxSubAccounts, RuntimeOrigin as RococoOrigin, - SubAccountDeposit, -}; -use rococo_runtime_constants::currency::*; -use rococo_system_emulated_network::{ - rococo_emulated_chain::RococoRelayPallet, RococoRelay, RococoRelaySender, -}; - -type Balance = u128; -type RococoIdentity = ::Identity; -type RococoBalances = ::Balances; -type RococoIdentityMigrator = ::IdentityMigrator; -type PeopleRococoIdentity = ::Identity; -type PeopleRococoBalances = ::Balances; - -#[derive(Clone, Debug)] -struct Identity { - relay: IdentityInfo, - para: IdentityInfoParachain, - subs: Subs, -} - -impl Identity { - fn new( - full: bool, - additional: Option>, - subs: Subs, - ) -> Self { - let pgp_fingerprint = [ - 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, - 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, - ]; - let make_data = |data: &[u8], full: bool| -> Data { - if full { - Data::Raw(data.to_vec().try_into().unwrap()) - } else { - Data::None - } - }; - let (github, discord) = additional - .as_ref() - .and_then(|vec| vec.first()) - .map(|(g, d)| (g.clone(), d.clone())) - .unwrap_or((Data::None, Data::None)); - Self { - relay: IdentityInfo { - display: make_data(b"xcm-test", full), - legal: make_data(b"The Xcm Test, Esq.", full), - web: make_data(b"https://visitme/", full), - riot: make_data(b"xcm-riot", full), - email: make_data(b"xcm-test@gmail.com", full), - pgp_fingerprint: Some(pgp_fingerprint), - image: make_data(b"xcm-test.png", full), - twitter: make_data(b"@xcm-test", full), - additional: additional.unwrap_or_default(), - }, - para: IdentityInfoParachain { - display: make_data(b"xcm-test", full), - legal: make_data(b"The Xcm Test, Esq.", full), - web: make_data(b"https://visitme/", full), - matrix: make_data(b"xcm-matrix@server", full), - email: make_data(b"xcm-test@gmail.com", full), - pgp_fingerprint: Some(pgp_fingerprint), - image: make_data(b"xcm-test.png", full), - twitter: make_data(b"@xcm-test", full), - github, - discord, - }, - subs, - } - } -} - -#[derive(Clone, Debug)] -enum Subs { - Zero, - Many(u32), -} - -enum IdentityOn<'a> { - Relay(&'a IdentityInfo), - Para(&'a IdentityInfoParachain), -} - -impl IdentityOn<'_> { - fn calculate_deposit(self) -> Balance { - match self { - IdentityOn::Relay(id) => { - let base_deposit = BasicDeposit::get(); - let byte_deposit = - ByteDeposit::get() * TryInto::::try_into(id.encoded_size()).unwrap(); - base_deposit + byte_deposit - }, - IdentityOn::Para(id) => { - let base_deposit = BasicDepositParachain::get(); - let byte_deposit = ByteDepositParachain::get() * - TryInto::::try_into(id.encoded_size()).unwrap(); - base_deposit + byte_deposit - }, - } - } -} - -/// Generate an `AccountId32` from a `u32`. -/// This creates a 32-byte array, initially filled with `255`, and then repeatedly fills it -/// with the 4-byte little-endian representation of the `u32` value, until the array is full. -/// -/// **Example**: -/// -/// `account_from_u32(5)` will return an `AccountId32` with the bytes -/// `[0, 5, 0, 0, 0, 0, 0, 0, 0, 5 ... ]` -fn account_from_u32(id: u32) -> AccountId32 { - let mut buffer = [255u8; 32]; - let id_bytes = id.to_le_bytes(); - let id_size = id_bytes.len(); - for chunk in buffer.chunks_mut(id_size) { - chunk.clone_from_slice(&id_bytes); - } - AccountId32::new(buffer) -} - -// Set up the Relay Chain with an identity. -fn set_id_relay(id: &Identity) -> Balance { - let mut total_deposit: Balance = 0; - - // Set identity and Subs on Relay Chain - RococoRelay::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - - assert_ok!(RococoIdentity::set_identity( - RococoOrigin::signed(RococoRelaySender::get()), - Box::new(id.relay.clone()) - )); - - if let Subs::Many(n) = id.subs { - let subs: Vec<_> = (0..n) - .map(|i| (account_from_u32(i), Data::Raw(b"name".to_vec().try_into().unwrap()))) - .collect(); - - assert_ok!(RococoIdentity::set_subs( - RococoOrigin::signed(RococoRelaySender::get()), - subs, - )); - } - - let reserved_balance = RococoBalances::reserved_balance(RococoRelaySender::get()); - let id_deposit = IdentityOn::Relay(&id.relay).calculate_deposit(); - - let total_deposit = match id.subs { - Subs::Zero => { - total_deposit = id_deposit; // No subs - assert_expected_events!( - RococoRelay, - vec![ - RuntimeEvent::Identity(IdentityEvent::IdentitySet { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == RococoRelaySender::get(), - amount: *amount == id_deposit, - }, - ] - ); - total_deposit - }, - Subs::Many(n) => { - let sub_account_deposit = n as Balance * SubAccountDeposit::get(); - total_deposit = - sub_account_deposit + IdentityOn::Relay(&id.relay).calculate_deposit(); - assert_expected_events!( - RococoRelay, - vec![ - RuntimeEvent::Identity(IdentityEvent::IdentitySet { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == RococoRelaySender::get(), - amount: *amount == id_deposit, - }, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == RococoRelaySender::get(), - amount: *amount == sub_account_deposit, - }, - ] - ); - total_deposit - }, - }; - - assert_eq!(reserved_balance, total_deposit); - }); - total_deposit -} - -// Set up the parachain with an identity and (maybe) sub accounts, but with zero deposits. -fn assert_set_id_parachain(id: &Identity) { - // Set identity and Subs on Parachain with zero deposit - PeopleRococo::execute_with(|| { - let free_bal = PeopleRococoBalances::free_balance(PeopleRococoSender::get()); - let reserved_balance = PeopleRococoBalances::reserved_balance(PeopleRococoSender::get()); - - // total balance at Genesis should be zero - assert_eq!(reserved_balance + free_bal, 0); - - assert_ok!(PeopleRococoIdentity::set_identity_no_deposit( - &PeopleRococoSender::get(), - id.para.clone(), - )); - - match id.subs { - Subs::Zero => {}, - Subs::Many(n) => { - let subs: Vec<_> = (0..n) - .map(|ii| { - (account_from_u32(ii), Data::Raw(b"name".to_vec().try_into().unwrap())) - }) - .collect(); - assert_ok!(PeopleRococoIdentity::set_subs_no_deposit( - &PeopleRococoSender::get(), - subs, - )); - }, - } - - // No amount should be reserved as deposit amounts are set to 0. - let reserved_balance = PeopleRococoBalances::reserved_balance(PeopleRococoSender::get()); - assert_eq!(reserved_balance, 0); - assert!(PeopleRococoIdentity::identity(PeopleRococoSender::get()).is_some()); - - let (_, sub_accounts) = PeopleRococoIdentity::subs_of(PeopleRococoSender::get()); - - match id.subs { - Subs::Zero => assert_eq!(sub_accounts.len(), 0), - Subs::Many(n) => assert_eq!(sub_accounts.len(), n as usize), - } - }); -} - -// Reap the identity on the Relay Chain and assert that the correct things happen there. -fn assert_reap_id_relay(total_deposit: Balance, id: &Identity) { - RococoRelay::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - let free_bal_before_reap = RococoBalances::free_balance(RococoRelaySender::get()); - let reserved_balance = RococoBalances::reserved_balance(RococoRelaySender::get()); - - assert_eq!(reserved_balance, total_deposit); - - assert_ok!(RococoIdentityMigrator::reap_identity( - RococoOrigin::signed(RococoRelaySender::get()), - RococoRelaySender::get() - )); - - let remote_deposit = match id.subs { - Subs::Zero => calculate_remote_deposit(id.relay.encoded_size() as u32, 0), - Subs::Many(n) => calculate_remote_deposit(id.relay.encoded_size() as u32, n), - }; - - assert_expected_events!( - RococoRelay, - vec![ - // `reap_identity` sums the identity and subs deposits and unreserves them in one - // call. Therefore, we only expect one `Unreserved` event. - RuntimeEvent::Balances(BalancesEvent::Unreserved { who, amount }) => { - who: *who == RococoRelaySender::get(), - amount: *amount == total_deposit, - }, - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::IdentityReaped { - who, - }) => { - who: *who == PeopleRococoSender::get(), - }, - ] - ); - // Identity should be gone. - assert!(PeopleRococoIdentity::identity(RococoRelaySender::get()).is_none()); - - // Subs should be gone. - let (_, sub_accounts) = RococoIdentity::subs_of(RococoRelaySender::get()); - assert_eq!(sub_accounts.len(), 0); - - let reserved_balance = RococoBalances::reserved_balance(RococoRelaySender::get()); - assert_eq!(reserved_balance, 0); - - // Free balance should be greater (i.e. the teleport should work even if 100% of an - // account's balance is reserved for Identity). - let free_bal_after_reap = RococoBalances::free_balance(RococoRelaySender::get()); - assert!(free_bal_after_reap > free_bal_before_reap); - - // Implicit: total_deposit > remote_deposit. As in, accounts should always have enough - // reserved for the parachain deposit. - assert_eq!(free_bal_after_reap, free_bal_before_reap + total_deposit - remote_deposit); - }); -} - -// Reaping the identity on the Relay Chain will have sent an XCM program to the parachain. Ensure -// that everything happens as expected. -fn assert_reap_parachain(id: &Identity) { - PeopleRococo::execute_with(|| { - let reserved_balance = PeopleRococoBalances::reserved_balance(PeopleRococoSender::get()); - let id_deposit = IdentityOn::Para(&id.para).calculate_deposit(); - let total_deposit = match id.subs { - Subs::Zero => id_deposit, - Subs::Many(n) => id_deposit + n as Balance * SubAccountDepositParachain::get(), - }; - assert_reap_events(id_deposit, id); - assert_eq!(reserved_balance, total_deposit); - - // Should have at least one ED after in free balance after the reap. - assert!(PeopleRococoBalances::free_balance(PeopleRococoSender::get()) >= PEOPLE_ROCOCO_ED); - }); -} - -// Assert the events that should happen on the parachain upon reaping an identity on the Relay -// Chain. -fn assert_reap_events(id_deposit: Balance, id: &Identity) { - type RuntimeEvent = ::RuntimeEvent; - match id.subs { - Subs::Zero => { - assert_expected_events!( - PeopleRococo, - vec![ - // Deposit and Endowed from teleport - RuntimeEvent::Balances(BalancesEvent::Minted { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Endowed { .. }) => {}, - // Amount reserved for identity info - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleRococoSender::get(), - amount: *amount == id_deposit, - }, - // Confirmation from Migrator with individual identity and subs deposits - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::DepositUpdated { - who, identity, subs - }) => { - who: *who == PeopleRococoSender::get(), - identity: *identity == id_deposit, - subs: *subs == 0, - }, - RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { .. }) => {}, - ] - ); - }, - Subs::Many(n) => { - let subs_deposit = n as Balance * SubAccountDepositParachain::get(); - assert_expected_events!( - PeopleRococo, - vec![ - // Deposit and Endowed from teleport - RuntimeEvent::Balances(BalancesEvent::Minted { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Endowed { .. }) => {}, - // Amount reserved for identity info - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleRococoSender::get(), - amount: *amount == id_deposit, - }, - // Amount reserved for subs - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleRococoSender::get(), - amount: *amount == subs_deposit, - }, - // Confirmation from Migrator with individual identity and subs deposits - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::DepositUpdated { - who, identity, subs - }) => { - who: *who == PeopleRococoSender::get(), - identity: *identity == id_deposit, - subs: *subs == subs_deposit, - }, - RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { .. }) => {}, - ] - ); - }, - }; -} - -/// Duplicate of the impl of `ToParachainIdentityReaper` in the Rococo runtime. -fn calculate_remote_deposit(bytes: u32, subs: u32) -> Balance { - // Note: These `deposit` functions and `EXISTENTIAL_DEPOSIT` correspond to the Relay Chain's. - // Pulled in: use rococo_runtime_constants::currency::*; - let para_basic_deposit = deposit(1, 17) / 100; - let para_byte_deposit = deposit(0, 1) / 100; - let para_sub_account_deposit = deposit(1, 53) / 100; - let para_existential_deposit = EXISTENTIAL_DEPOSIT / 10; - - // pallet deposits - let id_deposit = - para_basic_deposit.saturating_add(para_byte_deposit.saturating_mul(bytes as Balance)); - let subs_deposit = para_sub_account_deposit.saturating_mul(subs as Balance); - - id_deposit - .saturating_add(subs_deposit) - .saturating_add(para_existential_deposit.saturating_mul(2)) -} - -// Represent some `additional` data that would not be migrated to the parachain. The encoded size, -// and thus the byte deposit, should decrease. -fn nonsensical_additional() -> BoundedVec<(Data, Data), MaxAdditionalFields> { - BoundedVec::try_from(vec![( - Data::Raw(b"fOo".to_vec().try_into().unwrap()), - Data::Raw(b"baR".to_vec().try_into().unwrap()), - )]) - .unwrap() -} - -// Represent some `additional` data that will be migrated to the parachain as first-class fields. -fn meaningful_additional() -> BoundedVec<(Data, Data), MaxAdditionalFields> { - BoundedVec::try_from(vec![ - ( - Data::Raw(b"github".to_vec().try_into().unwrap()), - Data::Raw(b"niels-username".to_vec().try_into().unwrap()), - ), - ( - Data::Raw(b"discord".to_vec().try_into().unwrap()), - Data::Raw(b"bohr-username".to_vec().try_into().unwrap()), - ), - ]) - .unwrap() -} - -// Execute a single test case. -fn assert_relay_para_flow(id: &Identity) { - let total_deposit = set_id_relay(id); - assert_set_id_parachain(id); - assert_reap_id_relay(total_deposit, id); - assert_reap_parachain(id); -} - -// Tests with empty `IdentityInfo`. - -#[test] -fn on_reap_identity_works_for_minimal_identity_with_zero_subs() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_minimal_identity() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_minimal_identity_with_max_subs() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Many(MaxSubAccounts::get()))); -} - -// Tests with full `IdentityInfo`. - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional_max_subs() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Many(MaxSubAccounts::get()))); -} - -// Tests with full `IdentityInfo` and `additional` fields that will _not_ be migrated. - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, Some(nonsensical_additional()), Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional() { - assert_relay_para_flow(&Identity::new(true, Some(nonsensical_additional()), Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional_max_subs() { - assert_relay_para_flow(&Identity::new( - true, - Some(nonsensical_additional()), - Subs::Many(MaxSubAccounts::get()), - )); -} - -// Tests with full `IdentityInfo` and `additional` fields that will be migrated. - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, Some(meaningful_additional()), Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional() { - assert_relay_para_flow(&Identity::new(true, Some(meaningful_additional()), Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional_max_subs() { - assert_relay_para_flow(&Identity::new( - true, - Some(meaningful_additional()), - Subs::Many(MaxSubAccounts::get()), - )); -} diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/teleport.rs index 350d87d638ab25bd66a411a67fa3f109bdaffff9..44e6b3934f0e7999d15e78d0393aed129ada2455 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-rococo/src/tests/teleport.rs @@ -14,70 +14,38 @@ // limitations under the License. use crate::imports::*; -use people_rococo_runtime::xcm_config::XcmConfig as PeopleRococoXcmConfig; -use rococo_runtime::xcm_config::XcmConfig as RococoXcmConfig; +use emulated_integration_tests_common::{ + test_parachain_is_trusted_teleporter_for_relay, test_relay_is_trusted_teleporter, +}; -fn relay_origin_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - Rococo::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(627_959_000, 7_200))); +#[test] +fn teleport_from_and_to_relay() { + let amount = ROCOCO_ED * 100; + let native_asset: Assets = (Here, amount).into(); - assert_expected_events!( + test_relay_is_trusted_teleporter!( Rococo, - vec![ - // Amount to teleport is withdrawn from Sender - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == t.sender.account_id, - amount: *amount == t.args.amount, - }, - // Amount to teleport is deposited in Relay's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - ] - ); -} - -fn relay_dest_assertions(t: SystemParaToRelayTest) { - type RuntimeEvent = ::RuntimeEvent; - - Rococo::assert_ump_queue_processed( - true, - Some(PeopleRococo::para_id()), - Some(Weight::from_parts(304_266_000, 7_186)), + RococoXcmConfig, + vec![PeopleRococo], + (native_asset, amount) ); - assert_expected_events!( + test_parachain_is_trusted_teleporter_for_relay!( + PeopleRococo, + PeopleRococoXcmConfig, Rococo, - vec![ - // Amount is withdrawn from Relay Chain's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] + amount ); } fn relay_dest_assertions_fail(_t: SystemParaToRelayTest) { - Rococo::assert_ump_queue_processed( - false, - Some(PeopleRococo::para_id()), - Some(Weight::from_parts(157_718_000, 3_593)), - ); + Rococo::assert_ump_queue_processed(false, Some(PeopleRococo::para_id()), None); } fn para_origin_assertions(t: SystemParaToRelayTest) { type RuntimeEvent = ::RuntimeEvent; - PeopleRococo::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts( - 600_000_000, - 7_000, - ))); + PeopleRococo::assert_xcm_pallet_attempted_complete(None); PeopleRococo::assert_parachain_system_ump_sent(); @@ -93,33 +61,6 @@ fn para_origin_assertions(t: SystemParaToRelayTest) { ); } -fn para_dest_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - PeopleRococo::assert_dmp_queue_complete(Some(Weight::from_parts(162_456_000, 0))); - - assert_expected_events!( - PeopleRococo, - vec![ - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - -fn relay_limited_teleport_assets(t: RelayToSystemParaTest) -> DispatchResult { - ::XcmPallet::limited_teleport_assets( - t.signed_origin, - bx!(t.args.dest.into()), - bx!(t.args.beneficiary.into()), - bx!(t.args.assets.into()), - t.args.fee_asset_item, - t.args.weight_limit, - ) -} - fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResult { ::PolkadotXcm::limited_teleport_assets( t.signed_origin, @@ -131,92 +72,8 @@ fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResu ) } -/// Limited Teleport of native asset from Relay Chain to the System Parachain should work -#[test] -fn limited_teleport_native_assets_from_relay_to_system_para_works() { - // Init values for Relay Chain - let amount_to_send: Balance = ROCOCO_ED * 1000; - let dest = Rococo::child_location_of(PeopleRococo::para_id()); - let beneficiary_id = PeopleRococoReceiver::get(); - let test_args = TestContext { - sender: RococoSender::get(), - receiver: PeopleRococoReceiver::get(), - args: TestArgs::new_relay(dest, beneficiary_id, amount_to_send), - }; - - let mut test = RelayToSystemParaTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(relay_origin_assertions); - test.set_assertion::(para_dest_assertions); - test.set_dispatchable::(relay_limited_teleport_assets); - test.assert(); - - let delivery_fees = Rococo::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); -} - -/// Limited Teleport of native asset from System Parachain to Relay Chain -/// should work when there is enough balance in Relay Chain's `CheckAccount` -#[test] -fn limited_teleport_native_assets_back_from_system_para_to_relay_works() { - // Dependency - Relay Chain's `CheckAccount` should have enough balance - limited_teleport_native_assets_from_relay_to_system_para_works(); - - let amount_to_send: Balance = PEOPLE_ROCOCO_ED * 1000; - let destination = PeopleRococo::parent_location(); - let beneficiary_id = RococoReceiver::get(); - let assets = (Parent, amount_to_send).into(); - - // Fund a sender - PeopleRococo::fund_accounts(vec![(PeopleRococoSender::get(), ROCOCO_ED * 2_000u128)]); - - let test_args = TestContext { - sender: PeopleRococoSender::get(), - receiver: RococoReceiver::get(), - args: TestArgs::new_para(destination, beneficiary_id, amount_to_send, assets, None, 0), - }; - - let mut test = SystemParaToRelayTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(para_origin_assertions); - test.set_assertion::(relay_dest_assertions); - test.set_dispatchable::(system_para_limited_teleport_assets); - test.assert(); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - let delivery_fees = PeopleRococo::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); -} - /// Limited Teleport of native asset from System Parachain to Relay Chain -/// should't work when there is not enough balance in Relay Chain's `CheckAccount` +/// shouldn't work when there is not enough balance in Relay Chain's `CheckAccount` #[test] fn limited_teleport_native_assets_from_system_para_to_relay_fails() { // Init values for Relay Chain diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/Cargo.toml b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/Cargo.toml index bc093dc0de6356d7cd98d20d12d63748ed248ff5..aa6eebc5458f4a1f149b8d5981f18d9e646e7339 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/Cargo.toml +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/Cargo.toml @@ -8,25 +8,24 @@ description = "People Westend runtime integration tests with xcm-emulator" publish = false [dependencies] -codec = { package = "parity-scale-codec", version = "3.4.0", default-features = false } +codec = { workspace = true } # Substrate -sp-runtime = { path = "../../../../../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../../../../../substrate/frame/support", default-features = false } -pallet-balances = { path = "../../../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../../../substrate/frame/message-queue", default-features = false } -pallet-identity = { path = "../../../../../../../substrate/frame/identity", default-features = false } +frame-support = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-identity = { workspace = true } +pallet-xcm = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../../../../polkadot/xcm/xcm-executor", default-features = false } -westend-runtime = { path = "../../../../../../../polkadot/runtime/westend" } -westend-runtime-constants = { path = "../../../../../../../polkadot/runtime/westend/constants" } -polkadot-runtime-common = { path = "../../../../../../../polkadot/runtime/common" } +polkadot-runtime-common = { workspace = true, default-features = true } +westend-runtime-constants = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -asset-test-utils = { path = "../../../../../runtimes/assets/test-utils" } -parachains-common = { path = "../../../../../common" } -people-westend-runtime = { path = "../../../../../runtimes/people/people-westend" } -emulated-integration-tests-common = { path = "../../../common", default-features = false } -westend-system-emulated-network = { path = "../../../networks/westend-system" } +asset-test-utils = { workspace = true, default-features = true } +emulated-integration-tests-common = { workspace = true } +parachains-common = { workspace = true, default-features = true } +westend-system-emulated-network = { workspace = true } diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/lib.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/lib.rs index 77ac7cfc78c78c6f51ea174b2436d05ee612e0b7..418cfea07ddc2b7fec7e372fd7c54e62631f4df8 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/lib.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/lib.rs @@ -15,14 +15,8 @@ #[cfg(test)] mod imports { - pub use codec::Encode; // Substrate - pub use frame_support::{ - assert_ok, - pallet_prelude::Weight, - sp_runtime::{AccountId32, DispatchResult}, - traits::fungibles::Inspect, - }; + pub use frame_support::{assert_ok, sp_runtime::DispatchResult, traits::fungibles::Inspect}; // Polkadot pub use xcm::prelude::*; @@ -35,16 +29,23 @@ mod imports { }; pub use parachains_common::Balance; pub use westend_system_emulated_network::{ + self, people_westend_emulated_chain::{ - genesis::ED as PEOPLE_WESTEND_ED, PeopleWestendParaPallet as PeopleWestendPallet, + people_westend_runtime::{ + xcm_config::XcmConfig as PeopleWestendXcmConfig, + ExistentialDeposit as PeopleWestendExistentialDeposit, + }, + PeopleWestendParaPallet as PeopleWestendPallet, + }, + westend_emulated_chain::{ + genesis::ED as WESTEND_ED, westend_runtime::xcm_config::XcmConfig as WestendXcmConfig, + WestendRelayPallet as WestendPallet, }, - westend_emulated_chain::{genesis::ED as WESTEND_ED, WestendRelayPallet as WestendPallet}, PeopleWestendPara as PeopleWestend, PeopleWestendParaReceiver as PeopleWestendReceiver, PeopleWestendParaSender as PeopleWestendSender, WestendRelay as Westend, WestendRelayReceiver as WestendReceiver, WestendRelaySender as WestendSender, }; - pub type RelayToSystemParaTest = Test; pub type SystemParaToRelayTest = Test; } diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/claim_assets.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/claim_assets.rs new file mode 100644 index 0000000000000000000000000000000000000000..42ccc459286a2dde06c0fc96dc125a527e649973 --- /dev/null +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/claim_assets.rs @@ -0,0 +1,29 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Tests related to claiming assets trapped during XCM execution. + +use crate::imports::*; + +use emulated_integration_tests_common::test_chain_can_claim_assets; +use xcm_executor::traits::DropAssets; + +#[test] +fn assets_can_be_claimed() { + let amount = PeopleWestendExistentialDeposit::get(); + let assets: Assets = (Parent, amount).into(); + + test_chain_can_claim_assets!(PeopleWestend, RuntimeCall, NetworkId::Westend, assets, amount); +} diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/mod.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/mod.rs index 80c00021ca53db3850d6d32c1584ae7ae924933f..08749b295dc21def8feb2c2318bcbed2b258ba9e 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/mod.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/mod.rs @@ -13,5 +13,5 @@ // See the License for the specific language governing permissions and // limitations under the License. -mod reap_identity; +mod claim_assets; mod teleport; diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/reap_identity.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/reap_identity.rs deleted file mode 100644 index 3ed8592918d65b81737a4e8206a3bc23b3684b5f..0000000000000000000000000000000000000000 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/reap_identity.rs +++ /dev/null @@ -1,551 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 - -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -//! # OnReapIdentity Tests -//! -//! This file contains the test cases for migrating Identity data away from the Westend Relay -//! chain and to the PeopleWestend parachain. This migration is part of the broader Minimal Relay -//! effort: -//! https://github.com/polkadot-fellows/RFCs/blob/main/text/0032-minimal-relay.md -//! -//! ## Overview -//! -//! The tests validate the robustness and correctness of the `OnReapIdentityHandler` -//! ensuring that it behaves as expected in various scenarios. Key aspects tested include: -//! -//! - **Deposit Handling**: Confirming that deposits are correctly migrated from the Relay Chain to -//! the People parachain in various scenarios (different `IdentityInfo` fields and different -//! numbers of sub-accounts). -//! -//! ### Test Scenarios -//! -//! The tests are categorized into several scenarios, each resulting in different deposits required -//! on the destination parachain. The tests ensure: -//! -//! - Reserved deposits on the Relay Chain are fully released; -//! - The freed deposit from the Relay Chain is sufficient for the parachain deposit; and -//! - The account will exist on the parachain. - -use crate::imports::*; -use frame_support::BoundedVec; -use pallet_balances::Event as BalancesEvent; -use pallet_identity::{legacy::IdentityInfo, Data, Event as IdentityEvent}; -use people_westend_runtime::people::{ - BasicDeposit as BasicDepositParachain, ByteDeposit as ByteDepositParachain, - IdentityInfo as IdentityInfoParachain, SubAccountDeposit as SubAccountDepositParachain, -}; -use westend_runtime::{ - BasicDeposit, ByteDeposit, MaxAdditionalFields, MaxSubAccounts, RuntimeOrigin as WestendOrigin, - SubAccountDeposit, -}; -use westend_runtime_constants::currency::*; -use westend_system_emulated_network::{ - westend_emulated_chain::WestendRelayPallet, WestendRelay, WestendRelaySender, -}; - -type Balance = u128; -type WestendIdentity = ::Identity; -type WestendBalances = ::Balances; -type WestendIdentityMigrator = ::IdentityMigrator; -type PeopleWestendIdentity = ::Identity; -type PeopleWestendBalances = ::Balances; - -#[derive(Clone, Debug)] -struct Identity { - relay: IdentityInfo, - para: IdentityInfoParachain, - subs: Subs, -} - -impl Identity { - fn new( - full: bool, - additional: Option>, - subs: Subs, - ) -> Self { - let pgp_fingerprint = [ - 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, - 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, - ]; - let make_data = |data: &[u8], full: bool| -> Data { - if full { - Data::Raw(data.to_vec().try_into().unwrap()) - } else { - Data::None - } - }; - let (github, discord) = additional - .as_ref() - .and_then(|vec| vec.first()) - .map(|(g, d)| (g.clone(), d.clone())) - .unwrap_or((Data::None, Data::None)); - Self { - relay: IdentityInfo { - display: make_data(b"xcm-test", full), - legal: make_data(b"The Xcm Test, Esq.", full), - web: make_data(b"https://visitme/", full), - riot: make_data(b"xcm-riot", full), - email: make_data(b"xcm-test@gmail.com", full), - pgp_fingerprint: Some(pgp_fingerprint), - image: make_data(b"xcm-test.png", full), - twitter: make_data(b"@xcm-test", full), - additional: additional.unwrap_or_default(), - }, - para: IdentityInfoParachain { - display: make_data(b"xcm-test", full), - legal: make_data(b"The Xcm Test, Esq.", full), - web: make_data(b"https://visitme/", full), - matrix: make_data(b"xcm-matrix@server", full), - email: make_data(b"xcm-test@gmail.com", full), - pgp_fingerprint: Some(pgp_fingerprint), - image: make_data(b"xcm-test.png", full), - twitter: make_data(b"@xcm-test", full), - github, - discord, - }, - subs, - } - } -} - -#[derive(Clone, Debug)] -enum Subs { - Zero, - Many(u32), -} - -enum IdentityOn<'a> { - Relay(&'a IdentityInfo), - Para(&'a IdentityInfoParachain), -} - -impl IdentityOn<'_> { - fn calculate_deposit(self) -> Balance { - match self { - IdentityOn::Relay(id) => { - let base_deposit = BasicDeposit::get(); - let byte_deposit = - ByteDeposit::get() * TryInto::::try_into(id.encoded_size()).unwrap(); - base_deposit + byte_deposit - }, - IdentityOn::Para(id) => { - let base_deposit = BasicDepositParachain::get(); - let byte_deposit = ByteDepositParachain::get() * - TryInto::::try_into(id.encoded_size()).unwrap(); - base_deposit + byte_deposit - }, - } - } -} - -/// Generate an `AccountId32` from a `u32`. -/// This creates a 32-byte array, initially filled with `255`, and then repeatedly fills it -/// with the 4-byte little-endian representation of the `u32` value, until the array is full. -/// -/// **Example**: -/// -/// `account_from_u32(5)` will return an `AccountId32` with the bytes -/// `[0, 5, 0, 0, 0, 0, 0, 0, 0, 5 ... ]` -fn account_from_u32(id: u32) -> AccountId32 { - let mut buffer = [255u8; 32]; - let id_bytes = id.to_le_bytes(); - let id_size = id_bytes.len(); - for chunk in buffer.chunks_mut(id_size) { - chunk.clone_from_slice(&id_bytes); - } - AccountId32::new(buffer) -} - -// Set up the Relay Chain with an identity. -fn set_id_relay(id: &Identity) -> Balance { - let mut total_deposit: Balance = 0; - - // Set identity and Subs on Relay Chain - WestendRelay::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - - assert_ok!(WestendIdentity::set_identity( - WestendOrigin::signed(WestendRelaySender::get()), - Box::new(id.relay.clone()) - )); - - if let Subs::Many(n) = id.subs { - let subs: Vec<_> = (0..n) - .map(|i| (account_from_u32(i), Data::Raw(b"name".to_vec().try_into().unwrap()))) - .collect(); - - assert_ok!(WestendIdentity::set_subs( - WestendOrigin::signed(WestendRelaySender::get()), - subs, - )); - } - - let reserved_balance = WestendBalances::reserved_balance(WestendRelaySender::get()); - let id_deposit = IdentityOn::Relay(&id.relay).calculate_deposit(); - - let total_deposit = match id.subs { - Subs::Zero => { - total_deposit = id_deposit; // No subs - assert_expected_events!( - WestendRelay, - vec![ - RuntimeEvent::Identity(IdentityEvent::IdentitySet { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == WestendRelaySender::get(), - amount: *amount == id_deposit, - }, - ] - ); - total_deposit - }, - Subs::Many(n) => { - let sub_account_deposit = n as Balance * SubAccountDeposit::get(); - total_deposit = - sub_account_deposit + IdentityOn::Relay(&id.relay).calculate_deposit(); - assert_expected_events!( - WestendRelay, - vec![ - RuntimeEvent::Identity(IdentityEvent::IdentitySet { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == WestendRelaySender::get(), - amount: *amount == id_deposit, - }, - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == WestendRelaySender::get(), - amount: *amount == sub_account_deposit, - }, - ] - ); - total_deposit - }, - }; - - assert_eq!(reserved_balance, total_deposit); - }); - total_deposit -} - -// Set up the parachain with an identity and (maybe) sub accounts, but with zero deposits. -fn assert_set_id_parachain(id: &Identity) { - // Set identity and Subs on Parachain with zero deposit - PeopleWestend::execute_with(|| { - let free_bal = PeopleWestendBalances::free_balance(PeopleWestendSender::get()); - let reserved_balance = PeopleWestendBalances::reserved_balance(PeopleWestendSender::get()); - - // total balance at Genesis should be zero - assert_eq!(reserved_balance + free_bal, 0); - - assert_ok!(PeopleWestendIdentity::set_identity_no_deposit( - &PeopleWestendSender::get(), - id.para.clone(), - )); - - match id.subs { - Subs::Zero => {}, - Subs::Many(n) => { - let subs: Vec<_> = (0..n) - .map(|ii| { - (account_from_u32(ii), Data::Raw(b"name".to_vec().try_into().unwrap())) - }) - .collect(); - assert_ok!(PeopleWestendIdentity::set_subs_no_deposit( - &PeopleWestendSender::get(), - subs, - )); - }, - } - - // No amount should be reserved as deposit amounts are set to 0. - let reserved_balance = PeopleWestendBalances::reserved_balance(PeopleWestendSender::get()); - assert_eq!(reserved_balance, 0); - assert!(PeopleWestendIdentity::identity(PeopleWestendSender::get()).is_some()); - - let (_, sub_accounts) = PeopleWestendIdentity::subs_of(PeopleWestendSender::get()); - - match id.subs { - Subs::Zero => assert_eq!(sub_accounts.len(), 0), - Subs::Many(n) => assert_eq!(sub_accounts.len(), n as usize), - } - }); -} - -// Reap the identity on the Relay Chain and assert that the correct things happen there. -fn assert_reap_id_relay(total_deposit: Balance, id: &Identity) { - WestendRelay::execute_with(|| { - type RuntimeEvent = ::RuntimeEvent; - let free_bal_before_reap = WestendBalances::free_balance(WestendRelaySender::get()); - let reserved_balance = WestendBalances::reserved_balance(WestendRelaySender::get()); - - assert_eq!(reserved_balance, total_deposit); - - assert_ok!(WestendIdentityMigrator::reap_identity( - WestendOrigin::signed(WestendRelaySender::get()), - WestendRelaySender::get() - )); - - let remote_deposit = match id.subs { - Subs::Zero => calculate_remote_deposit(id.relay.encoded_size() as u32, 0), - Subs::Many(n) => calculate_remote_deposit(id.relay.encoded_size() as u32, n), - }; - - assert_expected_events!( - WestendRelay, - vec![ - // `reap_identity` sums the identity and subs deposits and unreserves them in one - // call. Therefore, we only expect one `Unreserved` event. - RuntimeEvent::Balances(BalancesEvent::Unreserved { who, amount }) => { - who: *who == WestendRelaySender::get(), - amount: *amount == total_deposit, - }, - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::IdentityReaped { - who, - }) => { - who: *who == PeopleWestendSender::get(), - }, - ] - ); - // Identity should be gone. - assert!(PeopleWestendIdentity::identity(WestendRelaySender::get()).is_none()); - - // Subs should be gone. - let (_, sub_accounts) = WestendIdentity::subs_of(WestendRelaySender::get()); - assert_eq!(sub_accounts.len(), 0); - - let reserved_balance = WestendBalances::reserved_balance(WestendRelaySender::get()); - assert_eq!(reserved_balance, 0); - - // Free balance should be greater (i.e. the teleport should work even if 100% of an - // account's balance is reserved for Identity). - let free_bal_after_reap = WestendBalances::free_balance(WestendRelaySender::get()); - assert!(free_bal_after_reap > free_bal_before_reap); - - // Implicit: total_deposit > remote_deposit. As in, accounts should always have enough - // reserved for the parachain deposit. - assert_eq!(free_bal_after_reap, free_bal_before_reap + total_deposit - remote_deposit); - }); -} - -// Reaping the identity on the Relay Chain will have sent an XCM program to the parachain. Ensure -// that everything happens as expected. -fn assert_reap_parachain(id: &Identity) { - PeopleWestend::execute_with(|| { - let reserved_balance = PeopleWestendBalances::reserved_balance(PeopleWestendSender::get()); - let id_deposit = IdentityOn::Para(&id.para).calculate_deposit(); - let total_deposit = match id.subs { - Subs::Zero => id_deposit, - Subs::Many(n) => id_deposit + n as Balance * SubAccountDepositParachain::get(), - }; - assert_reap_events(id_deposit, id); - assert_eq!(reserved_balance, total_deposit); - - // Should have at least one ED after in free balance after the reap. - assert!( - PeopleWestendBalances::free_balance(PeopleWestendSender::get()) >= PEOPLE_WESTEND_ED - ); - }); -} - -// Assert the events that should happen on the parachain upon reaping an identity on the Relay -// Chain. -fn assert_reap_events(id_deposit: Balance, id: &Identity) { - type RuntimeEvent = ::RuntimeEvent; - match id.subs { - Subs::Zero => { - assert_expected_events!( - PeopleWestend, - vec![ - // Deposit and Endowed from teleport - RuntimeEvent::Balances(BalancesEvent::Minted { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Endowed { .. }) => {}, - // Amount reserved for identity info - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleWestendSender::get(), - amount: *amount == id_deposit, - }, - // Confirmation from Migrator with individual identity and subs deposits - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::DepositUpdated { - who, identity, subs - }) => { - who: *who == PeopleWestendSender::get(), - identity: *identity == id_deposit, - subs: *subs == 0, - }, - RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { .. }) => {}, - ] - ); - }, - Subs::Many(n) => { - let subs_deposit = n as Balance * SubAccountDepositParachain::get(); - assert_expected_events!( - PeopleWestend, - vec![ - // Deposit and Endowed from teleport - RuntimeEvent::Balances(BalancesEvent::Minted { .. }) => {}, - RuntimeEvent::Balances(BalancesEvent::Endowed { .. }) => {}, - // Amount reserved for identity info - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleWestendSender::get(), - amount: *amount == id_deposit, - }, - // Amount reserved for subs - RuntimeEvent::Balances(BalancesEvent::Reserved { who, amount }) => { - who: *who == PeopleWestendSender::get(), - amount: *amount == subs_deposit, - }, - // Confirmation from Migrator with individual identity and subs deposits - RuntimeEvent::IdentityMigrator( - polkadot_runtime_common::identity_migrator::Event::DepositUpdated { - who, identity, subs - }) => { - who: *who == PeopleWestendSender::get(), - identity: *identity == id_deposit, - subs: *subs == subs_deposit, - }, - RuntimeEvent::MessageQueue(pallet_message_queue::Event::Processed { .. }) => {}, - ] - ); - }, - }; -} - -/// Duplicate of the impl of `ToParachainIdentityReaper` in the Westend runtime. -fn calculate_remote_deposit(bytes: u32, subs: u32) -> Balance { - // Note: These `deposit` functions and `EXISTENTIAL_DEPOSIT` correspond to the Relay Chain's. - // Pulled in: use westend_runtime_constants::currency::*; - let para_basic_deposit = deposit(1, 17) / 100; - let para_byte_deposit = deposit(0, 1) / 100; - let para_sub_account_deposit = deposit(1, 53) / 100; - let para_existential_deposit = EXISTENTIAL_DEPOSIT / 10; - - // pallet deposits - let id_deposit = - para_basic_deposit.saturating_add(para_byte_deposit.saturating_mul(bytes as Balance)); - let subs_deposit = para_sub_account_deposit.saturating_mul(subs as Balance); - - id_deposit - .saturating_add(subs_deposit) - .saturating_add(para_existential_deposit.saturating_mul(2)) -} - -// Represent some `additional` data that would not be migrated to the parachain. The encoded size, -// and thus the byte deposit, should decrease. -fn nonsensical_additional() -> BoundedVec<(Data, Data), MaxAdditionalFields> { - BoundedVec::try_from(vec![( - Data::Raw(b"fOo".to_vec().try_into().unwrap()), - Data::Raw(b"baR".to_vec().try_into().unwrap()), - )]) - .unwrap() -} - -// Represent some `additional` data that will be migrated to the parachain as first-class fields. -fn meaningful_additional() -> BoundedVec<(Data, Data), MaxAdditionalFields> { - BoundedVec::try_from(vec![ - ( - Data::Raw(b"github".to_vec().try_into().unwrap()), - Data::Raw(b"niels-username".to_vec().try_into().unwrap()), - ), - ( - Data::Raw(b"discord".to_vec().try_into().unwrap()), - Data::Raw(b"bohr-username".to_vec().try_into().unwrap()), - ), - ]) - .unwrap() -} - -// Execute a single test case. -fn assert_relay_para_flow(id: &Identity) { - let total_deposit = set_id_relay(id); - assert_set_id_parachain(id); - assert_reap_id_relay(total_deposit, id); - assert_reap_parachain(id); -} - -// Tests with empty `IdentityInfo`. - -#[test] -fn on_reap_identity_works_for_minimal_identity_with_zero_subs() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_minimal_identity() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_minimal_identity_with_max_subs() { - assert_relay_para_flow(&Identity::new(false, None, Subs::Many(MaxSubAccounts::get()))); -} - -// Tests with full `IdentityInfo`. - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_no_additional_max_subs() { - assert_relay_para_flow(&Identity::new(true, None, Subs::Many(MaxSubAccounts::get()))); -} - -// Tests with full `IdentityInfo` and `additional` fields that will _not_ be migrated. - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, Some(nonsensical_additional()), Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional() { - assert_relay_para_flow(&Identity::new(true, Some(nonsensical_additional()), Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_nonsense_additional_max_subs() { - assert_relay_para_flow(&Identity::new( - true, - Some(nonsensical_additional()), - Subs::Many(MaxSubAccounts::get()), - )); -} - -// Tests with full `IdentityInfo` and `additional` fields that will be migrated. - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional_zero_subs() { - assert_relay_para_flow(&Identity::new(true, Some(meaningful_additional()), Subs::Zero)); -} - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional() { - assert_relay_para_flow(&Identity::new(true, Some(meaningful_additional()), Subs::Many(1))); -} - -#[test] -fn on_reap_identity_works_for_full_identity_meaningful_additional_max_subs() { - assert_relay_para_flow(&Identity::new( - true, - Some(meaningful_additional()), - Subs::Many(MaxSubAccounts::get()), - )); -} diff --git a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/teleport.rs b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/teleport.rs index 8697477ba769329755b40a87132c62b213861cc4..83888031723ffffef24f86717741ddab1bf2598a 100644 --- a/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/teleport.rs +++ b/cumulus/parachains/integration-tests/emulated/tests/people/people-westend/src/tests/teleport.rs @@ -14,70 +14,38 @@ // limitations under the License. use crate::imports::*; -use people_westend_runtime::xcm_config::XcmConfig as PeopleWestendXcmConfig; -use westend_runtime::xcm_config::XcmConfig as WestendXcmConfig; +use emulated_integration_tests_common::{ + test_parachain_is_trusted_teleporter_for_relay, test_relay_is_trusted_teleporter, +}; -fn relay_origin_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - Westend::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts(627_959_000, 7_200))); +#[test] +fn teleport_from_and_to_relay() { + let amount = WESTEND_ED * 100; + let native_asset: Assets = (Here, amount).into(); - assert_expected_events!( + test_relay_is_trusted_teleporter!( Westend, - vec![ - // Amount to teleport is withdrawn from Sender - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == t.sender.account_id, - amount: *amount == t.args.amount, - }, - // Amount to teleport is deposited in Relay's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - ] - ); -} - -fn relay_dest_assertions(t: SystemParaToRelayTest) { - type RuntimeEvent = ::RuntimeEvent; - - Westend::assert_ump_queue_processed( - true, - Some(PeopleWestend::para_id()), - Some(Weight::from_parts(304_266_000, 7_186)), + WestendXcmConfig, + vec![PeopleWestend], + (native_asset, amount) ); - assert_expected_events!( + test_parachain_is_trusted_teleporter_for_relay!( + PeopleWestend, + PeopleWestendXcmConfig, Westend, - vec![ - // Amount is withdrawn from Relay Chain's `CheckAccount` - RuntimeEvent::Balances(pallet_balances::Event::Burned { who, amount }) => { - who: *who == ::XcmPallet::check_account(), - amount: *amount == t.args.amount, - }, - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] + amount ); } fn relay_dest_assertions_fail(_t: SystemParaToRelayTest) { - Westend::assert_ump_queue_processed( - false, - Some(PeopleWestend::para_id()), - Some(Weight::from_parts(157_718_000, 3_593)), - ); + Westend::assert_ump_queue_processed(false, Some(PeopleWestend::para_id()), None); } fn para_origin_assertions(t: SystemParaToRelayTest) { type RuntimeEvent = ::RuntimeEvent; - PeopleWestend::assert_xcm_pallet_attempted_complete(Some(Weight::from_parts( - 351_425_000, - 3_593, - ))); + PeopleWestend::assert_xcm_pallet_attempted_complete(None); PeopleWestend::assert_parachain_system_ump_sent(); @@ -93,33 +61,6 @@ fn para_origin_assertions(t: SystemParaToRelayTest) { ); } -fn para_dest_assertions(t: RelayToSystemParaTest) { - type RuntimeEvent = ::RuntimeEvent; - - PeopleWestend::assert_dmp_queue_complete(Some(Weight::from_parts(162_456_000, 0))); - - assert_expected_events!( - PeopleWestend, - vec![ - // Amount minus fees are deposited in Receiver's account - RuntimeEvent::Balances(pallet_balances::Event::Minted { who, .. }) => { - who: *who == t.receiver.account_id, - }, - ] - ); -} - -fn relay_limited_teleport_assets(t: RelayToSystemParaTest) -> DispatchResult { - ::XcmPallet::limited_teleport_assets( - t.signed_origin, - bx!(t.args.dest.into()), - bx!(t.args.beneficiary.into()), - bx!(t.args.assets.into()), - t.args.fee_asset_item, - t.args.weight_limit, - ) -} - fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResult { ::PolkadotXcm::limited_teleport_assets( t.signed_origin, @@ -131,92 +72,8 @@ fn system_para_limited_teleport_assets(t: SystemParaToRelayTest) -> DispatchResu ) } -/// Limited Teleport of native asset from Relay Chain to the System Parachain should work -#[test] -fn limited_teleport_native_assets_from_relay_to_system_para_works() { - // Init values for Relay Chain - let amount_to_send: Balance = WESTEND_ED * 1000; - let dest = Westend::child_location_of(PeopleWestend::para_id()); - let beneficiary_id = PeopleWestendReceiver::get(); - let test_args = TestContext { - sender: WestendSender::get(), - receiver: PeopleWestendReceiver::get(), - args: TestArgs::new_relay(dest, beneficiary_id, amount_to_send), - }; - - let mut test = RelayToSystemParaTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(relay_origin_assertions); - test.set_assertion::(para_dest_assertions); - test.set_dispatchable::(relay_limited_teleport_assets); - test.assert(); - - let delivery_fees = Westend::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); -} - -/// Limited Teleport of native asset from System Parachain to Relay Chain -/// should work when there is enough balance in Relay Chain's `CheckAccount` -#[test] -fn limited_teleport_native_assets_back_from_system_para_to_relay_works() { - // Dependency - Relay Chain's `CheckAccount` should have enough balance - limited_teleport_native_assets_from_relay_to_system_para_works(); - - let amount_to_send: Balance = PEOPLE_WESTEND_ED * 1000; - let destination = PeopleWestend::parent_location(); - let beneficiary_id = WestendReceiver::get(); - let assets = (Parent, amount_to_send).into(); - - // Fund a sender - PeopleWestend::fund_accounts(vec![(PeopleWestendSender::get(), WESTEND_ED * 2_000u128)]); - - let test_args = TestContext { - sender: PeopleWestendSender::get(), - receiver: WestendReceiver::get(), - args: TestArgs::new_para(destination, beneficiary_id, amount_to_send, assets, None, 0), - }; - - let mut test = SystemParaToRelayTest::new(test_args); - - let sender_balance_before = test.sender.balance; - let receiver_balance_before = test.receiver.balance; - - test.set_assertion::(para_origin_assertions); - test.set_assertion::(relay_dest_assertions); - test.set_dispatchable::(system_para_limited_teleport_assets); - test.assert(); - - let sender_balance_after = test.sender.balance; - let receiver_balance_after = test.receiver.balance; - - let delivery_fees = PeopleWestend::execute_with(|| { - xcm_helpers::teleport_assets_delivery_fees::< - ::XcmSender, - >(test.args.assets.clone(), 0, test.args.weight_limit, test.args.beneficiary, test.args.dest) - }); - - // Sender's balance is reduced - assert_eq!(sender_balance_before - amount_to_send - delivery_fees, sender_balance_after); - // Receiver's balance is increased - assert!(receiver_balance_after > receiver_balance_before); -} - /// Limited Teleport of native asset from System Parachain to Relay Chain -/// should't work when there is not enough balance in Relay Chain's `CheckAccount` +/// shouldn't work when there is not enough balance in Relay Chain's `CheckAccount` #[test] fn limited_teleport_native_assets_from_system_para_to_relay_fails() { // Init values for Relay Chain diff --git a/cumulus/parachains/pallets/collective-content/Cargo.toml b/cumulus/parachains/pallets/collective-content/Cargo.toml index 207259bee52ceb68ba45b1237100cfe5367201f7..c52021f67e36233eb46c2fe703c9c6cef963ab76 100644 --- a/cumulus/parachains/pallets/collective-content/Cargo.toml +++ b/cumulus/parachains/pallets/collective-content/Cargo.toml @@ -10,19 +10,18 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +scale-info = { features = ["derive"], workspace = true } -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 } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } -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 } +sp-core = { workspace = true } +sp-runtime = { workspace = true } [dev-dependencies] -sp-io = { path = "../../../../substrate/primitives/io", default-features = false } +sp-io = { workspace = true } [features] default = ["std"] @@ -48,5 +47,4 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", ] diff --git a/cumulus/parachains/pallets/collective-content/src/lib.rs b/cumulus/parachains/pallets/collective-content/src/lib.rs index b1c960ad6a0d337d6b84aaaba59f7fa0625a8124..7ea3c2d79fa793fd3726bf9ee0b59eaac598eb38 100644 --- a/cumulus/parachains/pallets/collective-content/src/lib.rs +++ b/cumulus/parachains/pallets/collective-content/src/lib.rs @@ -46,7 +46,6 @@ pub use weights::WeightInfo; use frame_support::{traits::schedule::DispatchTime, BoundedVec}; use sp_core::ConstU32; -use sp_std::prelude::*; /// IPFS compatible CID. // Worst case 2 bytes base and codec, 2 bytes hash type and size, 64 bytes hash digest. diff --git a/cumulus/parachains/pallets/collective-content/src/mock.rs b/cumulus/parachains/pallets/collective-content/src/mock.rs index 5cb0126425e59a67332d880cc8b925f50b1753c2..91f9c29933d91dd9be6f604c28da869317a5003d 100644 --- a/cumulus/parachains/pallets/collective-content/src/mock.rs +++ b/cumulus/parachains/pallets/collective-content/src/mock.rs @@ -18,9 +18,7 @@ pub use crate as pallet_collective_content; use crate::WeightInfo; use frame_support::{ - derive_impl, ord_parameter_types, parameter_types, - traits::{ConstU32, ConstU64}, - weights::Weight, + derive_impl, ord_parameter_types, parameter_types, traits::ConstU32, weights::Weight, }; use frame_system::EnsureSignedBy; use sp_runtime::{traits::IdentityLookup, BuildStorage}; @@ -70,7 +68,6 @@ impl frame_system::Config for Test { type AccountId = AccountId; type Lookup = IdentityLookup; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = ConstU64<250>; type Version = (); type PalletInfo = PalletInfo; type AccountData = (); diff --git a/cumulus/parachains/pallets/collective-content/src/tests.rs b/cumulus/parachains/pallets/collective-content/src/tests.rs index 4910b30b89af84430a60e2eab011ed2c5c6a3d03..7fee5eea101dbc94e2180b104cdfb2d8a1d040cd 100644 --- a/cumulus/parachains/pallets/collective-content/src/tests.rs +++ b/cumulus/parachains/pallets/collective-content/src/tests.rs @@ -16,7 +16,8 @@ //! Tests. use super::{mock::*, *}; -use frame_support::{assert_noop, assert_ok, error::BadOrigin, pallet_prelude::Pays}; +use frame_support::{assert_noop, assert_ok, pallet_prelude::Pays}; +use sp_runtime::traits::BadOrigin; /// returns CID hash of 68 bytes of given `i`. fn create_cid(i: u8) -> OpaqueCid { diff --git a/cumulus/parachains/pallets/parachain-info/Cargo.toml b/cumulus/parachains/pallets/parachain-info/Cargo.toml index 17981d238fd1880e81ce04ebbe5b2a045ba27e41..e0bed23c4f8c0931d1b5b13c36a696378f62fd83 100644 --- a/cumulus/parachains/pallets/parachain-info/Cargo.toml +++ b/cumulus/parachains/pallets/parachain-info/Cargo.toml @@ -10,16 +10,15 @@ description = "Pallet to store the parachain ID" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../substrate/frame/system", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } +sp-runtime = { workspace = true } -cumulus-primitives-core = { path = "../../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] @@ -30,7 +29,6 @@ std = [ "frame-system/std", "scale-info/std", "sp-runtime/std", - "sp-std/std", ] try-runtime = [ "frame-support/try-runtime", diff --git a/cumulus/parachains/pallets/parachain-info/src/lib.rs b/cumulus/parachains/pallets/parachain-info/src/lib.rs index a4ef448a6b6b9b934e9e49a4a4797a590ad55d6b..0aaa7adaa51c0198fa1025337a31ff790df2113b 100644 --- a/cumulus/parachains/pallets/parachain-info/src/lib.rs +++ b/cumulus/parachains/pallets/parachain-info/src/lib.rs @@ -41,7 +41,7 @@ pub mod pallet { #[pallet::genesis_config] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, pub parachain_id: ParaId, } diff --git a/cumulus/parachains/pallets/ping/Cargo.toml b/cumulus/parachains/pallets/ping/Cargo.toml index 15169b08b9108998d850f6333e458d73580d1b2a..51fc384a4f1408ba7ad9c05f9d172146290d4cd5 100644 --- a/cumulus/parachains/pallets/ping/Cargo.toml +++ b/cumulus/parachains/pallets/ping/Cargo.toml @@ -10,18 +10,17 @@ description = "Ping Pallet for Cumulus XCM/UMP testing." workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../substrate/frame/system", default-features = false } +sp-runtime = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } +xcm = { workspace = true } -cumulus-primitives-core = { path = "../../../primitives/core", default-features = false } -cumulus-pallet-xcm = { path = "../../../pallets/xcm", default-features = false } +cumulus-primitives-core = { workspace = true } +cumulus-pallet-xcm = { workspace = true } [features] default = ["std"] @@ -33,7 +32,6 @@ std = [ "frame-system/std", "scale-info/std", "sp-runtime/std", - "sp-std/std", "xcm/std", ] diff --git a/cumulus/parachains/pallets/ping/src/lib.rs b/cumulus/parachains/pallets/ping/src/lib.rs index a738c05e0366bc44da562f59f7e9a638a8251d9c..729494cbd251d6ff5ea3271a040c28bb786ea849 100644 --- a/cumulus/parachains/pallets/ping/src/lib.rs +++ b/cumulus/parachains/pallets/ping/src/lib.rs @@ -18,12 +18,14 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_xcm::{ensure_sibling_para, Origin as CumulusOrigin}; use cumulus_primitives_core::ParaId; use frame_support::{parameter_types, BoundedVec}; use frame_system::Config as SystemConfig; use sp_runtime::traits::Saturating; -use sp_std::prelude::*; use xcm::latest::prelude::*; pub use pallet::*; diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml index 888193c5c6ea7e02e879428b920cd1ed70c15e54..0143c09036d26908b011f3319f4dda2b90dd9631 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/Cargo.toml @@ -10,96 +10,96 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-asset-conversion-tx-payment = { path = "../../../../../substrate/frame/transaction-payment/asset-conversion-tx-payment", default-features = false } -pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion-ops = { path = "../../../../../substrate/frame/asset-conversion/ops", default-features = false } -pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", 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-proxy = { path = "../../../../../substrate/frame/proxy", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-state-trie-migration = { path = "../../../../../substrate/frame/state-trie-migration", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-uniques = { path = "../../../../../substrate/frame/uniques", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } -sp-weights = { path = "../../../../../substrate/primitives/weights", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-asset-conversion-tx-payment = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion-ops = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-assets-freezer = { workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-multisig = { workspace = true } +pallet-nft-fractionalization = { workspace = true } +pallet-nfts = { workspace = true } +pallet-nfts-runtime-api = { workspace = true } +pallet-proxy = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-uniques = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-inherents = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } +sp-weights = { workspace = true } # num-traits feature needed for dex integer sq root: -primitive-types = { version = "0.12.1", default-features = false, features = ["codec", "num-traits", "scale-info"] } +primitive-types = { features = ["codec", "num-traits", "scale-info"], workspace = true } # Polkadot -rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/constants", 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, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false } +rococo-runtime-constants = { workspace = true } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } -assets-common = { path = "../common", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { features = ["bridging"], workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } +assets-common = { workspace = true } # Bridges -pallet-xcm-bridge-hub-router = { path = "../../../../../bridges/modules/xcm-bridge-hub-router", default-features = false } -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-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 } -snowbridge-router-primitives = { path = "../../../../../bridges/snowbridge/primitives/router", default-features = false } +pallet-xcm-bridge-hub-router = { workspace = true } +bp-asset-hub-rococo = { workspace = true } +bp-asset-hub-westend = { workspace = true } +bp-bridge-hub-rococo = { workspace = true } +bp-bridge-hub-westend = { workspace = true } +snowbridge-router-primitives = { workspace = true } [dev-dependencies] -asset-test-utils = { path = "../test-utils" } +asset-test-utils = { workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -116,6 +116,7 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "pallet-asset-conversion-ops/runtime-benchmarks", "pallet-asset-conversion/runtime-benchmarks", + "pallet-assets-freezer/runtime-benchmarks", "pallet-assets/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-collator-selection/runtime-benchmarks", @@ -124,7 +125,6 @@ runtime-benchmarks = [ "pallet-nft-fractionalization/runtime-benchmarks", "pallet-nfts/runtime-benchmarks", "pallet-proxy/runtime-benchmarks", - "pallet-state-trie-migration/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", "pallet-uniques/runtime-benchmarks", "pallet-utility/runtime-benchmarks", @@ -138,7 +138,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "cumulus-pallet-aura-ext/try-runtime", @@ -152,6 +152,7 @@ try-runtime = [ "pallet-asset-conversion-ops/try-runtime", "pallet-asset-conversion-tx-payment/try-runtime", "pallet-asset-conversion/try-runtime", + "pallet-assets-freezer/try-runtime", "pallet-assets/try-runtime", "pallet-aura/try-runtime", "pallet-authorship/try-runtime", @@ -163,7 +164,6 @@ try-runtime = [ "pallet-nfts/try-runtime", "pallet-proxy/try-runtime", "pallet-session/try-runtime", - "pallet-state-trie-migration/try-runtime", "pallet-timestamp/try-runtime", "pallet-transaction-payment/try-runtime", "pallet-uniques/try-runtime", @@ -192,6 +192,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking?/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -201,6 +202,7 @@ std = [ "pallet-asset-conversion-ops/std", "pallet-asset-conversion-tx-payment/std", "pallet-asset-conversion/std", + "pallet-assets-freezer/std", "pallet-assets/std", "pallet-aura/std", "pallet-authorship/std", @@ -213,7 +215,6 @@ std = [ "pallet-nfts/std", "pallet-proxy/std", "pallet-session/std", - "pallet-state-trie-migration/std", "pallet-timestamp/std", "pallet-transaction-payment-rpc-runtime-api/std", "pallet-transaction-payment/std", @@ -239,7 +240,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -248,11 +248,14 @@ std = [ "testnet-parachains-constants/std", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = ["metadata-hash"] diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs index 239ccac19ec7778039fb1ee56f4e772b3ddd3711..99e510e22695da8dff3867e84125c68b113f6973 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/build.rs @@ -13,10 +13,17 @@ // See the License for the specific language governing permissions and // limitations under the License. -#[cfg(feature = "std")] +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] fn main() { substrate_wasm_builder::WasmBuilder::build_using_defaults(); } +#[cfg(all(feature = "metadata-hash", feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("ROC", 12) + .build(); +} + #[cfg(not(feature = "std"))] fn main() {} diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs index f81a107fae0537095ece60c58592ca5e2b7068f7..4c7356707ab61c0e3ef4c6a97f4c83d3728c5f53 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/lib.rs @@ -27,6 +27,9 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use assets_common::{ foreign_creators::ForeignCreators, local_and_foreign_assets::{LocalFromLeft, TargetFromLeft}, @@ -45,7 +48,6 @@ use sp_runtime::{ }; use testnet_parachains_constants::rococo::snowbridge::EthereumNetwork; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -69,7 +71,7 @@ use frame_system::{ limits::{BlockLength, BlockWeights}, EnsureRoot, EnsureSigned, EnsureSignedBy, }; -use pallet_asset_conversion_tx_payment::AssetConversionAdapter; +use pallet_asset_conversion_tx_payment::SwapAssetAdapter; use pallet_nfts::PalletFeatures; use parachains_common::{ impls::DealWithFees, @@ -81,10 +83,13 @@ use sp_runtime::{Perbill, RuntimeDebug}; use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*}; use xcm_config::{ ForeignAssetsConvertedConcreteId, ForeignCreatorsSovereignAccountOf, GovernanceLocation, - PoolAssetsConvertedConcreteId, TokenLocation, TokenLocationV3, - TrustBackedAssetsConvertedConcreteId, TrustBackedAssetsPalletLocationV3, + PoolAssetsConvertedConcreteId, TokenLocation, TrustBackedAssetsConvertedConcreteId, + TrustBackedAssetsPalletLocation, }; +#[cfg(test)] +mod tests; + #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; @@ -93,15 +98,15 @@ use pallet_xcm::{EnsureXcm, IsVoiceOfBody}; use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate}; #[cfg(feature = "runtime-benchmarks")] use xcm::latest::prelude::{ - Asset, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, NetworkId, - NonFungible, Parent, ParentThen, Response, XCM_VERSION, + Asset, Assets as XcmAssets, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, + NetworkId, NonFungible, Parent, ParentThen, Response, XCM_VERSION, }; use xcm::{ latest::prelude::{AssetId, BodyId}, - IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, + VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, }; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects}, +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::Error as XcmPaymentApiError, }; @@ -118,10 +123,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("statemine"), impl_name: create_runtime_str!("statemine"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 15, + transaction_version: 16, state_version: 1, }; @@ -257,7 +262,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = MetadataDepositPerByte; type ApprovalDeposit = ApprovalDeposit; type StringLimit = AssetsStringLimit; - type Freezer = (); + type Freezer = AssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_local::WeightInfo; type CallbackHandle = (); @@ -267,6 +272,13 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = (); } +// Allow Freezes for the `Assets` pallet +pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + parameter_types! { pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon"); pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0); @@ -295,7 +307,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = ConstU128<0>; type ApprovalDeposit = ApprovalDeposit; type StringLimit = ConstU32<50>; - type Freezer = (); + type Freezer = PoolAssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_pool::WeightInfo; type CallbackHandle = (); @@ -303,16 +315,23 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = (); } +// Allow Freezes for the `PoolAssets` pallet +pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + /// Union fungibles implementation for `Assets` and `ForeignAssets`. pub type LocalAndForeignAssets = fungibles::UnionOf< Assets, ForeignAssets, LocalFromLeft< - AssetIdForTrustBackedAssetsConvert, + AssetIdForTrustBackedAssetsConvert, AssetIdForTrustBackedAssets, - xcm::v3::Location, + xcm::v4::Location, >, - xcm::v3::Location, + xcm::v4::Location, AccountId, >; @@ -320,25 +339,25 @@ pub type LocalAndForeignAssets = fungibles::UnionOf< pub type NativeAndAssets = fungible::UnionOf< Balances, LocalAndForeignAssets, - TargetFromLeft, - xcm::v3::Location, + TargetFromLeft, + xcm::v4::Location, AccountId, >; pub type PoolIdToAccountId = pallet_asset_conversion::AccountIdConverter< AssetConversionPalletId, - (xcm::v3::Location, xcm::v3::Location), + (xcm::v4::Location, xcm::v4::Location), >; impl pallet_asset_conversion::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Balance = Balance; type HigherPrecisionBalance = sp_core::U256; - type AssetKind = xcm::v3::Location; + type AssetKind = xcm::v4::Location; type Assets = NativeAndAssets; type PoolId = (Self::AssetKind, Self::AssetKind); type PoolLocator = pallet_asset_conversion::WithFirstAsset< - TokenLocationV3, + TokenLocation, AccountId, Self::AssetKind, PoolIdToAccountId, @@ -346,7 +365,7 @@ impl pallet_asset_conversion::Config for Runtime { type PoolAssetId = u32; type PoolAssets = PoolAssets; type PoolSetupFee = ConstU128<0>; // Asset class deposit fees are sufficient to prevent spam - type PoolSetupFeeAsset = TokenLocationV3; + type PoolSetupFeeAsset = TokenLocation; type PoolSetupFeeTarget = ResolveAssetTo; type LiquidityWithdrawalFee = LiquidityWithdrawalFee; type LPFee = ConstU32<3>; @@ -356,10 +375,10 @@ impl pallet_asset_conversion::Config for Runtime { type WeightInfo = weights::pallet_asset_conversion::WeightInfo; #[cfg(feature = "runtime-benchmarks")] type BenchmarkHelper = assets_common::benchmarks::AssetPairFactory< - TokenLocationV3, + TokenLocation, parachain_info::Pallet, xcm_config::TrustBackedAssetsPalletIndex, - xcm::v3::Location, + xcm::v4::Location, >; } @@ -393,17 +412,17 @@ pub type ForeignAssetsInstance = pallet_assets::Instance2; impl pallet_assets::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Balance = Balance; - type AssetId = xcm::v3::Location; - type AssetIdParameter = xcm::v3::Location; + type AssetId = xcm::v4::Location; + type AssetIdParameter = xcm::v4::Location; type Currency = Balances; type CreateOrigin = ForeignCreators< ( - FromSiblingParachain, xcm::v3::Location>, - FromNetwork, + FromSiblingParachain, xcm::v4::Location>, + FromNetwork, ), ForeignCreatorsSovereignAccountOf, AccountId, - xcm::v3::Location, + xcm::v4::Location, >; type ForceOrigin = AssetsForceOrigin; type AssetDeposit = ForeignAssetsAssetDeposit; @@ -411,7 +430,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte; type ApprovalDeposit = ForeignAssetsApprovalDeposit; type StringLimit = ForeignAssetsAssetsStringLimit; - type Freezer = (); + type Freezer = ForeignAssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_foreign::WeightInfo; type CallbackHandle = (); @@ -421,6 +440,13 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = xcm_config::XcmBenchmarkHelper; } +// Allow Freezes for the `ForeignAssets` pallet +pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + parameter_types! { // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes. pub const DepositBase: Balance = deposit(1, 88); @@ -670,7 +696,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -700,12 +726,21 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = xcm_config::XcmOriginToTransactDispatchOrigin; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } @@ -766,11 +801,19 @@ impl pallet_collator_selection::Config for Runtime { type WeightInfo = weights::pallet_collator_selection::WeightInfo; } +parameter_types! { + pub StakingPot: AccountId = CollatorSelection::account_id(); +} + impl pallet_asset_conversion_tx_payment::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type Fungibles = LocalAndForeignAssets; - type OnChargeAssetTransaction = - AssetConversionAdapter; + type AssetId = xcm::v4::Location; + type OnChargeAssetTransaction = SwapAssetAdapter< + TokenLocation, + NativeAndAssets, + AssetConversion, + ResolveAssetTo, + >; } parameter_types! { @@ -944,8 +987,9 @@ construct_runtime!( NftFractionalization: pallet_nft_fractionalization = 54, PoolAssets: pallet_assets:: = 55, AssetConversion: pallet_asset_conversion = 56, - - StateTrieMigration: pallet_state_trie_migration = 70, + AssetsFreezer: pallet_assets_freezer:: = 57, + ForeignAssetsFreezer: pallet_assets_freezer:: = 58, + PoolAssetsFreezer: pallet_assets_freezer:: = 59, // TODO: the pallet instance should be removed once all pools have migrated // to the new account IDs. @@ -972,21 +1016,27 @@ pub type SignedExtra = ( frame_system::CheckWeight, pallet_asset_conversion_tx_payment::ChargeAssetTxPayment, cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = generic::UncheckedExtrinsic; /// Migrations to apply on runtime upgrade. -#[allow(deprecated)] pub type Migrations = ( InitStorageVersions, // unreleased cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, pallet_collator_selection::migration::v2::MigrationToV2, + frame_support::migrations::RemovePallet, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); +parameter_types! { + pub const StateTrieMigrationName: &'static str = "StateTrieMigration"; +} + /// Migration to initialize storage versions for pallets added after genesis. /// /// This is now done automatically (see ), @@ -1123,7 +1173,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -1186,16 +1236,16 @@ impl_runtime_apis! { impl pallet_asset_conversion::AssetConversionApi< Block, Balance, - xcm::v3::Location, + xcm::v4::Location, > for Runtime { - fn quote_price_exact_tokens_for_tokens(asset1: xcm::v3::Location, asset2: xcm::v3::Location, amount: Balance, include_fee: bool) -> Option { + fn quote_price_exact_tokens_for_tokens(asset1: xcm::v4::Location, asset2: xcm::v4::Location, amount: Balance, include_fee: bool) -> Option { AssetConversion::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee) } - fn quote_price_tokens_for_exact_tokens(asset1: xcm::v3::Location, asset2: xcm::v3::Location, amount: Balance, include_fee: bool) -> Option { + fn quote_price_tokens_for_exact_tokens(asset1: xcm::v4::Location, asset2: xcm::v4::Location, amount: Balance, include_fee: bool) -> Option { AssetConversion::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee) } - fn get_reserves(asset1: xcm::v3::Location, asset2: xcm::v3::Location) -> Option<(Balance, Balance)> { + fn get_reserves(asset1: xcm::v4::Location, asset2: xcm::v4::Location) -> Option<(Balance, Balance)> { AssetConversion::get_reserves(asset1, asset2).ok() } } @@ -1284,17 +1334,10 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { - let acceptable = vec![ - // native token - VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get())) - ]; - - Ok(acceptable - .into_iter() - .filter_map(|asset| asset.into_version(xcm_version).ok()) - .collect()) + let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { @@ -1304,11 +1347,11 @@ impl_runtime_apis! { Ok(WeightToFee::weight_to_fee(&weight)) }, Ok(asset_id) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); Err(XcmPaymentApiError::AssetNotFound) }, Err(_) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); Err(XcmPaymentApiError::VersionedConversionFailed) } } @@ -1323,67 +1366,25 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm_executor::RecordXcm; - use xcm::prelude::*; - - pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; - let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) } - fn dry_run_xcm(origin_location: VersionedLocation, program: VersionedXcm) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm::prelude::*; + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } - let origin_location: Location = origin_location.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Location version conversion failed with error: {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let program: Xcm = program.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Xcm version conversion failed with error {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let mut hash = program.using_encoded(sp_core::hashing::blake2_256); - let result = xcm_executor::XcmExecutor::::prepare_and_execute( - origin_location, - program, - &mut hash, - Weight::MAX, // Max limit available for execution. - Weight::zero(), - ); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(XcmDryRunEffects { - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) } } @@ -1456,7 +1457,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -1526,7 +1527,7 @@ impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(xcm::v4::Assets, u32, Location, Box)> { + ) -> Option<(XcmAssets, u32, Location, alloc::boxed::Box)> { // Transfer to Relay some local AH asset (local-reserve-transfer) while paying // fees using teleported native token. // (We don't care that Relay doesn't accept incoming unknown AH local asset) @@ -1557,11 +1558,11 @@ impl_runtime_apis! { ); let transfer_asset: Asset = (asset_location, asset_amount).into(); - let assets: xcm::v4::Assets = vec![fee_asset.clone(), transfer_asset].into(); + let assets: XcmAssets = vec![fee_asset.clone(), transfer_asset].into(); let fee_index = if assets.get(0).unwrap().eq(&fee_asset) { 0 } else { 1 }; // verify transferred successfully - let verify = Box::new(move || { + let verify = alloc::boxed::Box::new(move || { // verify native balance after transfer, decreased by transferred fee amount // (plus transport fees) assert!(Balances::free_balance(&who) <= balance - fee_amount); @@ -1595,7 +1596,7 @@ impl_runtime_apis! { let bridged_asset_hub = xcm_config::bridging::to_westend::AssetHubWestend::get(); let _ = PolkadotXcm::force_xcm_version( RuntimeOrigin::root(), - Box::new(bridged_asset_hub.clone()), + alloc::boxed::Box::new(bridged_asset_hub.clone()), XCM_VERSION, ).map_err(|e| { log::error!( @@ -1625,7 +1626,7 @@ impl_runtime_apis! { fn valid_destination() -> Result { Ok(TokenLocation::get()) } - fn worst_case_holding(depositable_count: u32) -> xcm::v4::Assets { + fn worst_case_holding(depositable_count: u32) -> XcmAssets { // A mix of fungible, non-fungible, and concrete assets. let holding_non_fungibles = MaxAssetsIntoHolding::get() / 2 - depositable_count; let holding_fungibles = holding_non_fungibles.saturating_sub(2); // -2 for two `iter::once` bellow @@ -1686,15 +1687,13 @@ impl_runtime_apis! { (0u64, Response::Version(Default::default())) } - fn worst_case_asset_exchange() -> Result<(xcm::v4::Assets, xcm::v4::Assets), BenchmarkError> { + fn worst_case_asset_exchange() -> Result<(XcmAssets, XcmAssets), BenchmarkError> { Err(BenchmarkError::Skip) } fn universal_alias() -> Result<(Location, Junction), BenchmarkError> { - match xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() { - Some(alias) => Ok(alias), - None => Err(BenchmarkError::Skip) - } + xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() + .ok_or(BenchmarkError::Skip) } fn transact_origin_and_runtime_call() -> Result<(Location, RuntimeCall), BenchmarkError> { @@ -1705,9 +1704,9 @@ impl_runtime_apis! { Ok(TokenLocation::get()) } - fn claimable_asset() -> Result<(Location, Location, xcm::v4::Assets), BenchmarkError> { + fn claimable_asset() -> Result<(Location, Location, XcmAssets), BenchmarkError> { let origin = TokenLocation::get(); - let assets: xcm::v4::Assets = (TokenLocation::get(), 1_000 * UNITS).into(); + let assets: XcmAssets = (TokenLocation::get(), 1_000 * UNITS).into(); let ticket = Location { parents: 0, interior: Here }; Ok((origin, ticket, assets)) } @@ -1784,105 +1783,3 @@ cumulus_pallet_parachain_system::register_validate_block! { Runtime = Runtime, BlockExecutor = cumulus_pallet_aura_ext::BlockExecutor::, } - -parameter_types! { - // The deposit configuration for the singed migration. Specially if you want to allow any signed account to do the migration (see `SignedFilter`, these deposits should be high) - pub const MigrationSignedDepositPerItem: Balance = CENTS; - pub const MigrationSignedDepositBase: Balance = 2_000 * CENTS; - pub const MigrationMaxKeyLen: u32 = 512; -} - -impl pallet_state_trie_migration::Config for Runtime { - type RuntimeEvent = RuntimeEvent; - type Currency = Balances; - type RuntimeHoldReason = RuntimeHoldReason; - type SignedDepositPerItem = MigrationSignedDepositPerItem; - type SignedDepositBase = MigrationSignedDepositBase; - // An origin that can control the whole pallet: should be Root, or a part of your council. - type ControlOrigin = frame_system::EnsureSignedBy; - // specific account for the migration, can trigger the signed migrations. - type SignedFilter = frame_system::EnsureSignedBy; - - // Replace this with weight based on your runtime. - type WeightInfo = pallet_state_trie_migration::weights::SubstrateWeight; - - type MaxKeyLen = MigrationMaxKeyLen; -} - -frame_support::ord_parameter_types! { - pub const MigController: AccountId = AccountId::from(hex_literal::hex!("8458ed39dc4b6f6c7255f7bc42be50c2967db126357c999d44e12ca7ac80dc52")); - pub const RootMigController: AccountId = AccountId::from(hex_literal::hex!("8458ed39dc4b6f6c7255f7bc42be50c2967db126357c999d44e12ca7ac80dc52")); -} - -#[test] -fn ensure_key_ss58() { - use frame_support::traits::SortedMembers; - use sp_core::crypto::Ss58Codec; - let acc = - AccountId::from_ss58check("5F4EbSkZz18X36xhbsjvDNs6NuZ82HyYtq5UiJ1h9SBHJXZD").unwrap(); - assert_eq!(acc, MigController::sorted_members()[0]); - let acc = - AccountId::from_ss58check("5F4EbSkZz18X36xhbsjvDNs6NuZ82HyYtq5UiJ1h9SBHJXZD").unwrap(); - assert_eq!(acc, RootMigController::sorted_members()[0]); -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::{CENTS, MILLICENTS}; - use sp_runtime::traits::Zero; - use sp_weights::WeightToFee; - use testnet_parachains_constants::rococo::fee; - - /// We can fit at least 1000 transfers in a block. - #[test] - fn sane_block_weight() { - use pallet_balances::WeightInfo; - let block = RuntimeBlockWeights::get().max_block; - let base = RuntimeBlockWeights::get().get(DispatchClass::Normal).base_extrinsic; - let transfer = - base + weights::pallet_balances::WeightInfo::::transfer_allow_death(); - - let fit = block.checked_div_per_component(&transfer).unwrap_or_default(); - assert!(fit >= 1000, "{} should be at least 1000", fit); - } - - /// The fee for one transfer is at most 1 CENT. - #[test] - fn sane_transfer_fee() { - use pallet_balances::WeightInfo; - let base = RuntimeBlockWeights::get().get(DispatchClass::Normal).base_extrinsic; - let transfer = - base + weights::pallet_balances::WeightInfo::::transfer_allow_death(); - - let fee: Balance = fee::WeightToFee::weight_to_fee(&transfer); - assert!(fee <= CENTS, "{} MILLICENTS should be at most 1000", fee / MILLICENTS); - } - - /// Weight is being charged for both dimensions. - #[test] - fn weight_charged_for_both_components() { - let fee: Balance = fee::WeightToFee::weight_to_fee(&Weight::from_parts(10_000, 0)); - assert!(!fee.is_zero(), "Charges for ref time"); - - let fee: Balance = fee::WeightToFee::weight_to_fee(&Weight::from_parts(0, 10_000)); - assert_eq!(fee, CENTS, "10kb maps to CENT"); - } - - /// Filling up a block by proof size is at most 30 times more expensive than ref time. - /// - /// This is just a sanity check. - #[test] - fn full_block_fee_ratio() { - let block = RuntimeBlockWeights::get().max_block; - let time_fee: Balance = - fee::WeightToFee::weight_to_fee(&Weight::from_parts(block.ref_time(), 0)); - let proof_fee: Balance = - fee::WeightToFee::weight_to_fee(&Weight::from_parts(0, block.proof_size())); - - let proof_o_time = proof_fee.checked_div(time_fee).unwrap_or_default(); - assert!(proof_o_time <= 30, "{} should be at most 30", proof_o_time); - let time_o_proof = time_fee.checked_div(proof_fee).unwrap_or_default(); - assert!(time_o_proof <= 30, "{} should be at most 30", time_o_proof); - } -} diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/tests/mod.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/tests/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..12c0bc4e168800a7efd0a72daf75244e92b79255 --- /dev/null +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/tests/mod.rs @@ -0,0 +1,72 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! # Tests for the Rococo runtime. + +use super::*; +use crate::{CENTS, MILLICENTS}; +use sp_runtime::traits::Zero; +use sp_weights::WeightToFee; +use testnet_parachains_constants::rococo::fee; + +/// We can fit at least 1000 transfers in a block. +#[test] +fn sane_block_weight() { + use pallet_balances::WeightInfo; + let block = RuntimeBlockWeights::get().max_block; + let base = RuntimeBlockWeights::get().get(DispatchClass::Normal).base_extrinsic; + let transfer = base + weights::pallet_balances::WeightInfo::::transfer_allow_death(); + + let fit = block.checked_div_per_component(&transfer).unwrap_or_default(); + assert!(fit >= 1000, "{} should be at least 1000", fit); +} + +/// The fee for one transfer is at most 1 CENT. +#[test] +fn sane_transfer_fee() { + use pallet_balances::WeightInfo; + let base = RuntimeBlockWeights::get().get(DispatchClass::Normal).base_extrinsic; + let transfer = base + weights::pallet_balances::WeightInfo::::transfer_allow_death(); + + let fee: Balance = fee::WeightToFee::weight_to_fee(&transfer); + assert!(fee <= CENTS, "{} MILLICENTS should be at most 1000", fee / MILLICENTS); +} + +/// Weight is being charged for both dimensions. +#[test] +fn weight_charged_for_both_components() { + let fee: Balance = fee::WeightToFee::weight_to_fee(&Weight::from_parts(10_000, 0)); + assert!(!fee.is_zero(), "Charges for ref time"); + + let fee: Balance = fee::WeightToFee::weight_to_fee(&Weight::from_parts(0, 10_000)); + assert_eq!(fee, CENTS, "10kb maps to CENT"); +} + +/// Filling up a block by proof size is at most 30 times more expensive than ref time. +/// +/// This is just a sanity check. +#[test] +fn full_block_fee_ratio() { + let block = RuntimeBlockWeights::get().max_block; + let time_fee: Balance = + fee::WeightToFee::weight_to_fee(&Weight::from_parts(block.ref_time(), 0)); + let proof_fee: Balance = + fee::WeightToFee::weight_to_fee(&Weight::from_parts(0, block.proof_size())); + + let proof_o_time = proof_fee.checked_div(time_fee).unwrap_or_default(); + assert!(proof_o_time <= 30, "{} should be at most 30", proof_o_time); + let time_o_proof = time_fee.checked_div(proof_fee).unwrap_or_default(); + assert!(time_o_proof <= 30, "{} should be at most 30", time_o_proof); +} diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs index c1e5c6a74293995b6e3702f19b8b3750c34b192f..fc63a0814d0a4af4ac9e264db8757e5abe2da36d 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs @@ -47,7 +47,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_foreign.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_foreign.rs index 5148edb0ee9e2c5f97c9c0afe830e0f87f2ac92f..c76c1137335a17938e5b409c1642a09ce9824fcd 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_foreign.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_foreign.rs @@ -531,4 +531,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_local.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_local.rs index 4ee235830aed23f9b6c6743a90aa5095bf6f9ed9..cf4f60042bc683fa3a161bbf6d0b9695a718b720 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_local.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_local.rs @@ -528,4 +528,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_pool.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_pool.rs index df7ad2c633867aaf5fea7c737ed926cccb5e2c80..2cd85de0098952d14e15f9e362e6fbe48d2741e7 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_pool.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_assets_pool.rs @@ -528,4 +528,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_message_queue.rs index 45531ccfa797c52ead00833f765347f1282816c7..cd72703104ad0fee8744b904e950def1872d2456 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_message_queue.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_xcm_bridge_hub_router.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_xcm_bridge_hub_router.rs index 775bc3bdb80f54a8db97d1c1fdbf5a837fdb95b1..0a86037391b42d71340d8d0665a9210d8b9a0281 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_xcm_bridge_hub_router.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/pallet_xcm_bridge_hub_router.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_bridge_hub_router` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("asset-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -49,32 +49,32 @@ use core::marker::PhantomData; pub struct WeightInfo(PhantomData); impl pallet_xcm_bridge_hub_router::WeightInfo for WeightInfo { /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `ToWestendXcmRouter::Bridge` (r:1 w:1) /// Proof: `ToWestendXcmRouter::Bridge` (`max_values`: Some(1), `max_size`: Some(17), added: 512, mode: `MaxEncodedLen`) fn on_initialize_when_non_congested() -> Weight { // Proof Size summary in bytes: // Measured: `154` - // Estimated: `1639` - // Minimum execution time: 7_853_000 picoseconds. - Weight::from_parts(8_443_000, 0) - .saturating_add(Weight::from_parts(0, 1639)) + // Estimated: `5487` + // Minimum execution time: 8_078_000 picoseconds. + Weight::from_parts(8_455_000, 0) + .saturating_add(Weight::from_parts(0, 5487)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) fn on_initialize_when_congested() -> Weight { // Proof Size summary in bytes: // Measured: `144` - // Estimated: `1629` - // Minimum execution time: 4_333_000 picoseconds. - Weight::from_parts(4_501_000, 0) - .saturating_add(Weight::from_parts(0, 1629)) + // Estimated: `5487` + // Minimum execution time: 4_291_000 picoseconds. + Weight::from_parts(4_548_000, 0) + .saturating_add(Weight::from_parts(0, 5487)) .saturating_add(T::DbWeight::get().reads(2)) } /// Storage: `ToWestendXcmRouter::Bridge` (r:1 w:1) @@ -83,14 +83,12 @@ impl pallet_xcm_bridge_hub_router::WeightInfo for Weigh // Proof Size summary in bytes: // Measured: `150` // Estimated: `1502` - // Minimum execution time: 10_167_000 picoseconds. - Weight::from_parts(10_667_000, 0) + // Minimum execution time: 9_959_000 picoseconds. + Weight::from_parts(10_372_000, 0) .saturating_add(Weight::from_parts(0, 1502)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: `PolkadotXcm::SupportedVersion` (r:2 w:0) - /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: UNKNOWN KEY `0x3302afcb67e838a3f960251b417b9a4f` (r:1 w:0) @@ -100,7 +98,9 @@ impl pallet_xcm_bridge_hub_router::WeightInfo for Weigh /// Storage: `ToWestendXcmRouter::Bridge` (r:1 w:1) /// Proof: `ToWestendXcmRouter::Bridge` (`max_values`: Some(1), `max_size`: Some(17), added: 512, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0) - /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + /// Storage: `PolkadotXcm::SupportedVersion` (r:2 w:0) + /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) /// Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) @@ -108,17 +108,17 @@ impl pallet_xcm_bridge_hub_router::WeightInfo for Weigh /// Storage: `ParachainSystem::RelevantMessagingState` (r:1 w:0) /// Proof: `ParachainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1) - /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`) fn send_message() -> Weight { // Proof Size summary in bytes: // Measured: `448` // Estimated: `6388` - // Minimum execution time: 60_584_000 picoseconds. - Weight::from_parts(62_467_000, 0) + // Minimum execution time: 45_888_000 picoseconds. + Weight::from_parts(47_022_000, 0) .saturating_add(Weight::from_parts(0, 6388)) .saturating_add(T::DbWeight::get().reads(12)) .saturating_add(T::DbWeight::get().writes(4)) diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/mod.rs index 8e675ad0cf8e627a1f547a181db1737767e84d7c..8c52ecd9f1b1fa66bc027be7b1d376ff6882517a 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/mod.rs @@ -18,10 +18,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 7fab35842509deceba14e89e5bbf6bebe2240528..3d6ae6ddd1d210b5a94d39237d67d4378e9bedec 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-11-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("asset-hub-rococo-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -54,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 21_643_000 picoseconds. - Weight::from_parts(22_410_000, 3593) + // Minimum execution time: 34_180_000 picoseconds. + Weight::from_parts(34_745_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 43_758_000 picoseconds. - Weight::from_parts(44_654_000, 6196) + // Minimum execution time: 42_638_000 picoseconds. + Weight::from_parts(43_454_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -90,20 +90,17 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `246` // Estimated: `8799` - // Minimum execution time: 87_978_000 picoseconds. - Weight::from_parts(88_517_000, 8799) + // Minimum execution time: 102_916_000 picoseconds. + Weight::from_parts(105_699_000, 8799) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(5)) } - // Storage: `ParachainInfo::ParachainId` (r:1 w:0) - // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) pub fn reserve_asset_deposited() -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `1489` - // Minimum execution time: 6_883_000 picoseconds. - Weight::from_parts(6_979_000, 1489) - .saturating_add(T::DbWeight::get().reads(1)) + // Estimated: `0` + // Minimum execution time: 1_805_000 picoseconds. + Weight::from_parts(1_901_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -125,8 +122,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `246` // Estimated: `6196` - // Minimum execution time: 198_882_000 picoseconds. - Weight::from_parts(199_930_000, 6196) + // Minimum execution time: 108_018_000 picoseconds. + Weight::from_parts(110_310_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -134,8 +131,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_343_000 picoseconds. - Weight::from_parts(3_487_000, 0) + // Minimum execution time: 3_507_000 picoseconds. + Weight::from_parts(3_724_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -143,13 +140,11 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 19_399_000 picoseconds. - Weight::from_parts(19_659_000, 3593) + // Minimum execution time: 26_269_000 picoseconds. + Weight::from_parts(26_706_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: `System::Account` (r:2 w:2) - // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -160,6 +155,8 @@ impl WeightInfo { // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) @@ -168,8 +165,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6196` - // Minimum execution time: 59_017_000 picoseconds. - Weight::from_parts(60_543_000, 6196) + // Minimum execution time: 84_759_000 picoseconds. + Weight::from_parts(86_157_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -193,8 +190,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `145` // Estimated: `3610` - // Minimum execution time: 45_409_000 picoseconds. - Weight::from_parts(47_041_000, 3610) + // Minimum execution time: 50_876_000 picoseconds. + Weight::from_parts(51_512_000, 3610) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(3)) } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index 4454494badcbfe9b4f429312e24b63786b83ef75..bee6bcdf21cf3fed11ef63d593b5b0dfb1f0f10b 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs index 664d2b9c9dd593536404f02d895a414e6c232bfa..2d1914e059bf7a95f629a821ce885fb02faa02a1 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/src/xcm_config.rs @@ -55,17 +55,16 @@ use xcm_builder::{ EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, FungiblesAdapter, GlobalConsensusParachainConvertsFor, HashedDescription, IsConcrete, LocalMint, NetworkExportTableItem, NoChecking, NonFungiblesAdapter, ParentAsSuperuser, ParentIsPreset, - RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, + RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, SovereignPaidRemoteExporter, SovereignSignedViaLocation, StartsWith, StartsWithExplicitGlobalConsensus, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; parameter_types! { pub const TokenLocation: Location = Location::parent(); - pub const TokenLocationV3: xcm::v3::Location = xcm::v3::Location::parent(); pub const RelayNetwork: NetworkId = NetworkId::Rococo; pub RelayChainOrigin: RuntimeOrigin = cumulus_pallet_xcm::Origin::Relay.into(); pub UniversalLocation: InteriorLocation = @@ -74,8 +73,6 @@ parameter_types! { pub TrustBackedAssetsPalletLocation: Location = PalletInstance(TrustBackedAssetsPalletIndex::get()).into(); pub TrustBackedAssetsPalletIndex: u8 = ::index() as u8; - pub TrustBackedAssetsPalletLocationV3: xcm::v3::Location = - xcm::v3::Junction::PalletInstance(::index() as u8).into(); pub ForeignAssetsPalletLocation: Location = PalletInstance(::index() as u8).into(); pub PoolAssetsPalletLocation: Location = @@ -177,7 +174,7 @@ pub type ForeignAssetsConvertedConcreteId = assets_common::ForeignAssetsConverte StartsWithExplicitGlobalConsensus, ), Balance, - xcm::v3::Location, + xcm::v4::Location, >; /// Means for transacting foreign assets from different global consensus. @@ -337,10 +334,11 @@ impl xcm_executor::Config for XcmConfig { type OriginConverter = XcmOriginToTransactDispatchOrigin; // Asset Hub trusts only particular, pre-configured bridged locations from a different consensus // as reserve locations (we trust the Bridge Hub to relay the message that a reserve is being - // held). Asset Hub may _act_ as a reserve location for ROC and assets created - // under `pallet-assets`. Users must use teleport where allowed (e.g. ROC with the Relay Chain). + // held). On Rococo Asset Hub, we allow Westend Asset Hub to act as reserve for any asset native + // to the Westend ecosystem. We also allow Ethereum contracts to act as reserves for the foreign + // assets identified by the same respective contracts locations. type IsReserve = ( - bridging::to_westend::IsTrustedBridgedReserveLocationForConcreteAsset, + bridging::to_westend::WestendAssetFromAssetHubWestend, bridging::to_ethereum::IsTrustedBridgedReserveLocationForForeignAsset, ); type IsTeleporter = TrustedTeleporters; @@ -360,7 +358,7 @@ impl xcm_executor::Config for XcmConfig { ResolveTo, >, cumulus_primitives_utility::SwapFirstAssetTrader< - TokenLocationV3, + TokenLocation, crate::AssetConversion, WeightToFee, crate::NativeAndAssets, @@ -368,7 +366,7 @@ impl xcm_executor::Config for XcmConfig { TrustBackedAssetsAsLocation< TrustBackedAssetsPalletLocation, Balance, - xcm::v3::Location, + xcm::v4::Location, >, ForeignAssetsConvertedConcreteId, ), @@ -412,7 +410,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = @@ -501,17 +499,17 @@ pub type ForeignCreatorsSovereignAccountOf = ( /// Simple conversion of `u32` into an `AssetId` for use in benchmarking. pub struct XcmBenchmarkHelper; #[cfg(feature = "runtime-benchmarks")] -impl pallet_assets::BenchmarkHelper for XcmBenchmarkHelper { - fn create_asset_id_parameter(id: u32) -> xcm::v3::Location { - xcm::v3::Location::new(1, [xcm::v3::Junction::Parachain(id)]) +impl pallet_assets::BenchmarkHelper for XcmBenchmarkHelper { + fn create_asset_id_parameter(id: u32) -> xcm::v4::Location { + xcm::v4::Location::new(1, [xcm::v4::Junction::Parachain(id)]) } } /// All configuration related to bridging pub mod bridging { use super::*; + use alloc::collections::btree_set::BTreeSet; use assets_common::matching; - use sp_std::collections::btree_set::BTreeSet; // common/shared parameters parameter_types! { @@ -540,13 +538,13 @@ pub mod bridging { /// (`AssetId` has to be aligned with `BridgeTable`) pub XcmBridgeHubRouterFeeAssetId: AssetId = TokenLocation::get().into(); - pub BridgeTable: sp_std::vec::Vec = - sp_std::vec::Vec::new().into_iter() + pub BridgeTable: alloc::vec::Vec = + alloc::vec::Vec::new().into_iter() .chain(to_westend::BridgeTable::get()) .collect(); - pub EthereumBridgeTable: sp_std::vec::Vec = - sp_std::vec::Vec::new().into_iter() + pub EthereumBridgeTable: alloc::vec::Vec = + alloc::vec::Vec::new().into_iter() .chain(to_ethereum::BridgeTable::get()) .collect(); } @@ -568,20 +566,19 @@ pub mod bridging { ); pub const WestendNetwork: NetworkId = NetworkId::Westend; - pub AssetHubWestend: Location = Location::new(2, [GlobalConsensus(WestendNetwork::get()), Parachain(bp_asset_hub_westend::ASSET_HUB_WESTEND_PARACHAIN_ID)]); + pub WestendEcosystem: Location = Location::new(2, [GlobalConsensus(WestendNetwork::get())]); pub WndLocation: Location = Location::new(2, [GlobalConsensus(WestendNetwork::get())]); - - pub WndFromAssetHubWestend: (AssetFilter, Location) = ( - Wild(AllOf { fun: WildFungible, id: AssetId(WndLocation::get()) }), - AssetHubWestend::get() - ); + pub AssetHubWestend: Location = Location::new(2, [ + GlobalConsensus(WestendNetwork::get()), + Parachain(bp_asset_hub_westend::ASSET_HUB_WESTEND_PARACHAIN_ID) + ]); /// Set up exporters configuration. /// `Option` represents static "base fee" which is used for total delivery fee calculation. - pub BridgeTable: sp_std::vec::Vec = sp_std::vec![ + pub BridgeTable: alloc::vec::Vec = alloc::vec![ NetworkExportTableItem::new( WestendNetwork::get(), - Some(sp_std::vec![ + Some(alloc::vec![ AssetHubWestend::get().interior.split_global().expect("invalid configuration for AssetHubWestend").1, ]), SiblingBridgeHub::get(), @@ -595,7 +592,7 @@ pub mod bridging { /// Universal aliases pub UniversalAliases: BTreeSet<(Location, Junction)> = BTreeSet::from_iter( - sp_std::vec![ + alloc::vec![ (SiblingBridgeHubWithBridgeHubWestendInstance::get(), GlobalConsensus(WestendNetwork::get())) ] ); @@ -607,17 +604,9 @@ pub mod bridging { } } - /// Trusted reserve locations filter for `xcm_executor::Config::IsReserve`. - /// Locations from which the runtime accepts reserved assets. - pub type IsTrustedBridgedReserveLocationForConcreteAsset = - matching::IsTrustedBridgedReserveLocationForConcreteAsset< - UniversalLocation, - ( - // allow receive WND from AssetHubWestend - xcm_builder::Case, - // and nothing else - ), - >; + /// Allow any asset native to the Westend ecosystem if it comes from Westend Asset Hub. + pub type WestendAssetFromAssetHubWestend = + matching::RemoteAssetFromLocation, AssetHubWestend>; impl Contains for ToWestendXcmRouter { fn contains(call: &RuntimeCall) -> bool { @@ -651,10 +640,10 @@ pub mod bridging { /// Set up exporters configuration. /// `Option` represents static "base fee" which is used for total delivery fee calculation. - pub BridgeTable: sp_std::vec::Vec = sp_std::vec![ + pub BridgeTable: alloc::vec::Vec = alloc::vec![ NetworkExportTableItem::new( EthereumNetwork::get(), - Some(sp_std::vec![Junctions::Here]), + Some(alloc::vec![Junctions::Here]), SiblingBridgeHub::get(), Some(( XcmBridgeHubRouterFeeAssetId::get(), @@ -665,14 +654,14 @@ pub mod bridging { /// Universal aliases pub UniversalAliases: BTreeSet<(Location, Junction)> = BTreeSet::from_iter( - sp_std::vec![ + alloc::vec![ (SiblingBridgeHubWithEthereumInboundQueueInstance::get(), GlobalConsensus(EthereumNetwork::get())), ] ); } pub type IsTrustedBridgedReserveLocationForForeignAsset = - matching::IsForeignConcreteAsset>; + IsForeignConcreteAsset>; impl Contains<(Location, Junction)> for UniversalAliases { fn contains(alias: &(Location, Junction)) -> bool { @@ -699,8 +688,7 @@ pub mod bridging { false => None, } }); - assert!(alias.is_some(), "we expect here BridgeHubRococo to Westend mapping at least"); - Some(alias.unwrap()) + Some(alias.expect("we expect here BridgeHubRococo to Westend mapping at least")) } } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-rococo/tests/tests.rs b/cumulus/parachains/runtimes/assets/asset-hub-rococo/tests/tests.rs index f670c5f424efeac0e00ddf472f1948e06d93bd68..83f4f9ec3dc5da6cde0edfec2ace179eb87c7fc1 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-rococo/tests/tests.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-rococo/tests/tests.rs @@ -34,6 +34,7 @@ use asset_test_utils::{ ExtBuilder, SlotDurations, }; use codec::{Decode, Encode}; +use core::ops::Mul; use cumulus_primitives_utility::ChargeWeightInFungibles; use frame_support::{ assert_noop, assert_ok, @@ -48,7 +49,6 @@ use frame_support::{ use parachains_common::{AccountId, AssetIdForTrustBackedAssets, AuraId, Balance}; use sp_consensus_aura::SlotDuration; use sp_runtime::traits::MaybeEquivalence; -use sp_std::ops::Mul; use std::convert::Into; use testnet_parachains_constants::rococo::{consensus::*, currency::UNITS, fee::WeightToFee}; use xcm::latest::prelude::{Assets as XcmAssets, *}; @@ -85,7 +85,7 @@ fn slot_durations() -> SlotDurations { fn setup_pool_for_paying_fees_with_foreign_assets( (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance): ( AccountId, - xcm::v3::Location, + Location, Balance, ), ) { @@ -93,7 +93,7 @@ fn setup_pool_for_paying_fees_with_foreign_assets( // setup a pool to pay fees with `foreign_asset_id_location` tokens let pool_owner: AccountId = [14u8; 32].into(); - let native_asset = xcm::v3::Location::parent(); + let native_asset = Location::parent(); let pool_liquidity: Balance = existential_deposit.max(foreign_asset_id_minimum_balance).mul(100_000); @@ -105,15 +105,15 @@ fn setup_pool_for_paying_fees_with_foreign_assets( assert_ok!(ForeignAssets::mint( RuntimeOrigin::signed(foreign_asset_owner), - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), pool_owner.clone().into(), (foreign_asset_id_minimum_balance + pool_liquidity).mul(2).into(), )); assert_ok!(AssetConversion::create_pool( RuntimeOrigin::signed(pool_owner.clone()), - Box::new(native_asset.into()), - Box::new(foreign_asset_id_location.into()) + Box::new(native_asset.clone().into()), + Box::new(foreign_asset_id_location.clone().into()) )); assert_ok!(AssetConversion::add_liquidity( @@ -217,24 +217,14 @@ fn test_buy_and_refund_weight_with_swap_local_asset_xcm_trader() { assert_ok!(AssetConversion::create_pool( RuntimeHelper::origin_of(bob.clone()), - Box::new( - xcm::v3::Location::try_from(native_location.clone()).expect("conversion works") - ), - Box::new( - xcm::v3::Location::try_from(asset_1_location.clone()) - .expect("conversion works") - ) + Box::new(Location::try_from(native_location.clone()).expect("conversion works")), + Box::new(Location::try_from(asset_1_location.clone()).expect("conversion works")) )); assert_ok!(AssetConversion::add_liquidity( RuntimeHelper::origin_of(bob.clone()), - Box::new( - xcm::v3::Location::try_from(native_location.clone()).expect("conversion works") - ), - Box::new( - xcm::v3::Location::try_from(asset_1_location.clone()) - .expect("conversion works") - ), + Box::new(Location::try_from(native_location.clone()).expect("conversion works")), + Box::new(Location::try_from(asset_1_location.clone()).expect("conversion works")), pool_liquidity, pool_liquidity, 1, @@ -270,8 +260,8 @@ fn test_buy_and_refund_weight_with_swap_local_asset_xcm_trader() { let refund_weight = Weight::from_parts(1_000_000_000, 0); let refund = WeightToFee::weight_to_fee(&refund_weight); let (reserve1, reserve2) = AssetConversion::get_reserves( - xcm::v3::Location::try_from(native_location).expect("conversion works"), - xcm::v3::Location::try_from(asset_1_location.clone()).expect("conversion works"), + Location::try_from(native_location).expect("conversion works"), + Location::try_from(asset_1_location.clone()).expect("conversion works"), ) .unwrap(); let asset_refund = @@ -309,14 +299,10 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { let bob: AccountId = SOME_ASSET_ADMIN.into(); let staking_pot = CollatorSelection::account_id(); let native_location = - xcm::v3::Location::try_from(TokenLocation::get()).expect("conversion works"); - let foreign_location = xcm::v3::Location { + Location::try_from(TokenLocation::get()).expect("conversion works"); + let foreign_location = Location { parents: 1, - interior: ( - xcm::v3::Junction::Parachain(1234), - xcm::v3::Junction::GeneralIndex(12345), - ) - .into(), + interior: (Junction::Parachain(1234), Junction::GeneralIndex(12345)).into(), }; // bob's initial balance for native and `asset1` assets. let initial_balance = 200 * UNITS; @@ -325,26 +311,26 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { // init asset, balances and pool. assert_ok!(>::create( - foreign_location, + foreign_location.clone(), bob.clone(), true, 10 )); - assert_ok!(ForeignAssets::mint_into(foreign_location, &bob, initial_balance)); + assert_ok!(ForeignAssets::mint_into(foreign_location.clone(), &bob, initial_balance)); assert_ok!(Balances::mint_into(&bob, initial_balance)); assert_ok!(Balances::mint_into(&staking_pot, initial_balance)); assert_ok!(AssetConversion::create_pool( RuntimeHelper::origin_of(bob.clone()), - Box::new(native_location), - Box::new(foreign_location) + Box::new(native_location.clone()), + Box::new(foreign_location.clone()) )); assert_ok!(AssetConversion::add_liquidity( RuntimeHelper::origin_of(bob.clone()), - Box::new(native_location), - Box::new(foreign_location), + Box::new(native_location.clone()), + Box::new(foreign_location.clone()), pool_liquidity, pool_liquidity, 1, @@ -353,11 +339,9 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { )); // keep initial total issuance to assert later. - let asset_total_issuance = ForeignAssets::total_issuance(foreign_location); + let asset_total_issuance = ForeignAssets::total_issuance(foreign_location.clone()); let native_total_issuance = Balances::total_issuance(); - let foreign_location_latest: Location = foreign_location.try_into().unwrap(); - // prepare input to buy weight. let weight = Weight::from_parts(4_000_000_000, 0); let fee = WeightToFee::weight_to_fee(&weight); @@ -365,7 +349,7 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { AssetConversion::get_amount_in(&fee, &pool_liquidity, &pool_liquidity).unwrap(); let extra_amount = 100; let ctx = XcmContext { origin: None, message_id: XcmHash::default(), topic: None }; - let payment: Asset = (foreign_location_latest.clone(), asset_fee + extra_amount).into(); + let payment: Asset = (foreign_location.clone(), asset_fee + extra_amount).into(); // init trader and buy weight. let mut trader = ::Trader::new(); @@ -373,13 +357,11 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { trader.buy_weight(weight, payment.into(), &ctx).expect("Expected Ok"); // assert. - let unused_amount = unused_asset - .fungible - .get(&foreign_location_latest.clone().into()) - .map_or(0, |a| *a); + let unused_amount = + unused_asset.fungible.get(&foreign_location.clone().into()).map_or(0, |a| *a); assert_eq!(unused_amount, extra_amount); assert_eq!( - ForeignAssets::total_issuance(foreign_location), + ForeignAssets::total_issuance(foreign_location.clone()), asset_total_issuance + asset_fee ); @@ -387,13 +369,13 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { let refund_weight = Weight::from_parts(1_000_000_000, 0); let refund = WeightToFee::weight_to_fee(&refund_weight); let (reserve1, reserve2) = - AssetConversion::get_reserves(native_location, foreign_location).unwrap(); + AssetConversion::get_reserves(native_location, foreign_location.clone()).unwrap(); let asset_refund = AssetConversion::get_amount_out(&refund, &reserve1, &reserve2).unwrap(); // refund. let actual_refund = trader.refund_weight(refund_weight, &ctx).unwrap(); - assert_eq!(actual_refund, (foreign_location_latest, asset_refund).into()); + assert_eq!(actual_refund, (foreign_location.clone(), asset_refund).into()); // assert. assert_eq!(Balances::balance(&staking_pot), initial_balance); @@ -500,17 +482,13 @@ fn test_foreign_asset_xcm_take_first_trader() { .execute_with(|| { // We need root origin to create a sufficient asset let minimum_asset_balance = 3333333_u128; - let foreign_location = xcm::v3::Location { + let foreign_location = Location { parents: 1, - interior: ( - xcm::v3::Junction::Parachain(1234), - xcm::v3::Junction::GeneralIndex(12345), - ) - .into(), + interior: (Junction::Parachain(1234), Junction::GeneralIndex(12345)).into(), }; assert_ok!(ForeignAssets::force_create( RuntimeHelper::root_origin(), - foreign_location.into(), + foreign_location.clone().into(), AccountId::from(ALICE).into(), true, minimum_asset_balance @@ -519,13 +497,11 @@ fn test_foreign_asset_xcm_take_first_trader() { // We first mint enough asset for the account to exist for assets assert_ok!(ForeignAssets::mint( RuntimeHelper::origin_of(AccountId::from(ALICE)), - foreign_location.into(), + foreign_location.clone().into(), AccountId::from(ALICE).into(), minimum_asset_balance )); - let asset_location_v4: Location = foreign_location.try_into().unwrap(); - // Set Alice as block author, who will receive fees RuntimeHelper::run_to_block(2, AccountId::from(ALICE)); @@ -535,7 +511,7 @@ fn test_foreign_asset_xcm_take_first_trader() { // Lets calculate amount needed let asset_amount_needed = ForeignAssetFeeAsExistentialDepositMultiplierFeeCharger::charge_weight_in_fungibles( - foreign_location, + foreign_location.clone(), bought ) .expect("failed to compute"); @@ -543,7 +519,7 @@ fn test_foreign_asset_xcm_take_first_trader() { // Lets pay with: asset_amount_needed + asset_amount_extra let asset_amount_extra = 100_u128; let asset: Asset = - (asset_location_v4.clone(), asset_amount_needed + asset_amount_extra).into(); + (foreign_location.clone(), asset_amount_needed + asset_amount_extra).into(); let mut trader = ::Trader::new(); let ctx = XcmContext { origin: None, message_id: XcmHash::default(), topic: None }; @@ -551,16 +527,15 @@ fn test_foreign_asset_xcm_take_first_trader() { // Lets buy_weight and make sure buy_weight does not return an error let unused_assets = trader.buy_weight(bought, asset.into(), &ctx).expect("Expected Ok"); // Check whether a correct amount of unused assets is returned - assert_ok!( - unused_assets.ensure_contains(&(asset_location_v4, asset_amount_extra).into()) - ); + assert_ok!(unused_assets + .ensure_contains(&(foreign_location.clone(), asset_amount_extra).into())); // Drop trader drop(trader); // Make sure author(Alice) has received the amount assert_eq!( - ForeignAssets::balance(foreign_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_location.clone(), AccountId::from(ALICE)), minimum_asset_balance + asset_amount_needed ); @@ -841,15 +816,13 @@ fn test_assets_balances_api_works() { .build() .execute_with(|| { let local_asset_id = 1; - let foreign_asset_id_location = xcm::v3::Location::new( - 1, - [xcm::v3::Junction::Parachain(1234), xcm::v3::Junction::GeneralIndex(12345)], - ); + let foreign_asset_id_location = + Location::new(1, [Junction::Parachain(1234), Junction::GeneralIndex(12345)]); // check before assert_eq!(Assets::balance(local_asset_id, AccountId::from(ALICE)), 0); assert_eq!( - ForeignAssets::balance(foreign_asset_id_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_asset_id_location.clone(), AccountId::from(ALICE)), 0 ); assert_eq!(Balances::free_balance(AccountId::from(ALICE)), 0); @@ -886,7 +859,7 @@ fn test_assets_balances_api_works() { let foreign_asset_minimum_asset_balance = 3333333_u128; assert_ok!(ForeignAssets::force_create( RuntimeHelper::root_origin(), - foreign_asset_id_location, + foreign_asset_id_location.clone(), AccountId::from(SOME_ASSET_ADMIN).into(), false, foreign_asset_minimum_asset_balance @@ -895,7 +868,7 @@ fn test_assets_balances_api_works() { // We first mint enough asset for the account to exist for assets assert_ok!(ForeignAssets::mint( RuntimeHelper::origin_of(AccountId::from(SOME_ASSET_ADMIN)), - foreign_asset_id_location, + foreign_asset_id_location.clone(), AccountId::from(ALICE).into(), 6 * foreign_asset_minimum_asset_balance )); @@ -906,7 +879,7 @@ fn test_assets_balances_api_works() { minimum_asset_balance ); assert_eq!( - ForeignAssets::balance(foreign_asset_id_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_asset_id_location.clone(), AccountId::from(ALICE)), 6 * minimum_asset_balance ); assert_eq!(Balances::free_balance(AccountId::from(ALICE)), some_currency); @@ -932,10 +905,8 @@ fn test_assets_balances_api_works() { .into()))); // check foreign asset assert!(result.inner().iter().any(|asset| asset.eq(&( - WithLatestLocationConverter::::convert_back( - &foreign_asset_id_location - ) - .unwrap(), + WithLatestLocationConverter::::convert_back(&foreign_asset_id_location) + .unwrap(), 6 * foreign_asset_minimum_asset_balance ) .into()))); @@ -1025,14 +996,11 @@ asset_test_utils::include_asset_transactor_transfer_with_pallet_assets_instance_ Runtime, XcmConfig, ForeignAssetsInstance, - xcm::v3::Location, + Location, JustTry, collator_session_keys(), ExistentialDeposit::get(), - xcm::v3::Location::new( - 1, - [xcm::v3::Junction::Parachain(1313), xcm::v3::Junction::GeneralIndex(12345)] - ), + Location::new(1, [Junction::Parachain(1313), Junction::GeneralIndex(12345)]), Box::new(|| { assert!(Assets::asset_ids().collect::>().is_empty()); }), @@ -1047,8 +1015,8 @@ asset_test_utils::include_create_and_manage_foreign_assets_for_local_consensus_p WeightToFee, ForeignCreatorsSovereignAccountOf, ForeignAssetsInstance, - xcm::v3::Location, - WithLatestLocationConverter, + Location, + WithLatestLocationConverter, collator_session_keys(), ExistentialDeposit::get(), AssetDeposit::get(), @@ -1138,16 +1106,17 @@ mod asset_hub_rococo_tests { let block_author_account = AccountId::from(BLOCK_AUTHOR_ACCOUNT); let staking_pot = StakingPot::get(); - let foreign_asset_id_location = xcm::v3::Location::new( - 2, - [xcm::v3::Junction::GlobalConsensus(xcm::v3::NetworkId::Westend)], - ); + let foreign_asset_id_location = + Location::new(2, [Junction::GlobalConsensus(NetworkId::Westend)]); let foreign_asset_id_minimum_balance = 1_000_000_000; // sovereign account as foreign asset owner (can be whoever for this scenario) let foreign_asset_owner = LocationToAccountId::convert_location(&Location::parent()).unwrap(); - let foreign_asset_create_params = - (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance); + let foreign_asset_create_params = ( + foreign_asset_owner, + foreign_asset_id_location.clone(), + foreign_asset_id_minimum_balance, + ); asset_test_utils::test_cases_over_bridge::receive_reserve_asset_deposited_from_different_consensus_works::< Runtime, @@ -1181,7 +1150,7 @@ mod asset_hub_rococo_tests { // check now foreign asset for staking pot assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &staking_pot ), 0 @@ -1195,7 +1164,7 @@ mod asset_hub_rococo_tests { // staking pot receives no foreign assets assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &staking_pot ), 0 @@ -1211,16 +1180,17 @@ mod asset_hub_rococo_tests { let block_author_account = AccountId::from(BLOCK_AUTHOR_ACCOUNT); let staking_pot = StakingPot::get(); - let foreign_asset_id_location = xcm::v3::Location::new( - 2, - [xcm::v3::Junction::GlobalConsensus(xcm::v3::NetworkId::Westend)], - ); + let foreign_asset_id_location = + Location::new(2, [Junction::GlobalConsensus(NetworkId::Westend)]); let foreign_asset_id_minimum_balance = 1_000_000_000; // sovereign account as foreign asset owner (can be whoever for this scenario) let foreign_asset_owner = LocationToAccountId::convert_location(&Location::parent()).unwrap(); - let foreign_asset_create_params = - (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance); + let foreign_asset_create_params = ( + foreign_asset_owner, + foreign_asset_id_location.clone(), + foreign_asset_id_minimum_balance, + ); asset_test_utils::test_cases_over_bridge::receive_reserve_asset_deposited_from_different_consensus_works::< Runtime, @@ -1245,7 +1215,7 @@ mod asset_hub_rococo_tests { // check block author before assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &block_author_account ), 0 @@ -1255,7 +1225,7 @@ mod asset_hub_rococo_tests { // `TakeFirstAssetTrader` puts fees to the block author assert!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &block_author_account ) > 0 ); @@ -1277,7 +1247,7 @@ mod asset_hub_rococo_tests { collator_session_keys(), bridging_to_asset_hub_westend, || { - sp_std::vec![ + vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -1287,16 +1257,16 @@ mod asset_hub_rococo_tests { bp_asset_hub_rococo::XcmBridgeHubRouterCall::report_bridge_status { bridge_id: Default::default(), is_congested: true, - } + }, ) .encode() .into(), - } + }, ] .into() }, || { - sp_std::vec![ + vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -1306,11 +1276,11 @@ mod asset_hub_rococo_tests { bp_asset_hub_rococo::XcmBridgeHubRouterCall::report_bridge_status { bridge_id: Default::default(), is_congested: false, - } + }, ) .encode() .into(), - } + }, ] .into() }, diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml index bacc9c1b7c29eba47f0ddc1140771407e7d1ab3c..77130ff846b5ad32dd760dd9364c9685dd619193 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/Cargo.toml @@ -10,94 +10,97 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -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-assets = { path = "../../../../../substrate/frame/assets", default-features = false } -pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", 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-proxy = { path = "../../../../../substrate/frame/proxy", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-state-trie-migration = { path = "../../../../../substrate/frame/state-trie-migration", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-uniques = { path = "../../../../../substrate/frame/uniques", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-asset-conversion-ops = { workspace = true } +pallet-asset-conversion-tx-payment = { workspace = true } +pallet-assets = { workspace = true } +pallet-asset-conversion = { workspace = true } +pallet-assets-freezer = { workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-multisig = { workspace = true } +pallet-nft-fractionalization = { workspace = true } +pallet-nfts = { workspace = true } +pallet-nfts-runtime-api = { workspace = true } +pallet-proxy = { workspace = true } +pallet-session = { workspace = true } +pallet-state-trie-migration = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-uniques = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-std = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # num-traits feature needed for dex integer sq root: -primitive-types = { version = "0.12.1", default-features = false, features = ["codec", "num-traits", "scale-info"] } +primitive-types = { features = ["codec", "num-traits", "scale-info"], workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../../../../polkadot/xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +westend-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } -assets-common = { path = "../common", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +pallet-message-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { features = ["bridging"], workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } +assets-common = { workspace = true } # Bridges -pallet-xcm-bridge-hub-router = { path = "../../../../../bridges/modules/xcm-bridge-hub-router", default-features = false } -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-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 } +pallet-xcm-bridge-hub-router = { workspace = true } +bp-asset-hub-rococo = { workspace = true } +bp-asset-hub-westend = { workspace = true } +bp-bridge-hub-rococo = { workspace = true } +bp-bridge-hub-westend = { workspace = true } +snowbridge-router-primitives = { workspace = true } [dev-dependencies] -asset-test-utils = { path = "../test-utils" } +asset-test-utils = { workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -114,6 +117,7 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "pallet-asset-conversion-ops/runtime-benchmarks", "pallet-asset-conversion/runtime-benchmarks", + "pallet-assets-freezer/runtime-benchmarks", "pallet-assets/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-collator-selection/runtime-benchmarks", @@ -132,10 +136,11 @@ runtime-benchmarks = [ "parachains-common/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", "polkadot-runtime-common/runtime-benchmarks", + "snowbridge-router-primitives/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "cumulus-pallet-aura-ext/try-runtime", @@ -149,6 +154,7 @@ try-runtime = [ "pallet-asset-conversion-ops/try-runtime", "pallet-asset-conversion-tx-payment/try-runtime", "pallet-asset-conversion/try-runtime", + "pallet-assets-freezer/try-runtime", "pallet-assets/try-runtime", "pallet-aura/try-runtime", "pallet-authorship/try-runtime", @@ -189,6 +195,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking?/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -198,6 +205,7 @@ std = [ "pallet-asset-conversion-ops/std", "pallet-asset-conversion-tx-payment/std", "pallet-asset-conversion/std", + "pallet-assets-freezer/std", "pallet-assets/std", "pallet-aura/std", "pallet-authorship/std", @@ -225,6 +233,7 @@ std = [ "polkadot-runtime-common/std", "primitive-types/std", "scale-info/std", + "snowbridge-router-primitives/std", "sp-api/std", "sp-block-builder/std", "sp-consensus-aura/std", @@ -243,11 +252,14 @@ std = [ "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = ["metadata-hash"] diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs index 239ccac19ec7778039fb1ee56f4e772b3ddd3711..cf9664aeb2f3e4ae8cfd74c24c833ba7021a3432 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/build.rs @@ -13,10 +13,17 @@ // See the License for the specific language governing permissions and // limitations under the License. -#[cfg(feature = "std")] +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] fn main() { substrate_wasm_builder::WasmBuilder::build_using_defaults(); } +#[cfg(all(feature = "metadata-hash", feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("WND", 12) + .build(); +} + #[cfg(not(feature = "std"))] fn main() {} diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs index b5c3ed5053c4b77e1ecf0adeb8c99c5beecb81e0..ebbc000d1413883037ccab3048a36c0f8a2b8ec3 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/lib.rs @@ -27,6 +27,9 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use assets_common::{ local_and_foreign_assets::{LocalFromLeft, TargetFromLeft}, AssetIdForTrustBackedAssetsConvert, @@ -52,7 +55,7 @@ use frame_system::{ limits::{BlockLength, BlockWeights}, EnsureRoot, EnsureSigned, EnsureSignedBy, }; -use pallet_asset_conversion_tx_payment::AssetConversionAdapter; +use pallet_asset_conversion_tx_payment::SwapAssetAdapter; use pallet_nfts::{DestroyWitness, PalletFeatures}; use pallet_xcm::EnsureXcm; use parachains_common::{ @@ -68,39 +71,39 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, Perbill, Permill, RuntimeDebug, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; -use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*}; +use testnet_parachains_constants::westend::{ + consensus::*, currency::*, fee::WeightToFee, snowbridge::EthereumNetwork, time::*, +}; use xcm_config::{ ForeignAssetsConvertedConcreteId, ForeignCreatorsSovereignAccountOf, PoolAssetsConvertedConcreteId, TrustBackedAssetsConvertedConcreteId, - TrustBackedAssetsPalletLocationV3, WestendLocation, WestendLocationV3, - XcmOriginToTransactDispatchOrigin, + TrustBackedAssetsPalletLocation, WestendLocation, XcmOriginToTransactDispatchOrigin, }; #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; -use assets_common::{foreign_creators::ForeignCreators, matching::FromSiblingParachain}; +use assets_common::{ + foreign_creators::ForeignCreators, + matching::{FromNetwork, FromSiblingParachain}, +}; use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate}; use xcm::{ + latest::prelude::AssetId, prelude::{VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm}, - IntoVersion, }; -// We exclude `Assets` since it's the name of a pallet -use xcm::latest::prelude::AssetId; - #[cfg(feature = "runtime-benchmarks")] use xcm::latest::prelude::{ - Asset, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, NetworkId, - NonFungible, Parent, ParentThen, Response, XCM_VERSION, + Asset, Assets as XcmAssets, Fungible, Here, InteriorLocation, Junction, Junction::*, Location, + NetworkId, NonFungible, Parent, ParentThen, Response, XCM_VERSION, }; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects}, +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::Error as XcmPaymentApiError, }; @@ -120,10 +123,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("westmint"), impl_name: create_runtime_str!("westmint"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 15, + transaction_version: 16, state_version: 1, }; @@ -258,7 +261,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = MetadataDepositPerByte; type ApprovalDeposit = ApprovalDeposit; type StringLimit = AssetsStringLimit; - type Freezer = (); + type Freezer = AssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_local::WeightInfo; type CallbackHandle = (); @@ -268,6 +271,13 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = (); } +// Allow Freezes for the `Assets` pallet +pub type AssetsFreezerInstance = pallet_assets_freezer::Instance1; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + parameter_types! { pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon"); pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0); @@ -295,7 +305,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = ConstU128<0>; type ApprovalDeposit = ConstU128<0>; type StringLimit = ConstU32<50>; - type Freezer = (); + type Freezer = PoolAssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_pool::WeightInfo; type CallbackHandle = (); @@ -303,16 +313,23 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = (); } +// Allow Freezes for the `PoolAssets` pallet +pub type PoolAssetsFreezerInstance = pallet_assets_freezer::Instance3; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + /// Union fungibles implementation for `Assets` and `ForeignAssets`. pub type LocalAndForeignAssets = fungibles::UnionOf< Assets, ForeignAssets, LocalFromLeft< - AssetIdForTrustBackedAssetsConvert, + AssetIdForTrustBackedAssetsConvert, AssetIdForTrustBackedAssets, - xcm::v3::Location, + xcm::v4::Location, >, - xcm::v3::Location, + xcm::v4::Location, AccountId, >; @@ -320,25 +337,25 @@ pub type LocalAndForeignAssets = fungibles::UnionOf< pub type NativeAndAssets = fungible::UnionOf< Balances, LocalAndForeignAssets, - TargetFromLeft, - xcm::v3::Location, + TargetFromLeft, + xcm::v4::Location, AccountId, >; pub type PoolIdToAccountId = pallet_asset_conversion::AccountIdConverter< AssetConversionPalletId, - (xcm::v3::Location, xcm::v3::Location), + (xcm::v4::Location, xcm::v4::Location), >; impl pallet_asset_conversion::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Balance = Balance; type HigherPrecisionBalance = sp_core::U256; - type AssetKind = xcm::v3::Location; + type AssetKind = xcm::v4::Location; type Assets = NativeAndAssets; type PoolId = (Self::AssetKind, Self::AssetKind); type PoolLocator = pallet_asset_conversion::WithFirstAsset< - WestendLocationV3, + WestendLocation, AccountId, Self::AssetKind, PoolIdToAccountId, @@ -346,7 +363,7 @@ impl pallet_asset_conversion::Config for Runtime { type PoolAssetId = u32; type PoolAssets = PoolAssets; type PoolSetupFee = ConstU128<0>; // Asset class deposit fees are sufficient to prevent spam - type PoolSetupFeeAsset = WestendLocationV3; + type PoolSetupFeeAsset = WestendLocation; type PoolSetupFeeTarget = ResolveAssetTo; type LiquidityWithdrawalFee = LiquidityWithdrawalFee; type LPFee = ConstU32<3>; @@ -356,10 +373,10 @@ impl pallet_asset_conversion::Config for Runtime { type WeightInfo = weights::pallet_asset_conversion::WeightInfo; #[cfg(feature = "runtime-benchmarks")] type BenchmarkHelper = assets_common::benchmarks::AssetPairFactory< - WestendLocationV3, + WestendLocation, parachain_info::Pallet, xcm_config::TrustBackedAssetsPalletIndex, - xcm::v3::Location, + xcm::v4::Location, >; } @@ -393,14 +410,17 @@ pub type ForeignAssetsInstance = pallet_assets::Instance2; impl pallet_assets::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Balance = Balance; - type AssetId = xcm::v3::Location; - type AssetIdParameter = xcm::v3::Location; + type AssetId = xcm::v4::Location; + type AssetIdParameter = xcm::v4::Location; type Currency = Balances; type CreateOrigin = ForeignCreators< - FromSiblingParachain, xcm::v3::Location>, + ( + FromSiblingParachain, xcm::v4::Location>, + FromNetwork, + ), ForeignCreatorsSovereignAccountOf, AccountId, - xcm::v3::Location, + xcm::v4::Location, >; type ForceOrigin = AssetsForceOrigin; type AssetDeposit = ForeignAssetsAssetDeposit; @@ -408,7 +428,7 @@ impl pallet_assets::Config for Runtime { type MetadataDepositPerByte = ForeignAssetsMetadataDepositPerByte; type ApprovalDeposit = ForeignAssetsApprovalDeposit; type StringLimit = ForeignAssetsAssetsStringLimit; - type Freezer = (); + type Freezer = ForeignAssetsFreezer; type Extra = (); type WeightInfo = weights::pallet_assets_foreign::WeightInfo; type CallbackHandle = (); @@ -418,6 +438,13 @@ impl pallet_assets::Config for Runtime { type BenchmarkHelper = xcm_config::XcmBenchmarkHelper; } +// Allow Freezes for the `ForeignAssets` pallet +pub type ForeignAssetsFreezerInstance = pallet_assets_freezer::Instance2; +impl pallet_assets_freezer::Config for Runtime { + type RuntimeFreezeReason = RuntimeFreezeReason; + type RuntimeEvent = RuntimeEvent; +} + parameter_types! { // One storage item; key size is 32; value is size 4+4+16+32 bytes = 56 bytes. pub const DepositBase: Balance = deposit(1, 88); @@ -669,7 +696,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -697,13 +724,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type VersionWrapper = PolkadotXcm; // Enqueue XCMP messages from siblings for later processing. type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } @@ -758,11 +794,19 @@ impl pallet_collator_selection::Config for Runtime { type WeightInfo = weights::pallet_collator_selection::WeightInfo; } +parameter_types! { + pub StakingPot: AccountId = CollatorSelection::account_id(); +} + impl pallet_asset_conversion_tx_payment::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type Fungibles = LocalAndForeignAssets; - type OnChargeAssetTransaction = - AssetConversionAdapter; + type AssetId = xcm::v4::Location; + type OnChargeAssetTransaction = SwapAssetAdapter< + WestendLocation, + NativeAndAssets, + AssetConversion, + ResolveAssetTo, + >; } parameter_types! { @@ -937,6 +981,9 @@ construct_runtime!( NftFractionalization: pallet_nft_fractionalization = 54, PoolAssets: pallet_assets:: = 55, AssetConversion: pallet_asset_conversion = 56, + AssetsFreezer: pallet_assets_freezer:: = 57, + ForeignAssetsFreezer: pallet_assets_freezer:: = 58, + PoolAssetsFreezer: pallet_assets_freezer:: = 59, StateTrieMigration: pallet_state_trie_migration = 70, @@ -965,6 +1012,7 @@ pub type SignedExtra = ( frame_system::CheckWeight, pallet_asset_conversion_tx_payment::ChargeAssetTxPayment, cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = @@ -984,6 +1032,7 @@ pub type Migrations = ( DeleteUndecodableStorage, // unreleased cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); @@ -1174,7 +1223,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -1281,18 +1330,18 @@ impl_runtime_apis! { impl pallet_asset_conversion::AssetConversionApi< Block, Balance, - xcm::v3::Location, + xcm::v4::Location, > for Runtime { - fn quote_price_exact_tokens_for_tokens(asset1: xcm::v3::Location, asset2: xcm::v3::Location, amount: Balance, include_fee: bool) -> Option { + fn quote_price_exact_tokens_for_tokens(asset1: xcm::v4::Location, asset2: xcm::v4::Location, amount: Balance, include_fee: bool) -> Option { AssetConversion::quote_price_exact_tokens_for_tokens(asset1, asset2, amount, include_fee) } - fn quote_price_tokens_for_exact_tokens(asset1: xcm::v3::Location, asset2: xcm::v3::Location, amount: Balance, include_fee: bool) -> Option { + fn quote_price_tokens_for_exact_tokens(asset1: xcm::v4::Location, asset2: xcm::v4::Location, amount: Balance, include_fee: bool) -> Option { AssetConversion::quote_price_tokens_for_exact_tokens(asset1, asset2, amount, include_fee) } - fn get_reserves(asset1: xcm::v3::Location, asset2: xcm::v3::Location) -> Option<(Balance, Balance)> { + fn get_reserves(asset1: xcm::v4::Location, asset2: xcm::v4::Location) -> Option<(Balance, Balance)> { AssetConversion::get_reserves(asset1, asset2).ok() } } @@ -1318,17 +1367,10 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { - let acceptable = vec![ - // native token - VersionedAssetId::from(AssetId(xcm_config::WestendLocation::get())) - ]; - - Ok(acceptable - .into_iter() - .filter_map(|asset| asset.into_version(xcm_version).ok()) - .collect()) + let acceptable_assets = vec![AssetId(xcm_config::WestendLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { @@ -1338,11 +1380,11 @@ impl_runtime_apis! { Ok(WeightToFee::weight_to_fee(&weight)) }, Ok(asset_id) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); Err(XcmPaymentApiError::AssetNotFound) }, Err(_) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); Err(XcmPaymentApiError::VersionedConversionFailed) } } @@ -1357,67 +1399,25 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm_executor::RecordXcm; - use xcm::prelude::*; - - pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; - let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) } - fn dry_run_xcm(origin_location: VersionedLocation, program: VersionedXcm) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm::prelude::*; + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } - let origin_location: Location = origin_location.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Location version conversion failed with error: {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let program: Xcm = program.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Xcm version conversion failed with error {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let mut hash = program.using_encoded(sp_core::hashing::blake2_256); - let result = xcm_executor::XcmExecutor::::prepare_and_execute( - origin_location, - program, - &mut hash, - Weight::MAX, // Max limit available for execution. - Weight::zero(), - ); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(XcmDryRunEffects { - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) } } @@ -1553,7 +1553,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -1618,7 +1618,7 @@ impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(xcm::v4::Assets, u32, Location, Box)> { + ) -> Option<(XcmAssets, u32, Location, alloc::boxed::Box)> { // Transfer to Relay some local AH asset (local-reserve-transfer) while paying // fees using teleported native token. // (We don't care that Relay doesn't accept incoming unknown AH local asset) @@ -1649,11 +1649,11 @@ impl_runtime_apis! { ); let transfer_asset: Asset = (asset_location, asset_amount).into(); - let assets: xcm::v4::Assets = vec![fee_asset.clone(), transfer_asset].into(); + let assets: XcmAssets = vec![fee_asset.clone(), transfer_asset].into(); let fee_index = if assets.get(0).unwrap().eq(&fee_asset) { 0 } else { 1 }; // verify transferred successfully - let verify = Box::new(move || { + let verify = alloc::boxed::Box::new(move || { // verify native balance after transfer, decreased by transferred fee amount // (plus transport fees) assert!(Balances::free_balance(&who) <= balance - fee_amount); @@ -1692,7 +1692,7 @@ impl_runtime_apis! { let bridged_asset_hub = xcm_config::bridging::to_rococo::AssetHubRococo::get(); let _ = PolkadotXcm::force_xcm_version( RuntimeOrigin::root(), - Box::new(bridged_asset_hub.clone()), + alloc::boxed::Box::new(bridged_asset_hub.clone()), XCM_VERSION, ).map_err(|e| { log::error!( @@ -1722,7 +1722,7 @@ impl_runtime_apis! { fn valid_destination() -> Result { Ok(WestendLocation::get()) } - fn worst_case_holding(depositable_count: u32) -> xcm::v4::Assets { + fn worst_case_holding(depositable_count: u32) -> XcmAssets { // A mix of fungible, non-fungible, and concrete assets. let holding_non_fungibles = MaxAssetsIntoHolding::get() / 2 - depositable_count; let holding_fungibles = holding_non_fungibles - 2; // -2 for two `iter::once` bellow @@ -1783,15 +1783,13 @@ impl_runtime_apis! { (0u64, Response::Version(Default::default())) } - fn worst_case_asset_exchange() -> Result<(xcm::v4::Assets, xcm::v4::Assets), BenchmarkError> { + fn worst_case_asset_exchange() -> Result<(XcmAssets, XcmAssets), BenchmarkError> { Err(BenchmarkError::Skip) } fn universal_alias() -> Result<(Location, Junction), BenchmarkError> { - match xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() { - Some(alias) => Ok(alias), - None => Err(BenchmarkError::Skip) - } + xcm_config::bridging::BridgingBenchmarksHelper::prepare_universal_alias() + .ok_or(BenchmarkError::Skip) } fn transact_origin_and_runtime_call() -> Result<(Location, RuntimeCall), BenchmarkError> { @@ -1802,9 +1800,9 @@ impl_runtime_apis! { Ok(WestendLocation::get()) } - fn claimable_asset() -> Result<(Location, Location, xcm::v4::Assets), BenchmarkError> { + fn claimable_asset() -> Result<(Location, Location, XcmAssets), BenchmarkError> { let origin = WestendLocation::get(); - let assets: xcm::v4::Assets = (AssetId(WestendLocation::get()), 1_000 * UNITS).into(); + let assets: XcmAssets = (AssetId(WestendLocation::get()), 1_000 * UNITS).into(); let ticket = Location { parents: 0, interior: Here }; Ok((origin, ticket, assets)) } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/cumulus_pallet_parachain_system.rs index c1e5c6a74293995b6e3702f19b8b3750c34b192f..fc63a0814d0a4af4ac9e264db8757e5abe2da36d 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/cumulus_pallet_parachain_system.rs @@ -47,7 +47,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_foreign.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_foreign.rs index 52ba2fd6c40fcfea552b181bcb05cfecab75f6b4..2692de9aeb50daf5085cba094406b63d6a95c829 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_foreign.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_foreign.rs @@ -537,4 +537,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_local.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_local.rs index e78366b91cbe8100c2a46c47a8708c3f1aed918d..d2e12549a45c705882a5233d1e4a0825ada8b1eb 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_local.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_local.rs @@ -535,4 +535,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_pool.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_pool.rs index 65cae81069c40f7369d31d8411bf882521b71e11..8368f6e583ccf147a7fb9cf0eb9b9ba04b98da3b 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_pool.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_assets_pool.rs @@ -529,4 +529,14 @@ impl pallet_assets::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } + + fn transfer_all() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 46_573_000 picoseconds. + Weight::from_parts(47_385_000, 3593) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_message_queue.rs index 45531ccfa797c52ead00833f765347f1282816c7..cd72703104ad0fee8744b904e950def1872d2456 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_message_queue.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_xcm_bridge_hub_router.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_xcm_bridge_hub_router.rs index 84d717b0283c764cac14cce63ca34f81c9f58e8c..21d15c75af553da60ecf0648186a26255bb72890 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_xcm_bridge_hub_router.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/pallet_xcm_bridge_hub_router.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_bridge_hub_router` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("asset-hub-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -49,48 +49,46 @@ use core::marker::PhantomData; pub struct WeightInfo(PhantomData); impl pallet_xcm_bridge_hub_router::WeightInfo for WeightInfo { /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `ToRococoXcmRouter::Bridge` (r:1 w:1) /// Proof: `ToRococoXcmRouter::Bridge` (`max_values`: Some(1), `max_size`: Some(17), added: 512, mode: `MaxEncodedLen`) fn on_initialize_when_non_congested() -> Weight { // Proof Size summary in bytes: - // Measured: `193` - // Estimated: `1678` - // Minimum execution time: 8_095_000 picoseconds. - Weight::from_parts(8_393_000, 0) - .saturating_add(Weight::from_parts(0, 1678)) + // Measured: `226` + // Estimated: `5487` + // Minimum execution time: 8_363_000 picoseconds. + Weight::from_parts(8_620_000, 0) + .saturating_add(Weight::from_parts(0, 5487)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) fn on_initialize_when_congested() -> Weight { // Proof Size summary in bytes: // Measured: `111` - // Estimated: `1596` - // Minimum execution time: 3_417_000 picoseconds. - Weight::from_parts(3_583_000, 0) - .saturating_add(Weight::from_parts(0, 1596)) + // Estimated: `5487` + // Minimum execution time: 3_436_000 picoseconds. + Weight::from_parts(3_586_000, 0) + .saturating_add(Weight::from_parts(0, 5487)) .saturating_add(T::DbWeight::get().reads(2)) } /// Storage: `ToRococoXcmRouter::Bridge` (r:1 w:1) /// Proof: `ToRococoXcmRouter::Bridge` (`max_values`: Some(1), `max_size`: Some(17), added: 512, mode: `MaxEncodedLen`) fn report_bridge_status() -> Weight { // Proof Size summary in bytes: - // Measured: `117` + // Measured: `150` // Estimated: `1502` - // Minimum execution time: 10_280_000 picoseconds. - Weight::from_parts(10_703_000, 0) + // Minimum execution time: 9_706_000 picoseconds. + Weight::from_parts(10_139_000, 0) .saturating_add(Weight::from_parts(0, 1502)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: `PolkadotXcm::SupportedVersion` (r:2 w:0) - /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: UNKNOWN KEY `0x3302afcb67e838a3f960251b417b9a4f` (r:1 w:0) @@ -100,7 +98,9 @@ impl pallet_xcm_bridge_hub_router::WeightInfo for Weigh /// Storage: `ToRococoXcmRouter::Bridge` (r:1 w:1) /// Proof: `ToRococoXcmRouter::Bridge` (`max_values`: Some(1), `max_size`: Some(17), added: 512, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0) - /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + /// Storage: `PolkadotXcm::SupportedVersion` (r:2 w:0) + /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) /// Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) @@ -108,18 +108,18 @@ impl pallet_xcm_bridge_hub_router::WeightInfo for Weigh /// Storage: `ParachainSystem::RelevantMessagingState` (r:1 w:0) /// Proof: `ParachainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::InboundXcmpSuspended` (r:1 w:0) - /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::InboundXcmpSuspended` (`max_values`: Some(1), `max_size`: Some(4002), added: 4497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1) - /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`) fn send_message() -> Weight { // Proof Size summary in bytes: - // Measured: `487` - // Estimated: `6427` - // Minimum execution time: 63_624_000 picoseconds. - Weight::from_parts(66_071_000, 0) - .saturating_add(Weight::from_parts(0, 6427)) + // Measured: `520` + // Estimated: `6460` + // Minimum execution time: 46_250_000 picoseconds. + Weight::from_parts(47_801_000, 0) + .saturating_add(Weight::from_parts(0, 6460)) .saturating_add(T::DbWeight::get().reads(12)) .saturating_add(T::DbWeight::get().writes(4)) } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/mod.rs index 8c77774da2dd747f4c3321ae9e2dfb3984cedb0f..d39052c5c03b84f8c02f8257bd9f5a739f4f8624 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/mod.rs @@ -17,10 +17,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index eaf07aac52cefa88f524e6f3a2180ab9faf2b088..f7891aedc496d188bcf4bab06c68b8d3d3373b52 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -1,24 +1,25 @@ // Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 +// This file is part of Cumulus. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-vmdtonbz-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("asset-hub-westend-dev"), DB CACHE: 1024 // Executed Command: @@ -42,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -53,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 20_295_000 picoseconds. - Weight::from_parts(21_142_000, 3593) + // Minimum execution time: 32_612_000 picoseconds. + Weight::from_parts(33_359_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -64,8 +65,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 42_356_000 picoseconds. - Weight::from_parts(43_552_000, 6196) + // Minimum execution time: 41_144_000 picoseconds. + Weight::from_parts(41_788_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -89,20 +90,17 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `246` // Estimated: `8799` - // Minimum execution time: 85_553_000 picoseconds. - Weight::from_parts(87_177_000, 8799) + // Minimum execution time: 101_340_000 picoseconds. + Weight::from_parts(103_686_000, 8799) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(5)) } - // Storage: `ParachainInfo::ParachainId` (r:1 w:0) - // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) pub fn reserve_asset_deposited() -> Weight { // Proof Size summary in bytes: // Measured: `0` - // Estimated: `1489` - // Minimum execution time: 6_166_000 picoseconds. - Weight::from_parts(6_352_000, 1489) - .saturating_add(T::DbWeight::get().reads(1)) + // Estimated: `0` + // Minimum execution time: 1_682_000 picoseconds. + Weight::from_parts(1_734_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -124,8 +122,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `246` // Estimated: `6196` - // Minimum execution time: 184_462_000 picoseconds. - Weight::from_parts(189_593_000, 6196) + // Minimum execution time: 107_335_000 picoseconds. + Weight::from_parts(109_665_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -133,8 +131,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_018_000 picoseconds. - Weight::from_parts(3_098_000, 0) + // Minimum execution time: 3_345_000 picoseconds. + Weight::from_parts(3_548_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -142,13 +140,11 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 18_583_000 picoseconds. - Weight::from_parts(19_057_000, 3593) + // Minimum execution time: 25_560_000 picoseconds. + Weight::from_parts(26_779_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: `System::Account` (r:2 w:2) - // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -159,6 +155,8 @@ impl WeightInfo { // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) @@ -167,8 +165,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `145` // Estimated: `6196` - // Minimum execution time: 56_666_000 picoseconds. - Weight::from_parts(58_152_000, 6196) + // Minimum execution time: 84_453_000 picoseconds. + Weight::from_parts(86_755_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -192,8 +190,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `145` // Estimated: `3610` - // Minimum execution time: 44_197_000 picoseconds. - Weight::from_parts(45_573_000, 3610) + // Minimum execution time: 50_463_000 picoseconds. + Weight::from_parts(51_587_000, 3610) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(3)) } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index fc196abea0f5e61d746760e2b2bf5a7d8d0a476b..127bc173c103741839ac2466b0d6ae7d5942ea7f 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -42,7 +42,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs index 35a42627ad71004642b278bba1ff1a564929061f..d61381d3f50b7c5379c71716f60addd6333adb8e 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/src/xcm_config.rs @@ -42,6 +42,7 @@ use parachains_common::{ }; use polkadot_parachain_primitives::primitives::Sibling; use polkadot_runtime_common::xcm_sender::ExponentialPrice; +use snowbridge_router_primitives::inbound::GlobalConsensusEthereumConvertsFor; use sp_runtime::traits::{AccountIdConversion, ConvertInto}; use xcm::latest::prelude::*; use xcm_builder::{ @@ -51,17 +52,16 @@ use xcm_builder::{ EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, FungiblesAdapter, GlobalConsensusParachainConvertsFor, HashedDescription, IsConcrete, LocalMint, NetworkExportTableItem, NoChecking, NonFungiblesAdapter, ParentAsSuperuser, ParentIsPreset, - RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, - SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, StartsWith, - StartsWithExplicitGlobalConsensus, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, - WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, - XcmFeeToAccount, + RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, + SignedAccountId32AsNative, SignedToAccountId32, SovereignPaidRemoteExporter, + SovereignSignedViaLocation, StartsWith, StartsWithExplicitGlobalConsensus, TakeWeightCredit, + TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; parameter_types! { pub const WestendLocation: Location = Location::parent(); - pub const WestendLocationV3: xcm::v3::Location = xcm::v3::Location::parent(); pub const RelayNetwork: Option = Some(NetworkId::Westend); pub RelayChainOrigin: RuntimeOrigin = cumulus_pallet_xcm::Origin::Relay.into(); pub UniversalLocation: InteriorLocation = @@ -70,8 +70,6 @@ parameter_types! { pub TrustBackedAssetsPalletLocation: Location = PalletInstance(TrustBackedAssetsPalletIndex::get()).into(); pub TrustBackedAssetsPalletIndex: u8 = ::index() as u8; - pub TrustBackedAssetsPalletLocationV3: xcm::v3::Location = - xcm::v3::Junction::PalletInstance(::index() as u8).into(); pub ForeignAssetsPalletLocation: Location = PalletInstance(::index() as u8).into(); pub PoolAssetsPalletLocation: Location = @@ -100,6 +98,9 @@ pub type LocationToAccountId = ( // Different global consensus parachain sovereign account. // (Used for over-bridge transfers and reserve processing) GlobalConsensusParachainConvertsFor, + // Ethereum contract sovereign account. + // (Used to get convert ethereum contract locations to sovereign account) + GlobalConsensusEthereumConvertsFor, ); /// Means for transacting the native currency on this chain. @@ -170,7 +171,7 @@ pub type ForeignAssetsConvertedConcreteId = assets_common::ForeignAssetsConverte StartsWithExplicitGlobalConsensus, ), Balance, - xcm::v3::Location, + xcm::v4::Location, >; /// Means for transacting foreign assets from different global consensus. @@ -357,9 +358,12 @@ impl xcm_executor::Config for XcmConfig { type OriginConverter = XcmOriginToTransactDispatchOrigin; // Asset Hub trusts only particular, pre-configured bridged locations from a different consensus // as reserve locations (we trust the Bridge Hub to relay the message that a reserve is being - // held). Asset Hub may _act_ as a reserve location for WND and assets created - // under `pallet-assets`. Users must use teleport where allowed (e.g. WND with the Relay Chain). - type IsReserve = (bridging::to_rococo::IsTrustedBridgedReserveLocationForConcreteAsset,); + // held). On Westend Asset Hub, we allow Rococo Asset Hub to act as reserve for any asset native + // to the Rococo or Ethereum ecosystems. + type IsReserve = ( + bridging::to_rococo::RococoOrEthereumAssetFromAssetHubRococo, + bridging::to_ethereum::IsTrustedBridgedReserveLocationForForeignAsset, + ); type IsTeleporter = TrustedTeleporters; type UniversalLocation = UniversalLocation; type Barrier = Barrier; @@ -377,7 +381,7 @@ impl xcm_executor::Config for XcmConfig { ResolveTo, >, cumulus_primitives_utility::SwapFirstAssetTrader< - WestendLocationV3, + WestendLocation, crate::AssetConversion, WeightToFee, crate::NativeAndAssets, @@ -385,7 +389,7 @@ impl xcm_executor::Config for XcmConfig { TrustBackedAssetsAsLocation< TrustBackedAssetsPalletLocation, Balance, - xcm::v3::Location, + xcm::v4::Location, >, ForeignAssetsConvertedConcreteId, ), @@ -429,10 +433,11 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); - type UniversalAliases = (bridging::to_rococo::UniversalAliases,); + type UniversalAliases = + (bridging::to_rococo::UniversalAliases, bridging::to_ethereum::UniversalAliases); type CallDispatcher = RuntimeCall; type SafeCallFilter = Everything; type Aliasers = Nothing; @@ -464,6 +469,13 @@ pub type XcmRouter = WithUniqueTopic<( // Router which wraps and sends xcm to BridgeHub to be delivered to the Rococo // GlobalConsensus ToRococoXcmRouter, + // Router which wraps and sends xcm to BridgeHub to be delivered to the Ethereum + // GlobalConsensus + SovereignPaidRemoteExporter< + bridging::to_ethereum::EthereumNetworkExportTable, + XcmpQueue, + UniversalLocation, + >, )>; impl pallet_xcm::Config for Runtime { @@ -505,22 +517,23 @@ pub type ForeignCreatorsSovereignAccountOf = ( SiblingParachainConvertsVia, AccountId32Aliases, ParentIsPreset, + GlobalConsensusEthereumConvertsFor, ); /// Simple conversion of `u32` into an `AssetId` for use in benchmarking. pub struct XcmBenchmarkHelper; #[cfg(feature = "runtime-benchmarks")] -impl pallet_assets::BenchmarkHelper for XcmBenchmarkHelper { - fn create_asset_id_parameter(id: u32) -> xcm::v3::Location { - xcm::v3::Location::new(1, [xcm::v3::Junction::Parachain(id)]) +impl pallet_assets::BenchmarkHelper for XcmBenchmarkHelper { + fn create_asset_id_parameter(id: u32) -> xcm::v4::Location { + xcm::v4::Location::new(1, [xcm::v4::Junction::Parachain(id)]) } } /// All configuration related to bridging pub mod bridging { use super::*; + use alloc::collections::btree_set::BTreeSet; use assets_common::matching; - use sp_std::collections::btree_set::BTreeSet; parameter_types! { /// Base price of every byte of the Westend -> Rococo message. Can be adjusted via @@ -548,8 +561,8 @@ pub mod bridging { /// (`AssetId` has to be aligned with `BridgeTable`) pub XcmBridgeHubRouterFeeAssetId: AssetId = WestendLocation::get().into(); - pub BridgeTable: sp_std::vec::Vec = - sp_std::vec::Vec::new().into_iter() + pub BridgeTable: alloc::vec::Vec = + alloc::vec::Vec::new().into_iter() .chain(to_rococo::BridgeTable::get()) .collect(); } @@ -569,20 +582,21 @@ pub mod bridging { ); pub const RococoNetwork: NetworkId = NetworkId::Rococo; - pub AssetHubRococo: Location = Location::new(2, [GlobalConsensus(RococoNetwork::get()), Parachain(bp_asset_hub_rococo::ASSET_HUB_ROCOCO_PARACHAIN_ID)]); + pub const EthereumNetwork: NetworkId = NetworkId::Ethereum { chain_id: 11155111 }; + pub RococoEcosystem: Location = Location::new(2, [GlobalConsensus(RococoNetwork::get())]); pub RocLocation: Location = Location::new(2, [GlobalConsensus(RococoNetwork::get())]); - - pub RocFromAssetHubRococo: (AssetFilter, Location) = ( - Wild(AllOf { fun: WildFungible, id: AssetId(RocLocation::get()) }), - AssetHubRococo::get() - ); + pub EthereumEcosystem: Location = Location::new(2, [GlobalConsensus(EthereumNetwork::get())]); + pub AssetHubRococo: Location = Location::new(2, [ + GlobalConsensus(RococoNetwork::get()), + Parachain(bp_asset_hub_rococo::ASSET_HUB_ROCOCO_PARACHAIN_ID) + ]); /// Set up exporters configuration. /// `Option` represents static "base fee" which is used for total delivery fee calculation. - pub BridgeTable: sp_std::vec::Vec = sp_std::vec![ + pub BridgeTable: alloc::vec::Vec = alloc::vec![ NetworkExportTableItem::new( RococoNetwork::get(), - Some(sp_std::vec![ + Some(alloc::vec![ AssetHubRococo::get().interior.split_global().expect("invalid configuration for AssetHubRococo").1, ]), SiblingBridgeHub::get(), @@ -596,7 +610,7 @@ pub mod bridging { /// Universal aliases pub UniversalAliases: BTreeSet<(Location, Junction)> = BTreeSet::from_iter( - sp_std::vec![ + alloc::vec![ (SiblingBridgeHubWithBridgeHubRococoInstance::get(), GlobalConsensus(RococoNetwork::get())) ] ); @@ -608,17 +622,12 @@ pub mod bridging { } } - /// Reserve locations filter for `xcm_executor::Config::IsReserve`. - /// Locations from which the runtime accepts reserved assets. - pub type IsTrustedBridgedReserveLocationForConcreteAsset = - matching::IsTrustedBridgedReserveLocationForConcreteAsset< - UniversalLocation, - ( - // allow receive ROC from AssetHubRococo - xcm_builder::Case, - // and nothing else - ), - >; + /// Allow any asset native to the Rococo or Ethereum ecosystems if it comes from Rococo + /// Asset Hub. + pub type RococoOrEthereumAssetFromAssetHubRococo = matching::RemoteAssetFromLocation< + (StartsWith, StartsWith), + AssetHubRococo, + >; impl Contains for ToRococoXcmRouter { fn contains(call: &RuntimeCall) -> bool { @@ -632,6 +641,67 @@ pub mod bridging { } } + pub mod to_ethereum { + use super::*; + use assets_common::matching::FromNetwork; + use sp_std::collections::btree_set::BTreeSet; + use testnet_parachains_constants::westend::snowbridge::{ + EthereumNetwork, INBOUND_QUEUE_PALLET_INDEX, + }; + + parameter_types! { + /// User fee for ERC20 token transfer back to Ethereum. + /// (initially was calculated by test `OutboundQueue::calculate_fees` - ETH/WND 1/400 and fee_per_gas 20 GWEI = 2200698000000 + *25%) + /// Needs to be more than fee calculated from DefaultFeeConfig FeeConfigRecord in snowbridge:parachain/pallets/outbound-queue/src/lib.rs + /// Polkadot uses 10 decimals, Kusama,Rococo,Westend 12 decimals. + pub const DefaultBridgeHubEthereumBaseFee: Balance = 2_750_872_500_000; + pub storage BridgeHubEthereumBaseFee: Balance = DefaultBridgeHubEthereumBaseFee::get(); + pub SiblingBridgeHubWithEthereumInboundQueueInstance: Location = Location::new( + 1, + [ + Parachain(SiblingBridgeHubParaId::get()), + PalletInstance(INBOUND_QUEUE_PALLET_INDEX) + ] + ); + + /// Set up exporters configuration. + /// `Option` represents static "base fee" which is used for total delivery fee calculation. + pub BridgeTable: sp_std::vec::Vec = sp_std::vec![ + NetworkExportTableItem::new( + EthereumNetwork::get(), + Some(sp_std::vec![Junctions::Here]), + SiblingBridgeHub::get(), + Some(( + XcmBridgeHubRouterFeeAssetId::get(), + BridgeHubEthereumBaseFee::get(), + ).into()) + ), + ]; + + /// Universal aliases + pub UniversalAliases: BTreeSet<(Location, Junction)> = BTreeSet::from_iter( + sp_std::vec![ + (SiblingBridgeHubWithEthereumInboundQueueInstance::get(), GlobalConsensus(EthereumNetwork::get())), + ] + ); + + pub EthereumBridgeTable: sp_std::vec::Vec = sp_std::vec::Vec::new().into_iter() + .chain(BridgeTable::get()) + .collect(); + } + + pub type EthereumNetworkExportTable = xcm_builder::NetworkExportTable; + + pub type IsTrustedBridgedReserveLocationForForeignAsset = + IsForeignConcreteAsset>; + + impl Contains<(Location, Junction)> for UniversalAliases { + fn contains(alias: &(Location, Junction)) -> bool { + UniversalAliases::get().contains(alias) + } + } + } + /// Benchmarks helper for bridging configuration. #[cfg(feature = "runtime-benchmarks")] pub struct BridgingBenchmarksHelper; @@ -648,8 +718,7 @@ pub mod bridging { false => None, } }); - assert!(alias.is_some(), "we expect here BridgeHubWestend to Rococo mapping at least"); - Some(alias.unwrap()) + Some(alias.expect("we expect here BridgeHubWestend to Rococo mapping at least")) } } } diff --git a/cumulus/parachains/runtimes/assets/asset-hub-westend/tests/tests.rs b/cumulus/parachains/runtimes/assets/asset-hub-westend/tests/tests.rs index b5957dd5df92ff1180909535cb6e604deadd8829..1c334d6f84f82fa8c045b05792fa452bc14be680 100644 --- a/cumulus/parachains/runtimes/assets/asset-hub-westend/tests/tests.rs +++ b/cumulus/parachains/runtimes/assets/asset-hub-westend/tests/tests.rs @@ -86,7 +86,7 @@ fn slot_durations() -> SlotDurations { fn setup_pool_for_paying_fees_with_foreign_assets( (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance): ( AccountId, - xcm::v3::Location, + xcm::v4::Location, Balance, ), ) { @@ -94,7 +94,7 @@ fn setup_pool_for_paying_fees_with_foreign_assets( // setup a pool to pay fees with `foreign_asset_id_location` tokens let pool_owner: AccountId = [14u8; 32].into(); - let native_asset = xcm::v3::Location::parent(); + let native_asset = xcm::v4::Location::parent(); let pool_liquidity: Balance = existential_deposit.max(foreign_asset_id_minimum_balance).mul(100_000); @@ -106,15 +106,15 @@ fn setup_pool_for_paying_fees_with_foreign_assets( assert_ok!(ForeignAssets::mint( RuntimeOrigin::signed(foreign_asset_owner), - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), pool_owner.clone().into(), (foreign_asset_id_minimum_balance + pool_liquidity).mul(2).into(), )); assert_ok!(AssetConversion::create_pool( RuntimeOrigin::signed(pool_owner.clone()), - Box::new(native_asset.into()), - Box::new(foreign_asset_id_location.into()) + Box::new(native_asset.clone().into()), + Box::new(foreign_asset_id_location.clone().into()) )); assert_ok!(AssetConversion::add_liquidity( @@ -219,10 +219,10 @@ fn test_buy_and_refund_weight_with_swap_local_asset_xcm_trader() { assert_ok!(AssetConversion::create_pool( RuntimeHelper::origin_of(bob.clone()), Box::new( - xcm::v3::Location::try_from(native_location.clone()).expect("conversion works") + xcm::v4::Location::try_from(native_location.clone()).expect("conversion works") ), Box::new( - xcm::v3::Location::try_from(asset_1_location.clone()) + xcm::v4::Location::try_from(asset_1_location.clone()) .expect("conversion works") ) )); @@ -230,10 +230,10 @@ fn test_buy_and_refund_weight_with_swap_local_asset_xcm_trader() { assert_ok!(AssetConversion::add_liquidity( RuntimeHelper::origin_of(bob.clone()), Box::new( - xcm::v3::Location::try_from(native_location.clone()).expect("conversion works") + xcm::v4::Location::try_from(native_location.clone()).expect("conversion works") ), Box::new( - xcm::v3::Location::try_from(asset_1_location.clone()) + xcm::v4::Location::try_from(asset_1_location.clone()) .expect("conversion works") ), pool_liquidity, @@ -271,8 +271,8 @@ fn test_buy_and_refund_weight_with_swap_local_asset_xcm_trader() { let refund_weight = Weight::from_parts(1_000_000_000, 0); let refund = WeightToFee::weight_to_fee(&refund_weight); let (reserve1, reserve2) = AssetConversion::get_reserves( - xcm::v3::Location::try_from(native_location).expect("conversion works"), - xcm::v3::Location::try_from(asset_1_location.clone()).expect("conversion works"), + xcm::v4::Location::try_from(native_location).expect("conversion works"), + xcm::v4::Location::try_from(asset_1_location.clone()).expect("conversion works"), ) .unwrap(); let asset_refund = @@ -310,12 +310,12 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { let bob: AccountId = SOME_ASSET_ADMIN.into(); let staking_pot = CollatorSelection::account_id(); let native_location = - xcm::v3::Location::try_from(WestendLocation::get()).expect("conversion works"); - let foreign_location = xcm::v3::Location { + xcm::v4::Location::try_from(WestendLocation::get()).expect("conversion works"); + let foreign_location = xcm::v4::Location { parents: 1, interior: ( - xcm::v3::Junction::Parachain(1234), - xcm::v3::Junction::GeneralIndex(12345), + xcm::v4::Junction::Parachain(1234), + xcm::v4::Junction::GeneralIndex(12345), ) .into(), }; @@ -326,26 +326,26 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { // init asset, balances and pool. assert_ok!(>::create( - foreign_location, + foreign_location.clone(), bob.clone(), true, 10 )); - assert_ok!(ForeignAssets::mint_into(foreign_location, &bob, initial_balance)); + assert_ok!(ForeignAssets::mint_into(foreign_location.clone(), &bob, initial_balance)); assert_ok!(Balances::mint_into(&bob, initial_balance)); assert_ok!(Balances::mint_into(&staking_pot, initial_balance)); assert_ok!(AssetConversion::create_pool( RuntimeHelper::origin_of(bob.clone()), - Box::new(native_location), - Box::new(foreign_location) + Box::new(native_location.clone()), + Box::new(foreign_location.clone()) )); assert_ok!(AssetConversion::add_liquidity( RuntimeHelper::origin_of(bob.clone()), - Box::new(native_location), - Box::new(foreign_location), + Box::new(native_location.clone()), + Box::new(foreign_location.clone()), pool_liquidity, pool_liquidity, 1, @@ -354,11 +354,9 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { )); // keep initial total issuance to assert later. - let asset_total_issuance = ForeignAssets::total_issuance(foreign_location); + let asset_total_issuance = ForeignAssets::total_issuance(foreign_location.clone()); let native_total_issuance = Balances::total_issuance(); - let foreign_location_latest: Location = foreign_location.try_into().unwrap(); - // prepare input to buy weight. let weight = Weight::from_parts(4_000_000_000, 0); let fee = WeightToFee::weight_to_fee(&weight); @@ -366,7 +364,7 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { AssetConversion::get_amount_in(&fee, &pool_liquidity, &pool_liquidity).unwrap(); let extra_amount = 100; let ctx = XcmContext { origin: None, message_id: XcmHash::default(), topic: None }; - let payment: Asset = (foreign_location_latest.clone(), asset_fee + extra_amount).into(); + let payment: Asset = (foreign_location.clone(), asset_fee + extra_amount).into(); // init trader and buy weight. let mut trader = ::Trader::new(); @@ -374,13 +372,11 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { trader.buy_weight(weight, payment.into(), &ctx).expect("Expected Ok"); // assert. - let unused_amount = unused_asset - .fungible - .get(&foreign_location_latest.clone().into()) - .map_or(0, |a| *a); + let unused_amount = + unused_asset.fungible.get(&foreign_location.clone().into()).map_or(0, |a| *a); assert_eq!(unused_amount, extra_amount); assert_eq!( - ForeignAssets::total_issuance(foreign_location), + ForeignAssets::total_issuance(foreign_location.clone()), asset_total_issuance + asset_fee ); @@ -388,13 +384,13 @@ fn test_buy_and_refund_weight_with_swap_foreign_asset_xcm_trader() { let refund_weight = Weight::from_parts(1_000_000_000, 0); let refund = WeightToFee::weight_to_fee(&refund_weight); let (reserve1, reserve2) = - AssetConversion::get_reserves(native_location, foreign_location).unwrap(); + AssetConversion::get_reserves(native_location, foreign_location.clone()).unwrap(); let asset_refund = AssetConversion::get_amount_out(&refund, &reserve1, &reserve2).unwrap(); // refund. let actual_refund = trader.refund_weight(refund_weight, &ctx).unwrap(); - assert_eq!(actual_refund, (foreign_location_latest, asset_refund).into()); + assert_eq!(actual_refund, (foreign_location.clone(), asset_refund).into()); // assert. assert_eq!(Balances::balance(&staking_pot), initial_balance); @@ -501,17 +497,17 @@ fn test_foreign_asset_xcm_take_first_trader() { .execute_with(|| { // We need root origin to create a sufficient asset let minimum_asset_balance = 3333333_u128; - let foreign_location = xcm::v3::Location { + let foreign_location = xcm::v4::Location { parents: 1, interior: ( - xcm::v3::Junction::Parachain(1234), - xcm::v3::Junction::GeneralIndex(12345), + xcm::v4::Junction::Parachain(1234), + xcm::v4::Junction::GeneralIndex(12345), ) .into(), }; assert_ok!(ForeignAssets::force_create( RuntimeHelper::root_origin(), - foreign_location.into(), + foreign_location.clone().into(), AccountId::from(ALICE).into(), true, minimum_asset_balance @@ -520,12 +516,12 @@ fn test_foreign_asset_xcm_take_first_trader() { // We first mint enough asset for the account to exist for assets assert_ok!(ForeignAssets::mint( RuntimeHelper::origin_of(AccountId::from(ALICE)), - foreign_location.into(), + foreign_location.clone().into(), AccountId::from(ALICE).into(), minimum_asset_balance )); - let asset_location_v4: Location = foreign_location.try_into().unwrap(); + let asset_location_v4: Location = foreign_location.clone().try_into().unwrap(); // Set Alice as block author, who will receive fees RuntimeHelper::run_to_block(2, AccountId::from(ALICE)); @@ -534,7 +530,7 @@ fn test_foreign_asset_xcm_take_first_trader() { let bought = Weight::from_parts(4_000_000_000u64, 0); // Lets calculate amount needed - let asset_amount_needed = ForeignAssetFeeAsExistentialDepositMultiplierFeeCharger::charge_weight_in_fungibles(foreign_location, bought) + let asset_amount_needed = ForeignAssetFeeAsExistentialDepositMultiplierFeeCharger::charge_weight_in_fungibles(foreign_location.clone(), bought) .expect("failed to compute"); // Lets pay with: asset_amount_needed + asset_amount_extra @@ -557,7 +553,7 @@ fn test_foreign_asset_xcm_take_first_trader() { // Make sure author(Alice) has received the amount assert_eq!( - ForeignAssets::balance(foreign_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_location.clone(), AccountId::from(ALICE)), minimum_asset_balance + asset_amount_needed ); @@ -837,11 +833,11 @@ fn test_assets_balances_api_works() { .build() .execute_with(|| { let local_asset_id = 1; - let foreign_asset_id_location = xcm::v3::Location { + let foreign_asset_id_location = xcm::v4::Location { parents: 1, interior: [ - xcm::v3::Junction::Parachain(1234), - xcm::v3::Junction::GeneralIndex(12345), + xcm::v4::Junction::Parachain(1234), + xcm::v4::Junction::GeneralIndex(12345), ] .into(), }; @@ -849,7 +845,7 @@ fn test_assets_balances_api_works() { // check before assert_eq!(Assets::balance(local_asset_id, AccountId::from(ALICE)), 0); assert_eq!( - ForeignAssets::balance(foreign_asset_id_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_asset_id_location.clone(), AccountId::from(ALICE)), 0 ); assert_eq!(Balances::free_balance(AccountId::from(ALICE)), 0); @@ -886,7 +882,7 @@ fn test_assets_balances_api_works() { let foreign_asset_minimum_asset_balance = 3333333_u128; assert_ok!(ForeignAssets::force_create( RuntimeHelper::root_origin(), - foreign_asset_id_location, + foreign_asset_id_location.clone(), AccountId::from(SOME_ASSET_ADMIN).into(), false, foreign_asset_minimum_asset_balance @@ -895,7 +891,7 @@ fn test_assets_balances_api_works() { // We first mint enough asset for the account to exist for assets assert_ok!(ForeignAssets::mint( RuntimeHelper::origin_of(AccountId::from(SOME_ASSET_ADMIN)), - foreign_asset_id_location, + foreign_asset_id_location.clone(), AccountId::from(ALICE).into(), 6 * foreign_asset_minimum_asset_balance )); @@ -906,7 +902,7 @@ fn test_assets_balances_api_works() { minimum_asset_balance ); assert_eq!( - ForeignAssets::balance(foreign_asset_id_location, AccountId::from(ALICE)), + ForeignAssets::balance(foreign_asset_id_location.clone(), AccountId::from(ALICE)), 6 * minimum_asset_balance ); assert_eq!(Balances::free_balance(AccountId::from(ALICE)), some_currency); @@ -932,7 +928,7 @@ fn test_assets_balances_api_works() { .into()))); // check foreign asset assert!(result.inner().iter().any(|asset| asset.eq(&( - WithLatestLocationConverter::::convert_back( + WithLatestLocationConverter::::convert_back( &foreign_asset_id_location ) .unwrap(), @@ -1025,13 +1021,13 @@ asset_test_utils::include_asset_transactor_transfer_with_pallet_assets_instance_ Runtime, XcmConfig, ForeignAssetsInstance, - xcm::v3::Location, + xcm::v4::Location, JustTry, collator_session_keys(), ExistentialDeposit::get(), - xcm::v3::Location { + xcm::v4::Location { parents: 1, - interior: [xcm::v3::Junction::Parachain(1313), xcm::v3::Junction::GeneralIndex(12345)] + interior: [xcm::v4::Junction::Parachain(1313), xcm::v4::Junction::GeneralIndex(12345)] .into() }, Box::new(|| { @@ -1048,8 +1044,8 @@ asset_test_utils::include_create_and_manage_foreign_assets_for_local_consensus_p WeightToFee, ForeignCreatorsSovereignAccountOf, ForeignAssetsInstance, - xcm::v3::Location, - WithLatestLocationConverter, + xcm::v4::Location, + WithLatestLocationConverter, collator_session_keys(), ExistentialDeposit::get(), AssetDeposit::get(), @@ -1127,12 +1123,12 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_pool_s let staking_pot = StakingPot::get(); let foreign_asset_id_location = - xcm::v3::Location::new(2, [xcm::v3::Junction::GlobalConsensus(xcm::v3::NetworkId::Rococo)]); + xcm::v4::Location::new(2, [xcm::v4::Junction::GlobalConsensus(xcm::v4::NetworkId::Rococo)]); let foreign_asset_id_minimum_balance = 1_000_000_000; // sovereign account as foreign asset owner (can be whoever for this scenario) let foreign_asset_owner = LocationToAccountId::convert_location(&Location::parent()).unwrap(); let foreign_asset_create_params = - (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance); + (foreign_asset_owner, foreign_asset_id_location.clone(), foreign_asset_id_minimum_balance); asset_test_utils::test_cases_over_bridge::receive_reserve_asset_deposited_from_different_consensus_works::< Runtime, @@ -1166,7 +1162,7 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_pool_s // check now foreign asset for staking pot assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &staking_pot ), 0 @@ -1180,7 +1176,7 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_pool_s // staking pot receives no foreign assets assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &staking_pot ), 0 @@ -1196,12 +1192,12 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_suffic let staking_pot = StakingPot::get(); let foreign_asset_id_location = - xcm::v3::Location::new(2, [xcm::v3::Junction::GlobalConsensus(xcm::v3::NetworkId::Rococo)]); + xcm::v4::Location::new(2, [xcm::v4::Junction::GlobalConsensus(xcm::v4::NetworkId::Rococo)]); let foreign_asset_id_minimum_balance = 1_000_000_000; // sovereign account as foreign asset owner (can be whoever for this scenario) let foreign_asset_owner = LocationToAccountId::convert_location(&Location::parent()).unwrap(); let foreign_asset_create_params = - (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance); + (foreign_asset_owner, foreign_asset_id_location.clone(), foreign_asset_id_minimum_balance); asset_test_utils::test_cases_over_bridge::receive_reserve_asset_deposited_from_different_consensus_works::< Runtime, @@ -1226,7 +1222,7 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_suffic // check block author before assert_eq!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &block_author_account ), 0 @@ -1236,7 +1232,7 @@ fn receive_reserve_asset_deposited_roc_from_asset_hub_rococo_fees_paid_by_suffic // `TakeFirstAssetTrader` puts fees to the block author assert!( ForeignAssets::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &block_author_account ) > 0 ); @@ -1258,7 +1254,7 @@ fn report_bridge_status_from_xcm_bridge_router_for_rococo_works() { collator_session_keys(), bridging_to_asset_hub_rococo, || { - sp_std::vec![ + vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -1268,16 +1264,16 @@ fn report_bridge_status_from_xcm_bridge_router_for_rococo_works() { bp_asset_hub_westend::XcmBridgeHubRouterCall::report_bridge_status { bridge_id: Default::default(), is_congested: true, - } + }, ) .encode() .into(), - } + }, ] .into() }, || { - sp_std::vec![ + vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -1287,11 +1283,11 @@ fn report_bridge_status_from_xcm_bridge_router_for_rococo_works() { bp_asset_hub_westend::XcmBridgeHubRouterCall::report_bridge_status { bridge_id: Default::default(), is_congested: false, - } + }, ) .encode() .into(), - } + }, ] .into() }, diff --git a/cumulus/parachains/runtimes/assets/common/Cargo.toml b/cumulus/parachains/runtimes/assets/common/Cargo.toml index 12dfd9da1fffbc6d1be0edc40ab6de3ebcc78e20..c6740269339d808f14d9dd2879f2ddd74b4e842b 100644 --- a/cumulus/parachains/runtimes/assets/common/Cargo.toml +++ b/cumulus/parachains/runtimes/assets/common/Cargo.toml @@ -10,30 +10,29 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } log = { workspace = true } -impl-trait-for-tuples = "0.2.2" +impl-trait-for-tuples = { workspace = true } # Substrate -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 } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -pallet-asset-conversion = { path = "../../../../../substrate/frame/asset-conversion", default-features = false } +frame-support = { workspace = true } +sp-api = { workspace = true } +sp-runtime = { workspace = true } +pallet-asset-conversion = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -parachains-common = { path = "../../../common", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } +parachains-common = { workspace = true } +cumulus-primitives-core = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -48,7 +47,6 @@ std = [ "scale-info/std", "sp-api/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", diff --git a/cumulus/parachains/runtimes/assets/common/src/benchmarks.rs b/cumulus/parachains/runtimes/assets/common/src/benchmarks.rs index 44bda1eb3709c74d808e696d5d3728a3354b747a..d59fddc4e8f0289fd8ab4aebe7465551c83c136a 100644 --- a/cumulus/parachains/runtimes/assets/common/src/benchmarks.rs +++ b/cumulus/parachains/runtimes/assets/common/src/benchmarks.rs @@ -13,9 +13,9 @@ // See the License for the specific language governing permissions and // limitations under the License. +use core::marker::PhantomData; use cumulus_primitives_core::ParaId; use sp_runtime::traits::Get; -use sp_std::marker::PhantomData; use xcm::latest::prelude::*; /// Creates asset pairs for liquidity pools with `Target` always being the first asset. diff --git a/cumulus/parachains/runtimes/assets/common/src/foreign_creators.rs b/cumulus/parachains/runtimes/assets/common/src/foreign_creators.rs index a9fd79bf939f575ac60007cd6920ac6db3ded773..95edb31da06e5a0ff1f9d40f3d385f6bd2c21e35 100644 --- a/cumulus/parachains/runtimes/assets/common/src/foreign_creators.rs +++ b/cumulus/parachains/runtimes/assets/common/src/foreign_creators.rs @@ -23,7 +23,7 @@ use xcm_executor::traits::ConvertLocation; /// `EnsureOriginWithArg` impl for `CreateOrigin` that allows only XCM origins that are locations /// containing the class location. pub struct ForeignCreators( - sp_std::marker::PhantomData<(IsForeign, AccountOf, AccountId, L)>, + core::marker::PhantomData<(IsForeign, AccountOf, AccountId, L)>, ); impl< IsForeign: ContainsPair, @@ -41,7 +41,7 @@ where fn try_origin( origin: RuntimeOrigin, asset_location: &L, - ) -> sp_std::result::Result { + ) -> core::result::Result { let origin_location = EnsureXcm::::try_origin(origin.clone())?; if !IsForeign::contains(asset_location, &origin_location) { return Err(origin) diff --git a/cumulus/parachains/runtimes/assets/common/src/fungible_conversion.rs b/cumulus/parachains/runtimes/assets/common/src/fungible_conversion.rs index e21203485a764c350b3d9890d7dcdaa89110babf..27ee2d6b5653c91bd922045005201439870c324a 100644 --- a/cumulus/parachains/runtimes/assets/common/src/fungible_conversion.rs +++ b/cumulus/parachains/runtimes/assets/common/src/fungible_conversion.rs @@ -16,9 +16,10 @@ //! Runtime API definition for assets. use crate::runtime_api::FungiblesAccessError; +use alloc::vec::Vec; +use core::borrow::Borrow; use frame_support::traits::Contains; use sp_runtime::traits::MaybeEquivalence; -use sp_std::{borrow::Borrow, vec::Vec}; use xcm::latest::{Asset, Location}; use xcm_builder::{ConvertedConcreteId, MatchedConvertedConcreteId}; use xcm_executor::traits::MatchesFungibles; diff --git a/cumulus/parachains/runtimes/assets/common/src/lib.rs b/cumulus/parachains/runtimes/assets/common/src/lib.rs index 431b5766147aeb8279ed2b1298691ceede856e5e..4bb593f98929e4dfcaf2879e759f863138f49282 100644 --- a/cumulus/parachains/runtimes/assets/common/src/lib.rs +++ b/cumulus/parachains/runtimes/assets/common/src/lib.rs @@ -23,6 +23,8 @@ pub mod local_and_foreign_assets; pub mod matching; pub mod runtime_api; +extern crate alloc; + use crate::matching::{LocalLocationPattern, ParentLocation}; use frame_support::traits::{Equals, EverythingBut}; use parachains_common::{AssetIdForTrustBackedAssets, CollectionId, ItemId}; diff --git a/cumulus/parachains/runtimes/assets/common/src/local_and_foreign_assets.rs b/cumulus/parachains/runtimes/assets/common/src/local_and_foreign_assets.rs index 58f5d2d57a7669b73876897f90e0da3e20730cbb..8a89089c7187726d30cc485b9280853a9da277e3 100644 --- a/cumulus/parachains/runtimes/assets/common/src/local_and_foreign_assets.rs +++ b/cumulus/parachains/runtimes/assets/common/src/local_and_foreign_assets.rs @@ -13,13 +13,13 @@ // See the License for the specific language governing permissions and // limitations under the License. +use core::marker::PhantomData; use frame_support::traits::Get; use sp_runtime::{ traits::{Convert, MaybeEquivalence}, Either, Either::{Left, Right}, }; -use sp_std::marker::PhantomData; use xcm::latest::Location; /// Converts a given [`Location`] to [`Either::Left`] when equal to `Target`, or diff --git a/cumulus/parachains/runtimes/assets/common/src/matching.rs b/cumulus/parachains/runtimes/assets/common/src/matching.rs index 3aad88e177caad1095a3dbe21dd3a3308b103680..9bb35d0c5328b8de455f6f3c75f4d2965d5fe44f 100644 --- a/cumulus/parachains/runtimes/assets/common/src/matching.rs +++ b/cumulus/parachains/runtimes/assets/common/src/matching.rs @@ -14,7 +14,10 @@ // limitations under the License. use cumulus_primitives_core::ParaId; -use frame_support::{pallet_prelude::Get, traits::ContainsPair}; +use frame_support::{ + pallet_prelude::Get, + traits::{Contains, ContainsPair}, +}; use xcm::prelude::*; use xcm_builder::ensure_is_remote; @@ -25,7 +28,7 @@ frame_support::parameter_types! { } /// Accepts an asset if it is from the origin. -pub struct IsForeignConcreteAsset(sp_std::marker::PhantomData); +pub struct IsForeignConcreteAsset(core::marker::PhantomData); impl> ContainsPair for IsForeignConcreteAsset { @@ -38,7 +41,7 @@ impl> ContainsPair /// Checks if `a` is from sibling location `b`. Checks that `Location-a` starts with /// `Location-b`, and that the `ParaId` of `b` is not equal to `a`. pub struct FromSiblingParachain( - sp_std::marker::PhantomData<(SelfParaId, L)>, + core::marker::PhantomData<(SelfParaId, L)>, ); impl, L: TryFrom + TryInto + Clone> ContainsPair for FromSiblingParachain @@ -62,7 +65,7 @@ impl, L: TryFrom + TryInto + Clone> /// Checks if `a` is from the expected global consensus network. Checks that `Location-a` /// starts with `Location-b`, and that network is a foreign consensus system. pub struct FromNetwork( - sp_std::marker::PhantomData<(UniversalLocation, ExpectedNetworkId, L)>, + core::marker::PhantomData<(UniversalLocation, ExpectedNetworkId, L)>, ); impl< UniversalLocation: Get, @@ -94,36 +97,33 @@ impl< } } -/// Adapter verifies if it is allowed to receive `Asset` from `Location`. -/// -/// Note: `Location` has to be from a different global consensus. -pub struct IsTrustedBridgedReserveLocationForConcreteAsset( - sp_std::marker::PhantomData<(UniversalLocation, Reserves)>, +/// Accept an asset if it is native to `AssetsAllowedNetworks` and it is coming from +/// `OriginLocation`. +pub struct RemoteAssetFromLocation( + core::marker::PhantomData<(AssetsAllowedNetworks, OriginLocation)>, ); -impl, Reserves: ContainsPair> - ContainsPair - for IsTrustedBridgedReserveLocationForConcreteAsset +impl, OriginLocation: Get> + ContainsPair for RemoteAssetFromLocation { fn contains(asset: &Asset, origin: &Location) -> bool { - let universal_source = UniversalLocation::get(); - log::trace!( - target: "xcm::contains", - "IsTrustedBridgedReserveLocationForConcreteAsset asset: {:?}, origin: {:?}, universal_source: {:?}", - asset, origin, universal_source - ); - - // check remote origin - if ensure_is_remote(universal_source.clone(), origin.clone()).is_err() { + let expected_origin = OriginLocation::get(); + // ensure `origin` is expected `OriginLocation` + if !expected_origin.eq(origin) { log::trace!( target: "xcm::contains", - "IsTrustedBridgedReserveLocationForConcreteAsset origin: {:?} is not remote to the universal_source: {:?}", - origin, universal_source + "RemoteAssetFromLocation asset: {:?}, origin: {:?} is not from expected {:?}", + asset, origin, expected_origin, ); return false + } else { + log::trace!( + target: "xcm::contains", + "RemoteAssetFromLocation asset: {asset:?}, origin: {origin:?}", + ); } - // check asset according to the configured reserve locations - Reserves::contains(asset, origin) + // ensure `asset` is from remote consensus listed in `AssetsAllowedNetworks` + AssetsAllowedNetworks::contains(&asset.id.0) } } diff --git a/cumulus/parachains/runtimes/assets/common/src/runtime_api.rs b/cumulus/parachains/runtimes/assets/common/src/runtime_api.rs index 19977cbedab07b638f71f32470d3768cabeba322..799b2f45b4dfbff288383821598954f30612f806 100644 --- a/cumulus/parachains/runtimes/assets/common/src/runtime_api.rs +++ b/cumulus/parachains/runtimes/assets/common/src/runtime_api.rs @@ -18,7 +18,7 @@ use codec::{Codec, Decode, Encode}; use sp_runtime::RuntimeDebug; #[cfg(feature = "std")] -use {sp_std::vec::Vec, xcm::latest::Asset}; +use {alloc::vec::Vec, xcm::latest::Asset}; /// The possible errors that can happen querying the storage of assets. #[derive(Eq, PartialEq, Encode, Decode, RuntimeDebug, scale_info::TypeInfo)] diff --git a/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml b/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml index 883c93c97b4de6774e86ee83b84d246dc1427f7f..529d6460fc4e46b6a7d04ae77c01f7135f6eed9d 100644 --- a/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml +++ b/cumulus/parachains/runtimes/assets/test-utils/Cargo.toml @@ -10,42 +10,41 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } +codec = { features = ["derive", "max-encoded-len"], workspace = true } # Substrate -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", 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 } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-assets = { workspace = true } +pallet-balances = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-session = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-runtimes-test-utils = { path = "../../test-utils", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +pallet-collator-selection = { workspace = true } +parachains-common = { workspace = true } +cumulus-primitives-core = { workspace = true } +parachain-info = { workspace = true } +parachains-runtimes-test-utils = { workspace = true } # Polkadot -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +pallet-xcm = { workspace = true } # Bridges -pallet-xcm-bridge-hub-router = { path = "../../../../../bridges/modules/xcm-bridge-hub-router", default-features = false } +pallet-xcm-bridge-hub-router = { workspace = true } [dev-dependencies] -hex-literal = "0.4.1" +hex-literal = { workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -68,7 +67,6 @@ std = [ "parachains-runtimes-test-utils/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", diff --git a/cumulus/parachains/runtimes/assets/test-utils/src/test_cases.rs b/cumulus/parachains/runtimes/assets/test-utils/src/test_cases.rs index 884b71369e79ad9713ea3cc8e243820862c9c20d..67b585ecfe86ff71f59888524353c12af1bc44c8 100644 --- a/cumulus/parachains/runtimes/assets/test-utils/src/test_cases.rs +++ b/cumulus/parachains/runtimes/assets/test-utils/src/test_cases.rs @@ -367,9 +367,9 @@ pub fn teleports_for_foreign_assets_works< ::Balance: From + Into, SovereignAccountOf: ConvertLocation>, >::AssetId: - From + Into, + From + Into, >::AssetIdParameter: - From + Into, + From + Into, >::Balance: From + Into, ::AccountId: @@ -381,11 +381,11 @@ pub fn teleports_for_foreign_assets_works< { // foreign parachain with the same consensus currency as asset let foreign_para_id = 2222; - let foreign_asset_id_location = xcm::v3::Location { + let foreign_asset_id_location = xcm::v4::Location { parents: 1, interior: [ - xcm::v3::Junction::Parachain(foreign_para_id), - xcm::v3::Junction::GeneralIndex(1234567), + xcm::v4::Junction::Parachain(foreign_para_id), + xcm::v4::Junction::GeneralIndex(1234567), ] .into(), }; @@ -438,14 +438,14 @@ pub fn teleports_for_foreign_assets_works< ); assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &target_account ), 0.into() ); assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &CheckingAccount::get() ), 0.into() @@ -454,14 +454,14 @@ pub fn teleports_for_foreign_assets_works< assert_total::< pallet_assets::Pallet, AccountIdOf, - >(foreign_asset_id_location, 0, 0); + >(foreign_asset_id_location.clone(), 0, 0); // create foreign asset (0 total issuance) let asset_minimum_asset_balance = 3333333_u128; assert_ok!( >::force_create( RuntimeHelper::::root_origin(), - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), asset_owner.into(), false, asset_minimum_asset_balance.into() @@ -470,12 +470,9 @@ pub fn teleports_for_foreign_assets_works< assert_total::< pallet_assets::Pallet, AccountIdOf, - >(foreign_asset_id_location, 0, 0); + >(foreign_asset_id_location.clone(), 0, 0); assert!(teleported_foreign_asset_amount > asset_minimum_asset_balance); - let foreign_asset_id_location_latest: Location = - foreign_asset_id_location.try_into().unwrap(); - // 1. process received teleported assets from sibling parachain (foreign_para_id) let xcm = Xcm(vec![ // BuyExecution with relaychain native token @@ -489,12 +486,12 @@ pub fn teleports_for_foreign_assets_works< }, // Process teleported asset ReceiveTeleportedAsset(Assets::from(vec![Asset { - id: AssetId(foreign_asset_id_location_latest.clone()), + id: AssetId(foreign_asset_id_location.clone()), fun: Fungible(teleported_foreign_asset_amount), }])), DepositAsset { assets: Wild(AllOf { - id: AssetId(foreign_asset_id_location_latest.clone()), + id: AssetId(foreign_asset_id_location.clone()), fun: WildFungibility::Fungible, }), beneficiary: Location { @@ -526,7 +523,7 @@ pub fn teleports_for_foreign_assets_works< ); assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &target_account ), teleported_foreign_asset_amount.into() @@ -538,7 +535,7 @@ pub fn teleports_for_foreign_assets_works< ); assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &CheckingAccount::get() ), 0.into() @@ -548,7 +545,7 @@ pub fn teleports_for_foreign_assets_works< pallet_assets::Pallet, AccountIdOf, >( - foreign_asset_id_location, + foreign_asset_id_location.clone(), teleported_foreign_asset_amount, teleported_foreign_asset_amount, ); @@ -566,7 +563,7 @@ pub fn teleports_for_foreign_assets_works< let target_account_balance_before_teleport = >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &target_account, ); let asset_to_teleport_away = asset_minimum_asset_balance * 3; @@ -580,7 +577,7 @@ pub fn teleports_for_foreign_assets_works< // Make sure the target account has enough native asset to pay for delivery fees let delivery_fees = xcm_helpers::teleport_assets_delivery_fees::( - (foreign_asset_id_location_latest.clone(), asset_to_teleport_away).into(), + (foreign_asset_id_location.clone(), asset_to_teleport_away).into(), 0, Unlimited, dest_beneficiary.clone(), @@ -596,7 +593,7 @@ pub fn teleports_for_foreign_assets_works< RuntimeHelper::::origin_of(target_account.clone()), dest, dest_beneficiary, - (foreign_asset_id_location_latest.clone(), asset_to_teleport_away), + (foreign_asset_id_location.clone(), asset_to_teleport_away), Some((runtime_para_id, foreign_para_id)), included_head, &alice, @@ -606,14 +603,14 @@ pub fn teleports_for_foreign_assets_works< // check balances assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &target_account ), (target_account_balance_before_teleport - asset_to_teleport_away.into()) ); assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &CheckingAccount::get() ), 0.into() @@ -623,7 +620,7 @@ pub fn teleports_for_foreign_assets_works< pallet_assets::Pallet, AccountIdOf, >( - foreign_asset_id_location, + foreign_asset_id_location.clone(), teleported_foreign_asset_amount - asset_to_teleport_away, teleported_foreign_asset_amount - asset_to_teleport_away, ); @@ -1559,9 +1556,6 @@ pub fn reserve_transfer_native_asset_to_non_teleport_para_works< ) .unwrap(); - let v4_xcm: Xcm<()> = xcm_sent.clone().try_into().unwrap(); - dbg!(&v4_xcm); - let delivery_fees = get_fungible_delivery_fees::< ::XcmSender, >(dest.clone(), Xcm::try_from(xcm_sent.clone()).unwrap()); diff --git a/cumulus/parachains/runtimes/assets/test-utils/src/test_cases_over_bridge.rs b/cumulus/parachains/runtimes/assets/test-utils/src/test_cases_over_bridge.rs index 0b2364dbb8bd858a95f6a109c800032cb286412b..e0b3f70c75468b69d3a660fb6777f536f4f7df37 100644 --- a/cumulus/parachains/runtimes/assets/test-utils/src/test_cases_over_bridge.rs +++ b/cumulus/parachains/runtimes/assets/test-utils/src/test_cases_over_bridge.rs @@ -331,7 +331,7 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< block_author_account: AccountIdOf, (foreign_asset_owner, foreign_asset_id_location, foreign_asset_id_minimum_balance): ( AccountIdOf, - xcm::v3::Location, + xcm::v4::Location, u128, ), foreign_asset_id_amount_to_transfer: u128, @@ -357,9 +357,9 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< BalanceOf: From + Into, XcmConfig: xcm_executor::Config, >::AssetId: - From + Into, + From + Into, >::AssetIdParameter: - From + Into, + From + Into, >::Balance: From + Into + From, ::AccountId: Into<<::RuntimeOrigin as OriginTrait>::AccountId> @@ -390,7 +390,7 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< assert_ok!( >::force_create( RuntimeHelper::::root_origin(), - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), foreign_asset_owner.into(), true, // is_sufficient=true foreign_asset_id_minimum_balance.into() @@ -409,7 +409,7 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< // ForeignAssets balances before assert_eq!( >::balance( - foreign_asset_id_location.into(), + foreign_asset_id_location.clone().into(), &target_account ), 0.into() @@ -418,11 +418,8 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< // additional check before additional_checks_before(); - let foreign_asset_id_location_latest: Location = - foreign_asset_id_location.try_into().unwrap(); - let expected_assets = Assets::from(vec![Asset { - id: AssetId(foreign_asset_id_location_latest.clone()), + id: AssetId(foreign_asset_id_location.clone()), fun: Fungible(foreign_asset_id_amount_to_transfer), }]); let expected_beneficiary = Location::new( @@ -439,7 +436,7 @@ pub fn receive_reserve_asset_deposited_from_different_consensus_works< ClearOrigin, BuyExecution { fees: Asset { - id: AssetId(foreign_asset_id_location_latest.clone()), + id: AssetId(foreign_asset_id_location.clone()), fun: Fungible(foreign_asset_id_amount_to_transfer), }, weight_limit: Unlimited, diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml index 574406ab305f33d4266dca1a3229b92a80ab9e8c..6d0fbd7d5c6605d09b358c2e2db2a1ef00b3fb7e 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/Cargo.toml @@ -3,133 +3,131 @@ name = "bridge-hub-rococo-runtime" version = "0.5.0" authors.workspace = true edition.workspace = true -description = "Rococo's BridgeHub parachain runtime" +description = "Rococo's BridgeHub parachain runtime" license = "Apache-2.0" [lints] workspace = true [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = [ +codec = { features = [ "derive", -] } -hex-literal = { version = "0.4.1" } +], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = [ +scale-info = { features = [ "derive", -] } +], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } -tuplex = { version = "0.1", default-features = false } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", 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-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-multisig = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-std = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/constants", 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, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +rococo-runtime-constants = { workspace = true } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = [ - "parameterized-consensus-hook", -] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = [ +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { features = [ "bridging", -] } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } +], workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +cumulus-primitives-utility = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } # Bridges -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-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-messages = { path = "../../../../../bridges/primitives/messages", default-features = false } -bp-parachains = { path = "../../../../../bridges/primitives/parachains", default-features = false } -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-runtime = { path = "../../../../../bridges/primitives/runtime", default-features = false } -bp-rococo = { path = "../../../../../bridges/chains/chain-rococo", default-features = false } -bp-westend = { path = "../../../../../bridges/chains/chain-westend", 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-xcm-bridge-hub = { path = "../../../../../bridges/modules/xcm-bridge-hub", default-features = false } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common", default-features = false } +bp-asset-hub-rococo = { workspace = true } +bp-asset-hub-westend = { workspace = true } +bp-bridge-hub-polkadot = { workspace = true } +bp-bridge-hub-rococo = { workspace = true } +bp-bridge-hub-westend = { workspace = true } +bp-header-chain = { workspace = true } +bp-messages = { workspace = true } +bp-parachains = { workspace = true } +bp-polkadot-bulletin = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-relayers = { workspace = true } +bp-runtime = { features = ["test-helpers"], workspace = true } +bp-rococo = { workspace = true } +bp-westend = { workspace = true } +pallet-bridge-grandpa = { workspace = true } +pallet-bridge-messages = { workspace = true } +pallet-bridge-parachains = { workspace = true } +pallet-bridge-relayers = { workspace = true } +pallet-xcm-bridge-hub = { workspace = true } +bridge-runtime-common = { workspace = true } # Ethereum Bridge (Snowbridge) -snowbridge-beacon-primitives = { path = "../../../../../bridges/snowbridge/primitives/beacon", default-features = false } -snowbridge-pallet-system = { path = "../../../../../bridges/snowbridge/pallets/system", default-features = false } -snowbridge-system-runtime-api = { path = "../../../../../bridges/snowbridge/pallets/system/runtime-api", default-features = false } -snowbridge-core = { path = "../../../../../bridges/snowbridge/primitives/core", default-features = false } -snowbridge-pallet-ethereum-client = { path = "../../../../../bridges/snowbridge/pallets/ethereum-client", default-features = false } -snowbridge-pallet-inbound-queue = { path = "../../../../../bridges/snowbridge/pallets/inbound-queue", default-features = false } -snowbridge-pallet-outbound-queue = { path = "../../../../../bridges/snowbridge/pallets/outbound-queue", default-features = false } -snowbridge-outbound-queue-runtime-api = { path = "../../../../../bridges/snowbridge/pallets/outbound-queue/runtime-api", 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-beacon-primitives = { workspace = true } +snowbridge-pallet-system = { workspace = true } +snowbridge-system-runtime-api = { workspace = true } +snowbridge-core = { workspace = true } +snowbridge-pallet-ethereum-client = { workspace = true } +snowbridge-pallet-inbound-queue = { workspace = true } +snowbridge-pallet-outbound-queue = { workspace = true } +snowbridge-outbound-queue-runtime-api = { workspace = true } +snowbridge-router-primitives = { workspace = true } +snowbridge-runtime-common = { workspace = true } -bridge-hub-common = { path = "../common", default-features = false } +bridge-hub-common = { workspace = true } [dev-dependencies] -static_assertions = "1.1" -bridge-hub-test-utils = { path = "../test-utils" } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common", features = [ +bridge-hub-test-utils = { workspace = true, default-features = true } +bridge-runtime-common = { features = [ "integrity-test", -] } -sp-keyring = { path = "../../../../../substrate/primitives/keyring" } -snowbridge-runtime-test-common = { path = "../../../../../bridges/snowbridge/runtime/test-common" } +], workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +snowbridge-runtime-test-common = { workspace = true, default-features = true } [features] default = ["std"] @@ -162,6 +160,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -219,9 +218,9 @@ std = [ "sp-version/std", "substrate-wasm-builder", "testnet-parachains-constants/std", - "tuplex/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -264,6 +263,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -305,4 +305,4 @@ fast-runtime = [] # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_common_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_common_config.rs index 5551b05e202547c99501b279e8839611efcc7f66..779cc537ee96dcc2fadc38452dfcd01c4c320789 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_common_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_common_config.rs @@ -21,14 +21,9 @@ //! For example, the messaging pallet needs to know the sending and receiving chains, but the //! GRANDPA tracking pallet only needs to be aware of one chain. -use super::{ - weights, AccountId, Balance, Balances, BlockNumber, Runtime, RuntimeEvent, RuntimeOrigin, -}; +use super::{weights, AccountId, Balance, Balances, BlockNumber, Runtime, RuntimeEvent}; use bp_parachains::SingleParaStoredHeaderDataBuilder; -use bp_runtime::UnderlyingChainProvider; -use bridge_runtime_common::messages::ThisChainWithMessages; use frame_support::{parameter_types, traits::ConstU32}; -use sp_runtime::RuntimeDebug; parameter_types! { pub const RelayChainHeadersToKeep: u32 = 1024; @@ -103,15 +98,3 @@ impl pallet_bridge_grandpa::Config for Runt // weights are also the same for both bridges. type WeightInfo = weights::pallet_bridge_grandpa::WeightInfo; } - -/// BridgeHubRococo chain from message lane point of view. -#[derive(RuntimeDebug, Clone, Copy)] -pub struct BridgeHubRococo; - -impl UnderlyingChainProvider for BridgeHubRococo { - type Chain = bp_bridge_hub_rococo::BridgeHubRococo; -} - -impl ThisChainWithMessages for BridgeHubRococo { - type RuntimeOrigin = RuntimeOrigin; -} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_bulletin_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_bulletin_config.rs index 94b936889b77c4460f9921956d6f7abef1ecb52c..83b92918dc4f442d3574d0476d25de90e9dc160a 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_bulletin_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_bulletin_config.rs @@ -20,23 +20,19 @@ //! are reusing Polkadot Bulletin chain primitives everywhere here. use crate::{ - bridge_common_config::BridgeHubRococo, weights, xcm_config::UniversalLocation, AccountId, - BridgeRococoBulletinGrandpa, BridgeRococoBulletinMessages, PolkadotXcm, Runtime, RuntimeEvent, - XcmOverRococoBulletin, XcmRouter, + weights, xcm_config::UniversalLocation, BridgeRococoBulletinGrandpa, + BridgeRococoBulletinMessages, PolkadotXcm, Runtime, RuntimeEvent, XcmOverRococoBulletin, + XcmRouter, +}; +use bp_messages::{ + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::FromBridgedChainMessagesProof, LaneId, }; -use bp_messages::LaneId; -use bp_runtime::Chain; use bridge_runtime_common::{ extensions::refund_relayer_extension::{ ActualFeeRefund, RefundBridgedMessages, RefundSignedExtensionAdapter, RefundableMessagesLane, }, - messages, - messages::{ - source::{FromBridgedChainMessagesDeliveryProof, TargetHeaderChainAdapter}, - target::{FromBridgedChainMessagesProof, SourceHeaderChainAdapter}, - MessageBridge, UnderlyingChainProvider, - }, messages_xcm_extension::{ SenderAndLane, XcmAsPlainPayload, XcmBlobHauler, XcmBlobHaulerAdapter, XcmBlobMessageDispatch, XcmVersionOfDestAndRemoteBridge, @@ -44,7 +40,6 @@ use bridge_runtime_common::{ }; use frame_support::{parameter_types, traits::PalletInfoAccess}; -use sp_runtime::RuntimeDebug; use xcm::{ latest::prelude::*, prelude::{InteriorLocation, NetworkId}, @@ -52,17 +47,6 @@ use xcm::{ use xcm_builder::BridgeBlobDispatcher; parameter_types! { - /// Maximal number of entries in the unrewarded relayers vector at the Rococo Bridge Hub. It matches the - /// maximal number of unrewarded relayers that the single confirmation transaction at Rococo Bulletin Chain - /// may process. - pub const MaxUnrewardedRelayerEntriesAtInboundLane: bp_messages::MessageNonce = - bp_polkadot_bulletin::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX; - /// Maximal number of unconfirmed messages at the Rococo Bridge Hub. It matches the maximal number of - /// unconfirmed messages that the single confirmation transaction at Rococo Bulletin Chain may process. - pub const MaxUnconfirmedMessagesAtInboundLane: bp_messages::MessageNonce = - bp_polkadot_bulletin::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX; - /// Bridge specific chain (network) identifier of the Rococo Bulletin Chain. - pub const RococoBulletinChainId: bp_runtime::ChainId = bp_polkadot_bulletin::PolkadotBulletin::ID; /// Interior location (relative to this runtime) of the with-RococoBulletin messages pallet. pub BridgeRococoToRococoBulletinMessagesPalletInstance: InteriorLocation = [ PalletInstance(::index() as u8) @@ -100,7 +84,7 @@ parameter_types! { XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, ); /// All active routes and their destinations. - pub ActiveLanes: sp_std::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = sp_std::vec![ + pub ActiveLanes: alloc::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = alloc::vec![ ( FromRococoPeopleToRococoBulletinRoute::get(), (RococoBulletinGlobalConsensusNetwork::get(), Here) @@ -142,31 +126,6 @@ impl XcmBlobHauler for ToRococoBulletinXcmBlobHauler { type OnMessagesDeliveredFromRococoBulletin = XcmBlobHaulerAdapter; -/// Messaging Bridge configuration for BridgeHubRococo -> Rococo Bulletin. -pub struct WithRococoBulletinMessageBridge; -impl MessageBridge for WithRococoBulletinMessageBridge { - // Bulletin chain assumes it is bridged with Polkadot Bridge Hub - const BRIDGED_MESSAGES_PALLET_NAME: &'static str = - bp_bridge_hub_polkadot::WITH_BRIDGE_HUB_POLKADOT_MESSAGES_PALLET_NAME; - type ThisChain = BridgeHubRococo; - type BridgedChain = RococoBulletin; - type BridgedHeaderChain = BridgeRococoBulletinGrandpa; -} - -/// Maximal outbound payload size of BridgeHubRococo -> RococoBulletin messages. -pub type ToRococoBulletinMaximalOutboundPayloadSize = - messages::source::FromThisChainMaximalOutboundPayloadSize; - -/// RococoBulletin chain from message lane point of view. -#[derive(RuntimeDebug, Clone, Copy)] -pub struct RococoBulletin; - -impl UnderlyingChainProvider for RococoBulletin { - type Chain = bp_polkadot_bulletin::PolkadotBulletin; -} - -impl messages::BridgedChainWithMessages for RococoBulletin {} - /// Signed extension that refunds relayers that are delivering messages from the Rococo Bulletin /// chain. pub type OnBridgeHubRococoRefundRococoBulletinMessages = RefundSignedExtensionAdapter< @@ -189,22 +148,20 @@ impl pallet_bridge_messages::Config for Runt type RuntimeEvent = RuntimeEvent; type WeightInfo = weights::pallet_bridge_messages_rococo_to_rococo_bulletin::WeightInfo; - type BridgedChainId = RococoBulletinChainId; + + type ThisChain = bp_bridge_hub_rococo::BridgeHubRococo; + type BridgedChain = bp_polkadot_bulletin::PolkadotBulletin; + type BridgedHeaderChain = BridgeRococoBulletinGrandpa; + type ActiveOutboundLanes = ActiveOutboundLanesToRococoBulletin; - type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; - type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; - type MaximalOutboundPayloadSize = ToRococoBulletinMaximalOutboundPayloadSize; type OutboundPayload = XcmAsPlainPayload; type InboundPayload = XcmAsPlainPayload; - type InboundRelayer = AccountId; type DeliveryPayments = (); - type TargetHeaderChain = TargetHeaderChainAdapter; type DeliveryConfirmationPayments = (); - type SourceHeaderChain = SourceHeaderChainAdapter; type MessageDispatch = XcmBlobMessageDispatch; type OnMessagesDelivered = OnMessagesDeliveredFromRococoBulletin; @@ -267,8 +224,7 @@ mod tests { runtime: Runtime, with_bridged_chain_grandpa_instance: BridgeGrandpaRococoBulletinInstance, with_bridged_chain_messages_instance: WithRococoBulletinMessagesInstance, - bridge: WithRococoBulletinMessageBridge, - this_chain: bp_rococo::Rococo, + this_chain: bp_bridge_hub_rococo::BridgeHubRococo, bridged_chain: bp_polkadot_bulletin::PolkadotBulletin, ); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_westend_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_westend_config.rs index 1681ac7f4687493c82c0a3233439b2a9d47a1ad0..9880e8a17c2b80d34ae6b62f9c8a588625105e70 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_westend_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/bridge_to_westend_config.rs @@ -17,27 +17,20 @@ //! Bridge definitions used on BridgeHubRococo for bridging to BridgeHubWestend. use crate::{ - bridge_common_config::{ - BridgeHubRococo, BridgeParachainWestendInstance, DeliveryRewardInBalance, - }, + bridge_common_config::{BridgeParachainWestendInstance, DeliveryRewardInBalance}, weights, xcm_config::UniversalLocation, - AccountId, BridgeWestendMessages, PolkadotXcm, Runtime, RuntimeEvent, XcmOverBridgeHubWestend, - XcmRouter, + BridgeWestendMessages, PolkadotXcm, Runtime, RuntimeEvent, XcmOverBridgeHubWestend, XcmRouter, +}; +use bp_messages::{ + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::FromBridgedChainMessagesProof, LaneId, }; -use bp_messages::LaneId; -use bp_runtime::Chain; use bridge_runtime_common::{ extensions::refund_relayer_extension::{ ActualFeeRefund, RefundBridgedMessages, RefundSignedExtensionAdapter, RefundableMessagesLane, }, - messages, - messages::{ - source::{FromBridgedChainMessagesDeliveryProof, TargetHeaderChainAdapter}, - target::{FromBridgedChainMessagesProof, SourceHeaderChainAdapter}, - MessageBridge, UnderlyingChainProvider, - }, messages_xcm_extension::{ SenderAndLane, XcmAsPlainPayload, XcmBlobHauler, XcmBlobHaulerAdapter, XcmBlobMessageDispatch, XcmVersionOfDestAndRemoteBridge, @@ -46,7 +39,6 @@ use bridge_runtime_common::{ use codec::Encode; use frame_support::{parameter_types, traits::PalletInfoAccess}; -use sp_runtime::RuntimeDebug; use xcm::{ latest::prelude::*, prelude::{InteriorLocation, NetworkId}, @@ -54,11 +46,6 @@ use xcm::{ use xcm_builder::BridgeBlobDispatcher; parameter_types! { - pub const MaxUnrewardedRelayerEntriesAtInboundLane: bp_messages::MessageNonce = - bp_bridge_hub_rococo::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX; - pub const MaxUnconfirmedMessagesAtInboundLane: bp_messages::MessageNonce = - bp_bridge_hub_rococo::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX; - pub const BridgeHubWestendChainId: bp_runtime::ChainId = BridgeHubWestend::ID; pub BridgeRococoToWestendMessagesPalletInstance: InteriorLocation = [PalletInstance(::index() as u8)].into(); pub WestendGlobalConsensusNetwork: NetworkId = NetworkId::Westend; pub WestendGlobalConsensusNetworkLocation: Location = Location::new( @@ -82,7 +69,7 @@ parameter_types! { ParentThen([Parachain(AssetHubRococoParaId::get().into())].into()).into(), XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, ); - pub ActiveLanes: sp_std::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = sp_std::vec![ + pub ActiveLanes: alloc::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = alloc::vec![ ( FromAssetHubRococoToAssetHubWestendRoute::get(), (WestendGlobalConsensusNetwork::get(), [Parachain(AssetHubWestendParaId::get().into())].into()) @@ -102,8 +89,8 @@ parameter_types! { } pub const XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND: LaneId = LaneId([0, 0, 0, 2]); -fn build_congestion_message(is_congested: bool) -> sp_std::vec::Vec> { - sp_std::vec![ +fn build_congestion_message(is_congested: bool) -> alloc::vec::Vec> { + alloc::vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -148,34 +135,6 @@ impl XcmBlobHauler for ToBridgeHubWestendXcmBlobHauler { type OnMessagesDeliveredFromWestend = XcmBlobHaulerAdapter; -/// Messaging Bridge configuration for BridgeHubRococo -> BridgeHubWestend -pub struct WithBridgeHubWestendMessageBridge; -impl MessageBridge for WithBridgeHubWestendMessageBridge { - const BRIDGED_MESSAGES_PALLET_NAME: &'static str = - bp_bridge_hub_rococo::WITH_BRIDGE_HUB_ROCOCO_MESSAGES_PALLET_NAME; - type ThisChain = BridgeHubRococo; - type BridgedChain = BridgeHubWestend; - type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders< - Runtime, - BridgeParachainWestendInstance, - bp_bridge_hub_westend::BridgeHubWestend, - >; -} - -/// Maximal outbound payload size of BridgeHubRococo -> BridgeHubWestend messages. -pub type ToBridgeHubWestendMaximalOutboundPayloadSize = - messages::source::FromThisChainMaximalOutboundPayloadSize; - -/// BridgeHubWestend chain from message lane point of view. -#[derive(RuntimeDebug, Clone, Copy)] -pub struct BridgeHubWestend; - -impl UnderlyingChainProvider for BridgeHubWestend { - type Chain = bp_bridge_hub_westend::BridgeHubWestend; -} - -impl messages::BridgedChainWithMessages for BridgeHubWestend {} - /// Signed extension that refunds relayers that are delivering messages from the Westend parachain. pub type OnBridgeHubRococoRefundBridgeHubWestendMessages = RefundSignedExtensionAdapter< RefundBridgedMessages< @@ -196,26 +155,28 @@ pub type WithBridgeHubWestendMessagesInstance = pallet_bridge_messages::Instance impl pallet_bridge_messages::Config for Runtime { type RuntimeEvent = RuntimeEvent; type WeightInfo = weights::pallet_bridge_messages_rococo_to_westend::WeightInfo; - type BridgedChainId = BridgeHubWestendChainId; + + type ThisChain = bp_bridge_hub_rococo::BridgeHubRococo; + type BridgedChain = bp_bridge_hub_westend::BridgeHubWestend; + type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders< + Runtime, + BridgeParachainWestendInstance, + bp_bridge_hub_westend::BridgeHubWestend, + >; + type ActiveOutboundLanes = ActiveOutboundLanesToBridgeHubWestend; - type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; - type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; - type MaximalOutboundPayloadSize = ToBridgeHubWestendMaximalOutboundPayloadSize; type OutboundPayload = XcmAsPlainPayload; type InboundPayload = XcmAsPlainPayload; - type InboundRelayer = AccountId; type DeliveryPayments = (); - type TargetHeaderChain = TargetHeaderChainAdapter; type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< Runtime, WithBridgeHubWestendMessagesInstance, DeliveryRewardInBalance, >; - type SourceHeaderChain = SourceHeaderChainAdapter; type MessageDispatch = XcmBlobMessageDispatch< FromWestendMessageBlobDispatcher, Self::WeightInfo, @@ -248,9 +209,8 @@ mod tests { assert_complete_bridge_types, extensions::refund_relayer_extension::RefundableParachain, integrity::{ - assert_complete_bridge_constants, check_message_lane_weights, - AssertBridgeMessagesPalletConstants, AssertBridgePalletNames, AssertChainConstants, - AssertCompleteBridgeConstants, + assert_complete_with_parachain_bridge_constants, check_message_lane_weights, + AssertChainConstants, AssertCompleteBridgeConstants, }, }; use parachains_common::Balance; @@ -292,36 +252,20 @@ mod tests { runtime: Runtime, with_bridged_chain_grandpa_instance: BridgeGrandpaWestendInstance, with_bridged_chain_messages_instance: WithBridgeHubWestendMessagesInstance, - bridge: WithBridgeHubWestendMessageBridge, - this_chain: bp_rococo::Rococo, - bridged_chain: bp_westend::Westend, + this_chain: bp_bridge_hub_rococo::BridgeHubRococo, + bridged_chain: bp_bridge_hub_westend::BridgeHubWestend, ); - assert_complete_bridge_constants::< + assert_complete_with_parachain_bridge_constants::< Runtime, BridgeGrandpaWestendInstance, WithBridgeHubWestendMessagesInstance, - WithBridgeHubWestendMessageBridge, + bp_westend::Westend, >(AssertCompleteBridgeConstants { this_chain_constants: AssertChainConstants { block_length: bp_bridge_hub_rococo::BlockLength::get(), block_weights: bp_bridge_hub_rococo::BlockWeightsForAsyncBacking::get(), }, - messages_pallet_constants: AssertBridgeMessagesPalletConstants { - max_unrewarded_relayers_in_bridged_confirmation_tx: - bp_bridge_hub_westend::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX, - max_unconfirmed_messages_in_bridged_confirmation_tx: - bp_bridge_hub_westend::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX, - bridged_chain_id: BridgeHubWestend::ID, - }, - pallet_names: AssertBridgePalletNames { - with_this_chain_messages_pallet_name: - bp_bridge_hub_rococo::WITH_BRIDGE_HUB_ROCOCO_MESSAGES_PALLET_NAME, - with_bridged_chain_grandpa_pallet_name: - bp_westend::WITH_WESTEND_GRANDPA_PALLET_NAME, - with_bridged_chain_messages_pallet_name: - bp_bridge_hub_westend::WITH_BRIDGE_HUB_WESTEND_MESSAGES_PALLET_NAME, - }, }); bridge_runtime_common::extensions::priority_calculator::per_relay_header::ensure_priority_boost_is_sane::< @@ -332,7 +276,7 @@ mod tests { bridge_runtime_common::extensions::priority_calculator::per_parachain_header::ensure_priority_boost_is_sane::< Runtime, - RefundableParachain, + RefundableParachain, PriorityBoostPerParachainHeader, >(FEE_BOOST_PER_PARACHAIN_HEADER); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs index 2a7f46feee6952d88ba67821087ecfa6b4f9bd51..c65880771e0863540bf6ff5687d5a8b18c8b3c4c 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/lib.rs @@ -35,6 +35,9 @@ pub mod bridge_to_westend_config; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use bridge_runtime_common::extensions::{ check_obsolete_extension::{ CheckAndBoostBridgeGrandpaTransactions, CheckAndBoostBridgeParachainsTransactions, @@ -58,7 +61,6 @@ use sp_runtime::{ ApplyExtrinsicResult, FixedU128, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -70,7 +72,7 @@ use frame_support::{ genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ConstBool, ConstU32, ConstU64, ConstU8, Get, TransformOrigin}, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -97,7 +99,11 @@ pub use sp_runtime::BuildStorage; use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate}; use rococo_runtime_constants::system_parachain::{ASSET_HUB_ID, BRIDGE_HUB_ID}; -use xcm::latest::prelude::*; +use xcm::prelude::*; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; @@ -106,6 +112,8 @@ use parachains_common::{ AVERAGE_ON_INITIALIZE_RATIO, NORMAL_DISPATCH_RATIO, }; +#[cfg(feature = "runtime-benchmarks")] +use alloc::boxed::Box; #[cfg(feature = "runtime-benchmarks")] use benchmark_helpers::DoNothingRouter; @@ -137,6 +145,7 @@ pub type SignedExtra = ( bridge_to_bulletin_config::OnBridgeHubRococoRefundRococoBulletinMessages, ), cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -148,8 +157,9 @@ pub type Migrations = ( pallet_collator_selection::migration::v2::MigrationToV2, pallet_multisig::migrations::v1::MigrateToV1, InitStorageVersions, - cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, // unreleased + cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, snowbridge_pallet_system::migration::v0::InitializeOnUpgrade< Runtime, ConstU32, @@ -209,7 +219,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("bridge-hub-rococo"), impl_name: create_runtime_str!("bridge-hub-rococo"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_016_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 5, @@ -389,7 +399,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -417,13 +427,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type VersionWrapper = PolkadotXcm; // Enqueue XCMP messages from siblings for later processing. type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } @@ -848,7 +867,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -952,6 +971,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::TokenLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -1129,7 +1202,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -1344,7 +1417,8 @@ impl_runtime_apis! { impl BridgeMessagesConfig for Runtime { fn is_relayer_rewarded(relayer: &Self::AccountId) -> bool { let bench_lane_id = >::bench_lane_id(); - let bridged_chain_id = bridge_to_westend_config::BridgeHubWestendChainId::get(); + use bp_runtime::Chain; + let bridged_chain_id =>::BridgedChain::ID; pallet_bridge_relayers::Pallet::::relayer_reward( relayer, bp_relayers::RewardsAccountParams::new( @@ -1364,7 +1438,7 @@ impl_runtime_apis! { prepare_message_proof_from_parachain::< Runtime, bridge_common_config::BridgeGrandpaWestendInstance, - bridge_to_westend_config::WithBridgeHubWestendMessageBridge, + bridge_to_westend_config::WithBridgeHubWestendMessagesInstance, >(params, generate_xcm_builder_bridge_message_sample([GlobalConsensus(Rococo), Parachain(42)].into())) } @@ -1374,7 +1448,7 @@ impl_runtime_apis! { prepare_message_delivery_proof_from_parachain::< Runtime, bridge_common_config::BridgeGrandpaWestendInstance, - bridge_to_westend_config::WithBridgeHubWestendMessageBridge, + bridge_to_westend_config::WithBridgeHubWestendMessagesInstance, >(params) } @@ -1399,7 +1473,7 @@ impl_runtime_apis! { prepare_message_proof_from_grandpa_chain::< Runtime, bridge_common_config::BridgeGrandpaRococoBulletinInstance, - bridge_to_bulletin_config::WithRococoBulletinMessageBridge, + bridge_to_bulletin_config::WithRococoBulletinMessagesInstance, >(params, generate_xcm_builder_bridge_message_sample([GlobalConsensus(Rococo), Parachain(42)].into())) } @@ -1409,7 +1483,7 @@ impl_runtime_apis! { prepare_message_delivery_proof_from_grandpa_chain::< Runtime, bridge_common_config::BridgeGrandpaRococoBulletinInstance, - bridge_to_bulletin_config::WithRococoBulletinMessageBridge, + bridge_to_bulletin_config::WithRococoBulletinMessagesInstance, >(params) } @@ -1435,7 +1509,7 @@ impl_runtime_apis! { fn prepare_parachain_heads_proof( parachains: &[bp_polkadot_core::parachains::ParaId], parachain_head_size: u32, - proof_size: bp_runtime::StorageProofSize, + proof_params: bp_runtime::UnverifiedStorageProofParams, ) -> ( pallet_bridge_parachains::RelayBlockNumber, pallet_bridge_parachains::RelayBlockHash, @@ -1445,7 +1519,7 @@ impl_runtime_apis! { prepare_parachain_heads_proof::( parachains, parachain_head_size, - proof_size, + proof_params, ) } } @@ -1523,41 +1597,42 @@ mod tests { use bp_polkadot_core::SuffixedCommonSignedExtensionExt; sp_io::TestExternalities::default().execute_with(|| { - frame_system::BlockHash::::insert(BlockNumber::zero(), Hash::default()); - let payload: SignedExtra = ( - frame_system::CheckNonZeroSender::new(), - frame_system::CheckSpecVersion::new(), - frame_system::CheckTxVersion::new(), - frame_system::CheckGenesis::new(), - frame_system::CheckEra::from(Era::Immortal), - frame_system::CheckNonce::from(10), - frame_system::CheckWeight::new(), - pallet_transaction_payment::ChargeTransactionPayment::from(10), - BridgeRejectObsoleteHeadersAndMessages, - ( - bridge_to_westend_config::OnBridgeHubRococoRefundBridgeHubWestendMessages::default(), - bridge_to_bulletin_config::OnBridgeHubRococoRefundRococoBulletinMessages::default(), - ), - cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), - ); - - // for BridgeHubRococo - { - let bhr_indirect_payload = bp_bridge_hub_rococo::SignedExtension::from_params( - VERSION.spec_version, - VERSION.transaction_version, - bp_runtime::TransactionEra::Immortal, - System::block_hash(BlockNumber::zero()), - 10, - 10, - (((), ()), ((), ())), - ); - assert_eq!(payload.encode(), bhr_indirect_payload.encode()); - assert_eq!( - payload.additional_signed().unwrap().encode(), - bhr_indirect_payload.additional_signed().unwrap().encode() - ) - } - }); + frame_system::BlockHash::::insert(BlockNumber::zero(), Hash::default()); + let payload: SignedExtra = ( + frame_system::CheckNonZeroSender::new(), + frame_system::CheckSpecVersion::new(), + frame_system::CheckTxVersion::new(), + frame_system::CheckGenesis::new(), + frame_system::CheckEra::from(Era::Immortal), + frame_system::CheckNonce::from(10), + frame_system::CheckWeight::new(), + pallet_transaction_payment::ChargeTransactionPayment::from(10), + BridgeRejectObsoleteHeadersAndMessages, + ( + bridge_to_westend_config::OnBridgeHubRococoRefundBridgeHubWestendMessages::default(), + bridge_to_bulletin_config::OnBridgeHubRococoRefundRococoBulletinMessages::default(), + ), + cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::new(false), + ); + + // for BridgeHubRococo + { + let bhr_indirect_payload = bp_bridge_hub_rococo::SignedExtension::from_params( + VERSION.spec_version, + VERSION.transaction_version, + bp_runtime::TransactionEra::Immortal, + System::block_hash(BlockNumber::zero()), + 10, + 10, + (((), ()), ((), ())), + ); + assert_eq!(payload.encode().split_last().unwrap().1, bhr_indirect_payload.encode()); + assert_eq!( + payload.additional_signed().unwrap().encode().split_last().unwrap().1, + bhr_indirect_payload.additional_signed().unwrap().encode() + ) + } + }); } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs index dc480c391636a92aad6e303a515524b5ce7ff2b1..8fcd7b10d931b03ec4cd9cc063e0bacf8878ed16 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/cumulus_pallet_parachain_system.rs @@ -47,7 +47,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs index 8c2435599f59780be56dcaa5060addee4c5c1d15..4ce57b2e50161a812ddf17a9bbd20d5fc58682a7 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_grandpa.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_grandpa` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-yaoqqom-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -48,32 +48,54 @@ use core::marker::PhantomData; /// Weight functions for `pallet_bridge_grandpa`. pub struct WeightInfo(PhantomData); impl pallet_bridge_grandpa::WeightInfo for WeightInfo { + /// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:0) + /// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendGrandpa::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendGrandpa::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendGrandpa::BestFinalized` (r:1 w:1) /// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`) - /// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:0) - /// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::FreeHeadersRemaining` (r:1 w:0) + /// Proof: `BridgeWestendGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1) /// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendGrandpa::ImportedHashes` (r:1 w:1) /// Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 w:2) /// Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) - /// The range of component `p` is `[1, 838]`. + /// The range of component `p` is `[1, 168]`. /// The range of component `v` is `[50, 100]`. fn submit_finality_proof(p: u32, v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `335 + p * (60 ±0)` + // Measured: `438 + p * (60 ±0)` // Estimated: `51735` - // Minimum execution time: 310_124_000 picoseconds. - Weight::from_parts(18_294_977, 0) + // Minimum execution time: 325_365_000 picoseconds. + Weight::from_parts(14_958_535, 0) .saturating_add(Weight::from_parts(0, 51735)) - // Standard Error: 5_665 - .saturating_add(Weight::from_parts(55_380_719, 0).saturating_mul(p.into())) - // Standard Error: 94_494 - .saturating_add(Weight::from_parts(2_765_959, 0).saturating_mul(v.into())) - .saturating_add(T::DbWeight::get().reads(5)) + // Standard Error: 15_085 + .saturating_add(Weight::from_parts(41_227_904, 0).saturating_mul(p.into())) + // Standard Error: 50_338 + .saturating_add(Weight::from_parts(2_664_555, 0).saturating_mul(v.into())) + .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(5)) } + /// Storage: `BridgeWestendGrandpa::CurrentAuthoritySet` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::ImportedHashesPointer` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::ImportedHashes` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::BestFinalized` (r:0 w:1) + /// Proof: `BridgeWestendGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::ImportedHeaders` (r:0 w:2) + /// Proof: `BridgeWestendGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) + fn force_set_pallet_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `452` + // Estimated: `51735` + // Minimum execution time: 79_562_000 picoseconds. + Weight::from_parts(82_479_000, 0) + .saturating_add(Weight::from_parts(0, 51735)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(6)) + } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_rococo_bulletin.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_rococo_bulletin.rs index d3255ab3875dd32e36958757685299800daf67f2..d0a7ed25363ddc697f64d9826bcd78246ff7aa97 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_rococo_bulletin.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_rococo_bulletin.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_messages` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-14, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -58,10 +58,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `621` + // Measured: `654` // Estimated: `52645` - // Minimum execution time: 36_661_000 picoseconds. - Weight::from_parts(38_106_000, 0) + // Minimum execution time: 36_836_000 picoseconds. + Weight::from_parts(37_858_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) @@ -74,13 +74,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `BridgePolkadotBulletinMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - fn receive_two_messages_proof() -> Weight { + /// The range of component `n` is `[1, 4076]`. + /// The range of component `n` is `[1, 4076]`. + fn receive_n_messages_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `621` + // Measured: `654` // Estimated: `52645` - // Minimum execution time: 47_599_000 picoseconds. - Weight::from_parts(49_731_000, 0) + // Minimum execution time: 36_587_000 picoseconds. + Weight::from_parts(37_516_000, 0) .saturating_add(Weight::from_parts(0, 52645)) + // Standard Error: 8_655 + .saturating_add(Weight::from_parts(11_649_169, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -94,10 +98,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof_with_outbound_lane_state() -> Weight { // Proof Size summary in bytes: - // Measured: `621` + // Measured: `654` // Estimated: `52645` - // Minimum execution time: 42_211_000 picoseconds. - Weight::from_parts(43_454_000, 0) + // Minimum execution time: 42_157_000 picoseconds. + Weight::from_parts(43_105_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) @@ -108,30 +112,20 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) /// Storage: `BridgePolkadotBulletinMessages::InboundLanes` (r:1 w:1) /// Proof: `BridgePolkadotBulletinMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_1_kb() -> Weight { - // Proof Size summary in bytes: - // Measured: `589` - // Estimated: `52645` - // Minimum execution time: 36_072_000 picoseconds. - Weight::from_parts(37_260_000, 0) - .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: `BridgePolkadotBulletinMessages::PalletOperatingMode` (r:1 w:0) - /// Proof: `BridgePolkadotBulletinMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) - /// Storage: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (r:1 w:0) - /// Proof: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) - /// Storage: `BridgePolkadotBulletinMessages::InboundLanes` (r:1 w:1) - /// Proof: `BridgePolkadotBulletinMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_16_kb() -> Weight { + /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) + /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `589` + // Measured: `654` // Estimated: `52645` - // Minimum execution time: 66_995_000 picoseconds. - Weight::from_parts(68_661_000, 0) + // Minimum execution time: 35_536_000 picoseconds. + Weight::from_parts(37_452_828, 0) .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(3)) + // Standard Error: 3 + .saturating_add(Weight::from_parts(2_269, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `BridgePolkadotBulletinMessages::PalletOperatingMode` (r:1 w:0) @@ -140,15 +134,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) /// Storage: `BridgePolkadotBulletinMessages::OutboundLanes` (r:1 w:1) /// Proof: `BridgePolkadotBulletinMessages::OutboundLanes` (`max_values`: Some(1), `max_size`: Some(44), added: 539, mode: `MaxEncodedLen`) + /// Storage: `BridgePolkadotBulletinMessages::OutboundMessages` (r:0 w:1) + /// Proof: `BridgePolkadotBulletinMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_single_message() -> Weight { // Proof Size summary in bytes: - // Measured: `588` + // Measured: `621` // Estimated: `2543` - // Minimum execution time: 25_553_000 picoseconds. - Weight::from_parts(26_205_000, 0) + // Minimum execution time: 25_800_000 picoseconds. + Weight::from_parts(26_666_000, 0) .saturating_add(Weight::from_parts(0, 2543)) .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes(2)) } /// Storage: `BridgePolkadotBulletinMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgePolkadotBulletinMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -156,15 +152,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) /// Storage: `BridgePolkadotBulletinMessages::OutboundLanes` (r:1 w:1) /// Proof: `BridgePolkadotBulletinMessages::OutboundLanes` (`max_values`: Some(1), `max_size`: Some(44), added: 539, mode: `MaxEncodedLen`) + /// Storage: `BridgePolkadotBulletinMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgePolkadotBulletinMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { // Proof Size summary in bytes: - // Measured: `588` + // Measured: `621` // Estimated: `2543` - // Minimum execution time: 25_610_000 picoseconds. - Weight::from_parts(26_273_000, 0) + // Minimum execution time: 27_262_000 picoseconds. + Weight::from_parts(27_997_000, 0) .saturating_add(Weight::from_parts(0, 2543)) .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `BridgePolkadotBulletinMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgePolkadotBulletinMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -172,15 +170,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `BridgePolkadotBulletinGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) /// Storage: `BridgePolkadotBulletinMessages::OutboundLanes` (r:1 w:1) /// Proof: `BridgePolkadotBulletinMessages::OutboundLanes` (`max_values`: Some(1), `max_size`: Some(44), added: 539, mode: `MaxEncodedLen`) + /// Storage: `BridgePolkadotBulletinMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgePolkadotBulletinMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { // Proof Size summary in bytes: - // Measured: `588` + // Measured: `621` // Estimated: `2543` - // Minimum execution time: 25_651_000 picoseconds. - Weight::from_parts(26_172_000, 0) + // Minimum execution time: 26_992_000 picoseconds. + Weight::from_parts(27_921_000, 0) .saturating_add(Weight::from_parts(0, 2543)) .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `BridgePolkadotBulletinMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgePolkadotBulletinMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -191,7 +191,7 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0) - /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) @@ -201,20 +201,20 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainSystem::RelevantMessagingState` (r:1 w:0) /// Proof: `ParachainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1) - /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `i` is `[128, 2048]`. - /// The range of component `i` is `[128, 2048]`. - fn receive_single_message_proof_with_dispatch(i: u32, ) -> Weight { + /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `780` + // Measured: `813` // Estimated: `52645` - // Minimum execution time: 64_219_000 picoseconds. - Weight::from_parts(65_848_290, 0) + // Minimum execution time: 55_509_000 picoseconds. + Weight::from_parts(59_826_763, 0) .saturating_add(Weight::from_parts(0, 52645)) - // Standard Error: 43 - .saturating_add(Weight::from_parts(7_577, 0).saturating_mul(i.into())) + // Standard Error: 7 + .saturating_add(Weight::from_parts(7_565, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(4)) } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_westend.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_westend.rs index 30ea9eed4a5b4f187ea76633400cff8c39991b46..dc6c917c6d00462453fd2368cc4cc4dbbed8aa67 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_westend.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_messages_rococo_to_westend.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_messages` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-14, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -51,7 +51,7 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) @@ -60,10 +60,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `605` + // Measured: `658` // Estimated: `52645` - // Minimum execution time: 40_349_000 picoseconds. - Weight::from_parts(41_856_000, 0) + // Minimum execution time: 40_198_000 picoseconds. + Weight::from_parts(42_079_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -71,27 +71,31 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) /// Proof: `BridgeWestendMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - fn receive_two_messages_proof() -> Weight { + /// The range of component `n` is `[1, 4076]`. + /// The range of component `n` is `[1, 4076]`. + fn receive_n_messages_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `605` + // Measured: `658` // Estimated: `52645` - // Minimum execution time: 50_514_000 picoseconds. - Weight::from_parts(52_254_000, 0) + // Minimum execution time: 39_990_000 picoseconds. + Weight::from_parts(41_381_000, 0) .saturating_add(Weight::from_parts(0, 52645)) + // Standard Error: 8_459 + .saturating_add(Weight::from_parts(11_710_167, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) @@ -100,10 +104,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof_with_outbound_lane_state() -> Weight { // Proof Size summary in bytes: - // Measured: `605` + // Measured: `658` // Estimated: `52645` - // Minimum execution time: 45_761_000 picoseconds. - Weight::from_parts(47_075_000, 0) + // Minimum execution time: 45_940_000 picoseconds. + Weight::from_parts(47_753_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -111,37 +115,25 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) /// Proof: `BridgeWestendMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_1_kb() -> Weight { - // Proof Size summary in bytes: - // Measured: `573` - // Estimated: `52645` - // Minimum execution time: 39_098_000 picoseconds. - Weight::from_parts(40_577_000, 0) - .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) - /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) - /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) - /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) - /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) - /// Proof: `BridgeWestendMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_16_kb() -> Weight { + /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) + /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `573` + // Measured: `658` // Estimated: `52645` - // Minimum execution time: 69_120_000 picoseconds. - Weight::from_parts(71_810_000, 0) + // Minimum execution time: 39_067_000 picoseconds. + Weight::from_parts(41_787_019, 0) .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(4)) + // Standard Error: 5 + .saturating_add(Weight::from_parts(2_295, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) @@ -154,15 +146,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:1 w:1) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendMessages::OutboundMessages` (r:0 w:1) + /// Proof: `BridgeWestendMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_single_message() -> Weight { // Proof Size summary in bytes: - // Measured: `447` - // Estimated: `3912` - // Minimum execution time: 32_325_000 picoseconds. - Weight::from_parts(33_070_000, 0) - .saturating_add(Weight::from_parts(0, 3912)) + // Measured: `501` + // Estimated: `3966` + // Minimum execution time: 33_107_000 picoseconds. + Weight::from_parts(34_364_000, 0) + .saturating_add(Weight::from_parts(0, 3966)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -174,15 +168,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:1 w:1) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgeWestendMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { // Proof Size summary in bytes: - // Measured: `447` - // Estimated: `3912` - // Minimum execution time: 32_180_000 picoseconds. - Weight::from_parts(33_202_000, 0) - .saturating_add(Weight::from_parts(0, 3912)) + // Measured: `501` + // Estimated: `3966` + // Minimum execution time: 34_826_000 picoseconds. + Weight::from_parts(35_563_000, 0) + .saturating_add(Weight::from_parts(0, 3966)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -194,20 +190,22 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:2 w:2) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgeWestendMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { // Proof Size summary in bytes: - // Measured: `447` + // Measured: `501` // Estimated: `6086` - // Minimum execution time: 36_774_000 picoseconds. - Weight::from_parts(37_774_000, 0) + // Minimum execution time: 38_725_000 picoseconds. + Weight::from_parts(39_727_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes(5)) } /// Storage: `BridgeWestendMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendMessages::InboundLanes` (r:1 w:1) @@ -215,7 +213,7 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0) - /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) @@ -225,18 +223,18 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainSystem::RelevantMessagingState` (r:1 w:0) /// Proof: `ParachainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1) - /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `i` is `[128, 2048]`. - /// The range of component `i` is `[128, 2048]`. - fn receive_single_message_proof_with_dispatch(i: u32, ) -> Weight { + /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `736` + // Measured: `789` // Estimated: `52645` - // Minimum execution time: 65_934_000 picoseconds. - Weight::from_parts(67_915_916, 0) + // Minimum execution time: 56_892_000 picoseconds. + Weight::from_parts(61_941_659, 0) .saturating_add(Weight::from_parts(0, 52645)) - // Standard Error: 65 - .saturating_add(Weight::from_parts(7_190, 0).saturating_mul(i.into())) + // Standard Error: 8 + .saturating_add(Weight::from_parts(7_580, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(4)) } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_parachains.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_parachains.rs index ea68852804e3955577bf822d42887bf5bd772657..8eb291ea14523b15d6c44b8ee72d637fcbe11166 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_parachains.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_parachains.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_parachains` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -56,20 +56,22 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeWestendParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 2]`. fn submit_parachain_heads_with_n_parachains(p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `434` + // Measured: `558` // Estimated: `2543` - // Minimum execution time: 31_135_000 picoseconds. - Weight::from_parts(32_061_351, 0) + // Minimum execution time: 34_889_000 picoseconds. + Weight::from_parts(36_100_759, 0) .saturating_add(Weight::from_parts(0, 2543)) - // Standard Error: 80_309 - .saturating_add(Weight::from_parts(99_724, 0).saturating_mul(p.into())) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + // Standard Error: 102_466 + .saturating_add(Weight::from_parts(178_820, 0).saturating_mul(p.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeWestendParachains::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendParachains::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) @@ -79,17 +81,19 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeWestendParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) fn submit_parachain_heads_with_1kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `434` + // Measured: `558` // Estimated: `2543` - // Minimum execution time: 32_263_000 picoseconds. - Weight::from_parts(33_139_000, 0) + // Minimum execution time: 36_501_000 picoseconds. + Weight::from_parts(37_266_000, 0) .saturating_add(Weight::from_parts(0, 2543)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeWestendParachains::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeWestendParachains::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) @@ -99,16 +103,18 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeWestendParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeWestendGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeWestendGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeWestendParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeWestendParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) fn submit_parachain_heads_with_16kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `434` + // Measured: `558` // Estimated: `2543` - // Minimum execution time: 61_313_000 picoseconds. - Weight::from_parts(62_200_000, 0) + // Minimum execution time: 66_059_000 picoseconds. + Weight::from_parts(67_139_000, 0) .saturating_add(Weight::from_parts(0, 2543)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_relayers.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_relayers.rs index 5ab4cb900d848f37f1a5777b686d294837688495..f8bb983e80aa776ae7fe8c9a756935096956e7dd 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_relayers.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_bridge_relayers.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_relayers` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -54,10 +54,10 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn claim_rewards() -> Weight { // Proof Size summary in bytes: - // Measured: `244` + // Measured: `278` // Estimated: `3593` - // Minimum execution time: 45_393_000 picoseconds. - Weight::from_parts(46_210_000, 0) + // Minimum execution time: 44_224_000 picoseconds. + Weight::from_parts(44_905_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -70,10 +70,10 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< /// Proof: `Balances::Reserves` (`max_values`: None, `max_size`: Some(1249), added: 3724, mode: `MaxEncodedLen`) fn register() -> Weight { // Proof Size summary in bytes: - // Measured: `97` + // Measured: `131` // Estimated: `4714` - // Minimum execution time: 23_767_000 picoseconds. - Weight::from_parts(24_217_000, 0) + // Minimum execution time: 23_902_000 picoseconds. + Weight::from_parts(24_702_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -84,10 +84,10 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< /// Proof: `Balances::Reserves` (`max_values`: None, `max_size`: Some(1249), added: 3724, mode: `MaxEncodedLen`) fn deregister() -> Weight { // Proof Size summary in bytes: - // Measured: `197` + // Measured: `231` // Estimated: `4714` - // Minimum execution time: 25_745_000 picoseconds. - Weight::from_parts(26_319_000, 0) + // Minimum execution time: 24_469_000 picoseconds. + Weight::from_parts(25_176_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -100,10 +100,10 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn slash_and_deregister() -> Weight { // Proof Size summary in bytes: - // Measured: `300` + // Measured: `334` // Estimated: `4714` - // Minimum execution time: 27_497_000 picoseconds. - Weight::from_parts(27_939_000, 0) + // Minimum execution time: 27_518_000 picoseconds. + Weight::from_parts(28_068_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -112,10 +112,10 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) fn register_relayer_reward() -> Weight { // Proof Size summary in bytes: - // Measured: `42` + // Measured: `76` // Estimated: `3538` - // Minimum execution time: 5_584_000 picoseconds. - Weight::from_parts(5_908_000, 0) + // Minimum execution time: 5_484_000 picoseconds. + Weight::from_parts(5_718_000, 0) .saturating_add(Weight::from_parts(0, 3538)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_message_queue.rs index 2fcd573ceb277116bda67180da8e0701593ab453..b6fee47d1435162a3e24dd204b896eb849a7e146 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/pallet_message_queue.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/mod.rs index 4f5bae0fe597b88b1c23fa4ab806cec98bf7d746..b40cbfeeb8f2770bbc15e77d2a0a657b209a45ef 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/mod.rs @@ -17,11 +17,11 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use codec::Encode; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index d7e8c41ff8ac41acfeb60f30774e8282939b6c1c..f2cee0e3e80751f3f9dde9cbb812623fb3ae2bf8 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-11-14, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -54,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 19_610_000 picoseconds. - Weight::from_parts(19_980_000, 3593) + // Minimum execution time: 30_988_000 picoseconds. + Weight::from_parts(31_496_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `153` // Estimated: `6196` - // Minimum execution time: 44_411_000 picoseconds. - Weight::from_parts(45_110_000, 6196) + // Minimum execution time: 42_805_000 picoseconds. + Weight::from_parts(44_207_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -90,8 +90,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `223` // Estimated: `8799` - // Minimum execution time: 89_739_000 picoseconds. - Weight::from_parts(91_256_000, 8799) + // Minimum execution time: 103_376_000 picoseconds. + Weight::from_parts(104_770_000, 8799) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(5)) } @@ -124,8 +124,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `171` // Estimated: `6196` - // Minimum execution time: 60_045_000 picoseconds. - Weight::from_parts(60_710_000, 6196) + // Minimum execution time: 71_234_000 picoseconds. + Weight::from_parts(72_990_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -133,8 +133,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_257_000 picoseconds. - Weight::from_parts(3_392_000, 0) + // Minimum execution time: 2_636_000 picoseconds. + Weight::from_parts(2_777_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -142,13 +142,11 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `52` // Estimated: `3593` - // Minimum execution time: 19_423_000 picoseconds. - Weight::from_parts(19_823_000, 3593) + // Minimum execution time: 23_839_000 picoseconds. + Weight::from_parts(24_568_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: `System::Account` (r:2 w:2) - // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -159,6 +157,8 @@ impl WeightInfo { // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) @@ -167,8 +167,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `122` // Estimated: `6196` - // Minimum execution time: 60_484_000 picoseconds. - Weight::from_parts(61_634_000, 6196) + // Minimum execution time: 78_345_000 picoseconds. + Weight::from_parts(80_558_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -192,8 +192,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3593` - // Minimum execution time: 44_863_000 picoseconds. - Weight::from_parts(45_549_000, 3593) + // Minimum execution time: 46_614_000 picoseconds. + Weight::from_parts(47_354_000, 3593) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(3)) } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index abd84f8e89b07799758c36b002c30db742305927..9c58072d402c91a13f63795bf5b4184f80ab2c0b 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::generic` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); @@ -68,8 +68,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `171` // Estimated: `6196` - // Minimum execution time: 61_813_000 picoseconds. - Weight::from_parts(62_996_000, 6196) + // Minimum execution time: 60_119_000 picoseconds. + Weight::from_parts(61_871_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -77,8 +77,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_044_000 picoseconds. - Weight::from_parts(2_112_000, 0) + // Minimum execution time: 998_000 picoseconds. + Weight::from_parts(1_038_000, 0) } // Storage: `PolkadotXcm::Queries` (r:1 w:0) // Proof: `PolkadotXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -86,58 +86,58 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `32` // Estimated: `3497` - // Minimum execution time: 7_472_000 picoseconds. - Weight::from_parts(7_723_000, 3497) + // Minimum execution time: 6_327_000 picoseconds. + Weight::from_parts(6_520_000, 3497) .saturating_add(T::DbWeight::get().reads(1)) } pub fn transact() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_414_000 picoseconds. - Weight::from_parts(8_765_000, 0) + // Minimum execution time: 6_783_000 picoseconds. + Weight::from_parts(7_117_000, 0) } pub fn refund_surplus() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_192_000 picoseconds. - Weight::from_parts(2_243_000, 0) + // Minimum execution time: 1_589_000 picoseconds. + Weight::from_parts(1_655_000, 0) } pub fn set_error_handler() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_866_000 picoseconds. - Weight::from_parts(1_931_000, 0) + // Minimum execution time: 1_013_000 picoseconds. + Weight::from_parts(1_045_000, 0) } pub fn set_appendix() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_847_000 picoseconds. - Weight::from_parts(1_921_000, 0) + // Minimum execution time: 1_005_000 picoseconds. + Weight::from_parts(1_044_000, 0) } pub fn clear_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_797_000 picoseconds. - Weight::from_parts(1_880_000, 0) + // Minimum execution time: 964_000 picoseconds. + Weight::from_parts(1_011_000, 0) } pub fn descend_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_458_000 picoseconds. - Weight::from_parts(2_523_000, 0) + // Minimum execution time: 1_005_000 picoseconds. + Weight::from_parts(1_027_000, 0) } pub fn clear_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_833_000 picoseconds. - Weight::from_parts(1_906_000, 0) + // Minimum execution time: 980_000 picoseconds. + Weight::from_parts(1_009_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -159,8 +159,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `171` // Estimated: `6196` - // Minimum execution time: 54_659_000 picoseconds. - Weight::from_parts(56_025_000, 6196) + // Minimum execution time: 56_726_000 picoseconds. + Weight::from_parts(59_300_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -170,8 +170,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `90` // Estimated: `3555` - // Minimum execution time: 10_953_000 picoseconds. - Weight::from_parts(11_220_000, 3555) + // Minimum execution time: 8_962_000 picoseconds. + Weight::from_parts(9_519_000, 3555) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -179,8 +179,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_834_000 picoseconds. - Weight::from_parts(1_892_000, 0) + // Minimum execution time: 999_000 picoseconds. + Weight::from_parts(1_035_000, 0) } // Storage: `PolkadotXcm::VersionNotifyTargets` (r:1 w:1) // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -200,8 +200,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `38` // Estimated: `3503` - // Minimum execution time: 22_238_000 picoseconds. - Weight::from_parts(22_690_000, 3503) + // Minimum execution time: 20_313_000 picoseconds. + Weight::from_parts(21_000_000, 3503) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -211,44 +211,44 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_798_000 picoseconds. - Weight::from_parts(3_936_000, 0) + // Minimum execution time: 2_820_000 picoseconds. + Weight::from_parts(2_949_000, 0) .saturating_add(T::DbWeight::get().writes(1)) } pub fn burn_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_985_000 picoseconds. - Weight::from_parts(3_099_000, 0) + // Minimum execution time: 1_293_000 picoseconds. + Weight::from_parts(1_354_000, 0) } pub fn expect_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_955_000 picoseconds. - Weight::from_parts(2_050_000, 0) + // Minimum execution time: 1_076_000 picoseconds. + Weight::from_parts(1_114_000, 0) } pub fn expect_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_939_000 picoseconds. - Weight::from_parts(1_990_000, 0) + // Minimum execution time: 1_014_000 picoseconds. + Weight::from_parts(1_055_000, 0) } pub fn expect_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_841_000 picoseconds. - Weight::from_parts(1_900_000, 0) + // Minimum execution time: 979_000 picoseconds. + Weight::from_parts(1_019_000, 0) } pub fn expect_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_081_000 picoseconds. - Weight::from_parts(2_145_000, 0) + // Minimum execution time: 1_161_000 picoseconds. + Weight::from_parts(1_208_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -270,8 +270,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `171` // Estimated: `6196` - // Minimum execution time: 59_600_000 picoseconds. - Weight::from_parts(61_572_000, 6196) + // Minimum execution time: 62_250_000 picoseconds. + Weight::from_parts(64_477_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -279,8 +279,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_390_000 picoseconds. - Weight::from_parts(4_517_000, 0) + // Minimum execution time: 4_286_000 picoseconds. + Weight::from_parts(4_476_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -302,8 +302,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `171` // Estimated: `6196` - // Minimum execution time: 53_864_000 picoseconds. - Weight::from_parts(55_527_000, 6196) + // Minimum execution time: 58_253_000 picoseconds. + Weight::from_parts(59_360_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -311,22 +311,22 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_879_000 picoseconds. - Weight::from_parts(1_947_000, 0) + // Minimum execution time: 1_026_000 picoseconds. + Weight::from_parts(1_065_000, 0) } pub fn set_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_827_000 picoseconds. - Weight::from_parts(1_900_000, 0) + // Minimum execution time: 993_000 picoseconds. + Weight::from_parts(1_015_000, 0) } pub fn clear_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_824_000 picoseconds. - Weight::from_parts(1_898_000, 0) + // Minimum execution time: 966_000 picoseconds. + Weight::from_parts(999_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -339,16 +339,16 @@ impl WeightInfo { // Storage: `BridgeWestendMessages::OutboundLanesCongestedSignals` (r:1 w:0) // Proof: `BridgeWestendMessages::OutboundLanesCongestedSignals` (`max_values`: Some(1), `max_size`: Some(21), added: 516, mode: `MaxEncodedLen`) // Storage: `BridgeWestendMessages::OutboundMessages` (r:0 w:1) - // Proof: `BridgeWestendMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(2621472), added: 2623947, mode: `MaxEncodedLen`) + // Proof: `BridgeWestendMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) /// The range of component `x` is `[1, 1000]`. pub fn export_message(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `190` // Estimated: `6130` - // Minimum execution time: 41_598_000 picoseconds. - Weight::from_parts(42_219_173, 6130) - // Standard Error: 426 - .saturating_add(Weight::from_parts(452_460, 0).saturating_mul(x.into())) + // Minimum execution time: 37_014_000 picoseconds. + Weight::from_parts(38_096_655, 6130) + // Standard Error: 61 + .saturating_add(Weight::from_parts(45_146, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -356,14 +356,14 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_812_000 picoseconds. - Weight::from_parts(1_898_000, 0) + // Minimum execution time: 996_000 picoseconds. + Weight::from_parts(1_025_000, 0) } pub fn unpaid_execution() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_915_000 picoseconds. - Weight::from_parts(1_976_000, 0) + // Minimum execution time: 1_001_000 picoseconds. + Weight::from_parts(1_044_000, 0) } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs index a0d2e91dffd2e9240ad9364e18ef52a7b3cab3b1..92368b29212119dc151cd02a2311e01a5b82ac16 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/xcm_config.rs @@ -21,7 +21,7 @@ use super::{ }; use bp_messages::LaneId; use bp_relayers::{PayRewardFromAccount, RewardsAccountOwner, RewardsAccountParams}; -use bp_runtime::ChainId; +use core::marker::PhantomData; use frame_support::{ parameter_types, traits::{tokens::imbalance::ResolveTo, ConstU32, Contains, Equals, Everything, Nothing}, @@ -41,7 +41,6 @@ use polkadot_runtime_common::xcm_sender::ExponentialPrice; use snowbridge_runtime_common::XcmExportFeeToSibling; use sp_core::Get; use sp_runtime::traits::AccountIdConversion; -use sp_std::marker::PhantomData; use testnet_parachains_constants::rococo::snowbridge::EthereumNetwork; use xcm::latest::prelude::*; use xcm_builder::{ @@ -49,10 +48,10 @@ use xcm_builder::{ AllowHrmpNotificationsFromRelayChain, AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, HandleFee, IsConcrete, ParentAsSuperuser, - ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, - SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, - TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeToAccount, + ParentIsPreset, RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, + SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, + SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, + WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, }; use xcm_executor::{ traits::{FeeManager, FeeReason, FeeReason::Export, TransactAsset}, @@ -212,7 +211,7 @@ impl xcm_executor::Config for XcmConfig { Self::AssetTransactor, crate::bridge_to_westend_config::WestendGlobalConsensusNetwork, crate::bridge_to_westend_config::AssetHubWestendParaId, - crate::bridge_to_westend_config::BridgeHubWestendChainId, + bp_bridge_hub_westend::BridgeHubWestend, crate::bridge_to_westend_config::AssetHubRococoToAssetHubWestendMessagesLane, >, XcmExportFeeToSibling< @@ -223,7 +222,7 @@ impl xcm_executor::Config for XcmConfig { Self::AssetTransactor, crate::EthereumOutboundQueue, >, - XcmFeeToAccount, + SendXcmFeeToAccount, ), >; type MessageExporter = ( @@ -302,22 +301,22 @@ pub struct XcmExportFeeToRelayerRewardAccounts< AssetTransactor, DestNetwork, DestParaId, - DestBridgedChainId, + DestBridgedChain, BridgeLaneId, ->(PhantomData<(AssetTransactor, DestNetwork, DestParaId, DestBridgedChainId, BridgeLaneId)>); +>(PhantomData<(AssetTransactor, DestNetwork, DestParaId, DestBridgedChain, BridgeLaneId)>); impl< AssetTransactor: TransactAsset, DestNetwork: Get, DestParaId: Get, - DestBridgedChainId: Get, + DestBridgedChain: bp_runtime::Chain, BridgeLaneId: Get, > HandleFee for XcmExportFeeToRelayerRewardAccounts< AssetTransactor, DestNetwork, DestParaId, - DestBridgedChainId, + DestBridgedChain, BridgeLaneId, > { @@ -326,6 +325,8 @@ impl< if bridged_network == DestNetwork::get() && destination == [Parachain(DestParaId::get().into())]) { + let bridged_chain_id = DestBridgedChain::ID; + // We have 2 relayer rewards accounts: // - the SA of the source parachain on this BH: this pays the relayers for delivering // Source para -> Target Para message delivery confirmations @@ -337,7 +338,7 @@ impl< AccountId, >::rewards_account(RewardsAccountParams::new( BridgeLaneId::get(), - DestBridgedChainId::get(), + bridged_chain_id, RewardsAccountOwner::ThisChain, )); @@ -346,7 +347,7 @@ impl< AccountId, >::rewards_account(RewardsAccountParams::new( BridgeLaneId::get(), - DestBridgedChainId::get(), + bridged_chain_id, RewardsAccountOwner::BridgedChain, )); @@ -354,24 +355,27 @@ impl< match asset.fun { Fungible(total_fee) => { let source_fee = total_fee / 2; - deposit_or_burn_fee::( + deposit_or_burn_fee::( Asset { id: asset.id.clone(), fun: Fungible(source_fee) }.into(), maybe_context, - source_para_account.clone(), + AccountId32 { network: None, id: source_para_account.clone().into() } + .into(), ); let dest_fee = total_fee - source_fee; - deposit_or_burn_fee::( + deposit_or_burn_fee::( Asset { id: asset.id, fun: Fungible(dest_fee) }.into(), maybe_context, - dest_para_account.clone(), + AccountId32 { network: None, id: dest_para_account.clone().into() } + .into(), ); }, NonFungible(_) => { - deposit_or_burn_fee::( + deposit_or_burn_fee::( asset.into(), maybe_context, - source_para_account.clone(), + AccountId32 { network: None, id: source_para_account.clone().into() } + .into(), ); }, } @@ -393,7 +397,9 @@ impl, FeeHandler: HandleFee> FeeManager fn is_waived(origin: Option<&Location>, fee_reason: FeeReason) -> bool { let Some(loc) = origin else { return false }; if let Export { network, destination: Here } = fee_reason { - return !(network == EthereumNetwork::get()) + if network == EthereumNetwork::get() { + return false + } } WaivedLocations::contains(loc) } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/snowbridge.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/snowbridge.rs index 5960ab7b55054f228d1e946e5d6e5ff7dd9706ac..c7b5850f9ffe56620e26e0751a6cb04c07311bb3 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/snowbridge.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/snowbridge.rs @@ -188,6 +188,7 @@ fn construct_extrinsic( OnBridgeHubRococoRefundRococoBulletinMessages::default(), ), cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::::new(false), ); let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap(); let signature = payload.using_encoded(|e| sender.sign(e)); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/tests.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/tests.rs index b309232825db3aa964b2fa1a1d8d739f06ec3153..e91837af0b21336d2a2ac5684d73318e3260a1d5 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/tests.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/tests/tests.rs @@ -65,6 +65,7 @@ fn construct_extrinsic( bridge_to_bulletin_config::OnBridgeHubRococoRefundRococoBulletinMessages::default(), ), cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::new(false), ); let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap(); let signature = payload.using_encoded(|e| sender.sign(e)); @@ -147,9 +148,8 @@ mod bridge_hub_westend_tests { }; use bridge_hub_test_utils::test_cases::from_parachain; use bridge_to_westend_config::{ - BridgeHubWestendChainId, BridgeHubWestendLocation, WestendGlobalConsensusNetwork, - WithBridgeHubWestendMessageBridge, WithBridgeHubWestendMessagesInstance, - XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, + BridgeHubWestendLocation, WestendGlobalConsensusNetwork, + WithBridgeHubWestendMessagesInstance, XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, }; // Para id of sibling chain used in tests. @@ -162,7 +162,6 @@ mod bridge_hub_westend_tests { BridgeGrandpaWestendInstance, BridgeParachainWestendInstance, WithBridgeHubWestendMessagesInstance, - WithBridgeHubWestendMessageBridge, >; #[test] @@ -315,11 +314,14 @@ mod bridge_hub_westend_tests { } }), || ExportMessage { network: Westend, destination: [Parachain(bridge_to_westend_config::AssetHubWestendParaId::get().into())].into(), xcm: Xcm(vec![]) }, - XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, Some((TokenLocation::get(), ExistentialDeposit::get()).into()), // value should be >= than value generated by `can_calculate_weight_for_paid_export_message_with_reserve_transfer` Some((TokenLocation::get(), bp_bridge_hub_rococo::BridgeHubRococoBaseXcmFeeInRocs::get()).into()), - || PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(BridgeHubWestendLocation::get()), XCM_VERSION).expect("version saved!"), + || { + PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(BridgeHubWestendLocation::get()), XCM_VERSION).expect("version saved!"); + + XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND + }, ) } @@ -352,8 +354,7 @@ mod bridge_hub_westend_tests { _ => None, } }), - XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, - || (), + || XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, ) } @@ -365,11 +366,9 @@ mod bridge_hub_westend_tests { slot_durations(), bp_bridge_hub_rococo::BRIDGE_HUB_ROCOCO_PARACHAIN_ID, bp_bridge_hub_westend::BRIDGE_HUB_WESTEND_PARACHAIN_ID, - BridgeHubWestendChainId::get(), SIBLING_PARACHAIN_ID, Rococo, - XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, - || (), + || XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, construct_and_apply_extrinsic, ) } @@ -382,11 +381,9 @@ mod bridge_hub_westend_tests { slot_durations(), bp_bridge_hub_rococo::BRIDGE_HUB_ROCOCO_PARACHAIN_ID, bp_bridge_hub_westend::BRIDGE_HUB_WESTEND_PARACHAIN_ID, - BridgeHubWestendChainId::get(), SIBLING_PARACHAIN_ID, Rococo, - XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, - || (), + || XCM_LANE_FOR_ASSET_HUB_ROCOCO_TO_ASSET_HUB_WESTEND, construct_and_apply_extrinsic, ) } @@ -403,8 +400,8 @@ mod bridge_hub_westend_tests { WeightToFee, >() }, - Perbill::from_percent(33), - Some(-33), + Perbill::from_percent(25), + Some(-25), &format!( "Estimate fee for `ExportMessage` for runtime: {:?}", ::Version::get() @@ -422,8 +419,8 @@ mod bridge_hub_westend_tests { RuntimeTestsAdapter, >(collator_session_keys(), construct_and_estimate_extrinsic_fee) }, - Perbill::from_percent(33), - Some(-33), + Perbill::from_percent(25), + Some(-25), &format!( "Estimate fee for `single message delivery` for runtime: {:?}", ::Version::get() @@ -441,8 +438,8 @@ mod bridge_hub_westend_tests { RuntimeTestsAdapter, >(collator_session_keys(), construct_and_estimate_extrinsic_fee) }, - Perbill::from_percent(33), - Some(-33), + Perbill::from_percent(25), + Some(-25), &format!( "Estimate fee for `single message confirmation` for runtime: {:?}", ::Version::get() @@ -456,8 +453,7 @@ mod bridge_hub_bulletin_tests { use bridge_common_config::BridgeGrandpaRococoBulletinInstance; use bridge_hub_test_utils::test_cases::from_grandpa_chain; use bridge_to_bulletin_config::{ - RococoBulletinChainId, RococoBulletinGlobalConsensusNetwork, - RococoBulletinGlobalConsensusNetworkLocation, WithRococoBulletinMessageBridge, + RococoBulletinGlobalConsensusNetwork, RococoBulletinGlobalConsensusNetworkLocation, WithRococoBulletinMessagesInstance, XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, }; @@ -470,7 +466,6 @@ mod bridge_hub_bulletin_tests { AllPalletsWithoutSystem, BridgeGrandpaRococoBulletinInstance, WithRococoBulletinMessagesInstance, - WithRococoBulletinMessageBridge, >; #[test] @@ -522,10 +517,13 @@ mod bridge_hub_bulletin_tests { destination: Here, xcm: Xcm(vec![]), }, - XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, Some((TokenLocation::get(), ExistentialDeposit::get()).into()), None, - || PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(RococoBulletinGlobalConsensusNetworkLocation::get()), XCM_VERSION).expect("version saved!"), + || { + PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(RococoBulletinGlobalConsensusNetworkLocation::get()), XCM_VERSION).expect("version saved!"); + + XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN + }, ) } @@ -558,8 +556,7 @@ mod bridge_hub_bulletin_tests { _ => None, } }), - XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, - || (), + || XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, ) } @@ -570,11 +567,9 @@ mod bridge_hub_bulletin_tests { collator_session_keys(), slot_durations(), bp_bridge_hub_rococo::BRIDGE_HUB_ROCOCO_PARACHAIN_ID, - RococoBulletinChainId::get(), SIBLING_PARACHAIN_ID, Rococo, - XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, - || (), + || XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, construct_and_apply_extrinsic, ) } @@ -586,52 +581,10 @@ mod bridge_hub_bulletin_tests { collator_session_keys(), slot_durations(), bp_bridge_hub_rococo::BRIDGE_HUB_ROCOCO_PARACHAIN_ID, - RococoBulletinChainId::get(), SIBLING_PARACHAIN_ID, Rococo, - XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, - || (), + || XCM_LANE_FOR_ROCOCO_PEOPLE_TO_ROCOCO_BULLETIN, construct_and_apply_extrinsic, ) } - - #[test] - pub fn can_calculate_fee_for_standalone_message_delivery_transaction() { - bridge_hub_test_utils::check_sane_fees_values( - "bp_bridge_hub_rococo::BridgeHubRococoBaseDeliveryFeeInRocs", - bp_bridge_hub_rococo::BridgeHubRococoBaseDeliveryFeeInRocs::get(), - || { - from_grandpa_chain::can_calculate_fee_for_standalone_message_delivery_transaction::< - RuntimeTestsAdapter, - >(collator_session_keys(), construct_and_estimate_extrinsic_fee) - }, - Perbill::from_percent(33), - None, /* we don't want lowering according to the Bulletin setup, because - * `from_grandpa_chain` is cheaper then `from_parachain_chain` */ - &format!( - "Estimate fee for `single message delivery` for runtime: {:?}", - ::Version::get() - ), - ) - } - - #[test] - pub fn can_calculate_fee_for_standalone_message_confirmation_transaction() { - bridge_hub_test_utils::check_sane_fees_values( - "bp_bridge_hub_rococo::BridgeHubRococoBaseConfirmationFeeInRocs", - bp_bridge_hub_rococo::BridgeHubRococoBaseConfirmationFeeInRocs::get(), - || { - from_grandpa_chain::can_calculate_fee_for_standalone_message_confirmation_transaction::< - RuntimeTestsAdapter, - >(collator_session_keys(), construct_and_estimate_extrinsic_fee) - }, - Perbill::from_percent(33), - None, /* we don't want lowering according to the Bulletin setup, because - * `from_grandpa_chain` is cheaper then `from_parachain_chain` */ - &format!( - "Estimate fee for `single message confirmation` for runtime: {:?}", - ::Version::get() - ), - ) - } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml index a7241cc6d10c45a292c3e0ffc0a8044e9b2fb706..1c9d8c0207b993517100b8be2e194c75336b4103 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/Cargo.toml @@ -10,101 +10,115 @@ license = "Apache-2.0" workspace = true [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } -tuplex = { version = "0.1", default-features = false } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", 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-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-multisig = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-std = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", 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, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +westend-runtime-constants = { workspace = true } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false, features = ["bridging"] } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { features = ["bridging"], workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } # Bridges -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-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-messages = { path = "../../../../../bridges/primitives/messages", default-features = false } -bp-parachains = { path = "../../../../../bridges/primitives/parachains", default-features = false } -bp-polkadot-core = { path = "../../../../../bridges/primitives/polkadot-core", default-features = false } -bp-relayers = { path = "../../../../../bridges/primitives/relayers", default-features = false } -bp-runtime = { path = "../../../../../bridges/primitives/runtime", default-features = false } -bp-rococo = { path = "../../../../../bridges/chains/chain-rococo", default-features = false } -bp-westend = { path = "../../../../../bridges/chains/chain-westend", 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-xcm-bridge-hub = { path = "../../../../../bridges/modules/xcm-bridge-hub", default-features = false } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common", default-features = false } -bridge-hub-common = { path = "../common", default-features = false } +bp-asset-hub-rococo = { workspace = true } +bp-asset-hub-westend = { workspace = true } +bp-bridge-hub-rococo = { workspace = true } +bp-bridge-hub-westend = { workspace = true } +bp-header-chain = { workspace = true } +bp-messages = { workspace = true } +bp-parachains = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-relayers = { workspace = true } +bp-runtime = { features = ["test-helpers"], workspace = true } +bp-rococo = { workspace = true } +bp-westend = { workspace = true } +pallet-bridge-grandpa = { workspace = true } +pallet-bridge-messages = { workspace = true } +pallet-bridge-parachains = { workspace = true } +pallet-bridge-relayers = { workspace = true } +pallet-xcm-bridge-hub = { workspace = true } +bridge-runtime-common = { workspace = true } +bridge-hub-common = { workspace = true } + +# Ethereum Bridge (Snowbridge) +snowbridge-beacon-primitives = { workspace = true } +snowbridge-pallet-system = { workspace = true } +snowbridge-system-runtime-api = { workspace = true } +snowbridge-core = { workspace = true } +snowbridge-pallet-ethereum-client = { workspace = true } +snowbridge-pallet-inbound-queue = { workspace = true } +snowbridge-pallet-outbound-queue = { workspace = true } +snowbridge-outbound-queue-runtime-api = { workspace = true } +snowbridge-router-primitives = { workspace = true } +snowbridge-runtime-common = { workspace = true } + [dev-dependencies] -static_assertions = "1.1" -bridge-hub-test-utils = { path = "../test-utils" } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common", features = ["integrity-test"] } -sp-keyring = { path = "../../../../../substrate/primitives/keyring" } +bridge-hub-test-utils = { workspace = true, default-features = true } +bridge-runtime-common = { features = ["integrity-test"], workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +snowbridge-runtime-test-common = { workspace = true, default-features = true } [features] default = ["std"] @@ -135,6 +149,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -165,6 +180,16 @@ std = [ "polkadot-runtime-common/std", "scale-info/std", "serde", + "snowbridge-beacon-primitives/std", + "snowbridge-core/std", + "snowbridge-outbound-queue-runtime-api/std", + "snowbridge-pallet-ethereum-client/std", + "snowbridge-pallet-inbound-queue/std", + "snowbridge-pallet-outbound-queue/std", + "snowbridge-pallet-system/std", + "snowbridge-router-primitives/std", + "snowbridge-runtime-common/std", + "snowbridge-system-runtime-api/std", "sp-api/std", "sp-block-builder/std", "sp-consensus-aura/std", @@ -181,10 +206,10 @@ std = [ "sp-version/std", "substrate-wasm-builder", "testnet-parachains-constants/std", - "tuplex/std", "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -216,9 +241,18 @@ runtime-benchmarks = [ "parachains-common/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", "polkadot-runtime-common/runtime-benchmarks", + "snowbridge-core/runtime-benchmarks", + "snowbridge-pallet-ethereum-client/runtime-benchmarks", + "snowbridge-pallet-inbound-queue/runtime-benchmarks", + "snowbridge-pallet-outbound-queue/runtime-benchmarks", + "snowbridge-pallet-system/runtime-benchmarks", + "snowbridge-router-primitives/runtime-benchmarks", + "snowbridge-runtime-common/runtime-benchmarks", + "snowbridge-runtime-test-common/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -248,10 +282,16 @@ try-runtime = [ "pallet-xcm/try-runtime", "parachain-info/try-runtime", "polkadot-runtime-common/try-runtime", + "snowbridge-pallet-ethereum-client/try-runtime", + "snowbridge-pallet-inbound-queue/try-runtime", + "snowbridge-pallet-outbound-queue/try-runtime", + "snowbridge-pallet-system/try-runtime", "sp-runtime/try-runtime", ] # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = [] + +fast-runtime = [] diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_ethereum_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_ethereum_config.rs new file mode 100644 index 0000000000000000000000000000000000000000..7922d3ed02b1fe73293fd7bf4344fb5609c3aeda --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_ethereum_config.rs @@ -0,0 +1,219 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +#[cfg(not(feature = "runtime-benchmarks"))] +use crate::XcmRouter; +use crate::{ + xcm_config, + xcm_config::{TreasuryAccount, UniversalLocation}, + Balances, EthereumInboundQueue, EthereumOutboundQueue, EthereumSystem, MessageQueue, Runtime, + RuntimeEvent, TransactionByteFee, +}; +use parachains_common::{AccountId, Balance}; +use snowbridge_beacon_primitives::{Fork, ForkVersions}; +use snowbridge_core::{gwei, meth, AllowSiblingsOnly, PricingParameters, Rewards}; +use snowbridge_router_primitives::{inbound::MessageToXcm, outbound::EthereumBlobExporter}; +use sp_core::H160; +use testnet_parachains_constants::westend::{ + currency::*, + fee::WeightToFee, + snowbridge::{EthereumNetwork, INBOUND_QUEUE_PALLET_INDEX}, +}; + +#[cfg(feature = "runtime-benchmarks")] +use benchmark_helpers::DoNothingRouter; +use frame_support::{parameter_types, weights::ConstantMultiplier}; +use pallet_xcm::EnsureXcm; +use sp_runtime::{ + traits::{ConstU32, ConstU8, Keccak256}, + FixedU128, +}; + +/// Exports message to the Ethereum Gateway contract. +pub type SnowbridgeExporter = EthereumBlobExporter< + UniversalLocation, + EthereumNetwork, + snowbridge_pallet_outbound_queue::Pallet, + snowbridge_core::AgentIdOf, +>; + +// Ethereum Bridge +parameter_types! { + pub storage EthereumGatewayAddress: H160 = H160(hex_literal::hex!("EDa338E4dC46038493b885327842fD3E301CaB39")); +} + +parameter_types! { + pub const CreateAssetCall: [u8;2] = [53, 0]; + pub const CreateAssetDeposit: u128 = (UNITS / 10) + EXISTENTIAL_DEPOSIT; + pub Parameters: PricingParameters = PricingParameters { + exchange_rate: FixedU128::from_rational(1, 400), + fee_per_gas: gwei(20), + rewards: Rewards { local: 1 * UNITS, remote: meth(1) }, + multiplier: FixedU128::from_rational(1, 1), + }; +} + +impl snowbridge_pallet_inbound_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Verifier = snowbridge_pallet_ethereum_client::Pallet; + type Token = Balances; + #[cfg(not(feature = "runtime-benchmarks"))] + type XcmSender = XcmRouter; + #[cfg(feature = "runtime-benchmarks")] + type XcmSender = DoNothingRouter; + type ChannelLookup = EthereumSystem; + type GatewayAddress = EthereumGatewayAddress; + #[cfg(feature = "runtime-benchmarks")] + type Helper = Runtime; + type MessageConverter = MessageToXcm< + CreateAssetCall, + CreateAssetDeposit, + ConstU8, + AccountId, + Balance, + >; + type WeightToFee = WeightToFee; + type LengthToFee = ConstantMultiplier; + type MaxMessageSize = ConstU32<2048>; + type WeightInfo = crate::weights::snowbridge_pallet_inbound_queue::WeightInfo; + type PricingParameters = EthereumSystem; + type AssetTransactor = ::AssetTransactor; +} + +impl snowbridge_pallet_outbound_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Hashing = Keccak256; + type MessageQueue = MessageQueue; + type Decimals = ConstU8<12>; + type MaxMessagePayloadSize = ConstU32<2048>; + type MaxMessagesPerBlock = ConstU32<32>; + type GasMeter = snowbridge_core::outbound::ConstantGasMeter; + type Balance = Balance; + type WeightToFee = WeightToFee; + type WeightInfo = crate::weights::snowbridge_pallet_outbound_queue::WeightInfo; + type PricingParameters = EthereumSystem; + type Channels = EthereumSystem; +} + +#[cfg(any(feature = "std", feature = "fast-runtime", feature = "runtime-benchmarks", test))] +parameter_types! { + pub const ChainForkVersions: ForkVersions = ForkVersions { + genesis: Fork { + version: [0, 0, 0, 0], // 0x00000000 + epoch: 0, + }, + altair: Fork { + version: [1, 0, 0, 0], // 0x01000000 + epoch: 0, + }, + bellatrix: Fork { + version: [2, 0, 0, 0], // 0x02000000 + epoch: 0, + }, + capella: Fork { + version: [3, 0, 0, 0], // 0x03000000 + epoch: 0, + }, + deneb: Fork { + version: [4, 0, 0, 0], // 0x04000000 + epoch: 0, + } + }; +} + +#[cfg(not(any(feature = "std", feature = "fast-runtime", feature = "runtime-benchmarks", test)))] +parameter_types! { + pub const ChainForkVersions: ForkVersions = ForkVersions { + genesis: Fork { + version: [144, 0, 0, 111], // 0x90000069 + epoch: 0, + }, + altair: Fork { + version: [144, 0, 0, 112], // 0x90000070 + epoch: 50, + }, + bellatrix: Fork { + version: [144, 0, 0, 113], // 0x90000071 + epoch: 100, + }, + capella: Fork { + version: [144, 0, 0, 114], // 0x90000072 + epoch: 56832, + }, + deneb: Fork { + version: [144, 0, 0, 115], // 0x90000073 + epoch: 132608, + }, + }; +} + +impl snowbridge_pallet_ethereum_client::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type ForkVersions = ChainForkVersions; + type WeightInfo = crate::weights::snowbridge_pallet_ethereum_client::WeightInfo; +} + +impl snowbridge_pallet_system::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type OutboundQueue = EthereumOutboundQueue; + type SiblingOrigin = EnsureXcm; + type AgentIdOf = snowbridge_core::AgentIdOf; + type TreasuryAccount = TreasuryAccount; + type Token = Balances; + type WeightInfo = crate::weights::snowbridge_pallet_system::WeightInfo; + #[cfg(feature = "runtime-benchmarks")] + type Helper = (); + type DefaultPricingParameters = Parameters; + type InboundDeliveryCost = EthereumInboundQueue; +} + +#[cfg(feature = "runtime-benchmarks")] +pub mod benchmark_helpers { + use crate::{EthereumBeaconClient, Runtime, RuntimeOrigin}; + use codec::Encode; + use snowbridge_beacon_primitives::BeaconHeader; + use snowbridge_pallet_inbound_queue::BenchmarkHelper; + use sp_core::H256; + use xcm::latest::{Assets, Location, SendError, SendResult, SendXcm, Xcm, XcmHash}; + + impl BenchmarkHelper for Runtime { + fn initialize_storage(beacon_header: BeaconHeader, block_roots_root: H256) { + EthereumBeaconClient::store_finalized_header(beacon_header, block_roots_root).unwrap(); + } + } + + pub struct DoNothingRouter; + impl SendXcm for DoNothingRouter { + type Ticket = Xcm<()>; + + fn validate( + _dest: &mut Option, + xcm: &mut Option>, + ) -> SendResult { + Ok((xcm.clone().unwrap(), Assets::new())) + } + fn deliver(xcm: Xcm<()>) -> Result { + let hash = xcm.using_encoded(sp_io::hashing::blake2_256); + Ok(hash) + } + } + + impl snowbridge_pallet_system::BenchmarkHelper for () { + fn make_xcm_origin(location: Location) -> RuntimeOrigin { + RuntimeOrigin::from(pallet_xcm::Origin::Xcm(location)) + } + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_rococo_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_rococo_config.rs index 425b53da30fc8a176fcddfe145fab66a41b60f8a..be4d40c2275f28f09191b782bdad88bc7526b8bd 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_rococo_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/bridge_to_rococo_config.rs @@ -18,23 +18,18 @@ use crate::{ bridge_common_config::DeliveryRewardInBalance, weights, xcm_config::UniversalLocation, - AccountId, BridgeRococoMessages, PolkadotXcm, Runtime, RuntimeEvent, RuntimeOrigin, - XcmOverBridgeHubRococo, XcmRouter, + BridgeRococoMessages, PolkadotXcm, Runtime, RuntimeEvent, XcmOverBridgeHubRococo, XcmRouter, +}; +use bp_messages::{ + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::FromBridgedChainMessagesProof, LaneId, }; -use bp_messages::LaneId; use bp_parachains::SingleParaStoredHeaderDataBuilder; -use bp_runtime::Chain; use bridge_runtime_common::{ extensions::refund_relayer_extension::{ ActualFeeRefund, RefundBridgedMessages, RefundSignedExtensionAdapter, RefundableMessagesLane, }, - messages, - messages::{ - source::{FromBridgedChainMessagesDeliveryProof, TargetHeaderChainAdapter}, - target::{FromBridgedChainMessagesProof, SourceHeaderChainAdapter}, - MessageBridge, ThisChainWithMessages, UnderlyingChainProvider, - }, messages_xcm_extension::{ SenderAndLane, XcmAsPlainPayload, XcmBlobHauler, XcmBlobHaulerAdapter, XcmBlobMessageDispatch, XcmVersionOfDestAndRemoteBridge, @@ -45,7 +40,6 @@ use frame_support::{ parameter_types, traits::{ConstU32, PalletInfoAccess}, }; -use sp_runtime::RuntimeDebug; use xcm::{ latest::prelude::*, prelude::{InteriorLocation, NetworkId}, @@ -59,11 +53,6 @@ parameter_types! { pub const RococoBridgeParachainPalletName: &'static str = "Paras"; pub const MaxRococoParaHeadDataSize: u32 = bp_rococo::MAX_NESTED_PARACHAIN_HEAD_DATA_SIZE; - pub const MaxUnrewardedRelayerEntriesAtInboundLane: bp_messages::MessageNonce = - bp_bridge_hub_westend::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX; - pub const MaxUnconfirmedMessagesAtInboundLane: bp_messages::MessageNonce = - bp_bridge_hub_westend::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX; - pub const BridgeHubRococoChainId: bp_runtime::ChainId = BridgeHubRococo::ID; pub BridgeWestendToRococoMessagesPalletInstance: InteriorLocation = [PalletInstance(::index() as u8)].into(); pub RococoGlobalConsensusNetwork: NetworkId = NetworkId::Rococo; pub RococoGlobalConsensusNetworkLocation: Location = Location::new( @@ -87,7 +76,7 @@ parameter_types! { ParentThen([Parachain(AssetHubWestendParaId::get().into())].into()).into(), XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, ); - pub ActiveLanes: sp_std::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = sp_std::vec![ + pub ActiveLanes: alloc::vec::Vec<(SenderAndLane, (NetworkId, InteriorLocation))> = alloc::vec![ ( FromAssetHubWestendToAssetHubRococoRoute::get(), (RococoGlobalConsensusNetwork::get(), [Parachain(AssetHubRococoParaId::get().into())].into()) @@ -107,8 +96,8 @@ parameter_types! { } pub const XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO: LaneId = LaneId([0, 0, 0, 2]); -fn build_congestion_message(is_congested: bool) -> sp_std::vec::Vec> { - sp_std::vec![ +fn build_congestion_message(is_congested: bool) -> alloc::vec::Vec> { + alloc::vec![ UnpaidExecution { weight_limit: Unlimited, check_origin: None }, Transact { origin_kind: OriginKind::Xcm, @@ -153,46 +142,6 @@ impl XcmBlobHauler for ToBridgeHubRococoXcmBlobHauler { /// On messages delivered callback. type OnMessagesDelivered = XcmBlobHaulerAdapter; -/// Messaging Bridge configuration for BridgeHubWestend -> BridgeHubRococo -pub struct WithBridgeHubRococoMessageBridge; -impl MessageBridge for WithBridgeHubRococoMessageBridge { - const BRIDGED_MESSAGES_PALLET_NAME: &'static str = - bp_bridge_hub_westend::WITH_BRIDGE_HUB_WESTEND_MESSAGES_PALLET_NAME; - type ThisChain = BridgeHubWestend; - type BridgedChain = BridgeHubRococo; - type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders< - Runtime, - BridgeParachainRococoInstance, - bp_bridge_hub_rococo::BridgeHubRococo, - >; -} - -/// Maximal outbound payload size of BridgeHubWestend -> BridgeHubRococo messages. -type ToBridgeHubRococoMaximalOutboundPayloadSize = - messages::source::FromThisChainMaximalOutboundPayloadSize; - -/// BridgeHubRococo chain from message lane point of view. -#[derive(RuntimeDebug, Clone, Copy)] -pub struct BridgeHubRococo; - -impl UnderlyingChainProvider for BridgeHubRococo { - type Chain = bp_bridge_hub_rococo::BridgeHubRococo; -} - -impl messages::BridgedChainWithMessages for BridgeHubRococo {} - -/// BridgeHubWestend chain from message lane point of view. -#[derive(RuntimeDebug, Clone, Copy)] -pub struct BridgeHubWestend; - -impl UnderlyingChainProvider for BridgeHubWestend { - type Chain = bp_bridge_hub_westend::BridgeHubWestend; -} - -impl ThisChainWithMessages for BridgeHubWestend { - type RuntimeOrigin = RuntimeOrigin; -} - /// Signed extension that refunds relayers that are delivering messages from the Rococo parachain. pub type OnBridgeHubWestendRefundBridgeHubRococoMessages = RefundSignedExtensionAdapter< RefundBridgedMessages< @@ -237,26 +186,28 @@ pub type WithBridgeHubRococoMessagesInstance = pallet_bridge_messages::Instance1 impl pallet_bridge_messages::Config for Runtime { type RuntimeEvent = RuntimeEvent; type WeightInfo = weights::pallet_bridge_messages::WeightInfo; - type BridgedChainId = BridgeHubRococoChainId; + + type ThisChain = bp_bridge_hub_westend::BridgeHubWestend; + type BridgedChain = bp_bridge_hub_rococo::BridgeHubRococo; + type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders< + Runtime, + BridgeParachainRococoInstance, + bp_bridge_hub_rococo::BridgeHubRococo, + >; + type ActiveOutboundLanes = ActiveOutboundLanesToBridgeHubRococo; - type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; - type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; - type MaximalOutboundPayloadSize = ToBridgeHubRococoMaximalOutboundPayloadSize; type OutboundPayload = XcmAsPlainPayload; type InboundPayload = XcmAsPlainPayload; - type InboundRelayer = AccountId; type DeliveryPayments = (); - type TargetHeaderChain = TargetHeaderChainAdapter; type DeliveryConfirmationPayments = pallet_bridge_relayers::DeliveryConfirmationPaymentsAdapter< Runtime, WithBridgeHubRococoMessagesInstance, DeliveryRewardInBalance, >; - type SourceHeaderChain = SourceHeaderChainAdapter; type MessageDispatch = XcmBlobMessageDispatch< FromRococoMessageBlobDispatcher, Self::WeightInfo, @@ -287,9 +238,8 @@ mod tests { assert_complete_bridge_types, extensions::refund_relayer_extension::RefundableParachain, integrity::{ - assert_complete_bridge_constants, check_message_lane_weights, - AssertBridgeMessagesPalletConstants, AssertBridgePalletNames, AssertChainConstants, - AssertCompleteBridgeConstants, + assert_complete_with_parachain_bridge_constants, check_message_lane_weights, + AssertChainConstants, AssertCompleteBridgeConstants, }, }; use parachains_common::Balance; @@ -331,35 +281,20 @@ mod tests { runtime: Runtime, with_bridged_chain_grandpa_instance: BridgeGrandpaRococoInstance, with_bridged_chain_messages_instance: WithBridgeHubRococoMessagesInstance, - bridge: WithBridgeHubRococoMessageBridge, - this_chain: bp_westend::Westend, - bridged_chain: bp_rococo::Rococo, + this_chain: bp_bridge_hub_westend::BridgeHubWestend, + bridged_chain: bp_bridge_hub_rococo::BridgeHubRococo, ); - assert_complete_bridge_constants::< + assert_complete_with_parachain_bridge_constants::< Runtime, BridgeGrandpaRococoInstance, WithBridgeHubRococoMessagesInstance, - WithBridgeHubRococoMessageBridge, + bp_rococo::Rococo, >(AssertCompleteBridgeConstants { this_chain_constants: AssertChainConstants { block_length: bp_bridge_hub_westend::BlockLength::get(), block_weights: bp_bridge_hub_westend::BlockWeightsForAsyncBacking::get(), }, - messages_pallet_constants: AssertBridgeMessagesPalletConstants { - max_unrewarded_relayers_in_bridged_confirmation_tx: - bp_bridge_hub_rococo::MAX_UNREWARDED_RELAYERS_IN_CONFIRMATION_TX, - max_unconfirmed_messages_in_bridged_confirmation_tx: - bp_bridge_hub_rococo::MAX_UNCONFIRMED_MESSAGES_IN_CONFIRMATION_TX, - bridged_chain_id: BridgeHubRococo::ID, - }, - pallet_names: AssertBridgePalletNames { - with_this_chain_messages_pallet_name: - bp_bridge_hub_westend::WITH_BRIDGE_HUB_WESTEND_MESSAGES_PALLET_NAME, - with_bridged_chain_grandpa_pallet_name: bp_rococo::WITH_ROCOCO_GRANDPA_PALLET_NAME, - with_bridged_chain_messages_pallet_name: - bp_bridge_hub_rococo::WITH_BRIDGE_HUB_ROCOCO_MESSAGES_PALLET_NAME, - }, }); bridge_runtime_common::extensions::priority_calculator::per_relay_header::ensure_priority_boost_is_sane::< @@ -370,7 +305,7 @@ mod tests { bridge_runtime_common::extensions::priority_calculator::per_parachain_header::ensure_priority_boost_is_sane::< Runtime, - RefundableParachain, + RefundableParachain, PriorityBoostPerParachainHeader, >(FEE_BOOST_PER_PARACHAIN_HEADER); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs index 4c467010c7c874bafe16697cd741a92bf13eb0c5..1c26742fd67f827e6134f5f5a08f35f6c00938e2 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/lib.rs @@ -28,10 +28,14 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); pub mod bridge_common_config; +pub mod bridge_to_ethereum_config; pub mod bridge_to_rococo_config; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use bridge_runtime_common::extensions::{ check_obsolete_extension::{ CheckAndBoostBridgeGrandpaTransactions, CheckAndBoostBridgeParachainsTransactions, @@ -49,7 +53,6 @@ use sp_runtime::{ ApplyExtrinsicResult, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -64,7 +67,7 @@ use frame_support::{ genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ConstBool, ConstU32, ConstU64, ConstU8, Get, TransformOrigin}, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -75,13 +78,18 @@ pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; pub use sp_runtime::{MultiAddress, Perbill, Permill}; use xcm_config::{XcmOriginToTransactDispatchOrigin, XcmRouter}; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; + use bp_runtime::HeaderId; #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate}; -use xcm::latest::prelude::*; +use xcm::prelude::*; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; @@ -89,7 +97,12 @@ use parachains_common::{ impls::DealWithFees, AccountId, Balance, BlockNumber, Hash, Header, Nonce, Signature, AVERAGE_ON_INITIALIZE_RATIO, NORMAL_DISPATCH_RATIO, }; +use snowbridge_core::{ + outbound::{Command, Fee}, + AgentId, PricingParameters, +}; use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*}; +use xcm::VersionedLocation; /// The address format for describing accounts. pub type Address = MultiAddress; @@ -116,6 +129,7 @@ pub type SignedExtra = ( BridgeRejectObsoleteHeadersAndMessages, (bridge_to_rococo_config::OnBridgeHubWestendRefundBridgeHubRococoMessages,), cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -129,6 +143,7 @@ pub type Migrations = ( InitStorageVersions, // unreleased cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); @@ -183,7 +198,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("bridge-hub-westend"), impl_name: create_runtime_str!("bridge-hub-westend"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_016_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 5, @@ -343,16 +358,19 @@ impl pallet_message_queue::Config for Runtime { type MessageProcessor = pallet_message_queue::mock_helpers::NoopMessageProcessor; #[cfg(not(feature = "runtime-benchmarks"))] - type MessageProcessor = xcm_builder::ProcessXcmMessage< - AggregateMessageOrigin, - xcm_executor::XcmExecutor, - RuntimeCall, + type MessageProcessor = bridge_hub_common::BridgeHubMessageRouter< + xcm_builder::ProcessXcmMessage< + AggregateMessageOrigin, + xcm_executor::XcmExecutor, + RuntimeCall, + >, + EthereumOutboundQueue, >; type Size = u32; // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -379,13 +397,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } @@ -499,6 +526,11 @@ construct_runtime!( BridgeRococoMessages: pallet_bridge_messages:: = 44, XcmOverBridgeHubRococo: pallet_xcm_bridge_hub:: = 45, + EthereumInboundQueue: snowbridge_pallet_inbound_queue = 80, + EthereumOutboundQueue: snowbridge_pallet_outbound_queue = 81, + EthereumBeaconClient: snowbridge_pallet_ethereum_client = 82, + EthereumSystem: snowbridge_pallet_system = 83, + // Message Queue. Importantly, is registered last so that messages are processed after // the `on_initialize` hooks of bridging pallets. MessageQueue: pallet_message_queue = 250, @@ -551,6 +583,11 @@ mod benches { [pallet_bridge_grandpa, RococoFinality] [pallet_bridge_parachains, WithinRococo] [pallet_bridge_messages, WestendToRococo] + // Ethereum Bridge + [snowbridge_pallet_inbound_queue, EthereumInboundQueue] + [snowbridge_pallet_outbound_queue, EthereumOutboundQueue] + [snowbridge_pallet_system, EthereumSystem] + [snowbridge_pallet_ethereum_client, EthereumBeaconClient] ); } @@ -597,7 +634,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -701,6 +738,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::WestendLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::WestendLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -759,6 +850,22 @@ impl_runtime_apis! { } } + impl snowbridge_outbound_queue_runtime_api::OutboundQueueApi for Runtime { + fn prove_message(leaf_index: u64) -> Option { + snowbridge_pallet_outbound_queue::api::prove_message::(leaf_index) + } + + fn calculate_fee(command: Command, parameters: Option>) -> Fee { + snowbridge_pallet_outbound_queue::api::calculate_fee::(command, parameters) + } + } + + impl snowbridge_system_runtime_api::ControlApi for Runtime { + fn agent_id(location: VersionedLocation) -> Option { + snowbridge_pallet_system::api::agent_id::(location) + } + } + #[cfg(feature = "try-runtime")] impl frame_try_runtime::TryRuntime for Runtime { fn on_runtime_upgrade(checks: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) { @@ -817,7 +924,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -859,7 +966,7 @@ impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(Assets, u32, Location, Box)> { + ) -> Option<(Assets, u32, Location, alloc::boxed::Box)> { // BH only supports teleports to system parachain. // Relay/native token can be teleported between BH and Relay. let native_location = Parent.into(); @@ -982,7 +1089,7 @@ impl_runtime_apis! { // save XCM version for remote bridge hub let _ = PolkadotXcm::force_xcm_version( RuntimeOrigin::root(), - Box::new(bridge_to_rococo_config::BridgeHubRococoLocation::get()), + alloc::boxed::Box::new(bridge_to_rococo_config::BridgeHubRococoLocation::get()), XCM_VERSION, ).map_err(|e| { log::error!( @@ -1029,7 +1136,8 @@ impl_runtime_apis! { impl BridgeMessagesConfig for Runtime { fn is_relayer_rewarded(relayer: &Self::AccountId) -> bool { let bench_lane_id = >::bench_lane_id(); - let bridged_chain_id = bridge_to_rococo_config::BridgeHubRococoChainId::get(); + use bp_runtime::Chain; + let bridged_chain_id =>::BridgedChain::ID; pallet_bridge_relayers::Pallet::::relayer_reward( relayer, bp_relayers::RewardsAccountParams::new( @@ -1049,7 +1157,7 @@ impl_runtime_apis! { prepare_message_proof_from_parachain::< Runtime, bridge_to_rococo_config::BridgeGrandpaRococoInstance, - bridge_to_rococo_config::WithBridgeHubRococoMessageBridge, + bridge_to_rococo_config::WithBridgeHubRococoMessagesInstance, >(params, generate_xcm_builder_bridge_message_sample([GlobalConsensus(Westend), Parachain(42)].into())) } @@ -1059,7 +1167,7 @@ impl_runtime_apis! { prepare_message_delivery_proof_from_parachain::< Runtime, bridge_to_rococo_config::BridgeGrandpaRococoInstance, - bridge_to_rococo_config::WithBridgeHubRococoMessageBridge, + bridge_to_rococo_config::WithBridgeHubRococoMessagesInstance, >(params) } @@ -1085,7 +1193,7 @@ impl_runtime_apis! { fn prepare_parachain_heads_proof( parachains: &[bp_polkadot_core::parachains::ParaId], parachain_head_size: u32, - proof_size: bp_runtime::StorageProofSize, + proof_params: bp_runtime::UnverifiedStorageProofParams, ) -> ( pallet_bridge_parachains::RelayBlockNumber, pallet_bridge_parachains::RelayBlockHash, @@ -1095,7 +1203,7 @@ impl_runtime_apis! { prepare_parachain_heads_proof::( parachains, parachain_head_size, - proof_size, + proof_params, ) } } @@ -1173,39 +1281,40 @@ mod tests { use bp_polkadot_core::SuffixedCommonSignedExtensionExt; sp_io::TestExternalities::default().execute_with(|| { - frame_system::BlockHash::::insert(BlockNumber::zero(), Hash::default()); - let payload: SignedExtra = ( - frame_system::CheckNonZeroSender::new(), - frame_system::CheckSpecVersion::new(), - frame_system::CheckTxVersion::new(), - frame_system::CheckGenesis::new(), - frame_system::CheckEra::from(Era::Immortal), - frame_system::CheckNonce::from(10), - frame_system::CheckWeight::new(), - pallet_transaction_payment::ChargeTransactionPayment::from(10), - BridgeRejectObsoleteHeadersAndMessages, - ( - bridge_to_rococo_config::OnBridgeHubWestendRefundBridgeHubRococoMessages::default(), - ), - cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new() - ); - - { - let bh_indirect_payload = bp_bridge_hub_westend::SignedExtension::from_params( - VERSION.spec_version, - VERSION.transaction_version, - bp_runtime::TransactionEra::Immortal, - System::block_hash(BlockNumber::zero()), - 10, - 10, - (((), ()), ((), ())), - ); - assert_eq!(payload.encode(), bh_indirect_payload.encode()); - assert_eq!( - payload.additional_signed().unwrap().encode(), - bh_indirect_payload.additional_signed().unwrap().encode() - ) - } - }); + frame_system::BlockHash::::insert(BlockNumber::zero(), Hash::default()); + let payload: SignedExtra = ( + frame_system::CheckNonZeroSender::new(), + frame_system::CheckSpecVersion::new(), + frame_system::CheckTxVersion::new(), + frame_system::CheckGenesis::new(), + frame_system::CheckEra::from(Era::Immortal), + frame_system::CheckNonce::from(10), + frame_system::CheckWeight::new(), + pallet_transaction_payment::ChargeTransactionPayment::from(10), + BridgeRejectObsoleteHeadersAndMessages, + ( + bridge_to_rococo_config::OnBridgeHubWestendRefundBridgeHubRococoMessages::default(), + ), + cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::new(false), + ); + + { + let bh_indirect_payload = bp_bridge_hub_westend::SignedExtension::from_params( + VERSION.spec_version, + VERSION.transaction_version, + bp_runtime::TransactionEra::Immortal, + System::block_hash(BlockNumber::zero()), + 10, + 10, + (((), ()), ((), ())), + ); + assert_eq!(payload.encode().split_last().unwrap().1, bh_indirect_payload.encode()); + assert_eq!( + payload.additional_signed().unwrap().encode().split_last().unwrap().1, + bh_indirect_payload.additional_signed().unwrap().encode() + ) + } + }); } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/cumulus_pallet_parachain_system.rs index dc480c391636a92aad6e303a515524b5ce7ff2b1..8fcd7b10d931b03ec4cd9cc063e0bacf8878ed16 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/cumulus_pallet_parachain_system.rs @@ -47,7 +47,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/mod.rs index 245daaf8ed91b69db2a604c51e394c2d768b1c26..9b7f7188782faedc0af4186511fd3ab5e1b02685 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/mod.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/mod.rs @@ -43,6 +43,11 @@ pub mod paritydb_weights; pub mod rocksdb_weights; pub mod xcm; +pub mod snowbridge_pallet_ethereum_client; +pub mod snowbridge_pallet_inbound_queue; +pub mod snowbridge_pallet_outbound_queue; +pub mod snowbridge_pallet_system; + pub use block_weights::constants::BlockExecutionWeight; pub use extrinsic_weights::constants::ExtrinsicBaseWeight; pub use rocksdb_weights::constants::RocksDbWeight; diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs index e87ed668dfc7acb1a92a7535d92392a272370277..fa7efc260489bead50ba63969571e018248ddefe 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_grandpa.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_grandpa` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-13, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-11, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-yaoqqom-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -48,32 +48,54 @@ use core::marker::PhantomData; /// Weight functions for `pallet_bridge_grandpa`. pub struct WeightInfo(PhantomData); impl pallet_bridge_grandpa::WeightInfo for WeightInfo { + /// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:0) + /// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoGrandpa::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoGrandpa::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoGrandpa::BestFinalized` (r:1 w:1) /// Proof: `BridgeRococoGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`) - /// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:0) - /// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::FreeHeadersRemaining` (r:1 w:0) + /// Proof: `BridgeRococoGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoGrandpa::ImportedHashesPointer` (r:1 w:1) /// Proof: `BridgeRococoGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoGrandpa::ImportedHashes` (r:1 w:1) /// Proof: `BridgeRococoGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoGrandpa::ImportedHeaders` (r:0 w:2) /// Proof: `BridgeRococoGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) - /// The range of component `p` is `[1, 838]`. + /// The range of component `p` is `[1, 168]`. /// The range of component `v` is `[50, 100]`. fn submit_finality_proof(p: u32, v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `231 + p * (60 ±0)` + // Measured: `268 + p * (60 ±0)` // Estimated: `51735` - // Minimum execution time: 303_549_000 picoseconds. - Weight::from_parts(306_232_000, 0) + // Minimum execution time: 294_381_000 picoseconds. + Weight::from_parts(21_868_057, 0) .saturating_add(Weight::from_parts(0, 51735)) - // Standard Error: 4_641 - .saturating_add(Weight::from_parts(55_196_301, 0).saturating_mul(p.into())) - // Standard Error: 35_813 - .saturating_add(Weight::from_parts(70_584, 0).saturating_mul(v.into())) - .saturating_add(T::DbWeight::get().reads(5)) + // Standard Error: 14_649 + .saturating_add(Weight::from_parts(40_681_012, 0).saturating_mul(p.into())) + // Standard Error: 48_883 + .saturating_add(Weight::from_parts(2_466_672, 0).saturating_mul(v.into())) + .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(5)) } + /// Storage: `BridgeRococoGrandpa::CurrentAuthoritySet` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::CurrentAuthoritySet` (`max_values`: Some(1), `max_size`: Some(50250), added: 50745, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::ImportedHashesPointer` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::ImportedHashesPointer` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::ImportedHashes` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::ImportedHashes` (`max_values`: Some(1024), `max_size`: Some(36), added: 1521, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::BestFinalized` (r:0 w:1) + /// Proof: `BridgeRococoGrandpa::BestFinalized` (`max_values`: Some(1), `max_size`: Some(36), added: 531, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::ImportedHeaders` (r:0 w:2) + /// Proof: `BridgeRococoGrandpa::ImportedHeaders` (`max_values`: Some(1024), `max_size`: Some(68), added: 1553, mode: `MaxEncodedLen`) + fn force_set_pallet_state() -> Weight { + // Proof Size summary in bytes: + // Measured: `282` + // Estimated: `51735` + // Minimum execution time: 96_441_000 picoseconds. + Weight::from_parts(110_957_000, 0) + .saturating_add(Weight::from_parts(0, 51735)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(6)) + } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_messages.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_messages.rs index 305a8726fa1bb67da8ac239d9f2b66e795582fe5..1033387b527e415732dda8f61224064cba07c64a 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_messages.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_messages.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_messages` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-13, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-04, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -51,7 +51,7 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) @@ -60,10 +60,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `502` + // Measured: `522` // Estimated: `52645` - // Minimum execution time: 40_646_000 picoseconds. - Weight::from_parts(41_754_000, 0) + // Minimum execution time: 40_289_000 picoseconds. + Weight::from_parts(42_150_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -71,27 +71,30 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) /// Proof: `BridgeRococoMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - fn receive_two_messages_proof() -> Weight { + /// The range of component `n` is `[1, 4076]`. + fn receive_n_messages_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `502` + // Measured: `522` // Estimated: `52645` - // Minimum execution time: 50_898_000 picoseconds. - Weight::from_parts(52_743_000, 0) + // Minimum execution time: 40_572_000 picoseconds. + Weight::from_parts(41_033_000, 0) .saturating_add(Weight::from_parts(0, 52645)) + // Standard Error: 12_000 + .saturating_add(Weight::from_parts(11_710_588, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) @@ -100,10 +103,10 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn receive_single_message_proof_with_outbound_lane_state() -> Weight { // Proof Size summary in bytes: - // Measured: `502` + // Measured: `522` // Estimated: `52645` - // Minimum execution time: 45_848_000 picoseconds. - Weight::from_parts(47_036_000, 0) + // Minimum execution time: 46_655_000 picoseconds. + Weight::from_parts(49_576_000, 0) .saturating_add(Weight::from_parts(0, 52645)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) @@ -111,37 +114,24 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) /// Proof: `BridgeRococoMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_1_kb() -> Weight { - // Proof Size summary in bytes: - // Measured: `433` - // Estimated: `52645` - // Minimum execution time: 39_085_000 picoseconds. - Weight::from_parts(41_623_000, 0) - .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(1)) - } - /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) - /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) - /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:0) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) - /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) - /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) - /// Proof: `BridgeRococoMessages::InboundLanes` (`max_values`: None, `max_size`: Some(49180), added: 51655, mode: `MaxEncodedLen`) - fn receive_single_message_proof_16_kb() -> Weight { + /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) + /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `433` + // Measured: `522` // Estimated: `52645` - // Minimum execution time: 72_754_000 picoseconds. - Weight::from_parts(74_985_000, 0) + // Minimum execution time: 40_245_000 picoseconds. + Weight::from_parts(43_461_320, 0) .saturating_add(Weight::from_parts(0, 52645)) - .saturating_add(T::DbWeight::get().reads(4)) + // Standard Error: 21 + .saturating_add(Weight::from_parts(2_246, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) @@ -154,15 +144,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:1 w:1) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoMessages::OutboundMessages` (r:0 w:1) + /// Proof: `BridgeRococoMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_single_message() -> Weight { // Proof Size summary in bytes: - // Measured: `337` - // Estimated: `3802` - // Minimum execution time: 31_479_000 picoseconds. - Weight::from_parts(32_280_000, 0) - .saturating_add(Weight::from_parts(0, 3802)) + // Measured: `357` + // Estimated: `3822` + // Minimum execution time: 32_001_000 picoseconds. + Weight::from_parts(32_842_000, 0) + .saturating_add(Weight::from_parts(0, 3822)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -174,15 +166,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:1 w:1) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgeRococoMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { // Proof Size summary in bytes: - // Measured: `337` - // Estimated: `3802` - // Minimum execution time: 31_807_000 picoseconds. - Weight::from_parts(32_219_000, 0) - .saturating_add(Weight::from_parts(0, 3802)) + // Measured: `357` + // Estimated: `3822` + // Minimum execution time: 33_287_000 picoseconds. + Weight::from_parts(33_769_000, 0) + .saturating_add(Weight::from_parts(0, 3822)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) @@ -194,20 +188,22 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Proof: UNKNOWN KEY `0x6e0a18b62a1de81c5f519181cc611e18` (r:1 w:0) /// Storage: `BridgeRelayers::RelayerRewards` (r:2 w:2) /// Proof: `BridgeRelayers::RelayerRewards` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoMessages::OutboundMessages` (r:0 w:2) + /// Proof: `BridgeRococoMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { // Proof Size summary in bytes: - // Measured: `337` + // Measured: `357` // Estimated: `6086` - // Minimum execution time: 36_450_000 picoseconds. - Weight::from_parts(37_288_000, 0) + // Minimum execution time: 37_136_000 picoseconds. + Weight::from_parts(38_294_000, 0) .saturating_add(Weight::from_parts(0, 6086)) .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes(5)) } /// Storage: `BridgeRococoMessages::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoMessages::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::OutboundXcmpStatus` (r:1 w:1) - /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::OutboundXcmpStatus` (`max_values`: Some(1), `max_size`: Some(1282), added: 1777, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:1 w:0) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoMessages::InboundLanes` (r:1 w:1) @@ -215,7 +211,7 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainInfo::ParachainId` (r:1 w:0) /// Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `XcmpQueue::DeliveryFeeFactor` (r:1 w:0) - /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Proof: `XcmpQueue::DeliveryFeeFactor` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) @@ -225,17 +221,17 @@ impl pallet_bridge_messages::WeightInfo for WeightInfo< /// Storage: `ParachainSystem::RelevantMessagingState` (r:1 w:0) /// Proof: `ParachainSystem::RelevantMessagingState` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `XcmpQueue::OutboundXcmpMessages` (r:0 w:1) - /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `i` is `[128, 2048]`. - fn receive_single_message_proof_with_dispatch(i: u32, ) -> Weight { + /// Proof: `XcmpQueue::OutboundXcmpMessages` (`max_values`: None, `max_size`: Some(105506), added: 107981, mode: `MaxEncodedLen`) + /// The range of component `n` is `[1, 16384]`. + fn receive_single_n_bytes_message_proof_with_dispatch(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `633` + // Measured: `653` // Estimated: `52645` - // Minimum execution time: 67_047_000 picoseconds. - Weight::from_parts(68_717_105, 0) + // Minimum execution time: 55_942_000 picoseconds. + Weight::from_parts(60_615_769, 0) .saturating_add(Weight::from_parts(0, 52645)) - // Standard Error: 138 - .saturating_add(Weight::from_parts(8_056, 0).saturating_mul(i.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(7_225, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(4)) } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_parachains.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_parachains.rs index 9819bd4065411bec6799de3f2aa41c318f53a122..b4748f1417059e91e482c650f5046ef09b76a7af 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_parachains.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_parachains.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_parachains` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -56,18 +56,20 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeRococoParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) /// The range of component `p` is `[1, 2]`. fn submit_parachain_heads_with_n_parachains(_p: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `291` + // Measured: `315` // Estimated: `2543` - // Minimum execution time: 29_994_000 picoseconds. - Weight::from_parts(31_005_636, 0) + // Minimum execution time: 34_177_000 picoseconds. + Weight::from_parts(35_662_308, 0) .saturating_add(Weight::from_parts(0, 2543)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeRococoParachains::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoParachains::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) @@ -77,17 +79,19 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeRococoParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) fn submit_parachain_heads_with_1kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `291` + // Measured: `315` // Estimated: `2543` - // Minimum execution time: 31_425_000 picoseconds. - Weight::from_parts(32_163_000, 0) + // Minimum execution time: 35_975_000 picoseconds. + Weight::from_parts(36_510_000, 0) .saturating_add(Weight::from_parts(0, 2543)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `BridgeRococoParachains::PalletOperatingMode` (r:1 w:0) /// Proof: `BridgeRococoParachains::PalletOperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) @@ -97,16 +101,18 @@ impl pallet_bridge_parachains::WeightInfo for WeightInf /// Proof: `BridgeRococoParachains::ParasInfo` (`max_values`: Some(1), `max_size`: Some(60), added: 555, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHashes` (r:1 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHashes` (`max_values`: Some(64), `max_size`: Some(64), added: 1054, mode: `MaxEncodedLen`) + /// Storage: `BridgeRococoGrandpa::FreeHeadersRemaining` (r:1 w:1) + /// Proof: `BridgeRococoGrandpa::FreeHeadersRemaining` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `BridgeRococoParachains::ImportedParaHeads` (r:0 w:1) /// Proof: `BridgeRococoParachains::ImportedParaHeads` (`max_values`: Some(64), `max_size`: Some(196), added: 1186, mode: `MaxEncodedLen`) fn submit_parachain_heads_with_16kb_proof() -> Weight { // Proof Size summary in bytes: - // Measured: `291` + // Measured: `315` // Estimated: `2543` - // Minimum execution time: 60_062_000 picoseconds. - Weight::from_parts(61_201_000, 0) + // Minimum execution time: 62_837_000 picoseconds. + Weight::from_parts(63_562_000, 0) .saturating_add(Weight::from_parts(0, 2543)) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(4)) } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_relayers.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_relayers.rs index ed96f0cd87c9e73ee8c842ab9f4f5d60bf81c2ac..60d81dc3082a86ea3cea3951d4ed59cf9be8ed56 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_relayers.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_bridge_relayers.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_bridge_relayers` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -56,8 +56,8 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `207` // Estimated: `3593` - // Minimum execution time: 45_732_000 picoseconds. - Weight::from_parts(46_282_000, 0) + // Minimum execution time: 43_132_000 picoseconds. + Weight::from_parts(43_923_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -72,8 +72,8 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `61` // Estimated: `4714` - // Minimum execution time: 22_934_000 picoseconds. - Weight::from_parts(23_531_000, 0) + // Minimum execution time: 22_765_000 picoseconds. + Weight::from_parts(23_576_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -86,8 +86,8 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `160` // Estimated: `4714` - // Minimum execution time: 25_187_000 picoseconds. - Weight::from_parts(25_679_000, 0) + // Minimum execution time: 24_013_000 picoseconds. + Weight::from_parts(24_460_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) @@ -102,8 +102,8 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `263` // Estimated: `4714` - // Minimum execution time: 27_015_000 picoseconds. - Weight::from_parts(27_608_000, 0) + // Minimum execution time: 26_946_000 picoseconds. + Weight::from_parts(27_485_000, 0) .saturating_add(Weight::from_parts(0, 4714)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(3)) @@ -114,8 +114,8 @@ impl pallet_bridge_relayers::WeightInfo for WeightInfo< // Proof Size summary in bytes: // Measured: `6` // Estimated: `3538` - // Minimum execution time: 5_207_000 picoseconds. - Weight::from_parts(5_394_000, 0) + // Minimum execution time: 4_658_000 picoseconds. + Weight::from_parts(4_902_000, 0) .saturating_add(Weight::from_parts(0, 3538)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_message_queue.rs index 2fcd573ceb277116bda67180da8e0701593ab453..b6fee47d1435162a3e24dd204b896eb849a7e146 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/pallet_message_queue.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_ethereum_client.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_ethereum_client.rs new file mode 100644 index 0000000000000000000000000000000000000000..23e2a9cffb0b4f0f02a1df6fa0b13f5340de4d14 --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_ethereum_client.rs @@ -0,0 +1,120 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Autogenerated weights for `snowbridge_pallet_ethereum_client` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-06-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `Claras-MacBook-Pro-2.local`, CPU: `` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("bridge-hub-rococo-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/release/polkadot-parachain +// benchmark +// pallet +// --chain=bridge-hub-rococo-dev +// --pallet=snowbridge_pallet_ethereum_client +// --extrinsic +// * +// --wasm-execution=compiled +// --steps +// 50 +// --repeat +// 20 +// --output +// cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/snowbridge_pallet_ethereum_client.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `snowbridge_pallet_ethereum_client`. +pub struct WeightInfo(PhantomData); +impl snowbridge_pallet_ethereum_client::WeightInfo for WeightInfo { + /// Storage: `EthereumBeaconClient::FinalizedBeaconStateIndex` (r:1 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconStateIndex` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconStateMapping` (r:1 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconStateMapping` (`max_values`: None, `max_size`: Some(36), added: 2511, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:0 w:1) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::InitialCheckpointRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::InitialCheckpointRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:0 w:1) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:0 w:1) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:0 w:1) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + fn force_checkpoint() -> Weight { + // Proof Size summary in bytes: + // Measured: `76` + // Estimated: `3501` + // Minimum execution time: 67_553_000_000 picoseconds. + Weight::from_parts(68_677_000_000, 0) + .saturating_add(Weight::from_parts(0, 3501)) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(8)) + } + /// Storage: `EthereumBeaconClient::OperatingMode` (r:1 w:0) + /// Proof: `EthereumBeaconClient::OperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:1 w:0) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + fn submit() -> Weight { + // Proof Size summary in bytes: + // Measured: `92749` + // Estimated: `93857` + // Minimum execution time: 16_988_000_000 picoseconds. + Weight::from_parts(17_125_000_000, 0) + .saturating_add(Weight::from_parts(0, 93857)) + .saturating_add(T::DbWeight::get().reads(6)) + } + /// Storage: `EthereumBeaconClient::OperatingMode` (r:1 w:0) + /// Proof: `EthereumBeaconClient::OperatingMode` (`max_values`: Some(1), `max_size`: Some(1), added: 496, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::LatestFinalizedBlockRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::LatestFinalizedBlockRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::FinalizedBeaconState` (r:1 w:0) + /// Proof: `EthereumBeaconClient::FinalizedBeaconState` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::NextSyncCommittee` (r:1 w:1) + /// Proof: `EthereumBeaconClient::NextSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::CurrentSyncCommittee` (r:1 w:0) + /// Proof: `EthereumBeaconClient::CurrentSyncCommittee` (`max_values`: Some(1), `max_size`: Some(92372), added: 92867, mode: `MaxEncodedLen`) + /// Storage: `EthereumBeaconClient::ValidatorsRoot` (r:1 w:0) + /// Proof: `EthereumBeaconClient::ValidatorsRoot` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + fn submit_with_sync_committee() -> Weight { + // Proof Size summary in bytes: + // Measured: `92749` + // Estimated: `93857` + // Minimum execution time: 84_553_000_000 picoseconds. + Weight::from_parts(87_459_000_000, 0) + .saturating_add(Weight::from_parts(0, 93857)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_inbound_queue.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_inbound_queue.rs new file mode 100644 index 0000000000000000000000000000000000000000..153c1d363be10888601dfa66bdcdf5e88af57001 --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_inbound_queue.rs @@ -0,0 +1,69 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Autogenerated weights for `snowbridge_pallet_inbound_queue` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-09-06, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `macbook pro 14 m2`, CPU: `m2-arm64` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/polkadot-parachain +// benchmark +// pallet +// --chain=bridge-hub-rococo-dev +// --pallet=snowbridge_inbound_queue +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --steps +// 50 +// --repeat +// 20 +// --output +// ./parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/snowbridge_inbound_queue.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `snowbridge_pallet_inbound_queue`. +pub struct WeightInfo(PhantomData); +impl snowbridge_pallet_inbound_queue::WeightInfo for WeightInfo { + /// Storage: EthereumInboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumInboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: EthereumBeaconClient ExecutionHeaders (r:1 w:0) + /// Proof: EthereumBeaconClient ExecutionHeaders (max_values: None, max_size: Some(136), added: 2611, mode: MaxEncodedLen) + /// Storage: EthereumInboundQueue Nonce (r:1 w:1) + /// Proof: EthereumInboundQueue Nonce (max_values: None, max_size: Some(20), added: 2495, mode: MaxEncodedLen) + /// Storage: System Account (r:1 w:1) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + fn submit() -> Weight { + // Proof Size summary in bytes: + // Measured: `800` + // Estimated: `7200` + // Minimum execution time: 200_000_000 picoseconds. + Weight::from_parts(200_000_000, 0) + .saturating_add(Weight::from_parts(0, 7200)) + .saturating_add(T::DbWeight::get().reads(9)) + .saturating_add(T::DbWeight::get().writes(6)) + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_outbound_queue.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_outbound_queue.rs new file mode 100644 index 0000000000000000000000000000000000000000..8adcef076e00add856e387b1a875116f5e8f0208 --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_outbound_queue.rs @@ -0,0 +1,87 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Autogenerated weights for `snowbridge_outbound_queue` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-20, STEPS: `2`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `192.168.1.13`, CPU: `` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 + +// Executed Command: +// ../target/release/polkadot-parachain +// benchmark +// pallet +// --chain=bridge-hub-rococo-dev +// --pallet=snowbridge_outbound_queue +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --output +// ../parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/snowbridge_outbound_queue.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `snowbridge_outbound_queue`. +pub struct WeightInfo(PhantomData); +impl snowbridge_pallet_outbound_queue::WeightInfo for WeightInfo { + /// Storage: EthereumOutboundQueue MessageLeaves (r:1 w:1) + /// Proof Skipped: EthereumOutboundQueue MessageLeaves (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: EthereumOutboundQueue PendingHighPriorityMessageCount (r:1 w:1) + /// Proof: EthereumOutboundQueue PendingHighPriorityMessageCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue Nonce (r:1 w:1) + /// Proof: EthereumOutboundQueue Nonce (max_values: None, max_size: Some(20), added: 2495, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue Messages (r:1 w:1) + /// Proof Skipped: EthereumOutboundQueue Messages (max_values: Some(1), max_size: None, mode: Measured) + fn do_process_message() -> Weight { + // Proof Size summary in bytes: + // Measured: `42` + // Estimated: `3485` + // Minimum execution time: 39_000_000 picoseconds. + Weight::from_parts(39_000_000, 3485) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(4_u64)) + } + /// Storage: EthereumOutboundQueue MessageLeaves (r:1 w:0) + /// Proof Skipped: EthereumOutboundQueue MessageLeaves (max_values: Some(1), max_size: None, mode: Measured) + /// Storage: System Digest (r:1 w:1) + /// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured) + fn commit() -> Weight { + // Proof Size summary in bytes: + // Measured: `1094` + // Estimated: `2579` + // Minimum execution time: 28_000_000 picoseconds. + Weight::from_parts(28_000_000, 2579) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + + fn commit_single() -> Weight { + // Proof Size summary in bytes: + // Measured: `1094` + // Estimated: `2579` + // Minimum execution time: 9_000_000 picoseconds. + Weight::from_parts(9_000_000, 1586) + .saturating_add(T::DbWeight::get().reads(2_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_system.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_system.rs new file mode 100644 index 0000000000000000000000000000000000000000..c6c188e323af84d11ba396cb9ab4e97983bac33c --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/snowbridge_pallet_system.rs @@ -0,0 +1,256 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Autogenerated weights for `snowbridge_system` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-10-09, STEPS: `2`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `crake.local`, CPU: `` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 + +// Executed Command: +// target/release/polkadot-parachain +// benchmark +// pallet +// --chain +// bridge-hub-rococo-dev +// --pallet=snowbridge_pallet_system +// --extrinsic=* +// --execution=wasm +// --wasm-execution=compiled +// --output +// parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/snowbridge_pallet_system.rs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `snowbridge_system`. +pub struct WeightInfo(PhantomData); +impl snowbridge_pallet_system::WeightInfo for WeightInfo { + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:1) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn upgrade() -> Weight { + // Proof Size summary in bytes: + // Measured: `80` + // Estimated: `3517` + // Minimum execution time: 47_000_000 picoseconds. + Weight::from_parts(47_000_000, 0) + .saturating_add(Weight::from_parts(0, 3517)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: EthereumSystem Agents (r:1 w:1) + /// Proof: EthereumSystem Agents (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen) + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:1) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn create_agent() -> Weight { + // Proof Size summary in bytes: + // Measured: `187` + // Estimated: `6196` + // Minimum execution time: 87_000_000 picoseconds. + Weight::from_parts(87_000_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(6)) + } + /// Storage: System Account (r:2 w:2) + /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + /// Storage: EthereumSystem Agents (r:1 w:0) + /// Proof: EthereumSystem Agents (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen) + /// Storage: EthereumSystem Channels (r:1 w:1) + /// Proof: EthereumSystem Channels (max_values: None, max_size: Some(12), added: 2487, mode: MaxEncodedLen) + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:1 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn create_channel() -> Weight { + // Proof Size summary in bytes: + // Measured: `602` + // Estimated: `69050` + // Minimum execution time: 84_000_000 picoseconds. + Weight::from_parts(84_000_000, 0) + .saturating_add(Weight::from_parts(0, 69050)) + .saturating_add(T::DbWeight::get().reads(8)) + .saturating_add(T::DbWeight::get().writes(5)) + } + /// Storage: EthereumSystem Channels (r:1 w:0) + /// Proof: EthereumSystem Channels (max_values: None, max_size: Some(12), added: 2487, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:2 w:2) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:0) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn update_channel() -> Weight { + // Proof Size summary in bytes: + // Measured: `256` + // Estimated: `6044` + // Minimum execution time: 41_000_000 picoseconds. + Weight::from_parts(41_000_000, 0) + .saturating_add(Weight::from_parts(0, 6044)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: EthereumSystem Channels (r:1 w:0) + /// Proof: EthereumSystem Channels (max_values: None, max_size: Some(12), added: 2487, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:2 w:2) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:0) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn force_update_channel() -> Weight { + // Proof Size summary in bytes: + // Measured: `256` + // Estimated: `6044` + // Minimum execution time: 41_000_000 picoseconds. + Weight::from_parts(41_000_000, 0) + .saturating_add(Weight::from_parts(0, 6044)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:1) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn set_operating_mode() -> Weight { + // Proof Size summary in bytes: + // Measured: `80` + // Estimated: `3517` + // Minimum execution time: 30_000_000 picoseconds. + Weight::from_parts(30_000_000, 0) + .saturating_add(Weight::from_parts(0, 3517)) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: EthereumSystem Agents (r:1 w:0) + /// Proof: EthereumSystem Agents (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:2 w:2) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:0) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn transfer_native_from_agent() -> Weight { + // Proof Size summary in bytes: + // Measured: `252` + // Estimated: `6044` + // Minimum execution time: 43_000_000 picoseconds. + Weight::from_parts(43_000_000, 0) + .saturating_add(Weight::from_parts(0, 6044)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: EthereumSystem Agents (r:1 w:0) + /// Proof: EthereumSystem Agents (max_values: None, max_size: Some(40), added: 2515, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:2 w:2) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:0) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn force_transfer_native_from_agent() -> Weight { + // Proof Size summary in bytes: + // Measured: `252` + // Estimated: `6044` + // Minimum execution time: 42_000_000 picoseconds. + Weight::from_parts(42_000_000, 0) + .saturating_add(Weight::from_parts(0, 6044)) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:1) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn set_token_transfer_fees() -> Weight { + // Proof Size summary in bytes: + // Measured: `80` + // Estimated: `3517` + // Minimum execution time: 31_000_000 picoseconds. + Weight::from_parts(42_000_000, 3517) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) + } + + /// Storage: ParachainInfo ParachainId (r:1 w:0) + /// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) + /// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0) + /// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen) + /// Storage: MessageQueue BookStateFor (r:1 w:1) + /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen) + /// Storage: MessageQueue ServiceHead (r:1 w:1) + /// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen) + /// Storage: MessageQueue Pages (r:0 w:1) + /// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen) + fn set_pricing_parameters() -> Weight { + // Proof Size summary in bytes: + // Measured: `80` + // Estimated: `3517` + // Minimum execution time: 31_000_000 picoseconds. + Weight::from_parts(42_000_000, 3517) + .saturating_add(T::DbWeight::get().reads(4_u64)) + .saturating_add(T::DbWeight::get().writes(3_u64)) + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/mod.rs index e8950678b40fd7b4e7afca8c998bc20c619e65ef..3961cc6d5cdd63a67b5ea4cbc805448e01f98939 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/mod.rs @@ -18,11 +18,11 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use codec::Encode; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 295abd481d7dc6decd39032bf6b0972cdc7ccf20..5bd1d1680aa1ef596940b16f3e5df911647b15f1 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -16,11 +16,11 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-vmdtonbz-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` -//! WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-rococo-dev"), DB CACHE: 1024 +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-westend-dev"), DB CACHE: 1024 // Executed Command: // target/production/polkadot-parachain @@ -33,17 +33,17 @@ // --heap-pages=4096 // --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json // --pallet=pallet_xcm_benchmarks::fungible -// --chain=bridge-hub-rococo-dev +// --chain=bridge-hub-westend-dev // --header=./cumulus/file_header.txt // --template=./cumulus/templates/xcm-bench-template.hbs -// --output=./cumulus/parachains/runtimes/bridge-hubs/bridge-hub-rococo/src/weights/xcm/ +// --output=./cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/ #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -54,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 19_037_000 picoseconds. - Weight::from_parts(19_602_000, 3593) + // Minimum execution time: 30_218_000 picoseconds. + Weight::from_parts(30_783_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,15 +65,13 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `153` // Estimated: `6196` - // Minimum execution time: 43_115_000 picoseconds. - Weight::from_parts(43_897_000, 6196) + // Minimum execution time: 42_631_000 picoseconds. + Weight::from_parts(43_127_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } // Storage: `System::Account` (r:3 w:3) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - // Storage: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) - // Proof: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -90,11 +88,11 @@ impl WeightInfo { // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn transfer_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `294` + // Measured: `260` // Estimated: `8799` - // Minimum execution time: 90_267_000 picoseconds. - Weight::from_parts(91_460_000, 8799) - .saturating_add(T::DbWeight::get().reads(11)) + // Minimum execution time: 100_978_000 picoseconds. + Weight::from_parts(102_819_000, 8799) + .saturating_add(T::DbWeight::get().reads(10)) .saturating_add(T::DbWeight::get().writes(5)) } // Storage: `Benchmark::Override` (r:0 w:0) @@ -106,8 +104,6 @@ impl WeightInfo { // Minimum execution time: 18_446_744_073_709_551_000 picoseconds. Weight::from_parts(18_446_744_073_709_551_000, 0) } - // Storage: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) - // Proof: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -126,19 +122,19 @@ impl WeightInfo { // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn initiate_reserve_withdraw() -> Weight { // Proof Size summary in bytes: - // Measured: `242` + // Measured: `208` // Estimated: `6196` - // Minimum execution time: 60_477_000 picoseconds. - Weight::from_parts(61_314_000, 6196) - .saturating_add(T::DbWeight::get().reads(10)) + // Minimum execution time: 71_533_000 picoseconds. + Weight::from_parts(72_922_000, 6196) + .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } pub fn receive_teleported_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_996_000 picoseconds. - Weight::from_parts(3_107_000, 0) + // Minimum execution time: 2_863_000 picoseconds. + Weight::from_parts(2_997_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -146,15 +142,11 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `52` // Estimated: `3593` - // Minimum execution time: 18_907_000 picoseconds. - Weight::from_parts(19_475_000, 3593) + // Minimum execution time: 23_763_000 picoseconds. + Weight::from_parts(24_438_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: `System::Account` (r:2 w:2) - // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - // Storage: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) - // Proof: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -165,21 +157,21 @@ impl WeightInfo { // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn deposit_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `193` + // Measured: `159` // Estimated: `6196` - // Minimum execution time: 59_143_000 picoseconds. - Weight::from_parts(60_316_000, 6196) - .saturating_add(T::DbWeight::get().reads(10)) + // Minimum execution time: 78_182_000 picoseconds. + Weight::from_parts(79_575_000, 6196) + .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } - // Storage: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) - // Proof: UNKNOWN KEY `0x48297505634037ef48c848c99c0b1f1b` (r:1 w:0) // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) // Storage: `ParachainSystem::UpwardDeliveryFeeFactor` (r:1 w:0) @@ -198,11 +190,11 @@ impl WeightInfo { // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn initiate_teleport() -> Weight { // Proof Size summary in bytes: - // Measured: `141` - // Estimated: `3606` - // Minimum execution time: 44_459_000 picoseconds. - Weight::from_parts(45_365_000, 3606) - .saturating_add(T::DbWeight::get().reads(9)) + // Measured: `107` + // Estimated: `3593` + // Minimum execution time: 46_767_000 picoseconds. + Weight::from_parts(47_823_000, 3593) + .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(3)) } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index 9281a880c7e1266d65d29436ca88e51e896c0363..ba434ff29629ff89a92d6ea663e5fcf8184d102f 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::generic` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-12, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-itmxxexx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-7wrmsoux-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("bridge-hub-westend-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); @@ -68,8 +68,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `208` // Estimated: `6196` - // Minimum execution time: 61_577_000 picoseconds. - Weight::from_parts(63_216_000, 6196) + // Minimum execution time: 58_505_000 picoseconds. + Weight::from_parts(60_437_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -77,8 +77,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_019_000 picoseconds. - Weight::from_parts(2_146_000, 0) + // Minimum execution time: 510_000 picoseconds. + Weight::from_parts(569_000, 0) } // Storage: `PolkadotXcm::Queries` (r:1 w:0) // Proof: `PolkadotXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -86,58 +86,58 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `32` // Estimated: `3497` - // Minimum execution time: 7_473_000 picoseconds. - Weight::from_parts(7_784_000, 3497) + // Minimum execution time: 5_597_000 picoseconds. + Weight::from_parts(5_884_000, 3497) .saturating_add(T::DbWeight::get().reads(1)) } pub fn transact() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 8_385_000 picoseconds. - Weight::from_parts(8_768_000, 0) + // Minimum execution time: 5_320_000 picoseconds. + Weight::from_parts(5_594_000, 0) } pub fn refund_surplus() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_181_000 picoseconds. - Weight::from_parts(2_304_000, 0) + // Minimum execution time: 1_164_000 picoseconds. + Weight::from_parts(1_227_000, 0) } pub fn set_error_handler() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_858_000 picoseconds. - Weight::from_parts(1_919_000, 0) + // Minimum execution time: 528_000 picoseconds. + Weight::from_parts(586_000, 0) } pub fn set_appendix() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_855_000 picoseconds. - Weight::from_parts(1_979_000, 0) + // Minimum execution time: 509_000 picoseconds. + Weight::from_parts(571_000, 0) } pub fn clear_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_823_000 picoseconds. - Weight::from_parts(1_890_000, 0) + // Minimum execution time: 511_000 picoseconds. + Weight::from_parts(546_000, 0) } pub fn descend_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_407_000 picoseconds. - Weight::from_parts(2_507_000, 0) + // Minimum execution time: 560_000 picoseconds. + Weight::from_parts(600_000, 0) } pub fn clear_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_838_000 picoseconds. - Weight::from_parts(1_894_000, 0) + // Minimum execution time: 514_000 picoseconds. + Weight::from_parts(558_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -159,8 +159,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `208` // Estimated: `6196` - // Minimum execution time: 54_847_000 picoseconds. - Weight::from_parts(55_742_000, 6196) + // Minimum execution time: 55_871_000 picoseconds. + Weight::from_parts(57_172_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -170,8 +170,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `90` // Estimated: `3555` - // Minimum execution time: 10_614_000 picoseconds. - Weight::from_parts(11_344_000, 3555) + // Minimum execution time: 8_487_000 picoseconds. + Weight::from_parts(8_800_000, 3555) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -179,8 +179,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_826_000 picoseconds. - Weight::from_parts(1_899_000, 0) + // Minimum execution time: 528_000 picoseconds. + Weight::from_parts(569_000, 0) } // Storage: `PolkadotXcm::VersionNotifyTargets` (r:1 w:1) // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -200,8 +200,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `38` // Estimated: `3503` - // Minimum execution time: 22_312_000 picoseconds. - Weight::from_parts(22_607_000, 3503) + // Minimum execution time: 19_803_000 picoseconds. + Weight::from_parts(20_368_000, 3503) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -211,44 +211,44 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_728_000 picoseconds. - Weight::from_parts(3_914_000, 0) + // Minimum execution time: 2_185_000 picoseconds. + Weight::from_parts(2_332_000, 0) .saturating_add(T::DbWeight::get().writes(1)) } pub fn burn_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_054_000 picoseconds. - Weight::from_parts(3_140_000, 0) + // Minimum execution time: 822_000 picoseconds. + Weight::from_parts(928_000, 0) } pub fn expect_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_996_000 picoseconds. - Weight::from_parts(2_148_000, 0) + // Minimum execution time: 603_000 picoseconds. + Weight::from_parts(643_000, 0) } pub fn expect_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_008_000 picoseconds. - Weight::from_parts(2_077_000, 0) + // Minimum execution time: 503_000 picoseconds. + Weight::from_parts(580_000, 0) } pub fn expect_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_837_000 picoseconds. - Weight::from_parts(1_913_000, 0) + // Minimum execution time: 534_000 picoseconds. + Weight::from_parts(577_000, 0) } pub fn expect_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_052_000 picoseconds. - Weight::from_parts(2_120_000, 0) + // Minimum execution time: 694_000 picoseconds. + Weight::from_parts(745_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -270,8 +270,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `208` // Estimated: `6196` - // Minimum execution time: 58_725_000 picoseconds. - Weight::from_parts(60_271_000, 6196) + // Minimum execution time: 61_083_000 picoseconds. + Weight::from_parts(62_214_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -279,8 +279,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_570_000 picoseconds. - Weight::from_parts(4_707_000, 0) + // Minimum execution time: 3_261_000 picoseconds. + Weight::from_parts(3_483_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -302,8 +302,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `208` // Estimated: `6196` - // Minimum execution time: 54_903_000 picoseconds. - Weight::from_parts(55_711_000, 6196) + // Minimum execution time: 56_270_000 picoseconds. + Weight::from_parts(57_443_000, 6196) .saturating_add(T::DbWeight::get().reads(9)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -311,22 +311,22 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_872_000 picoseconds. - Weight::from_parts(1_938_000, 0) + // Minimum execution time: 565_000 picoseconds. + Weight::from_parts(628_000, 0) } pub fn set_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_836_000 picoseconds. - Weight::from_parts(1_903_000, 0) + // Minimum execution time: 496_000 picoseconds. + Weight::from_parts(563_000, 0) } pub fn clear_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_847_000 picoseconds. - Weight::from_parts(1_900_000, 0) + // Minimum execution time: 518_000 picoseconds. + Weight::from_parts(557_000, 0) } // Storage: `ParachainInfo::ParachainId` (r:1 w:0) // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -339,16 +339,16 @@ impl WeightInfo { // Storage: `BridgeRococoMessages::OutboundLanesCongestedSignals` (r:1 w:0) // Proof: `BridgeRococoMessages::OutboundLanesCongestedSignals` (`max_values`: Some(1), `max_size`: Some(21), added: 516, mode: `MaxEncodedLen`) // Storage: `BridgeRococoMessages::OutboundMessages` (r:0 w:1) - // Proof: `BridgeRococoMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(2621472), added: 2623947, mode: `MaxEncodedLen`) + // Proof: `BridgeRococoMessages::OutboundMessages` (`max_values`: None, `max_size`: Some(65568), added: 68043, mode: `MaxEncodedLen`) /// The range of component `x` is `[1, 1000]`. pub fn export_message(x: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `225` // Estimated: `6165` - // Minimum execution time: 41_750_000 picoseconds. - Weight::from_parts(43_496_915, 6165) - // Standard Error: 623 - .saturating_add(Weight::from_parts(457_907, 0).saturating_mul(x.into())) + // Minimum execution time: 36_288_000 picoseconds. + Weight::from_parts(37_707_751, 6165) + // Standard Error: 124 + .saturating_add(Weight::from_parts(51_290, 0).saturating_mul(x.into())) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -356,14 +356,14 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_826_000 picoseconds. - Weight::from_parts(1_911_000, 0) + // Minimum execution time: 485_000 picoseconds. + Weight::from_parts(540_000, 0) } pub fn unpaid_execution() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_967_000 picoseconds. - Weight::from_parts(2_096_000, 0) + // Minimum execution time: 542_000 picoseconds. + Weight::from_parts(586_000, 0) } } diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/xcm_config.rs index c2ca8e47f2a61cf6d66613daa205caddafe192b0..81705ee2dc94c9095fba3d04dc17ff1c64285185 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/src/xcm_config.rs @@ -35,19 +35,24 @@ use parachains_common::{ }; use polkadot_parachain_primitives::primitives::Sibling; use polkadot_runtime_common::xcm_sender::ExponentialPrice; +use snowbridge_runtime_common::XcmExportFeeToSibling; use sp_runtime::traits::AccountIdConversion; +use sp_std::marker::PhantomData; +use testnet_parachains_constants::westend::snowbridge::EthereumNetwork; use xcm::latest::prelude::*; use xcm_builder::{ AccountId32Aliases, AllowExplicitUnpaidExecutionFrom, AllowHrmpNotificationsFromRelayChain, AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FrameTransactionalProcessor, - FungibleAdapter, IsConcrete, ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, - SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, - SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, - UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + FungibleAdapter, HandleFee, IsConcrete, ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, + SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, + SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, + TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, +}; +use xcm_executor::{ + traits::{FeeManager, FeeReason, FeeReason::Export}, + XcmExecutor, }; -use xcm_executor::XcmExecutor; parameter_types! { pub const WestendLocation: Location = Location::parent(); @@ -193,11 +198,24 @@ impl xcm_executor::Config for XcmConfig { type SubscriptionService = PolkadotXcm; type PalletInstancesInfo = AllPalletsWithSystem; type MaxAssetsIntoHolding = MaxAssetsIntoHolding; - type FeeManager = XcmFeeManagerFromComponents< + type FeeManager = XcmFeeManagerFromComponentsBridgeHub< WaivedLocations, - XcmFeeToAccount, + ( + XcmExportFeeToSibling< + bp_westend::Balance, + AccountId, + WestendLocation, + EthereumNetwork, + Self::AssetTransactor, + crate::EthereumOutboundQueue, + >, + SendXcmFeeToAccount, + ), >; - type MessageExporter = (crate::bridge_to_rococo_config::ToBridgeHubRococoHaulBlobExporter,); + type MessageExporter = ( + crate::bridge_to_rococo_config::ToBridgeHubRococoHaulBlobExporter, + crate::bridge_to_ethereum_config::SnowbridgeExporter, + ); type UniversalAliases = Nothing; type CallDispatcher = RuntimeCall; type SafeCallFilter = Everything; @@ -261,3 +279,24 @@ impl cumulus_pallet_xcm::Config for Runtime { type RuntimeEvent = RuntimeEvent; type XcmExecutor = XcmExecutor; } + +pub struct XcmFeeManagerFromComponentsBridgeHub( + PhantomData<(WaivedLocations, HandleFee)>, +); +impl, FeeHandler: HandleFee> FeeManager + for XcmFeeManagerFromComponentsBridgeHub +{ + fn is_waived(origin: Option<&Location>, fee_reason: FeeReason) -> bool { + let Some(loc) = origin else { return false }; + if let Export { network, destination: Here } = fee_reason { + if network == EthereumNetwork::get() { + return false + } + } + WaivedLocations::contains(loc) + } + + fn handle_fee(fee: Assets, context: Option<&XcmContext>, reason: FeeReason) { + FeeHandler::handle_fee(fee, context, reason); + } +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/snowbridge.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/snowbridge.rs new file mode 100644 index 0000000000000000000000000000000000000000..46a0fa7a664bb186d5e6f4f781a5e97f0ebc923f --- /dev/null +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/snowbridge.rs @@ -0,0 +1,202 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +#![cfg(test)] + +use bp_asset_hub_westend::ASSET_HUB_WESTEND_PARACHAIN_ID; +use bp_bridge_hub_westend::BRIDGE_HUB_WESTEND_PARACHAIN_ID; +use bp_polkadot_core::Signature; +use bridge_hub_westend_runtime::{ + bridge_to_rococo_config, xcm_config::XcmConfig, AllPalletsWithoutSystem, + BridgeRejectObsoleteHeadersAndMessages, Executive, MessageQueueServiceWeight, Runtime, + RuntimeCall, RuntimeEvent, SessionKeys, SignedExtra, UncheckedExtrinsic, +}; +use codec::{Decode, Encode}; +use cumulus_primitives_core::XcmError::{FailedToTransactAsset, NotHoldingFees}; +use frame_support::parameter_types; +use parachains_common::{AccountId, AuraId, Balance}; +use snowbridge_pallet_ethereum_client::WeightInfo; +use sp_core::H160; +use sp_keyring::AccountKeyring::Alice; +use sp_runtime::{ + generic::{Era, SignedPayload}, + AccountId32, +}; + +parameter_types! { + pub const DefaultBridgeHubEthereumBaseFee: Balance = 2_750_872_500_000; +} + +fn collator_session_keys() -> bridge_hub_test_utils::CollatorSessionKeys { + bridge_hub_test_utils::CollatorSessionKeys::new( + AccountId::from(Alice), + AccountId::from(Alice), + SessionKeys { aura: AuraId::from(Alice.public()) }, + ) +} + +#[test] +pub fn transfer_token_to_ethereum_works() { + snowbridge_runtime_test_common::send_transfer_token_message_success::( + 11155111, + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + ASSET_HUB_WESTEND_PARACHAIN_ID, + H160::random(), + H160::random(), + DefaultBridgeHubEthereumBaseFee::get(), + Box::new(|runtime_event_encoded: Vec| { + match RuntimeEvent::decode(&mut &runtime_event_encoded[..]) { + Ok(RuntimeEvent::EthereumOutboundQueue(event)) => Some(event), + _ => None, + } + }), + ) +} + +#[test] +pub fn unpaid_transfer_token_to_ethereum_fails_with_barrier() { + snowbridge_runtime_test_common::send_unpaid_transfer_token_message::( + 11155111, + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + ASSET_HUB_WESTEND_PARACHAIN_ID, + H160::random(), + H160::random(), + ) +} + +#[test] +pub fn transfer_token_to_ethereum_fee_not_enough() { + snowbridge_runtime_test_common::send_transfer_token_message_failure::( + 11155111, + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + ASSET_HUB_WESTEND_PARACHAIN_ID, + DefaultBridgeHubEthereumBaseFee::get() + 10_000_000_000, + H160::random(), + H160::random(), + // fee not enough + 10_000_000_000, + NotHoldingFees, + ) +} + +#[test] +pub fn transfer_token_to_ethereum_insufficient_fund() { + snowbridge_runtime_test_common::send_transfer_token_message_failure::( + 11155111, + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + ASSET_HUB_WESTEND_PARACHAIN_ID, + 1_000_000_000, + H160::random(), + H160::random(), + DefaultBridgeHubEthereumBaseFee::get(), + FailedToTransactAsset("Funds are unavailable"), + ) +} + +#[test] +fn max_message_queue_service_weight_is_more_than_beacon_extrinsic_weights() { + let max_message_queue_weight = MessageQueueServiceWeight::get(); + let force_checkpoint = + ::WeightInfo::force_checkpoint(); + let submit_checkpoint = + ::WeightInfo::submit(); + max_message_queue_weight.all_gt(force_checkpoint); + max_message_queue_weight.all_gt(submit_checkpoint); +} + +#[test] +fn ethereum_client_consensus_extrinsics_work() { + snowbridge_runtime_test_common::ethereum_extrinsic( + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + construct_and_apply_extrinsic, + ); +} + +#[test] +fn ethereum_to_polkadot_message_extrinsics_work() { + snowbridge_runtime_test_common::ethereum_to_polkadot_message_extrinsics_work( + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + construct_and_apply_extrinsic, + ); +} + +/// Tests that the digest items are as expected when a Ethereum Outbound message is received. +/// If the MessageQueue pallet is configured before (i.e. the MessageQueue pallet is listed before +/// the EthereumOutboundQueue in the construct_runtime macro) the EthereumOutboundQueue, this test +/// will fail. +#[test] +pub fn ethereum_outbound_queue_processes_messages_before_message_queue_works() { + snowbridge_runtime_test_common::ethereum_outbound_queue_processes_messages_before_message_queue_works::< + Runtime, + XcmConfig, + AllPalletsWithoutSystem, + >( + 11155111, + collator_session_keys(), + BRIDGE_HUB_WESTEND_PARACHAIN_ID, + ASSET_HUB_WESTEND_PARACHAIN_ID, + H160::random(), + H160::random(), + DefaultBridgeHubEthereumBaseFee::get(), + Box::new(|runtime_event_encoded: Vec| { + match RuntimeEvent::decode(&mut &runtime_event_encoded[..]) { + Ok(RuntimeEvent::EthereumOutboundQueue(event)) => Some(event), + _ => None, + } + }), + ) +} + +fn construct_extrinsic( + sender: sp_keyring::AccountKeyring, + call: RuntimeCall, +) -> UncheckedExtrinsic { + let account_id = AccountId32::from(sender.public()); + let extra: SignedExtra = ( + frame_system::CheckNonZeroSender::::new(), + frame_system::CheckSpecVersion::::new(), + frame_system::CheckTxVersion::::new(), + frame_system::CheckGenesis::::new(), + frame_system::CheckEra::::from(Era::immortal()), + frame_system::CheckNonce::::from( + frame_system::Pallet::::account(&account_id).nonce, + ), + frame_system::CheckWeight::::new(), + pallet_transaction_payment::ChargeTransactionPayment::::from(0), + BridgeRejectObsoleteHeadersAndMessages::default(), + (bridge_to_rococo_config::OnBridgeHubWestendRefundBridgeHubRococoMessages::default(),), + cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::::new(false), + ); + let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap(); + let signature = payload.using_encoded(|e| sender.sign(e)); + UncheckedExtrinsic::new_signed(call, account_id.into(), Signature::Sr25519(signature), extra) +} + +fn construct_and_apply_extrinsic( + origin: sp_keyring::AccountKeyring, + call: RuntimeCall, +) -> sp_runtime::DispatchOutcome { + let xt = construct_extrinsic(origin, call); + let r = Executive::apply_extrinsic(xt); + r.unwrap() +} diff --git a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/tests.rs b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/tests.rs index 836594140b2328081ff6c0de8cac40ea82dfb6f7..a66c0f84240c80cef33d21f35ee505db3c4fe292 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/tests.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/bridge-hub-westend/tests/tests.rs @@ -27,8 +27,7 @@ use bridge_hub_westend_runtime::{ SignedExtra, TransactionPayment, UncheckedExtrinsic, }; use bridge_to_rococo_config::{ - BridgeGrandpaRococoInstance, BridgeHubRococoChainId, BridgeHubRococoLocation, - BridgeParachainRococoInstance, WithBridgeHubRococoMessageBridge, + BridgeGrandpaRococoInstance, BridgeHubRococoLocation, BridgeParachainRococoInstance, WithBridgeHubRococoMessagesInstance, XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, }; use codec::{Decode, Encode}; @@ -53,7 +52,6 @@ type RuntimeTestsAdapter = from_parachain::WithRemoteParachainHelperAdapter< BridgeGrandpaRococoInstance, BridgeParachainRococoInstance, WithBridgeHubRococoMessagesInstance, - WithBridgeHubRococoMessageBridge, >; parameter_types! { @@ -79,6 +77,7 @@ fn construct_extrinsic( BridgeRejectObsoleteHeadersAndMessages::default(), (bridge_to_rococo_config::OnBridgeHubWestendRefundBridgeHubRococoMessages::default(),), cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim::new(), + frame_metadata_hash_extension::CheckMetadataHash::new(false), ); let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap(); let signature = payload.using_encoded(|e| sender.sign(e)); @@ -213,11 +212,14 @@ fn handle_export_message_from_system_parachain_add_to_outbound_queue_works() { } }), || ExportMessage { network: Rococo, destination: [Parachain(bridge_to_rococo_config::AssetHubRococoParaId::get().into())].into(), xcm: Xcm(vec![]) }, - XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, Some((WestendLocation::get(), ExistentialDeposit::get()).into()), // value should be >= than value generated by `can_calculate_weight_for_paid_export_message_with_reserve_transfer` Some((WestendLocation::get(), bp_bridge_hub_westend::BridgeHubWestendBaseXcmFeeInWnds::get()).into()), - || PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(BridgeHubRococoLocation::get()), XCM_VERSION).expect("version saved!"), + || { + PolkadotXcm::force_xcm_version(RuntimeOrigin::root(), Box::new(BridgeHubRococoLocation::get()), XCM_VERSION).expect("version saved!"); + + XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO + }, ) } @@ -249,8 +251,7 @@ fn message_dispatch_routing_works() { _ => None, } }), - XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, - || (), + || XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, ) } @@ -261,11 +262,9 @@ fn relayed_incoming_message_works() { slot_durations(), bp_bridge_hub_westend::BRIDGE_HUB_WESTEND_PARACHAIN_ID, bp_bridge_hub_rococo::BRIDGE_HUB_ROCOCO_PARACHAIN_ID, - BridgeHubRococoChainId::get(), SIBLING_PARACHAIN_ID, Westend, - XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, - || (), + || XCM_LANE_FOR_ASSET_HUB_WESTEND_TO_ASSET_HUB_ROCOCO, construct_and_apply_extrinsic, ) } @@ -301,8 +300,8 @@ pub fn can_calculate_fee_for_standalone_message_delivery_transaction() { RuntimeTestsAdapter, >(collator_session_keys(), construct_and_estimate_extrinsic_fee) }, - Perbill::from_percent(33), - Some(-33), + Perbill::from_percent(25), + Some(-25), &format!( "Estimate fee for `single message delivery` for runtime: {:?}", ::Version::get() @@ -320,8 +319,8 @@ pub fn can_calculate_fee_for_standalone_message_confirmation_transaction() { RuntimeTestsAdapter, >(collator_session_keys(), construct_and_estimate_extrinsic_fee) }, - Perbill::from_percent(33), - Some(-33), + Perbill::from_percent(25), + Some(-25), &format!( "Estimate fee for `single message confirmation` for runtime: {:?}", ::Version::get() diff --git a/cumulus/parachains/runtimes/bridge-hubs/common/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/common/Cargo.toml index 2f5f783ce48fb19e1087e24e712fc4dc52b607da..3ae43075000ba2ccd34c9efe1edfc91681201944 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/common/Cargo.toml +++ b/cumulus/parachains/runtimes/bridge-hubs/common/Cargo.toml @@ -7,16 +7,15 @@ description = "Bridge hub common utilities" license = "Apache-2.0" [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -xcm = { package = "staging-xcm", path = "../../../../../polkadot/xcm", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -snowbridge-core = { path = "../../../../../bridges/snowbridge/primitives/core", default-features = false } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } +frame-support = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +cumulus-primitives-core = { workspace = true } +xcm = { workspace = true } +pallet-message-queue = { workspace = true } +snowbridge-core = { workspace = true } [features] default = ["std"] @@ -29,7 +28,6 @@ std = [ "snowbridge-core/std", "sp-core/std", "sp-runtime/std", - "sp-std/std", "xcm/std", ] diff --git a/cumulus/parachains/runtimes/bridge-hubs/common/src/message_queue.rs b/cumulus/parachains/runtimes/bridge-hubs/common/src/message_queue.rs index c1bba65b0abc3c6949f94e9e904a5649f1a9d285..5f91897262f4b8eed44a2da7ad945945dda67cc4 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/common/src/message_queue.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/common/src/message_queue.rs @@ -14,6 +14,7 @@ // limitations under the License. //! Runtime configuration for MessageQueue pallet use codec::{Decode, Encode, MaxEncodedLen}; +use core::marker::PhantomData; use cumulus_primitives_core::{AggregateMessageOrigin as CumulusAggregateMessageOrigin, ParaId}; use frame_support::{ traits::{ProcessMessage, ProcessMessageError, QueueFootprint, QueuePausedQuery}, @@ -22,7 +23,6 @@ use frame_support::{ use pallet_message_queue::OnQueueChanged; use scale_info::TypeInfo; use snowbridge_core::ChannelId; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::v4::{Junction, Location}; /// The aggregate origin of an inbound message. diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml b/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml index 5f2a6e050d83c3db662f8ff4896d32dc8a28fde3..44a8646142d6c38d265c0b9cd518b1b7ddd192e3 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/Cargo.toml @@ -10,47 +10,46 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } -impl-trait-for-tuples = "0.2" +codec = { features = ["derive", "max-encoded-len"], workspace = true } +impl-trait-for-tuples = { workspace = true } log = { workspace = true } # Substrate -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-io = { path = "../../../../../substrate/primitives/io", default-features = false } -sp-keyring = { path = "../../../../../substrate/primitives/keyring" } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-tracing = { path = "../../../../../substrate/primitives/tracing" } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +pallet-balances = { workspace = true } +pallet-utility = { workspace = true } +pallet-timestamp = { workspace = true } # Cumulus -asset-test-utils = { path = "../../assets/test-utils" } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -parachains-runtimes-test-utils = { path = "../../test-utils", default-features = false } +asset-test-utils = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +parachains-common = { workspace = true } +parachains-runtimes-test-utils = { workspace = true } # Polkadot -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } # Bridges -bp-header-chain = { path = "../../../../../bridges/primitives/header-chain", default-features = false } -bp-messages = { path = "../../../../../bridges/primitives/messages", default-features = false } -bp-polkadot-core = { path = "../../../../../bridges/primitives/polkadot-core", default-features = false } -bp-relayers = { path = "../../../../../bridges/primitives/relayers", default-features = false } -bp-runtime = { path = "../../../../../bridges/primitives/runtime", default-features = false } -bp-test-utils = { path = "../../../../../bridges/primitives/test-utils", default-features = false } -pallet-bridge-grandpa = { path = "../../../../../bridges/modules/grandpa", default-features = false } -pallet-bridge-parachains = { path = "../../../../../bridges/modules/parachains", default-features = false } -pallet-bridge-messages = { path = "../../../../../bridges/modules/messages", default-features = false } -pallet-bridge-relayers = { path = "../../../../../bridges/modules/relayers", default-features = false } -bridge-runtime-common = { path = "../../../../../bridges/bin/runtime-common", default-features = false } +bp-header-chain = { workspace = true } +bp-messages = { workspace = true } +bp-polkadot-core = { workspace = true } +bp-relayers = { workspace = true } +bp-runtime = { workspace = true } +bp-test-utils = { workspace = true } +pallet-bridge-grandpa = { workspace = true } +pallet-bridge-parachains = { workspace = true } +pallet-bridge-messages = { features = ["test-helpers"], workspace = true } +pallet-bridge-relayers = { workspace = true } +bridge-runtime-common = { workspace = true } [features] default = ["std"] @@ -81,7 +80,6 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/lib.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/lib.rs index 1874f38de2df17e85c1f49723271d090e962eb70..0b3463f0df974dcc9ce46c1d811b363d5011bbb4 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/lib.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/lib.rs @@ -19,6 +19,8 @@ pub mod test_cases; pub mod test_data; +extern crate alloc; + pub use bp_test_utils::test_header; pub use parachains_runtimes_test_utils::*; use sp_runtime::Perbill; diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_grandpa_chain.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_grandpa_chain.rs index bfa2f0f50f94ca3ba2f663f9646be3165dd48220..f2f0ccecba132b9199f5ad75e124932fd1f5e320 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_grandpa_chain.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_grandpa_chain.rs @@ -22,22 +22,14 @@ use crate::{ test_data, }; +use alloc::{boxed::Box, vec}; use bp_header_chain::ChainWithGrandpa; -use bp_messages::{ - source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, LaneId, - UnrewardedRelayersState, -}; +use bp_messages::{LaneId, UnrewardedRelayersState}; use bp_relayers::{RewardsAccountOwner, RewardsAccountParams}; -use bp_runtime::{HashOf, UnderlyingChainOf}; -use bridge_runtime_common::{ - messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, - BridgedChain as MessageBridgedChain, MessageBridge, ThisChain as MessageThisChain, - }, - messages_xcm_extension::XcmAsPlainPayload, -}; +use bridge_runtime_common::messages_xcm_extension::XcmAsPlainPayload; use frame_support::traits::{OnFinalize, OnInitialize}; use frame_system::pallet_prelude::BlockNumberFor; +use pallet_bridge_messages::{BridgedChainOf, ThisChainOf}; use parachains_runtimes_test_utils::{ AccountIdOf, BasicParachainRuntime, CollatorSessionKeys, RuntimeCallOf, SlotDurations, }; @@ -53,13 +45,10 @@ pub trait WithRemoteGrandpaChainHelper { /// This chain runtime. type Runtime: BasicParachainRuntime + cumulus_pallet_xcmp_queue::Config - + BridgeGrandpaConfig< - Self::GPI, - BridgedChain = UnderlyingChainOf>, - > + BridgeMessagesConfig< + + BridgeGrandpaConfig> + + BridgeMessagesConfig< Self::MPI, InboundPayload = XcmAsPlainPayload, - InboundRelayer = bp_runtime::AccountIdOf>, OutboundPayload = XcmAsPlainPayload, > + pallet_bridge_relayers::Config; /// All pallets of this chain, excluding system pallet. @@ -69,38 +58,33 @@ pub trait WithRemoteGrandpaChainHelper { type GPI: 'static; /// Instance of the `pallet-bridge-messages`, used to bridge with remote GRANDPA chain. type MPI: 'static; - /// Messages bridge definition. - type MB: MessageBridge; } /// Adapter struct that implements [`WithRemoteGrandpaChainHelper`]. -pub struct WithRemoteGrandpaChainHelperAdapter( - sp_std::marker::PhantomData<(Runtime, AllPalletsWithoutSystem, GPI, MPI, MB)>, +pub struct WithRemoteGrandpaChainHelperAdapter( + core::marker::PhantomData<(Runtime, AllPalletsWithoutSystem, GPI, MPI)>, ); -impl WithRemoteGrandpaChainHelper - for WithRemoteGrandpaChainHelperAdapter +impl WithRemoteGrandpaChainHelper + for WithRemoteGrandpaChainHelperAdapter where Runtime: BasicParachainRuntime + cumulus_pallet_xcmp_queue::Config - + BridgeGrandpaConfig>> + + BridgeGrandpaConfig> + BridgeMessagesConfig< MPI, InboundPayload = XcmAsPlainPayload, - InboundRelayer = bp_runtime::AccountIdOf>, OutboundPayload = XcmAsPlainPayload, > + pallet_bridge_relayers::Config, AllPalletsWithoutSystem: OnInitialize> + OnFinalize>, GPI: 'static, MPI: 'static, - MB: MessageBridge, { type Runtime = Runtime; type AllPalletsWithoutSystem = AllPalletsWithoutSystem; type GPI = GPI; type MPI = MPI; - type MB = MB; } /// Test-case makes sure that Runtime can dispatch XCM messages submitted by relayer, @@ -110,11 +94,9 @@ pub fn relayed_incoming_message_works( collator_session_key: CollatorSessionKeys, slot_durations: SlotDurations, runtime_para_id: u32, - bridged_chain_id: bp_runtime::ChainId, sibling_parachain_id: u32, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, RuntimeCallOf, @@ -124,13 +106,7 @@ pub fn relayed_incoming_message_works( AccountIdOf: From, RuntimeCallOf: From> + From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { helpers::relayed_incoming_message_works::< RuntimeHelper::Runtime, @@ -147,10 +123,11 @@ pub fn relayed_incoming_message_works( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { + xcm, + bridged_chain_id| { let relay_header_number = 5u32.into(); - prepare_configuration(); + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 helpers::initialize_bridge_grandpa_pallet::( @@ -161,8 +138,8 @@ pub fn relayed_incoming_message_works( // to be submitted by relayer to this chain. let (relay_chain_header, grandpa_justification, message_proof) = test_data::from_grandpa_chain::make_complex_relayer_delivery_proofs::< - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -186,7 +163,7 @@ pub fn relayed_incoming_message_works( ( BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -218,11 +195,9 @@ pub fn free_relay_extrinsic_works( collator_session_key: CollatorSessionKeys, slot_durations: SlotDurations, runtime_para_id: u32, - bridged_chain_id: bp_runtime::ChainId, sibling_parachain_id: u32, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, RuntimeCallOf, @@ -233,13 +208,7 @@ pub fn free_relay_extrinsic_works( AccountIdOf: From, RuntimeCallOf: From> + From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { // ensure that the runtime allows free header submissions let free_headers_interval = ( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { - prepare_configuration(); + xcm, + bridged_chain_id| { + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 let initial_block_number = 0; @@ -291,8 +261,8 @@ pub fn free_relay_extrinsic_works( // to be submitted by relayer to this chain. let (relay_chain_header, grandpa_justification, message_proof) = test_data::from_grandpa_chain::make_complex_relayer_delivery_proofs::< - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -322,7 +292,7 @@ pub fn free_relay_extrinsic_works( ( BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -354,10 +324,8 @@ pub fn complex_relay_extrinsic_works( slot_durations: SlotDurations, runtime_para_id: u32, sibling_parachain_id: u32, - bridged_chain_id: bp_runtime::ChainId, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, RuntimeCallOf, @@ -370,13 +338,7 @@ pub fn complex_relay_extrinsic_works( RuntimeCallOf: From> + From> + From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { helpers::relayed_incoming_message_works::< RuntimeHelper::Runtime, @@ -393,10 +355,11 @@ pub fn complex_relay_extrinsic_works( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { + xcm, + bridged_chain_id| { let relay_header_number = 1u32.into(); - prepare_configuration(); + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 helpers::initialize_bridge_grandpa_pallet::( @@ -407,8 +370,8 @@ pub fn complex_relay_extrinsic_works( // to be submitted by relayer to this chain. let (relay_chain_header, grandpa_justification, message_proof) = test_data::from_grandpa_chain::make_complex_relayer_delivery_proofs::< - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -428,7 +391,7 @@ pub fn complex_relay_extrinsic_works( }.into(), BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -470,13 +433,7 @@ where pallet_utility::Config>, RuntimeCallOf: From> + From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -487,8 +444,8 @@ where // the message additionally let (relay_chain_header, grandpa_justification, message_proof) = test_data::from_grandpa_chain::make_complex_relayer_delivery_proofs::< - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), vec![Instruction::<()>::ClearOrigin; 1_024].into(), @@ -526,19 +483,11 @@ where AccountIdOf: From, RuntimeHelper::Runtime: pallet_utility::Config>, - MessageThisChain: + ThisChainOf: bp_runtime::Chain>, RuntimeCallOf: From> + From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::TargetHeaderChain: - TargetHeaderChain< - XcmAsPlainPayload, - AccountIdOf, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -550,7 +499,8 @@ where }; let (relay_chain_header, grandpa_justification, message_delivery_proof) = test_data::from_grandpa_chain::make_complex_relayer_confirmation_proofs::< - RuntimeHelper::MB, + BridgedChainOf, + ThisChainOf, (), >( LaneId::default(), @@ -587,13 +537,7 @@ where RuntimeHelper: WithRemoteGrandpaChainHelper, RuntimeCallOf: From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -604,8 +548,8 @@ where // the message additionally let (_, _, message_proof) = test_data::from_grandpa_chain::make_complex_relayer_delivery_proofs::< - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), vec![Instruction::<()>::ClearOrigin; 1_024].into(), @@ -639,19 +583,11 @@ pub fn can_calculate_fee_for_standalone_message_confirmation_transaction: From, - MessageThisChain: + ThisChainOf: bp_runtime::Chain>, RuntimeCallOf: From>, - UnderlyingChainOf>: ChainWithGrandpa, - >::TargetHeaderChain: - TargetHeaderChain< - XcmAsPlainPayload, - AccountIdOf, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>>, - >, - >, + BridgedChainOf: ChainWithGrandpa, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -663,7 +599,8 @@ where }; let (_, _, message_delivery_proof) = test_data::from_grandpa_chain::make_complex_relayer_confirmation_proofs::< - RuntimeHelper::MB, + BridgedChainOf, + ThisChainOf, (), >( LaneId::default(), diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_parachain.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_parachain.rs index 12ab382d9e0f6518afb93f118199170acb5f8cc6..0988528c3f2a0ae867d188d745a3b1e923ab0060 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_parachain.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/from_parachain.rs @@ -22,23 +22,16 @@ use crate::{ test_data, }; +use alloc::{boxed::Box, vec}; use bp_header_chain::ChainWithGrandpa; -use bp_messages::{ - source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, LaneId, - UnrewardedRelayersState, -}; +use bp_messages::{LaneId, UnrewardedRelayersState}; use bp_polkadot_core::parachains::ParaHash; use bp_relayers::{RewardsAccountOwner, RewardsAccountParams}; -use bp_runtime::{HashOf, Parachain, UnderlyingChainOf}; -use bridge_runtime_common::{ - messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, - BridgedChain as MessageBridgedChain, MessageBridge, ThisChain as MessageThisChain, - }, - messages_xcm_extension::XcmAsPlainPayload, -}; +use bp_runtime::{Chain, Parachain}; +use bridge_runtime_common::messages_xcm_extension::XcmAsPlainPayload; use frame_support::traits::{OnFinalize, OnInitialize}; use frame_system::pallet_prelude::BlockNumberFor; +use pallet_bridge_messages::{BridgedChainOf, ThisChainOf}; use parachains_runtimes_test_utils::{ AccountIdOf, BasicParachainRuntime, CollatorSessionKeys, RuntimeCallOf, SlotDurations, }; @@ -59,7 +52,6 @@ pub trait WithRemoteParachainHelper { + BridgeMessagesConfig< Self::MPI, InboundPayload = XcmAsPlainPayload, - InboundRelayer = bp_runtime::AccountIdOf>, OutboundPayload = XcmAsPlainPayload, > + pallet_bridge_relayers::Config; /// All pallets of this chain, excluding system pallet. @@ -71,17 +63,15 @@ pub trait WithRemoteParachainHelper { type PPI: 'static; /// Instance of the `pallet-bridge-messages`, used to bridge with remote parachain. type MPI: 'static; - /// Messages bridge definition. - type MB: MessageBridge; } /// Adapter struct that implements `WithRemoteParachainHelper`. -pub struct WithRemoteParachainHelperAdapter( - sp_std::marker::PhantomData<(Runtime, AllPalletsWithoutSystem, GPI, PPI, MPI, MB)>, +pub struct WithRemoteParachainHelperAdapter( + core::marker::PhantomData<(Runtime, AllPalletsWithoutSystem, GPI, PPI, MPI)>, ); -impl WithRemoteParachainHelper - for WithRemoteParachainHelperAdapter +impl WithRemoteParachainHelper + for WithRemoteParachainHelperAdapter where Runtime: BasicParachainRuntime + cumulus_pallet_xcmp_queue::Config @@ -90,7 +80,6 @@ where + BridgeMessagesConfig< MPI, InboundPayload = XcmAsPlainPayload, - InboundRelayer = bp_runtime::AccountIdOf>, OutboundPayload = XcmAsPlainPayload, > + pallet_bridge_relayers::Config, AllPalletsWithoutSystem: @@ -98,14 +87,13 @@ where GPI: 'static, PPI: 'static, MPI: 'static, - MB: MessageBridge, + // MB: MessageBridge, { type Runtime = Runtime; type AllPalletsWithoutSystem = AllPalletsWithoutSystem; type GPI = GPI; type PPI = PPI; type MPI = MPI; - type MB = MB; } /// Test-case makes sure that Runtime can dispatch XCM messages submitted by relayer, @@ -116,11 +104,9 @@ pub fn relayed_incoming_message_works( slot_durations: SlotDurations, runtime_para_id: u32, bridged_para_id: u32, - bridged_chain_id: bp_runtime::ChainId, sibling_parachain_id: u32, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, ::RuntimeCall, @@ -131,16 +117,9 @@ pub fn relayed_incoming_message_works( RuntimeCallOf: From> + From> + From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, { helpers::relayed_incoming_message_works::< RuntimeHelper::Runtime, @@ -157,11 +136,12 @@ pub fn relayed_incoming_message_works( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { + xcm, + bridged_chain_id| { let para_header_number = 5; let relay_header_number = 1; - prepare_configuration(); + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 helpers::initialize_bridge_grandpa_pallet::( @@ -179,8 +159,8 @@ pub fn relayed_incoming_message_works( message_proof, ) = test_data::from_parachain::make_complex_relayer_delivery_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -219,7 +199,7 @@ pub fn relayed_incoming_message_works( ( BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -252,11 +232,9 @@ pub fn free_relay_extrinsic_works( slot_durations: SlotDurations, runtime_para_id: u32, bridged_para_id: u32, - bridged_chain_id: bp_runtime::ChainId, sibling_parachain_id: u32, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, ::RuntimeCall, @@ -268,16 +246,9 @@ pub fn free_relay_extrinsic_works( RuntimeCallOf: From> + From> + From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, { // ensure that the runtime allows free header submissions let free_headers_interval = ( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { - prepare_configuration(); + xcm, + bridged_chain_id| { + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 let initial_block_number = 0; @@ -338,8 +310,8 @@ pub fn free_relay_extrinsic_works( message_proof, ) = test_data::from_parachain::make_complex_relayer_delivery_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -390,7 +362,7 @@ pub fn free_relay_extrinsic_works( ( BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -423,10 +395,8 @@ pub fn complex_relay_extrinsic_works( runtime_para_id: u32, bridged_para_id: u32, sibling_parachain_id: u32, - bridged_chain_id: bp_runtime::ChainId, local_relay_chain_id: NetworkId, - lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, construct_and_apply_extrinsic: fn( sp_keyring::AccountKeyring, ::RuntimeCall, @@ -440,16 +410,9 @@ pub fn complex_relay_extrinsic_works( + From> + From> + From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, { helpers::relayed_incoming_message_works::< RuntimeHelper::Runtime, @@ -466,11 +429,12 @@ pub fn complex_relay_extrinsic_works( relayer_id_at_bridged_chain, message_destination, message_nonce, - xcm| { + xcm, + bridged_chain_id| { let para_header_number = 5; let relay_header_number = 1; - prepare_configuration(); + let lane_id = prepare_configuration(); // start with bridged relay chain block#0 helpers::initialize_bridge_grandpa_pallet::( @@ -488,8 +452,8 @@ pub fn complex_relay_extrinsic_works( message_proof, ) = test_data::from_parachain::make_complex_relayer_delivery_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( lane_id, xcm.into(), @@ -518,7 +482,7 @@ pub fn complex_relay_extrinsic_works( }.into(), BridgeMessagesCall::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }.into(), @@ -565,16 +529,9 @@ where RuntimeCallOf: From> + From> + From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -592,8 +549,8 @@ where message_proof, ) = test_data::from_parachain::make_complex_relayer_delivery_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), vec![Instruction::<()>::ClearOrigin; 1_024].into(), @@ -612,7 +569,6 @@ where RuntimeHelper::GPI, RuntimeHelper::PPI, RuntimeHelper::MPI, - _, >( relay_chain_header, grandpa_justification, @@ -637,23 +593,14 @@ where AccountIdOf: From, RuntimeHelper::Runtime: pallet_utility::Config>, - MessageThisChain: - bp_runtime::Chain>, + ThisChainOf: + Chain>, RuntimeCallOf: From> + From> + From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::TargetHeaderChain: - TargetHeaderChain< - XcmAsPlainPayload, - AccountIdOf, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>>, - >, - >, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -672,8 +619,8 @@ where message_delivery_proof, ) = test_data::from_parachain::make_complex_relayer_confirmation_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), 1, @@ -714,16 +661,9 @@ where RuntimeHelper: WithRemoteParachainHelper, RuntimeCallOf: From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::SourceHeaderChain: - SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof< - HashOf>, - >, - >, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -741,8 +681,8 @@ where message_proof, ) = test_data::from_parachain::make_complex_relayer_delivery_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), vec![Instruction::<()>::ClearOrigin; 1_024].into(), @@ -757,7 +697,6 @@ where let call = test_data::from_parachain::make_standalone_relayer_delivery_call::< RuntimeHelper::Runtime, RuntimeHelper::MPI, - _, >( message_proof, helpers::relayer_id_at_bridged_chain::(), @@ -778,22 +717,13 @@ pub fn can_calculate_fee_for_standalone_message_confirmation_transaction: From, - MessageThisChain: - bp_runtime::Chain>, + ThisChainOf: + Chain>, RuntimeCallOf: From>, - UnderlyingChainOf>: - bp_runtime::Chain + Parachain, + BridgedChainOf: Chain + Parachain, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::TargetHeaderChain: - TargetHeaderChain< - XcmAsPlainPayload, - AccountIdOf, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>>, - >, - >, { run_test::(collator_session_key, 1000, vec![], || { // generate bridged relay chain finality, parachain heads and message proofs, @@ -806,8 +736,8 @@ where let (_, _, _, _, _, message_delivery_proof) = test_data::from_parachain::make_complex_relayer_confirmation_proofs::< >::BridgedChain, - RuntimeHelper::MB, - (), + BridgedChainOf, + ThisChainOf, >( LaneId::default(), 1, diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/helpers.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/helpers.rs index 0ce049cd1c4630c55c244afbc8a72213cb83d6b9..c4b5e5583baa0d9a22307e7f1fcb52ca5e95b0e9 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/helpers.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/helpers.rs @@ -22,13 +22,16 @@ use asset_test_utils::BasicParachainRuntime; use bp_messages::{LaneId, MessageNonce}; use bp_polkadot_core::parachains::{ParaHash, ParaId}; use bp_relayers::RewardsAccountParams; +use bp_runtime::Chain; use codec::Decode; +use core::marker::PhantomData; use frame_support::{ assert_ok, traits::{OnFinalize, OnInitialize, PalletInfoAccess}, }; use frame_system::pallet_prelude::BlockNumberFor; use pallet_bridge_grandpa::{BridgedBlockHash, BridgedHeader}; +use pallet_bridge_messages::BridgedChainOf; use parachains_common::AccountId; use parachains_runtimes_test_utils::{ mock_open_hrmp_channel, AccountIdOf, CollatorSessionKeys, RuntimeCallOf, SlotDurations, @@ -36,7 +39,6 @@ use parachains_runtimes_test_utils::{ use sp_core::Get; use sp_keyring::AccountKeyring::*; use sp_runtime::{traits::TrailingZeroInput, AccountId32}; -use sp_std::marker::PhantomData; use xcm::latest::prelude::*; /// Verify that the transaction has succeeded. @@ -240,10 +242,12 @@ pub(crate) fn initialize_bridge_grandpa_pallet( pub type CallsAndVerifiers = Vec<(RuntimeCallOf, Box)>; +pub type InboundRelayerId = bp_runtime::AccountIdOf>; + /// Returns relayer id at the bridged chain. pub fn relayer_id_at_bridged_chain, MPI>( -) -> Runtime::InboundRelayer { - Runtime::InboundRelayer::decode(&mut TrailingZeroInput::zeroes()).unwrap() +) -> InboundRelayerId { + Decode::decode(&mut TrailingZeroInput::zeroes()).unwrap() } /// Test-case makes sure that Runtime can dispatch XCM messages submitted by relayer, @@ -260,10 +264,11 @@ pub fn relayed_incoming_message_works( ) -> sp_runtime::DispatchOutcome, prepare_message_proof_import: impl FnOnce( Runtime::AccountId, - Runtime::InboundRelayer, + InboundRelayerId, InteriorLocation, MessageNonce, Xcm<()>, + bp_runtime::ChainId, ) -> CallsAndVerifiers, ) where Runtime: BasicParachainRuntime + cumulus_pallet_xcmp_queue::Config + BridgeMessagesConfig, @@ -275,6 +280,7 @@ pub fn relayed_incoming_message_works( let relayer_at_target = Bob; let relayer_id_on_target: AccountId32 = relayer_at_target.public().into(); let relayer_id_on_source = relayer_id_at_bridged_chain::(); + let bridged_chain_id = Runtime::BridgedChain::ID; assert_ne!(runtime_para_id, sibling_parachain_id); @@ -287,7 +293,7 @@ pub fn relayed_incoming_message_works( // value here is tricky - there are several transaction payment pallets and we don't // want to introduce additional bounds and traits here just for that, so let's just // select some presumably large value - sp_std::cmp::max::(Runtime::ExistentialDeposit::get(), 1u32.into()) * + core::cmp::max::(Runtime::ExistentialDeposit::get(), 1u32.into()) * 100_000_000u32.into(), )], || { @@ -336,6 +342,7 @@ pub fn relayed_incoming_message_works( message_destination, message_nonce, xcm.clone().into(), + bridged_chain_id, ), ); diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/mod.rs index bc1c7ec5e032c08fb36b3005d4abcaf24bb43ff4..a36a74dbbbc3ab4ec8413f1b92ede16289600413 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/mod.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_cases/mod.rs @@ -320,10 +320,9 @@ pub fn handle_export_message_from_system_parachain_to_outbound_queue_works< dyn Fn(Vec) -> Option>, >, export_message_instruction: fn() -> Instruction, - expected_lane_id: LaneId, existential_deposit: Option, maybe_paid_export_message: Option, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, ) where Runtime: BasicParachainRuntime + BridgeMessagesConfig, XcmConfig: xcm_executor::Config, @@ -333,7 +332,7 @@ pub fn handle_export_message_from_system_parachain_to_outbound_queue_works< let sibling_parachain_location = Location::new(1, [Parachain(sibling_parachain_id)]); run_test::(collator_session_key, runtime_para_id, vec![], || { - prepare_configuration(); + let expected_lane_id = prepare_configuration(); // check queue before assert_eq!( @@ -430,8 +429,7 @@ pub fn message_dispatch_routing_works< unwrap_cumulus_pallet_xcmp_queue_event: Box< dyn Fn(Vec) -> Option>, >, - expected_lane_id: LaneId, - prepare_configuration: impl Fn(), + prepare_configuration: impl Fn() -> LaneId, ) where Runtime: BasicParachainRuntime + cumulus_pallet_xcmp_queue::Config @@ -459,7 +457,7 @@ pub fn message_dispatch_routing_works< assert_ne!(runtime_para_id, sibling_parachain_id); run_test::(collator_session_key, runtime_para_id, vec![], || { - prepare_configuration(); + let expected_lane_id = prepare_configuration(); let mut alice = [0u8; 32]; alice[0] = 1; diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_grandpa_chain.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_grandpa_chain.rs index e5d5e7cac96ba14f6abfdae792908352f40d3e31..5c1dc492a9d2999e6473ca98ece70ffd4d7de905 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_grandpa_chain.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_grandpa_chain.rs @@ -19,30 +19,29 @@ use crate::test_data::prepare_inbound_xcm; use bp_messages::{ - source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, LaneId, MessageNonce, + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::FromBridgedChainMessagesProof, ChainWithMessages, LaneId, MessageNonce, UnrewardedRelayersState, }; -use bp_runtime::{AccountIdOf, BlockNumberOf, HeaderOf, StorageProofSize, UnderlyingChainOf}; +use bp_runtime::{AccountIdOf, BlockNumberOf, Chain, HeaderOf, UnverifiedStorageProofParams}; use bp_test_utils::make_default_justification; -use bridge_runtime_common::{ - messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, - BridgedChain as MessageBridgedChain, MessageBridge, ThisChain as MessageThisChain, - }, - messages_generation::{ - encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof, - prepare_messages_storage_proof, - }, - messages_xcm_extension::XcmAsPlainPayload, -}; +use bridge_runtime_common::messages_xcm_extension::XcmAsPlainPayload; use codec::Encode; use pallet_bridge_grandpa::{BridgedChain, BridgedHeader}; use sp_runtime::traits::Header as HeaderT; use xcm::latest::prelude::*; +use crate::test_cases::helpers::InboundRelayerId; use bp_header_chain::{justification::GrandpaJustification, ChainWithGrandpa}; use bp_messages::{DeliveredMessages, InboundLaneData, UnrewardedRelayer}; use bp_runtime::HashOf; +use pallet_bridge_messages::{ + messages_generation::{ + encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof, + prepare_messages_storage_proof, + }, + BridgedChainOf, +}; use sp_runtime::DigestItem; /// Prepare a batch call with bridged GRANDPA finality and message proof. @@ -50,22 +49,17 @@ pub fn make_complex_relayer_delivery_batch( bridged_header: BridgedHeader, bridged_justification: GrandpaJustification>, message_proof: FromBridgedChainMessagesProof>>, - relayer_id_at_bridged_chain: AccountIdOf>, + relayer_id_at_bridged_chain: InboundRelayerId, ) -> pallet_utility::Call where Runtime: pallet_bridge_grandpa::Config - + pallet_bridge_messages::Config< - MPI, - InboundPayload = XcmAsPlainPayload, - InboundRelayer = AccountIdOf>, - > + pallet_utility::Config, + + pallet_bridge_messages::Config + + pallet_utility::Config, GPI: 'static, MPI: 'static, - >::SourceHeaderChain: SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof>>, - >, ::RuntimeCall: From> + From>, + BridgedChainOf: Chain>>, { let submit_grandpa = pallet_bridge_grandpa::Call::::submit_finality_proof { finality_target: Box::new(bridged_header), @@ -73,7 +67,7 @@ where }; let submit_message = pallet_bridge_messages::Call::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }; @@ -97,15 +91,9 @@ where + pallet_utility::Config, GPI: 'static, MPI: 'static, - >::TargetHeaderChain: TargetHeaderChain< - XcmAsPlainPayload, - Runtime::AccountId, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>, - >, - >, ::RuntimeCall: From> + From>, + BridgedChainOf: Chain>>, { let submit_grandpa = pallet_bridge_grandpa::Call::::submit_finality_proof { finality_target: Box::new(bridged_header), @@ -124,24 +112,18 @@ where /// Prepare a call with message proof. pub fn make_standalone_relayer_delivery_call( message_proof: FromBridgedChainMessagesProof>>, - relayer_id_at_bridged_chain: AccountIdOf>, + relayer_id_at_bridged_chain: InboundRelayerId, ) -> Runtime::RuntimeCall where Runtime: pallet_bridge_grandpa::Config - + pallet_bridge_messages::Config< - MPI, - InboundPayload = XcmAsPlainPayload, - InboundRelayer = AccountIdOf>, - >, + + pallet_bridge_messages::Config, MPI: 'static, - >::SourceHeaderChain: SourceHeaderChain< - MessagesProof = FromBridgedChainMessagesProof>>, - >, Runtime::RuntimeCall: From>, + BridgedChainOf: Chain>>, { pallet_bridge_messages::Call::::receive_messages_proof { relayer_id_at_bridged_chain, - proof: message_proof, + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), } @@ -159,14 +141,8 @@ where Runtime: pallet_bridge_grandpa::Config + pallet_bridge_messages::Config, MPI: 'static, - >::TargetHeaderChain: TargetHeaderChain< - XcmAsPlainPayload, - Runtime::AccountId, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof< - HashOf>, - >, - >, Runtime::RuntimeCall: From>, + BridgedChainOf: Chain>>, { pallet_bridge_messages::Call::::receive_messages_delivery_proof { proof: message_delivery_proof, @@ -176,39 +152,43 @@ where } /// Prepare storage proofs of messages, stored at the (bridged) source GRANDPA chain. -pub fn make_complex_relayer_delivery_proofs( +pub fn make_complex_relayer_delivery_proofs( lane_id: LaneId, - xcm_message: Xcm, + xcm_message: Xcm<()>, message_nonce: MessageNonce, message_destination: Junctions, - header_number: BlockNumberOf>, + header_number: BlockNumberOf, is_minimal_call: bool, ) -> ( - HeaderOf>, - GrandpaJustification>>, - FromBridgedChainMessagesProof>>, + HeaderOf, + GrandpaJustification>, + FromBridgedChainMessagesProof>, ) where - MB: MessageBridge, - MessageBridgedChain: Send + Sync + 'static, - UnderlyingChainOf>: ChainWithGrandpa, + BridgedChain: ChainWithGrandpa, + ThisChainWithMessages: ChainWithMessages, { + // prepare message let message_payload = prepare_inbound_xcm(xcm_message, message_destination); - let message_size = StorageProofSize::Minimal(message_payload.len() as u32); - // prepare para storage proof containing message - let (state_root, storage_proof) = prepare_messages_storage_proof::( - lane_id, - message_nonce..=message_nonce, - None, - message_size, - message_payload, - encode_all_messages, - encode_lane_data, - ); + // prepare storage proof containing message + let (state_root, storage_proof) = + prepare_messages_storage_proof::( + lane_id, + message_nonce..=message_nonce, + None, + UnverifiedStorageProofParams::from_db_size(message_payload.len() as u32), + |_| message_payload.clone(), + encode_all_messages, + encode_lane_data, + false, + false, + ); - let (header, justification) = make_complex_bridged_grandpa_header_proof::< - MessageBridgedChain, - >(state_root, header_number, is_minimal_call); + let (header, justification) = make_complex_bridged_grandpa_header_proof::( + state_root, + header_number, + is_minimal_call, + ); let message_proof = FromBridgedChainMessagesProof { bridged_header_hash: header.hash(), @@ -222,44 +202,44 @@ where } /// Prepare storage proofs of message confirmations, stored at the (bridged) target GRANDPA chain. -pub fn make_complex_relayer_confirmation_proofs( +pub fn make_complex_relayer_confirmation_proofs< + BridgedChain, + ThisChainWithMessages, + InnerXcmRuntimeCall, +>( lane_id: LaneId, - header_number: BlockNumberOf>, - relayer_id_at_this_chain: AccountIdOf>, + header_number: BlockNumberOf, + relayer_id_at_this_chain: AccountIdOf, relayers_state: UnrewardedRelayersState, ) -> ( - HeaderOf>, - GrandpaJustification>>, - FromBridgedChainMessagesDeliveryProof>>, + HeaderOf, + GrandpaJustification>, + FromBridgedChainMessagesDeliveryProof>, ) where - MB: MessageBridge, - MessageBridgedChain: Send + Sync + 'static, - MessageThisChain: Send + Sync + 'static, - UnderlyingChainOf>: ChainWithGrandpa, + BridgedChain: ChainWithGrandpa, + ThisChainWithMessages: ChainWithMessages, { // prepare storage proof containing message delivery proof - let (state_root, storage_proof) = prepare_message_delivery_storage_proof::( - lane_id, - InboundLaneData { - relayers: vec![ - UnrewardedRelayer { - relayer: relayer_id_at_this_chain, - messages: DeliveredMessages::new(1) - }; - relayers_state.unrewarded_relayer_entries as usize - ] - .into(), - last_confirmed_nonce: 1, - }, - StorageProofSize::Minimal(0), - ); + let (state_root, storage_proof) = + prepare_message_delivery_storage_proof::( + lane_id, + InboundLaneData { + relayers: vec![ + UnrewardedRelayer { + relayer: relayer_id_at_this_chain, + messages: DeliveredMessages::new(1) + }; + relayers_state.unrewarded_relayer_entries as usize + ] + .into(), + last_confirmed_nonce: 1, + }, + UnverifiedStorageProofParams::default(), + ); - let (header, justification) = make_complex_bridged_grandpa_header_proof::( - state_root, - header_number, - false, - ); + let (header, justification) = + make_complex_bridged_grandpa_header_proof::(state_root, header_number, false); let message_delivery_proof = FromBridgedChainMessagesDeliveryProof { bridged_header_hash: header.hash(), diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_parachain.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_parachain.rs index 5d3cba4e53b5ec7ec9cd2e6141e6e95aa8928970..b99c275bd0df94856eedcc1cc008c1d7a0b1a673 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_parachain.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/from_parachain.rs @@ -19,61 +19,58 @@ use super::{from_grandpa_chain::make_complex_bridged_grandpa_header_proof, prepare_inbound_xcm}; use bp_messages::{ - source_chain::TargetHeaderChain, target_chain::SourceHeaderChain, LaneId, + source_chain::FromBridgedChainMessagesDeliveryProof, + target_chain::FromBridgedChainMessagesProof, ChainWithMessages, LaneId, UnrewardedRelayersState, Weight, }; use bp_runtime::{ - AccountIdOf, BlockNumberOf, HeaderOf, Parachain, StorageProofSize, UnderlyingChainOf, + AccountIdOf, BlockNumberOf, Chain, HeaderOf, Parachain, UnverifiedStorageProofParams, }; use bp_test_utils::prepare_parachain_heads_proof; -use bridge_runtime_common::{ - messages::{ - source::FromBridgedChainMessagesDeliveryProof, target::FromBridgedChainMessagesProof, - BridgedChain as MessageBridgedChain, MessageBridge, ThisChain as MessageThisChain, - }, - messages_generation::{ - encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof, - prepare_messages_storage_proof, - }, - messages_xcm_extension::XcmAsPlainPayload, -}; +use bridge_runtime_common::messages_xcm_extension::XcmAsPlainPayload; use codec::Encode; use pallet_bridge_grandpa::BridgedHeader; use pallet_bridge_parachains::{RelayBlockHash, RelayBlockNumber}; use sp_runtime::traits::Header as HeaderT; use xcm::latest::prelude::*; +use crate::test_cases::helpers::InboundRelayerId; use bp_header_chain::{justification::GrandpaJustification, ChainWithGrandpa}; use bp_messages::{DeliveredMessages, InboundLaneData, MessageNonce, UnrewardedRelayer}; use bp_polkadot_core::parachains::{ParaHash, ParaHead, ParaHeadsProof, ParaId}; +use pallet_bridge_messages::{ + messages_generation::{ + encode_all_messages, encode_lane_data, prepare_message_delivery_storage_proof, + prepare_messages_storage_proof, + }, + BridgedChainOf, +}; use sp_runtime::SaturatedConversion; /// Prepare a batch call with relay finality proof, parachain head proof and message proof. -pub fn make_complex_relayer_delivery_batch( +pub fn make_complex_relayer_delivery_batch( relay_chain_header: BridgedHeader, grandpa_justification: GrandpaJustification>, parachain_heads: Vec<(ParaId, ParaHash)>, para_heads_proof: ParaHeadsProof, message_proof: FromBridgedChainMessagesProof, - relayer_id_at_bridged_chain: InboundRelayer, -) -> pallet_utility::Call where - Runtime:pallet_bridge_grandpa::Config + relayer_id_at_bridged_chain: InboundRelayerId, +) -> pallet_utility::Call +where + Runtime: pallet_bridge_grandpa::Config + pallet_bridge_parachains::Config - + pallet_bridge_messages::Config< - MPI, - InboundPayload = XcmAsPlainPayload, - InboundRelayer = InboundRelayer, - > + + pallet_bridge_messages::Config + pallet_utility::Config, GPI: 'static, PPI: 'static, MPI: 'static, - ParaHash: From<<>::BridgedChain as bp_runtime::Chain>::Hash>, - <>::BridgedChain as bp_runtime::Chain>::Hash: From, - <>::SourceHeaderChain as SourceHeaderChain>::MessagesProof: - From>, - ::RuntimeCall: - From> + ParaHash: From< + <>::BridgedChain as bp_runtime::Chain>::Hash, + >, + <>::BridgedChain as bp_runtime::Chain>::Hash: + From, + BridgedChainOf: Chain + Parachain, + ::RuntimeCall: From> + From> + From>, { @@ -93,7 +90,7 @@ pub fn make_complex_relayer_delivery_batch::receive_messages_proof { relayer_id_at_bridged_chain: relayer_id_at_bridged_chain.into(), - proof: message_proof.into(), + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), }; @@ -122,11 +119,7 @@ where MPI: 'static, >::BridgedChain: bp_runtime::Chain + ChainWithGrandpa, - >::TargetHeaderChain: TargetHeaderChain< - XcmAsPlainPayload, - Runtime::AccountId, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof, - >, + BridgedChainOf: Chain + Parachain, ::RuntimeCall: From> + From> + From>, @@ -160,23 +153,19 @@ where } /// Prepare a call with message proof. -pub fn make_standalone_relayer_delivery_call( +pub fn make_standalone_relayer_delivery_call( message_proof: FromBridgedChainMessagesProof, - relayer_id_at_bridged_chain: InboundRelayer, -) -> Runtime::RuntimeCall where - Runtime: pallet_bridge_messages::Config< - MPI, - InboundPayload = XcmAsPlainPayload, - InboundRelayer = InboundRelayer, - >, + relayer_id_at_bridged_chain: InboundRelayerId, +) -> Runtime::RuntimeCall +where + Runtime: pallet_bridge_messages::Config, MPI: 'static, - Runtime::RuntimeCall: From>, - <>::SourceHeaderChain as SourceHeaderChain>::MessagesProof: - From>, + Runtime::RuntimeCall: From>, + BridgedChainOf: Chain + Parachain, { pallet_bridge_messages::Call::::receive_messages_proof { relayer_id_at_bridged_chain: relayer_id_at_bridged_chain.into(), - proof: message_proof.into(), + proof: Box::new(message_proof), messages_count: 1, dispatch_weight: Weight::from_parts(1000000000, 0), } @@ -192,11 +181,7 @@ where Runtime: pallet_bridge_messages::Config, MPI: 'static, Runtime::RuntimeCall: From>, - >::TargetHeaderChain: TargetHeaderChain< - XcmAsPlainPayload, - Runtime::AccountId, - MessagesDeliveryProof = FromBridgedChainMessagesDeliveryProof, - >, + BridgedChainOf: Chain + Parachain, { pallet_bridge_messages::Call::::receive_messages_delivery_proof { proof: message_delivery_proof, @@ -206,9 +191,13 @@ where } /// Prepare storage proofs of messages, stored at the source chain. -pub fn make_complex_relayer_delivery_proofs( +pub fn make_complex_relayer_delivery_proofs< + BridgedRelayChain, + BridgedParachain, + ThisChainWithMessages, +>( lane_id: LaneId, - xcm_message: Xcm, + xcm_message: Xcm<()>, message_nonce: MessageNonce, message_destination: Junctions, para_header_number: u32, @@ -226,24 +215,27 @@ pub fn make_complex_relayer_delivery_proofs + ChainWithGrandpa, - MB: MessageBridge, - UnderlyingChainOf>: bp_runtime::Chain + Parachain, + BridgedParachain: bp_runtime::Chain + Parachain, + ThisChainWithMessages: ChainWithMessages, { + // prepare message let message_payload = prepare_inbound_xcm(xcm_message, message_destination); - let message_size = StorageProofSize::Minimal(message_payload.len() as u32); // prepare para storage proof containing message - let (para_state_root, para_storage_proof) = prepare_messages_storage_proof::( - lane_id, - message_nonce..=message_nonce, - None, - message_size, - message_payload, - encode_all_messages, - encode_lane_data, - ); + let (para_state_root, para_storage_proof) = + prepare_messages_storage_proof::( + lane_id, + message_nonce..=message_nonce, + None, + UnverifiedStorageProofParams::from_db_size(message_payload.len() as u32), + |_| message_payload.clone(), + encode_all_messages, + encode_lane_data, + false, + false, + ); let (relay_chain_header, justification, bridged_para_head, parachain_heads, para_heads_proof) = - make_complex_bridged_parachain_heads_proof::( + make_complex_bridged_parachain_heads_proof::( para_state_root, para_header_number, relay_header_number, @@ -270,12 +262,16 @@ where } /// Prepare storage proofs of message confirmations, stored at the target parachain. -pub fn make_complex_relayer_confirmation_proofs( +pub fn make_complex_relayer_confirmation_proofs< + BridgedRelayChain, + BridgedParachain, + ThisChainWithMessages, +>( lane_id: LaneId, para_header_number: u32, relay_header_number: u32, bridged_para_id: u32, - relayer_id_at_this_chain: AccountIdOf>, + relayer_id_at_this_chain: AccountIdOf, relayers_state: UnrewardedRelayersState, ) -> ( HeaderOf, @@ -288,28 +284,29 @@ pub fn make_complex_relayer_confirmation_proofs + ChainWithGrandpa, - MB: MessageBridge, - UnderlyingChainOf>: bp_runtime::Chain + Parachain, + BridgedParachain: bp_runtime::Chain + Parachain, + ThisChainWithMessages: ChainWithMessages, { // prepare para storage proof containing message delivery proof - let (para_state_root, para_storage_proof) = prepare_message_delivery_storage_proof::( - lane_id, - InboundLaneData { - relayers: vec![ - UnrewardedRelayer { - relayer: relayer_id_at_this_chain.into(), - messages: DeliveredMessages::new(1) - }; - relayers_state.unrewarded_relayer_entries as usize - ] - .into(), - last_confirmed_nonce: 1, - }, - StorageProofSize::Minimal(0), - ); + let (para_state_root, para_storage_proof) = + prepare_message_delivery_storage_proof::( + lane_id, + InboundLaneData { + relayers: vec![ + UnrewardedRelayer { + relayer: relayer_id_at_this_chain.into(), + messages: DeliveredMessages::new(1) + }; + relayers_state.unrewarded_relayer_entries as usize + ] + .into(), + last_confirmed_nonce: 1, + }, + UnverifiedStorageProofParams::default(), + ); let (relay_chain_header, justification, bridged_para_head, parachain_heads, para_heads_proof) = - make_complex_bridged_parachain_heads_proof::( + make_complex_bridged_parachain_heads_proof::( para_state_root, para_header_number, relay_header_number, @@ -334,7 +331,7 @@ where } /// Make bridged parachain header with given state root and relay header that is finalizing it. -pub fn make_complex_bridged_parachain_heads_proof( +pub fn make_complex_bridged_parachain_heads_proof( para_state_root: ParaHash, para_header_number: u32, relay_header_number: BlockNumberOf, @@ -350,20 +347,17 @@ pub fn make_complex_bridged_parachain_heads_proof( where BridgedRelayChain: bp_runtime::Chain + ChainWithGrandpa, - MB: MessageBridge, - ::BridgedChain: Send + Sync + 'static, - ::ThisChain: Send + Sync + 'static, - UnderlyingChainOf>: bp_runtime::Chain + Parachain, + BridgedParachain: bp_runtime::Chain + Parachain, { let bridged_para_head = ParaHead( - bp_test_utils::test_header_with_root::>( + bp_test_utils::test_header_with_root::>( para_header_number.into(), para_state_root, ) .encode(), ); let (relay_state_root, para_heads_proof, parachain_heads) = - prepare_parachain_heads_proof::>(vec![( + prepare_parachain_heads_proof::>(vec![( bridged_para_id, bridged_para_head.clone(), )]); diff --git a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs index 9285a1e7ad4500a4c2c7db73d9966dd711d852be..106eacd799ca3aee1daea2769423976154d50337 100644 --- a/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs +++ b/cumulus/parachains/runtimes/bridge-hubs/test-utils/src/test_data/mod.rs @@ -32,20 +32,16 @@ use bp_messages::MessageNonce; use bp_runtime::BasicOperatingMode; use bp_test_utils::authority_list; use xcm::GetVersion; -use xcm_builder::{HaulBlob, HaulBlobError, HaulBlobExporter}; +use xcm_builder::{BridgeMessage, HaulBlob, HaulBlobError, HaulBlobExporter}; use xcm_executor::traits::{validate_export, ExportXcm}; -pub fn prepare_inbound_xcm( - xcm_message: Xcm, - destination: InteriorLocation, -) -> Vec { - let location = xcm::VersionedInteriorLocation::V4(destination); - let xcm = xcm::VersionedXcm::::V4(xcm_message); - // this is the `BridgeMessage` from polkadot xcm builder, but it has no constructor - // or public fields, so just tuple - // (double encoding, because `.encode()` is called on original Xcm BLOB when it is pushed - // to the storage) - (location, xcm).encode().encode() +pub fn prepare_inbound_xcm(xcm_message: Xcm<()>, destination: InteriorLocation) -> Vec { + let location = xcm::VersionedInteriorLocation::from(destination); + let xcm = xcm::VersionedXcm::<()>::from(xcm_message); + + // (double encoding, because `.encode()` is called on original Xcm BLOB when it is pushed to the + // storage) + BridgeMessage { universal_dest: location, message: xcm }.encode().encode() } /// Helper that creates InitializationData mock data, that can be used to initialize bridge diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml b/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml index 8e7aa6d346420e0e65c169b539720d6264ab7b80..e98508ea02e63f7497f4263b4aea33d08f7e45c8 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/Cargo.toml @@ -10,87 +10,87 @@ description = "Westend Collectives Parachain Runtime" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-asset-rate = { path = "../../../../../substrate/frame/asset-rate", default-features = false } -pallet-alliance = { path = "../../../../../substrate/frame/alliance", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-collective = { path = "../../../../../substrate/frame/collective", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-preimage = { path = "../../../../../substrate/frame/preimage", default-features = false } -pallet-proxy = { path = "../../../../../substrate/frame/proxy", default-features = false } -pallet-scheduler = { path = "../../../../../substrate/frame/scheduler", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-state-trie-migration = { path = "../../../../../substrate/frame/state-trie-migration", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-treasury = { path = "../../../../../substrate/frame/treasury", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -pallet-referenda = { path = "../../../../../substrate/frame/referenda", default-features = false } -pallet-ranked-collective = { path = "../../../../../substrate/frame/ranked-collective", default-features = false } -pallet-core-fellowship = { path = "../../../../../substrate/frame/core-fellowship", default-features = false } -pallet-salary = { path = "../../../../../substrate/frame/salary", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-arithmetic = { path = "../../../../../substrate/primitives/arithmetic", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-asset-rate = { workspace = true } +pallet-alliance = { workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-collective = { workspace = true } +pallet-multisig = { workspace = true } +pallet-preimage = { workspace = true } +pallet-proxy = { workspace = true } +pallet-scheduler = { workspace = true } +pallet-session = { workspace = true } +pallet-state-trie-migration = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-treasury = { workspace = true } +pallet-utility = { workspace = true } +pallet-referenda = { workspace = true } +pallet-ranked-collective = { workspace = true } +pallet-core-fellowship = { workspace = true } +pallet-salary = { workspace = true } +sp-api = { workspace = true } +sp-arithmetic = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", default-features = false } +pallet-xcm = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +westend-runtime-constants = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +pallet-message-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -pallet-collective-content = { path = "../../../pallets/collective-content", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } +pallet-collator-selection = { workspace = true } +pallet-collective-content = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dev-dependencies] -sp-io = { path = "../../../../../substrate/primitives/io", features = ["std"] } +sp-io = { features = ["std"], workspace = true, default-features = true } [features] default = ["std"] @@ -130,6 +130,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "cumulus-pallet-aura-ext/try-runtime", @@ -227,7 +228,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -236,10 +236,11 @@ std = [ "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/ambassador/mod.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/ambassador/mod.rs index 0c9f428c1396bede97a67002d0554d98d62dbc39..a052a9d3800cc6880ccee84358883194cb46eb80 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/ambassador/mod.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/ambassador/mod.rs @@ -117,6 +117,7 @@ impl pallet_ranked_collective::Config for Runtime type MinRankOfClass = sp_runtime::traits::Identity; type MemberSwappedHandler = (crate::AmbassadorCore, crate::AmbassadorSalary); type VoteWeight = pallet_ranked_collective::Linear; + type MaxMemberCount = (); #[cfg(feature = "runtime-benchmarks")] type BenchmarkSetup = (crate::AmbassadorCore, crate::AmbassadorSalary); } @@ -219,7 +220,9 @@ impl pallet_core_fellowship::Config for Runtime { >; type ApproveOrigin = PromoteOrigin; type PromoteOrigin = PromoteOrigin; + type FastPromoteOrigin = Self::PromoteOrigin; type EvidenceSize = ConstU32<65536>; + type MaxRank = ConstU32<9>; } pub type AmbassadorSalaryInstance = pallet_salary::Instance2; diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs index 94765287637b57d47c588d9a4359666d1b54f509..942e0c294dd022c7c4dacf4febaf99b6ac686dbf 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/fellowship/mod.rs @@ -30,7 +30,7 @@ use frame_support::{ parameter_types, traits::{ tokens::UnityOrOuterConversion, EitherOf, EitherOfDiverse, FromContains, MapSuccess, - NeverEnsureOrigin, OriginTrait, TryWithMorphedArg, + OriginTrait, TryWithMorphedArg, }, PalletId, }; @@ -55,8 +55,6 @@ use xcm_builder::{AliasesIntoAccountId32, PayOverXcm}; #[cfg(feature = "runtime-benchmarks")] use crate::impls::benchmarks::{OpenHrmpChannel, PayWithEnsure}; -#[cfg(feature = "runtime-benchmarks")] -use testnet_parachains_constants::westend::currency::DOLLARS; /// The Fellowship members' ranks. pub mod ranks { @@ -152,6 +150,7 @@ impl pallet_ranked_collective::Config for Runtime type MinRankOfClass = tracks::MinRankOfClass; type MemberSwappedHandler = (crate::FellowshipCore, crate::FellowshipSalary); type VoteWeight = pallet_ranked_collective::Geometric; + type MaxMemberCount = (); #[cfg(feature = "runtime-benchmarks")] type BenchmarkSetup = (crate::FellowshipCore, crate::FellowshipSalary); } @@ -209,7 +208,9 @@ impl pallet_core_fellowship::Config for Runtime { >, EnsureCanPromoteTo, >; + type FastPromoteOrigin = Self::PromoteOrigin; type EvidenceSize = ConstU32<65536>; + type MaxRank = ConstU32<9>; } pub type FellowshipSalaryInstance = pallet_salary::Instance1; @@ -269,16 +270,6 @@ parameter_types! { pub SelfParaId: ParaId = ParachainInfo::parachain_id(); } -#[cfg(feature = "runtime-benchmarks")] -parameter_types! { - // Benchmark bond. Needed to make `propose_spend` work. - pub const TenPercent: Permill = Permill::from_percent(10); - // Benchmark minimum. Needed to make `propose_spend` work. - pub const BenchmarkProposalBondMinimum: Balance = 1 * DOLLARS; - // Benchmark maximum. Needed to make `propose_spend` work. - pub const BenchmarkProposalBondMaximum: Balance = 10 * DOLLARS; -} - /// [`PayOverXcm`] setup to pay the Fellowship Treasury. pub type FellowshipTreasuryPaymaster = PayOverXcm< FellowshipTreasuryInteriorLocation, @@ -294,28 +285,6 @@ pub type FellowshipTreasuryPaymaster = PayOverXcm< pub type FellowshipTreasuryInstance = pallet_treasury::Instance1; impl pallet_treasury::Config for Runtime { - // The creation of proposals via the treasury pallet is deprecated and should not be utilized. - // Instead, public or fellowship referenda should be used to propose and command the treasury - // spend or spend_local dispatchables. The parameters below have been configured accordingly to - // discourage its use. - // TODO: replace with `NeverEnsure` once polkadot-sdk 1.5 is released. - type ApproveOrigin = NeverEnsureOrigin<()>; - type OnSlash = (); - #[cfg(not(feature = "runtime-benchmarks"))] - type ProposalBond = HundredPercent; - #[cfg(not(feature = "runtime-benchmarks"))] - type ProposalBondMinimum = MaxBalance; - #[cfg(not(feature = "runtime-benchmarks"))] - type ProposalBondMaximum = MaxBalance; - - #[cfg(feature = "runtime-benchmarks")] - type ProposalBond = TenPercent; - #[cfg(feature = "runtime-benchmarks")] - type ProposalBondMinimum = BenchmarkProposalBondMinimum; - #[cfg(feature = "runtime-benchmarks")] - type ProposalBondMaximum = BenchmarkProposalBondMaximum; - // end. - type WeightInfo = weights::pallet_treasury::WeightInfo; type PalletId = FellowshipTreasuryPalletId; type Currency = Balances; diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/impls.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/impls.rs index e5b176fc77873805fb0e4ed6dba74d720ea3479a..ed5d4870e4a6d1722e1587a650395c6dd2c742dd 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/impls.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/impls.rs @@ -14,6 +14,8 @@ // limitations under the License. use crate::OriginCaller; +use alloc::boxed::Box; +use core::{cmp::Ordering, marker::PhantomData}; use frame_support::{ dispatch::DispatchResultWithPostInfo, traits::{Currency, PrivilegeCmp}, @@ -21,7 +23,6 @@ use frame_support::{ }; use pallet_alliance::{ProposalIndex, ProposalProvider}; use sp_runtime::DispatchError; -use sp_std::{cmp::Ordering, marker::PhantomData, prelude::*}; type AccountIdOf = ::AccountId; diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs index 35b505d9da6a786392af8628b09fbaf299d54609..21206d26dd573cc1473f3ba569433e9b7e61e7af 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/lib.rs @@ -42,10 +42,15 @@ mod weights; pub mod xcm_config; // Fellowship configurations. pub mod fellowship; + +extern crate alloc; + pub use ambassador::pallet_ambassador_origins; +use alloc::{vec, vec::Vec}; +use ambassador::AmbassadorCoreInstance; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; -use fellowship::{pallet_fellowship_origins, Fellows}; +use fellowship::{pallet_fellowship_origins, Fellows, FellowshipCoreInstance}; use impls::{AllianceProposalProvider, EqualOrGreatestRootCmp}; use sp_api::impl_runtime_apis; use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; @@ -56,7 +61,6 @@ use sp_runtime::{ ApplyExtrinsicResult, Perbill, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -69,10 +73,10 @@ use frame_support::{ genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ - fungible::HoldConsideration, ConstBool, ConstU16, ConstU32, ConstU64, ConstU8, - EitherOfDiverse, InstanceFilter, LinearStoragePrice, TransformOrigin, + fungible::HoldConsideration, ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, + InstanceFilter, LinearStoragePrice, TransformOrigin, }, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -102,7 +106,11 @@ use pallet_xcm::{EnsureXcm, IsVoiceOfBody}; use polkadot_runtime_common::{ impls::VersionedLocatableAsset, BlockHashCount, SlowAdjustingFeeUpdate, }; -use xcm::latest::{prelude::*, BodyId}; +use xcm::prelude::*; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; @@ -117,7 +125,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("collectives-westend"), impl_name: create_runtime_str!("collectives-westend"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 6, @@ -158,6 +166,7 @@ parameter_types! { }) .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO) .build_or_panic(); + pub const SS58Prefix: u8 = 42; } // Configure FRAME pallets to include in runtime. @@ -175,7 +184,7 @@ impl frame_system::Config for Runtime { type Version = Version; type AccountData = pallet_balances::AccountData; type SystemWeightInfo = weights::frame_system::WeightInfo; - type SS58Prefix = ConstU16<0>; + type SS58Prefix = SS58Prefix; type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode; type MaxConsumers = frame_support::traits::ConstU32<16>; } @@ -420,7 +429,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -448,13 +457,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type VersionWrapper = PolkadotXcm; // Enqueue XCMP messages from siblings for later processing. type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EitherOfDiverse, Fellows>; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } @@ -727,8 +745,13 @@ type Migrations = ( pallet_collator_selection::migration::v2::MigrationToV2, // unreleased cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, + // unreleased + pallet_core_fellowship::migration::MigrateV0ToV1, + // unreleased + pallet_core_fellowship::migration::MigrateV0ToV1, ); /// Executive: handles dispatch to the various modules. @@ -817,7 +840,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -921,6 +944,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::WndLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::WndLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -973,7 +1050,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -1022,7 +1099,7 @@ impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(Assets, u32, Location, Box)> { + ) -> Option<(Assets, u32, Location, alloc::boxed::Box)> { // Collectives only supports teleports to system parachain. // Relay/native token can be teleported between Collectives and Relay. let native_location = Parent.into(); diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/cumulus_pallet_parachain_system.rs index 0b7a2fc21cde4f12c821a0e89982db4813f3f832..92c8c88b515474ed5335f306c487ca1217a938b6 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/cumulus_pallet_parachain_system.rs @@ -47,7 +47,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs index f40940a8b25faa7c441b1ac9b237cb34e671cf17..6bedfcc7e012383657a059b87942517644057d8a 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_ambassador_core.rs @@ -58,6 +58,17 @@ impl pallet_core_fellowship::WeightInfo for WeightInfo< .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } + /// Storage: `AmbassadorCore::Params` (r:0 w:1) + /// Proof: `AmbassadorCore::Params` (`max_values`: Some(1), `max_size`: Some(364), added: 859, mode: `MaxEncodedLen`) + fn set_partial_params() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 11_000_000 picoseconds. + Weight::from_parts(11_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } /// Storage: `AmbassadorCore::Member` (r:1 w:1) /// Proof: `AmbassadorCore::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) /// Storage: `AmbassadorCollective::Members` (r:1 w:1) @@ -160,6 +171,20 @@ impl pallet_core_fellowship::WeightInfo for WeightInfo< .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(6)) } + fn promote_fast(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `16844` + // Estimated: `19894 + r * (2489 ±0)` + // Minimum execution time: 45_065_000 picoseconds. + Weight::from_parts(34_090_392, 19894) + // Standard Error: 18_620 + .saturating_add(Weight::from_parts(13_578_046, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 2489).saturating_mul(r.into())) + } /// Storage: `AmbassadorCollective::Members` (r:1 w:0) /// Proof: `AmbassadorCollective::Members` (`max_values`: None, `max_size`: Some(42), added: 2517, mode: `MaxEncodedLen`) /// Storage: `AmbassadorCore::Member` (r:1 w:1) diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs index 471ee82ead729ea5abff616f0c9fe3a86704fd91..05014e273f0009bf212969ba8705879747eedd75 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_core_fellowship_fellowship_core.rs @@ -57,6 +57,17 @@ impl pallet_core_fellowship::WeightInfo for WeightInfo< .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } + /// Storage: `FellowshipCore::Params` (r:0 w:1) + /// Proof: `FellowshipCore::Params` (`max_values`: Some(1), `max_size`: Some(364), added: 859, mode: `MaxEncodedLen`) + fn set_partial_params() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 11_000_000 picoseconds. + Weight::from_parts(12_000_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } /// Storage: `FellowshipCore::Member` (r:1 w:1) /// Proof: `FellowshipCore::Member` (`max_values`: None, `max_size`: Some(49), added: 2524, mode: `MaxEncodedLen`) /// Storage: `FellowshipCollective::Members` (r:1 w:1) @@ -159,6 +170,20 @@ impl pallet_core_fellowship::WeightInfo for WeightInfo< .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(6)) } + fn promote_fast(r: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `16844` + // Estimated: `19894 + r * (2489 ±0)` + // Minimum execution time: 45_065_000 picoseconds. + Weight::from_parts(34_090_392, 19894) + // Standard Error: 18_620 + .saturating_add(Weight::from_parts(13_578_046, 0).saturating_mul(r.into())) + .saturating_add(T::DbWeight::get().reads(3_u64)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(r.into()))) + .saturating_add(T::DbWeight::get().writes(3_u64)) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(r.into()))) + .saturating_add(Weight::from_parts(0, 2489).saturating_mul(r.into())) + } /// Storage: `FellowshipCollective::Members` (r:1 w:0) /// Proof: `FellowshipCollective::Members` (`max_values`: None, `max_size`: Some(42), added: 2517, mode: `MaxEncodedLen`) /// Storage: `FellowshipCore::Member` (r:1 w:1) diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_message_queue.rs index 4bd71c4e7d497b84f9a5b910015e439b69e41ef9..0bb6d3d0f1c451e6fd9bde07cced236845d380a6 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_message_queue.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs index 58540e646d8c3885bf84da512e2ddc3e42abc80e..5c513c3754ce84605465aa48ac43e7731e798d2a 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/weights/pallet_treasury.rs @@ -62,43 +62,6 @@ impl pallet_treasury::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: `FellowshipTreasury::ProposalCount` (r:1 w:1) - /// Proof: `FellowshipTreasury::ProposalCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `FellowshipTreasury::Proposals` (r:0 w:1) - /// Proof: `FellowshipTreasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) - fn propose_spend() -> Weight { - // Proof Size summary in bytes: - // Measured: `143` - // Estimated: `1489` - // Minimum execution time: 264_000_000 picoseconds. - Weight::from_parts(277_000_000, 0) - .saturating_add(Weight::from_parts(0, 1489)) - .saturating_add(T::DbWeight::get().reads(1)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: `FellowshipTreasury::Proposals` (r:1 w:1) - /// Proof: `FellowshipTreasury::Proposals` (`max_values`: None, `max_size`: Some(108), added: 2583, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:1 w:1) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - fn reject_proposal() -> Weight { - // Proof Size summary in bytes: - // Measured: `301` - // Estimated: `3593` - // Minimum execution time: 289_000_000 picoseconds. - Weight::from_parts(312_000_000, 0) - .saturating_add(Weight::from_parts(0, 3593)) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// The range of component `p` is `[0, 99]`. - fn approve_proposal(_p: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `0` - // Estimated: `0` - // Minimum execution time: 0_000 picoseconds. - Weight::from_parts(0, 0) - .saturating_add(Weight::from_parts(0, 0)) - } /// Storage: `FellowshipTreasury::Approvals` (r:1 w:1) /// Proof: `FellowshipTreasury::Approvals` (`max_values`: Some(1), `max_size`: Some(402), added: 897, mode: `MaxEncodedLen`) fn remove_approval() -> Weight { diff --git a/cumulus/parachains/runtimes/collectives/collectives-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/collectives/collectives-westend/src/xcm_config.rs index c68f230a16dc3d35b861df5aa7667d61d4cf53cf..08b1d192b0be18c73b5cad3cc26ead88bdbacb64 100644 --- a/cumulus/parachains/runtimes/collectives/collectives-westend/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/collectives/collectives-westend/src/xcm_config.rs @@ -40,14 +40,15 @@ use xcm_builder::{ DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FixedWeightBounds, FrameTransactionalProcessor, FungibleAdapter, IsConcrete, LocatableAssetId, OriginToPluralityVoice, ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, - SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, - SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, - UsingComponents, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, - XcmFeeToAccount, + SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, + SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, + TrailingSetTopicAsId, UsingComponents, WithComputedOrigin, WithUniqueTopic, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; parameter_types! { + pub const RootLocation: Location = Location::here(); pub const WndLocation: Location = Location::parent(); pub const RelayNetwork: Option = Some(NetworkId::Westend); pub RelayChainOrigin: RuntimeOrigin = cumulus_pallet_xcm::Origin::Relay.into(); @@ -139,6 +140,13 @@ impl Contains for ParentOrParentsPlurality { } } +pub struct LocalPlurality; +impl Contains for LocalPlurality { + fn contains(loc: &Location) -> bool { + matches!(loc.unpack(), (0, [Plurality { .. }])) + } +} + pub type Barrier = TrailingSetTopicAsId< DenyThenTry< DenyReserveTransferToRelayChain, @@ -173,6 +181,8 @@ pub type Barrier = TrailingSetTopicAsId< pub type WaivedLocations = ( RelayOrOtherSystemParachains, Equals, + Equals, + LocalPlurality, ); /// Cases where a remote origin is accepted as trusted Teleporter for a given asset: @@ -209,7 +219,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/constants/Cargo.toml b/cumulus/parachains/runtimes/constants/Cargo.toml index 561e8276b5f0543001e10fd21345ea5d3a65fee5..d54f1e7db6c167480858758bf56ed07941fb06c2 100644 --- a/cumulus/parachains/runtimes/constants/Cargo.toml +++ b/cumulus/parachains/runtimes/constants/Cargo.toml @@ -13,20 +13,20 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -smallvec = "1.11.0" +smallvec = { workspace = true, default-features = true } # Substrate -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +frame-support = { workspace = true } +sp-runtime = { workspace = true } # Polkadot -polkadot-core-primitives = { path = "../../../../polkadot/core-primitives", default-features = false } -rococo-runtime-constants = { path = "../../../../polkadot/runtime/rococo/constants", default-features = false, optional = true } -westend-runtime-constants = { path = "../../../../polkadot/runtime/westend/constants", default-features = false, optional = true } -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } +polkadot-core-primitives = { workspace = true } +rococo-runtime-constants = { optional = true, workspace = true } +westend-runtime-constants = { optional = true, workspace = true } +xcm = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] diff --git a/cumulus/parachains/runtimes/constants/src/westend.rs b/cumulus/parachains/runtimes/constants/src/westend.rs index 607d91e8808d7d9c0aacaa8d1f4056ba5ff06821..fec66cec2eb6a8df284a50b95c6b71c6a0d81c17 100644 --- a/cumulus/parachains/runtimes/constants/src/westend.rs +++ b/cumulus/parachains/runtimes/constants/src/westend.rs @@ -168,3 +168,19 @@ pub mod time { pub const HOURS: BlockNumber = MINUTES * 60; pub const DAYS: BlockNumber = HOURS * 24; } + +pub mod snowbridge { + use frame_support::parameter_types; + use xcm::opaque::lts::NetworkId; + + /// The pallet index of the Ethereum inbound queue pallet in the bridge hub runtime. + pub const INBOUND_QUEUE_PALLET_INDEX: u8 = 80; + + parameter_types! { + /// Network and location for the Ethereum chain. On Westend, the Ethereum chain bridged + /// to is the Sepolia Ethereum testnet, with chain ID 11155111. + /// + /// + pub EthereumNetwork: NetworkId = NetworkId::Ethereum { chain_id: 11155111 }; + } +} diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml b/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml index 74c5b5f8115958d0894af621e6c7307e3f67b9b7..dfa75b8d3cf3acf1bdf5e04adaf7c369c2ff3983 100644 --- a/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml +++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/Cargo.toml @@ -13,73 +13,73 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1", optional = true } +codec = { features = ["derive"], workspace = true } +hex-literal = { optional = true, workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } # Substrate -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-try-runtime = { path = "../../../../../substrate/frame/try-runtime", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -frame-system-rpc-runtime-api = { path = "../../../../../substrate/frame/system/rpc/runtime-api", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-insecure-randomness-collective-flip = { path = "../../../../../substrate/frame/insecure-randomness-collective-flip", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-contracts = { path = "../../../../../substrate/frame/contracts", default-features = false } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } +frame-benchmarking = { optional = true, workspace = true } +frame-try-runtime = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-insecure-randomness-collective-flip = { workspace = true } +pallet-balances = { workspace = true } +pallet-multisig = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +pallet-sudo = { workspace = true } +pallet-contracts = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +rococo-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +pallet-message-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } [features] default = ["std"] @@ -132,7 +132,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -140,6 +139,7 @@ std = [ "testnet-parachains-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -169,6 +169,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -202,4 +203,4 @@ try-runtime = [ # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/contracts.rs b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/contracts.rs index fcd786711bbe90096f2ef5b8d427cec23879027b..e8cc9d02fb0e4c6ac2db7ada26a641fea055ea76 100644 --- a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/contracts.rs +++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/contracts.rs @@ -65,6 +65,7 @@ impl Config for Runtime { type AddressGenerator = DefaultAddressGenerator; type MaxCodeLen = ConstU32<{ 123 * 1024 }>; type MaxStorageKeyLen = ConstU32<128>; + type MaxTransientStorageSize = ConstU32<{ 1 * 1024 * 1024 }>; type UnsafeUnstableInterface = ConstBool; type UploadOrigin = EnsureSigned; type InstantiateOrigin = EnsureSigned; diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs index df39cd811d1fd2751ea9ed9a4e277b2e536f0965..bf173fb618afc91601b11f2a31a93a8a928be15b 100644 --- a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs +++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/lib.rs @@ -29,6 +29,9 @@ mod contracts; mod weights; mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::AggregateMessageOrigin; use sp_api::impl_runtime_apis; @@ -40,7 +43,6 @@ use sp_runtime::{ ApplyExtrinsicResult, Perbill, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -50,8 +52,8 @@ use frame_support::{ dispatch::DispatchClass, genesis_builder_helper::{build_state, get_preset}, parameter_types, - traits::{ConstBool, ConstU16, ConstU32, ConstU64, ConstU8}, - weights::{ConstantMultiplier, Weight}, + traits::{ConstBool, ConstU32, ConstU64, ConstU8}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::limits::{BlockLength, BlockWeights}; @@ -62,7 +64,12 @@ use parachains_common::{ }; pub use parachains_common::{AuraId, Balance}; use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*}; +use xcm::prelude::*; use xcm_config::CollatorSelectionUpdateOrigin; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; @@ -106,6 +113,7 @@ pub type Migrations = ( pallet_contracts::Migration, // unreleased cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); @@ -136,7 +144,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("contracts-rococo"), impl_name: create_runtime_str!("contracts-rococo"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 7, @@ -171,6 +179,7 @@ parameter_types! { }) .avg_block_initialization(AVERAGE_ON_INITIALIZE_RATIO) .build_or_panic(); + pub const SS58Prefix: u8 = 42; } // Configure FRAME pallets to include in runtime. @@ -187,7 +196,7 @@ impl frame_system::Config for Runtime { type Version = Version; type AccountData = pallet_balances::AccountData; type SystemWeightInfo = frame_system::weights::SubstrateWeight; - type SS58Prefix = ConstU16<42>; + type SS58Prefix = SS58Prefix; type OnSetCode = cumulus_pallet_parachain_system::ParachainSetCode; type MaxConsumers = ConstU32<16>; } @@ -318,7 +327,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -480,7 +489,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -584,6 +593,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -704,7 +767,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -754,7 +817,7 @@ impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(Assets, u32, Location, Box)> { + ) -> Option<(Assets, u32, Location, alloc::boxed::Box)> { // Contracts-System-Para only supports teleports to system parachain. // Relay/native token can be teleported between Contracts-System-Para and Relay. let native_location = Parent.into(); diff --git a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/xcm_config.rs index 8c33710198605f05ec2f3f71c413e03190a3616c..6a41cf75d354693d232b9719289b8edefe1ec835 100644 --- a/cumulus/parachains/runtimes/contracts/contracts-rococo/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/contracts/contracts-rococo/src/xcm_config.rs @@ -42,10 +42,10 @@ use xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FixedWeightBounds, FrameTransactionalProcessor, FungibleAdapter, IsConcrete, NativeAsset, ParentAsSuperuser, - ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, - SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, - TrailingSetTopicAsId, UsingComponents, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + ParentIsPreset, RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, + SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, + SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, + WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -191,7 +191,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; @@ -284,7 +284,11 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { cumulus_primitives_core::ParaId, parachains_common::message_queue::ParaIdToSibling, >; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EitherOfDiverse< EnsureRoot, EnsureXcm>, @@ -294,6 +298,11 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + parameter_types! { pub const RelayOrigin: AggregateMessageOrigin = AggregateMessageOrigin::Parent; } diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml b/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml index ee9f5e87ec876d73d80eb088806f5b36f12079db..07d133c80be7293b2687d92dcf0ef08713239fe7 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/Cargo.toml @@ -10,73 +10,74 @@ license = "Apache-2.0" workspace = true [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -hex-literal = "0.4.1" +codec = { features = ["derive"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-broker = { path = "../../../../../substrate/frame/broker", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-broker = { workspace = true } +pallet-multisig = { workspace = true } +pallet-session = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-inherents = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../../../../polkadot/xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +rococo-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } [features] default = ["std"] @@ -93,6 +94,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking?/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -130,7 +132,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -138,6 +139,7 @@ std = [ "testnet-parachains-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -167,6 +169,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -196,4 +199,14 @@ try-runtime = [ "sp-runtime/try-runtime", ] -fast-runtime = [] +fast-runtime = [ + "rococo-runtime-constants/fast-runtime", +] + +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + +# A feature that should be enabled when the runtime should be built for on-chain +# deployment. This will disable stuff that shouldn't be part of the on-chain wasm +# to make it smaller, like logging for example. +on-chain-release-build = ["metadata-hash"] diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/build.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/build.rs index 28dacd20cf305ebdbc57eb2a30e3c98e4f8853d9..368a1e427aaafe9e45ad4370dbbaba16f5a31b06 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/build.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/build.rs @@ -13,20 +13,26 @@ // See the License for the specific language governing permissions and // limitations under the License. -#[cfg(feature = "std")] +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] fn main() { - substrate_wasm_builder::WasmBuilder::new() - .with_current_project() - .export_heap_base() - .import_memory() + substrate_wasm_builder::WasmBuilder::build_using_defaults(); + + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .set_file_name("fast_runtime_binary.rs") + .enable_feature("fast-runtime") + .build(); +} + +#[cfg(all(feature = "metadata-hash", feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("ROC", 12) .build(); - substrate_wasm_builder::WasmBuilder::new() - .with_current_project() + substrate_wasm_builder::WasmBuilder::init_with_defaults() .set_file_name("fast_runtime_binary.rs") .enable_feature("fast-runtime") - .import_memory() - .export_heap_base() + .enable_metadata_hash("ROC", 12) .build(); } diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs index 742dd50f6fa1f421d6ce4abf221e05f6902cc2ae..76ee06a87e8d82dea17914e4f03647da2a5f307a 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/coretime.rs @@ -14,29 +14,74 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::*; +use crate::{xcm_config::LocationToAccountId, *}; use codec::{Decode, Encode}; use cumulus_pallet_parachain_system::RelaychainDataProvider; use cumulus_primitives_core::relay_chain; use frame_support::{ parameter_types, traits::{ - fungible::{Balanced, Credit}, - OnUnbalanced, + fungible::{Balanced, Credit, Inspect}, + tokens::{Fortitude, Preservation}, + DefensiveResult, OnUnbalanced, }, }; -use pallet_broker::{CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf}; -use parachains_common::{AccountId, Balance, BlockNumber}; +use frame_system::Pallet as System; +use pallet_broker::{ + CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf, TaskId, +}; +use parachains_common::{AccountId, Balance}; +use rococo_runtime_constants::system_parachain::coretime; +use sp_runtime::traits::{AccountIdConversion, MaybeConvert}; use xcm::latest::prelude::*; +use xcm_executor::traits::{ConvertLocation, TransactAsset}; -pub struct CreditToCollatorPot; -impl OnUnbalanced> for CreditToCollatorPot { - fn on_nonzero_unbalanced(credit: Credit) { - let staking_pot = CollatorSelection::account_id(); - let _ = >::resolve(&staking_pot, credit); +pub struct BurnCoretimeRevenue; +impl OnUnbalanced> for BurnCoretimeRevenue { + fn on_nonzero_unbalanced(amount: Credit) { + let acc = RevenueAccumulationAccount::get(); + if !System::::account_exists(&acc) { + System::::inc_providers(&acc); + } + Balances::resolve(&acc, amount).defensive_ok(); } } +type AssetTransactor = ::AssetTransactor; + +fn burn_at_relay(stash: &AccountId, value: Balance) -> Result<(), XcmError> { + let dest = Location::parent(); + let stash_location = + Junction::AccountId32 { network: None, id: stash.clone().into() }.into_location(); + let asset = Asset { id: AssetId(Location::parent()), fun: Fungible(value) }; + let dummy_xcm_context = XcmContext { origin: None, message_id: [0; 32], topic: None }; + + let withdrawn = AssetTransactor::withdraw_asset(&asset, &stash_location, None)?; + + AssetTransactor::can_check_out(&dest, &asset, &dummy_xcm_context)?; + + let parent_assets = Into::::into(withdrawn) + .reanchored(&dest, &Here.into()) + .defensive_map_err(|_| XcmError::ReanchorFailed)?; + + PolkadotXcm::send_xcm( + Here, + Location::parent(), + Xcm(vec![ + Instruction::UnpaidExecution { + weight_limit: WeightLimit::Unlimited, + check_origin: None, + }, + ReceiveTeleportedAsset(parent_assets.clone()), + BurnAsset(parent_assets), + ]), + )?; + + AssetTransactor::check_out(&dest, &asset, &dummy_xcm_context); + + Ok(()) +} + /// A type containing the encoding of the coretime pallet in the Relay chain runtime. Used to /// construct any remote calls. The codec index must correspond to the index of `Coretime` in the /// `construct_runtime` of the Relay chain. @@ -66,11 +111,7 @@ enum CoretimeProviderCalls { parameter_types! { pub const BrokerPalletId: PalletId = PalletId(*b"py/broke"); -} - -parameter_types! { - pub storage CoreCount: Option = None; - pub storage CoretimeRevenue: Option<(BlockNumber, Balance)> = None; + pub RevenueAccumulationAccount: AccountId = BrokerPalletId::get().into_sub_account_truncating(b"burnstash"); } /// Type that implements the `CoretimeInterface` for the allocation of Coretime. Meant to operate @@ -205,26 +246,39 @@ impl CoretimeInterface for CoretimeAllocator { } } - fn check_notify_revenue_info() -> Option<(RCBlockNumberOf, Self::Balance)> { - let revenue = CoretimeRevenue::get(); - CoretimeRevenue::set(&None); - revenue + fn on_new_timeslice(_t: pallet_broker::Timeslice) { + let stash = RevenueAccumulationAccount::get(); + let value = + Balances::reducible_balance(&stash, Preservation::Expendable, Fortitude::Polite); + + if value > 0 { + log::debug!(target: "runtime::coretime", "Going to burn {value} stashed tokens at RC"); + match burn_at_relay(&stash, value) { + Ok(()) => { + log::debug!(target: "runtime::coretime", "Succesfully burnt {value} tokens"); + }, + Err(err) => { + log::error!(target: "runtime::coretime", "burn_at_relay failed: {err:?}"); + }, + } + } } +} - #[cfg(feature = "runtime-benchmarks")] - fn ensure_notify_revenue_info(when: RCBlockNumberOf, revenue: Self::Balance) { - CoretimeRevenue::set(&Some((when, revenue))); +pub struct SovereignAccountOf; +impl MaybeConvert for SovereignAccountOf { + fn maybe_convert(id: TaskId) -> Option { + // Currently all tasks are parachains. + let location = Location::new(1, [Parachain(id)]); + LocationToAccountId::convert_location(&location) } } impl pallet_broker::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; - type OnRevenue = CreditToCollatorPot; - #[cfg(feature = "fast-runtime")] - type TimeslicePeriod = ConstU32<10>; - #[cfg(not(feature = "fast-runtime"))] - type TimeslicePeriod = ConstU32<80>; + type OnRevenue = BurnCoretimeRevenue; + type TimeslicePeriod = ConstU32<{ coretime::TIMESLICE_PERIOD }>; type MaxLeasedCores = ConstU32<50>; type MaxReservedCores = ConstU32<10>; type Coretime = CoretimeAllocator; @@ -232,5 +286,7 @@ impl pallet_broker::Config for Runtime { type WeightInfo = weights::pallet_broker::WeightInfo; type PalletId = BrokerPalletId; type AdminOrigin = EnsureRoot; - type PriceAdapter = pallet_broker::Linear; + type SovereignAccountOf = SovereignAccountOf; + type MaxAutoRenewals = ConstU32<100>; + type PriceAdapter = pallet_broker::CenterTargetPrice; } diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs index ab925b04eb7c17cd63bdc1a193c3fd9fabe3d2b5..25324bf1776420bed76df472739f55cce4295ccc 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/lib.rs @@ -33,6 +33,9 @@ mod coretime; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; use frame_support::{ @@ -41,7 +44,7 @@ use frame_support::{ genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin}, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -66,16 +69,19 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, DispatchError, MultiAddress, Perbill, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; -use xcm::latest::prelude::*; +use xcm::prelude::*; use xcm_config::{ FellowshipLocation, GovernanceLocation, RocRelayLocation, XcmOriginToTransactDispatchOrigin, }; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; /// The address format for describing accounts. pub type Address = MultiAddress; @@ -100,6 +106,7 @@ pub type SignedExtra = ( frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -110,7 +117,10 @@ pub type UncheckedExtrinsic = pub type Migrations = ( pallet_collator_selection::migration::v2::MigrationToV2, cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, + cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5, pallet_broker::migration::MigrateV0ToV1, + pallet_broker::migration::MigrateV1ToV2, + pallet_broker::migration::MigrateV2ToV3, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); @@ -136,10 +146,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("coretime-rococo"), impl_name: create_runtime_str!("coretime-rococo"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 1, + transaction_version: 2, state_version: 1, }; @@ -301,7 +311,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -341,13 +351,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = RootOrFellows; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + pub const PERIOD: u32 = 6 * HOURS; pub const OFFSET: u32 = 0; @@ -535,7 +554,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -645,6 +664,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::RocRelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::RocRelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -703,7 +776,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -759,7 +832,7 @@ impl_runtime_apis! { let begin = 0; let end = 42; - let region_id = pallet_broker::Pallet::::issue(core, begin, end, None, None); + let region_id = pallet_broker::Pallet::::issue(core, begin, pallet_broker::CoreMask::complete(), end, None, None); Some(( Asset { fun: NonFungible(Index(region_id.into())), diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs index 89b1c4c86632ff0d19ee4fe1428978303ef92082..35708f22de20555656feec8ba2ce822dace81303 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/pallet_broker.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for `pallet_broker` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-20, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-06-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-x5tnzzy-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("coretime-rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -54,8 +54,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_918_000 picoseconds. - Weight::from_parts(2_092_000, 0) + // Minimum execution time: 2_024_000 picoseconds. + Weight::from_parts(2_121_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `10888` // Estimated: `13506` - // Minimum execution time: 21_943_000 picoseconds. - Weight::from_parts(22_570_000, 0) + // Minimum execution time: 21_654_000 picoseconds. + Weight::from_parts(22_591_000, 0) .saturating_add(Weight::from_parts(0, 13506)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -77,8 +77,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `12090` // Estimated: `13506` - // Minimum execution time: 20_923_000 picoseconds. - Weight::from_parts(21_354_000, 0) + // Minimum execution time: 20_769_000 picoseconds. + Weight::from_parts(21_328_000, 0) .saturating_add(Weight::from_parts(0, 13506)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -93,24 +93,34 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `466` // Estimated: `1951` - // Minimum execution time: 10_687_000 picoseconds. - Weight::from_parts(11_409_000, 0) + // Minimum execution time: 10_404_000 picoseconds. + Weight::from_parts(10_941_000, 0) .saturating_add(Weight::from_parts(0, 1951)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Configuration` (r:1 w:0) /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Leases` (r:1 w:1) + /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(401), added: 896, mode: `MaxEncodedLen`) + /// Storage: `Broker::Reservations` (r:1 w:0) + /// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(12021), added: 12516, mode: `MaxEncodedLen`) + /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + /// Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + /// Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParachainSystem::LastRelayChainBlockNumber` (r:1 w:0) /// Proof: `ParachainSystem::LastRelayChainBlockNumber` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Broker::InstaPoolIo` (r:3 w:3) /// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) - /// Storage: `Broker::Reservations` (r:1 w:0) - /// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(12021), added: 12516, mode: `MaxEncodedLen`) - /// Storage: `Broker::Leases` (r:1 w:1) - /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(401), added: 896, mode: `MaxEncodedLen`) /// Storage: `Broker::SaleInfo` (r:0 w:1) /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) /// Storage: `Broker::Status` (r:0 w:1) @@ -120,33 +130,34 @@ impl pallet_broker::WeightInfo for WeightInfo { /// The range of component `n` is `[0, 1000]`. fn start_sales(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `12567` - // Estimated: `14052` - // Minimum execution time: 111_288_000 picoseconds. - Weight::from_parts(117_804_282, 0) - .saturating_add(Weight::from_parts(0, 14052)) - // Standard Error: 391 - .saturating_add(Weight::from_parts(1_243, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(8)) - .saturating_add(T::DbWeight::get().writes(66)) + // Measured: `12599` + // Estimated: `15065 + n * (1 ±0)` + // Minimum execution time: 44_085_000 picoseconds. + Weight::from_parts(127_668_002, 0) + .saturating_add(Weight::from_parts(0, 15065)) + // Standard Error: 2_231 + .saturating_add(Weight::from_parts(20_604, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(13)) + .saturating_add(T::DbWeight::get().writes(59)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::SaleInfo` (r:1 w:1) /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:1 w:0) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:0 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn purchase() -> Weight { // Proof Size summary in bytes: - // Measured: `316` + // Measured: `332` // Estimated: `3593` - // Minimum execution time: 33_006_000 picoseconds. - Weight::from_parts(34_256_000, 0) + // Minimum execution time: 45_100_000 picoseconds. + Weight::from_parts(46_263_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `Broker::Configuration` (r:1 w:0) /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) @@ -154,55 +165,55 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::SaleInfo` (r:1 w:1) /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) - /// Storage: `Broker::AllowedRenewals` (r:1 w:2) - /// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:1 w:0) + /// Storage: `Broker::PotentialRenewals` (r:1 w:2) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:0 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) fn renew() -> Weight { // Proof Size summary in bytes: - // Measured: `434` + // Measured: `553` // Estimated: `4698` - // Minimum execution time: 61_473_000 picoseconds. - Weight::from_parts(66_476_000, 0) + // Minimum execution time: 65_944_000 picoseconds. + Weight::from_parts(68_666_000, 0) .saturating_add(Weight::from_parts(0, 4698)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(4)) + .saturating_add(T::DbWeight::get().writes(5)) } /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn transfer() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 13_771_000 picoseconds. - Weight::from_parts(14_374_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 13_794_000 picoseconds. + Weight::from_parts(14_450_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Regions` (r:1 w:2) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn partition() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 15_162_000 picoseconds. - Weight::from_parts(15_742_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 15_316_000 picoseconds. + Weight::from_parts(15_787_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } /// Storage: `Broker::Regions` (r:1 w:3) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn interlace() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 16_196_000 picoseconds. - Weight::from_parts(16_796_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 16_375_000 picoseconds. + Weight::from_parts(17_113_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -211,15 +222,15 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:1 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) fn assign() -> Weight { // Proof Size summary in bytes: - // Measured: `936` + // Measured: `937` // Estimated: `4681` - // Minimum execution time: 25_653_000 picoseconds. - Weight::from_parts(27_006_000, 0) + // Minimum execution time: 25_952_000 picoseconds. + Weight::from_parts(27_198_000, 0) .saturating_add(Weight::from_parts(0, 4681)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) @@ -227,7 +238,7 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:1 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) /// Storage: `Broker::InstaPoolIo` (r:2 w:2) @@ -236,10 +247,10 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`) fn pool() -> Weight { // Proof Size summary in bytes: - // Measured: `1002` + // Measured: `1003` // Estimated: `5996` - // Minimum execution time: 31_114_000 picoseconds. - Weight::from_parts(32_235_000, 0) + // Minimum execution time: 31_790_000 picoseconds. + Weight::from_parts(32_920_000, 0) .saturating_add(Weight::from_parts(0, 5996)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(5)) @@ -255,11 +266,11 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `652` // Estimated: `6196 + m * (2520 ±0)` - // Minimum execution time: 57_280_000 picoseconds. - Weight::from_parts(58_127_480, 0) + // Minimum execution time: 56_286_000 picoseconds. + Weight::from_parts(56_946_240, 0) .saturating_add(Weight::from_parts(0, 6196)) - // Standard Error: 41_670 - .saturating_add(Weight::from_parts(1_203_066, 0).saturating_mul(m.into())) + // Standard Error: 44_472 + .saturating_add(Weight::from_parts(1_684_838, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into()))) .saturating_add(T::DbWeight::get().writes(5)) @@ -279,25 +290,25 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn purchase_credit() -> Weight { // Proof Size summary in bytes: - // Measured: `215` - // Estimated: `3680` - // Minimum execution time: 59_968_000 picoseconds. - Weight::from_parts(62_315_000, 0) - .saturating_add(Weight::from_parts(0, 3680)) + // Measured: `322` + // Estimated: `3787` + // Minimum execution time: 64_967_000 picoseconds. + Weight::from_parts(66_504_000, 0) + .saturating_add(Weight::from_parts(0, 3787)) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn drop_region() -> Weight { // Proof Size summary in bytes: - // Measured: `465` - // Estimated: `3550` - // Minimum execution time: 50_887_000 picoseconds. - Weight::from_parts(57_366_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `466` + // Estimated: `3551` + // Minimum execution time: 37_552_000 picoseconds. + Weight::from_parts(46_263_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -311,8 +322,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `463` // Estimated: `3533` - // Minimum execution time: 84_472_000 picoseconds. - Weight::from_parts(96_536_000, 0) + // Minimum execution time: 79_625_000 picoseconds. + Weight::from_parts(86_227_000, 0) .saturating_add(Weight::from_parts(0, 3533)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) @@ -329,22 +340,22 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `857` // Estimated: `3593` - // Minimum execution time: 96_371_000 picoseconds. - Weight::from_parts(104_659_000, 0) + // Minimum execution time: 88_005_000 picoseconds. + Weight::from_parts(92_984_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) - /// Storage: `Broker::AllowedRenewals` (r:1 w:1) - /// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `Broker::PotentialRenewals` (r:1 w:1) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) fn drop_renewal() -> Weight { // Proof Size summary in bytes: // Measured: `957` // Estimated: `4698` - // Minimum execution time: 51_741_000 picoseconds. - Weight::from_parts(54_461_000, 0) + // Minimum execution time: 38_877_000 picoseconds. + Weight::from_parts(40_408_000, 0) .saturating_add(Weight::from_parts(0, 4698)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -360,13 +371,15 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 1000]`. - fn request_core_count(_n: u32, ) -> Weight { + fn request_core_count(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `74` // Estimated: `3539` - // Minimum execution time: 19_901_000 picoseconds. - Weight::from_parts(21_028_116, 0) + // Minimum execution time: 20_581_000 picoseconds. + Weight::from_parts(21_610_297, 0) .saturating_add(Weight::from_parts(0, 3539)) + // Standard Error: 119 + .saturating_add(Weight::from_parts(144, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -377,29 +390,29 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `266` // Estimated: `1487` - // Minimum execution time: 5_987_000 picoseconds. - Weight::from_parts(6_412_478, 0) + // Minimum execution time: 6_079_000 picoseconds. + Weight::from_parts(6_540_110, 0) .saturating_add(Weight::from_parts(0, 1487)) - // Standard Error: 16 - .saturating_add(Weight::from_parts(47, 0).saturating_mul(n.into())) + // Standard Error: 14 + .saturating_add(Weight::from_parts(10, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) - /// Proof: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) + /// Storage: `Broker::RevenueInbox` (r:1 w:1) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) /// Storage: `Broker::InstaPoolHistory` (r:1 w:1) /// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:2 w:1) + /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn process_revenue() -> Weight { // Proof Size summary in bytes: - // Measured: `447` + // Measured: `442` // Estimated: `6196` - // Minimum execution time: 38_623_000 picoseconds. - Weight::from_parts(39_773_000, 0) + // Minimum execution time: 42_947_000 picoseconds. + Weight::from_parts(43_767_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `Broker::InstaPoolIo` (r:3 w:3) /// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) @@ -412,13 +425,15 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Workplan` (r:0 w:60) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) /// The range of component `n` is `[0, 1000]`. - fn rotate_sale(_n: u32, ) -> Weight { + fn rotate_sale(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `12514` // Estimated: `13506` - // Minimum execution time: 97_074_000 picoseconds. - Weight::from_parts(101_247_740, 0) + // Minimum execution time: 93_426_000 picoseconds. + Weight::from_parts(96_185_447, 0) .saturating_add(Weight::from_parts(0, 13506)) + // Standard Error: 116 + .saturating_add(Weight::from_parts(4, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(65)) } @@ -430,8 +445,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `42` // Estimated: `3493` - // Minimum execution time: 6_317_000 picoseconds. - Weight::from_parts(6_521_000, 0) + // Minimum execution time: 5_842_000 picoseconds. + Weight::from_parts(6_077_000, 0) .saturating_add(Weight::from_parts(0, 3493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -454,8 +469,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `1321` // Estimated: `4786` - // Minimum execution time: 32_575_000 picoseconds. - Weight::from_parts(33_299_000, 0) + // Minimum execution time: 33_278_000 picoseconds. + Weight::from_parts(34_076_000, 0) .saturating_add(Weight::from_parts(0, 4786)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(4)) @@ -474,8 +489,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `74` // Estimated: `3539` - // Minimum execution time: 15_256_000 picoseconds. - Weight::from_parts(15_927_000, 0) + // Minimum execution time: 15_779_000 picoseconds. + Weight::from_parts(16_213_000, 0) .saturating_add(Weight::from_parts(0, 3539)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(2)) @@ -486,8 +501,19 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_783_000 picoseconds. - Weight::from_parts(1_904_000, 0) + // Minimum execution time: 1_774_000 picoseconds. + Weight::from_parts(1_873_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `Broker::RevenueInbox` (r:0 w:1) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) + fn notify_revenue() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 1_858_000 picoseconds. + Weight::from_parts(1_991_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -497,19 +523,19 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) /// Storage: `Broker::CoreCountInbox` (r:1 w:0) /// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) - /// Storage: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) - /// Proof: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) + /// Storage: `Broker::RevenueInbox` (r:1 w:0) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn do_tick_base() -> Weight { // Proof Size summary in bytes: - // Measured: `398` - // Estimated: `3863` - // Minimum execution time: 12_307_000 picoseconds. - Weight::from_parts(12_967_000, 0) - .saturating_add(Weight::from_parts(0, 3863)) + // Measured: `408` + // Estimated: `1893` + // Minimum execution time: 10_874_000 picoseconds. + Weight::from_parts(11_265_000, 0) + .saturating_add(Weight::from_parts(0, 1893)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Leases` (r:1 w:1) /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(401), added: 896, mode: `MaxEncodedLen`) @@ -517,10 +543,70 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `470` // Estimated: `1886` - // Minimum execution time: 6_597_000 picoseconds. - Weight::from_parts(6_969_000, 0) + // Minimum execution time: 6_525_000 picoseconds. + Weight::from_parts(6_769_000, 0) .saturating_add(Weight::from_parts(0, 1886)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } + /// Storage: `Broker::SaleInfo` (r:1 w:1) + /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) + /// Storage: `Broker::PotentialRenewals` (r:1 w:2) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `Broker::Configuration` (r:1 w:0) + /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Status` (r:1 w:0) + /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Authorship::Author` (r:1 w:0) + /// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `System::Digest` (r:1 w:0) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Broker::AutoRenewals` (r:1 w:1) + /// Proof: `Broker::AutoRenewals` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Workplan` (r:0 w:1) + /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) + fn enable_auto_renew() -> Weight { + // Proof Size summary in bytes: + // Measured: `914` + // Estimated: `4698` + // Minimum execution time: 51_938_000 picoseconds. + Weight::from_parts(55_025_000, 4698) + .saturating_add(T::DbWeight::get().reads(8_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) + } + /// Storage: `Broker::AutoRenewals` (r:1 w:1) + /// Proof: `Broker::AutoRenewals` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + fn disable_auto_renew() -> Weight { + // Proof Size summary in bytes: + // Measured: `480` + // Estimated: `1516` + // Minimum execution time: 9_628_000 picoseconds. + Weight::from_parts(10_400_000, 1516) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + /// Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + /// Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn on_new_timeslice() -> Weight { + // Proof Size summary in bytes: + // Measured: `322` + // Estimated: `3787` + // Minimum execution time: 45_561_000 picoseconds. + Weight::from_parts(47_306_000, 0) + .saturating_add(Weight::from_parts(0, 3787)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(3)) + } } diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/mod.rs index 9f79cea831aed66a0d073109233731751cdf99ed..b8db473f10662d5b1ef045d28f943fe0cb1430b9 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/mod.rs @@ -18,10 +18,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 7ff1cce2e072339dccd52c0809aafd59337db7b4..c8dbdadf7b15dfcd2ea86326fcff2495a2087a3a 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-05-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("coretime-rococo-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -54,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 26_642_000 picoseconds. - Weight::from_parts(27_583_000, 3593) + // Minimum execution time: 29_812_000 picoseconds. + Weight::from_parts(30_526_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 35_124_000 picoseconds. - Weight::from_parts(36_510_000, 6196) + // Minimum execution time: 39_430_000 picoseconds. + Weight::from_parts(39_968_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -88,8 +88,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `207` // Estimated: `6196` - // Minimum execution time: 55_950_000 picoseconds. - Weight::from_parts(57_207_000, 6196) + // Minimum execution time: 65_555_000 picoseconds. + Weight::from_parts(67_161_000, 6196) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -118,8 +118,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3571` - // Minimum execution time: 23_747_000 picoseconds. - Weight::from_parts(24_424_000, 3571) + // Minimum execution time: 30_491_000 picoseconds. + Weight::from_parts(31_991_000, 3571) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -127,8 +127,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_853_000 picoseconds. - Weight::from_parts(1_998_000, 0) + // Minimum execution time: 2_568_000 picoseconds. + Weight::from_parts(2_703_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -136,8 +136,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 19_164_000 picoseconds. - Weight::from_parts(19_643_000, 3593) + // Minimum execution time: 22_159_000 picoseconds. + Weight::from_parts(22_517_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -159,8 +159,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3593` - // Minimum execution time: 48_708_000 picoseconds. - Weight::from_parts(49_610_000, 3593) + // Minimum execution time: 57_126_000 picoseconds. + Weight::from_parts(58_830_000, 3593) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -180,8 +180,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3571` - // Minimum execution time: 20_586_000 picoseconds. - Weight::from_parts(21_147_000, 3571) + // Minimum execution time: 26_589_000 picoseconds. + Weight::from_parts(27_285_000, 3571) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index 16412eb49a5267d3f3f38cdd285e8f3b248a5f99..676048f92ad937e7cb80f268fdc1ca4e90779d42 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/xcm_config.rs index c16b40b8675fbce2878bca4ba1106b89bbd9e9b1..f56a3c42de0210669f55f0f27feb23b44b055cd6 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-rococo/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-rococo/src/xcm_config.rs @@ -43,10 +43,10 @@ use xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, IsConcrete, NonFungibleAdapter, ParentAsSuperuser, ParentIsPreset, - RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, + RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -213,7 +213,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml b/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml index 60cc7e2f765477052332b4c422facb8b19e1f5a4..5029c82f971d134c251da574d396a2eb3d58c25a 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/Cargo.toml @@ -10,73 +10,74 @@ license = "Apache-2.0" workspace = true [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -hex-literal = "0.4.1" +codec = { features = ["derive"], workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-broker = { path = "../../../../../substrate/frame/broker", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-broker = { workspace = true } +pallet-multisig = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-inherents = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../../../../polkadot/xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +westend-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } [features] default = ["std"] @@ -93,6 +94,7 @@ std = [ "cumulus-primitives-utility/std", "frame-benchmarking?/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", @@ -128,7 +130,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -137,6 +138,7 @@ std = [ "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -165,6 +167,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -193,4 +196,14 @@ try-runtime = [ "sp-runtime/try-runtime", ] -fast-runtime = [] +fast-runtime = [ + "westend-runtime-constants/fast-runtime", +] + +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + +# A feature that should be enabled when the runtime should be built for on-chain +# deployment. This will disable stuff that shouldn't be part of the on-chain wasm +# to make it smaller, like logging for example. +on-chain-release-build = ["metadata-hash"] diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/build.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/build.rs index 28dacd20cf305ebdbc57eb2a30e3c98e4f8853d9..2f10a39d1b2e238e29ab8a726c808c713914a0b7 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/build.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/build.rs @@ -13,20 +13,26 @@ // See the License for the specific language governing permissions and // limitations under the License. -#[cfg(feature = "std")] +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] fn main() { - substrate_wasm_builder::WasmBuilder::new() - .with_current_project() - .export_heap_base() - .import_memory() + substrate_wasm_builder::WasmBuilder::build_using_defaults(); + + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .set_file_name("fast_runtime_binary.rs") + .enable_feature("fast-runtime") + .build(); +} + +#[cfg(all(feature = "metadata-hash", feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("WND", 12) .build(); - substrate_wasm_builder::WasmBuilder::new() - .with_current_project() + substrate_wasm_builder::WasmBuilder::init_with_defaults() .set_file_name("fast_runtime_binary.rs") .enable_feature("fast-runtime") - .import_memory() - .export_heap_base() + .enable_metadata_hash("WND", 12) .build(); } diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs index 41cbc62fa2115ff3828e6910b750622a91ff0251..865ff68d4c659fd8c324595eadf790be655f9655 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/coretime.rs @@ -14,29 +14,74 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::*; +use crate::{xcm_config::LocationToAccountId, *}; use codec::{Decode, Encode}; use cumulus_pallet_parachain_system::RelaychainDataProvider; use cumulus_primitives_core::relay_chain; use frame_support::{ parameter_types, traits::{ - fungible::{Balanced, Credit}, - OnUnbalanced, + fungible::{Balanced, Credit, Inspect}, + tokens::{Fortitude, Preservation}, + DefensiveResult, OnUnbalanced, }, }; -use pallet_broker::{CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf}; -use parachains_common::{AccountId, Balance, BlockNumber}; +use frame_system::Pallet as System; +use pallet_broker::{ + CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600, RCBlockNumberOf, TaskId, Timeslice, +}; +use parachains_common::{AccountId, Balance}; +use sp_runtime::traits::{AccountIdConversion, MaybeConvert}; +use westend_runtime_constants::system_parachain::coretime; use xcm::latest::prelude::*; +use xcm_executor::traits::{ConvertLocation, TransactAsset}; -pub struct CreditToCollatorPot; -impl OnUnbalanced> for CreditToCollatorPot { - fn on_nonzero_unbalanced(credit: Credit) { - let staking_pot = CollatorSelection::account_id(); - let _ = >::resolve(&staking_pot, credit); +pub struct BurnCoretimeRevenue; +impl OnUnbalanced> for BurnCoretimeRevenue { + fn on_nonzero_unbalanced(amount: Credit) { + let acc = RevenueAccumulationAccount::get(); + if !System::::account_exists(&acc) { + System::::inc_providers(&acc); + } + Balances::resolve(&acc, amount).defensive_ok(); } } +type AssetTransactor = ::AssetTransactor; + +fn burn_at_relay(stash: &AccountId, value: Balance) -> Result<(), XcmError> { + let dest = Location::parent(); + let stash_location = + Junction::AccountId32 { network: None, id: stash.clone().into() }.into_location(); + let asset = Asset { id: AssetId(Location::parent()), fun: Fungible(value) }; + let dummy_xcm_context = XcmContext { origin: None, message_id: [0; 32], topic: None }; + + let withdrawn = AssetTransactor::withdraw_asset(&asset, &stash_location, None)?; + + AssetTransactor::can_check_out(&dest, &asset, &dummy_xcm_context)?; + + let parent_assets = Into::::into(withdrawn) + .reanchored(&dest, &Here.into()) + .defensive_map_err(|_| XcmError::ReanchorFailed)?; + + PolkadotXcm::send_xcm( + Here, + Location::parent(), + Xcm(vec![ + Instruction::UnpaidExecution { + weight_limit: WeightLimit::Unlimited, + check_origin: None, + }, + ReceiveTeleportedAsset(parent_assets.clone()), + BurnAsset(parent_assets), + ]), + )?; + + AssetTransactor::check_out(&dest, &asset, &dummy_xcm_context); + + Ok(()) +} + /// A type containing the encoding of the coretime pallet in the Relay chain runtime. Used to /// construct any remote calls. The codec index must correspond to the index of `Coretime` in the /// `construct_runtime` of the Relay chain. @@ -66,11 +111,7 @@ enum CoretimeProviderCalls { parameter_types! { pub const BrokerPalletId: PalletId = PalletId(*b"py/broke"); -} - -parameter_types! { - pub storage CoreCount: Option = None; - pub storage CoretimeRevenue: Option<(BlockNumber, Balance)> = None; + pub RevenueAccumulationAccount: AccountId = BrokerPalletId::get().into_sub_account_truncating(b"burnstash"); } /// Type that implements the `CoretimeInterface` for the allocation of Coretime. Meant to operate @@ -217,26 +258,39 @@ impl CoretimeInterface for CoretimeAllocator { } } - fn check_notify_revenue_info() -> Option<(RCBlockNumberOf, Self::Balance)> { - let revenue = CoretimeRevenue::get(); - CoretimeRevenue::set(&None); - revenue + fn on_new_timeslice(_timeslice: Timeslice) { + let stash = RevenueAccumulationAccount::get(); + let value = + Balances::reducible_balance(&stash, Preservation::Expendable, Fortitude::Polite); + + if value > 0 { + log::debug!(target: "runtime::coretime", "Going to burn {value} stashed tokens at RC"); + match burn_at_relay(&stash, value) { + Ok(()) => { + log::debug!(target: "runtime::coretime", "Succesfully burnt {value} tokens"); + }, + Err(err) => { + log::error!(target: "runtime::coretime", "burn_at_relay failed: {err:?}"); + }, + } + } } +} - #[cfg(feature = "runtime-benchmarks")] - fn ensure_notify_revenue_info(when: RCBlockNumberOf, revenue: Self::Balance) { - CoretimeRevenue::set(&Some((when, revenue))); +pub struct SovereignAccountOf; +impl MaybeConvert for SovereignAccountOf { + fn maybe_convert(id: TaskId) -> Option { + // Currently all tasks are parachains. + let location = Location::new(1, [Parachain(id)]); + LocationToAccountId::convert_location(&location) } } impl pallet_broker::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; - type OnRevenue = CreditToCollatorPot; - #[cfg(feature = "fast-runtime")] - type TimeslicePeriod = ConstU32<10>; - #[cfg(not(feature = "fast-runtime"))] - type TimeslicePeriod = ConstU32<80>; + type OnRevenue = BurnCoretimeRevenue; + type TimeslicePeriod = ConstU32<{ coretime::TIMESLICE_PERIOD }>; // We don't actually need any leases at launch but set to 10 in case we want to sudo some in. type MaxLeasedCores = ConstU32<10>; type MaxReservedCores = ConstU32<10>; @@ -245,5 +299,7 @@ impl pallet_broker::Config for Runtime { type WeightInfo = weights::pallet_broker::WeightInfo; type PalletId = BrokerPalletId; type AdminOrigin = EnsureRoot; - type PriceAdapter = pallet_broker::Linear; + type SovereignAccountOf = SovereignAccountOf; + type MaxAutoRenewals = ConstU32<20>; + type PriceAdapter = pallet_broker::CenterTargetPrice; } diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs index 61c7b6e495872be4881792a2d416b0bbf91ff068..a3051e4bf2713a4082f19df12082a4fb532b85bb 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/lib.rs @@ -33,6 +33,9 @@ mod coretime; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; use frame_support::{ @@ -41,7 +44,7 @@ use frame_support::{ genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, TransformOrigin}, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -66,16 +69,19 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, DispatchError, MultiAddress, Perbill, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; -use xcm::latest::prelude::*; +use xcm::prelude::*; use xcm_config::{ FellowshipLocation, GovernanceLocation, TokenRelayLocation, XcmOriginToTransactDispatchOrigin, }; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; /// The address format for describing accounts. pub type Address = MultiAddress; @@ -100,6 +106,7 @@ pub type SignedExtra = ( frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -111,6 +118,8 @@ pub type Migrations = ( pallet_collator_selection::migration::v2::MigrationToV2, cumulus_pallet_xcmp_queue::migration::v4::MigrationToV4, pallet_broker::migration::MigrateV0ToV1, + pallet_broker::migration::MigrateV1ToV2, + pallet_broker::migration::MigrateV2ToV3, // permanent pallet_xcm::migration::MigrateToLatestXcmVersion, ); @@ -136,10 +145,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("coretime-westend"), impl_name: create_runtime_str!("coretime-westend"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 1, + transaction_version: 2, state_version: 1, }; @@ -302,7 +311,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -342,13 +351,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = RootOrFellows; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + pub const PERIOD: u32 = 6 * HOURS; pub const OFFSET: u32 = 0; @@ -527,7 +545,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -637,6 +655,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::TokenRelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::TokenRelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -695,7 +767,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } @@ -751,7 +823,7 @@ impl_runtime_apis! { let begin = 0; let end = 42; - let region_id = pallet_broker::Pallet::::issue(core, begin, end, None, None); + let region_id = pallet_broker::Pallet::::issue(core, begin, pallet_broker::CoreMask::complete(), end, None, None); Some(( Asset { fun: NonFungible(Index(region_id.into())), diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs index 13d5fcf3898bcc07fce13c7ee2deeb8c2b9fa76f..74b1c4e470297e212825a94da1886784e869ccd9 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/pallet_broker.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for `pallet_broker` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-20, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-06-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-x5tnzzy-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("coretime-westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -54,8 +54,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_897_000 picoseconds. - Weight::from_parts(2_053_000, 0) + // Minimum execution time: 1_899_000 picoseconds. + Weight::from_parts(2_051_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `10888` // Estimated: `13506` - // Minimum execution time: 22_550_000 picoseconds. - Weight::from_parts(22_871_000, 0) + // Minimum execution time: 21_965_000 picoseconds. + Weight::from_parts(22_774_000, 0) .saturating_add(Weight::from_parts(0, 13506)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -77,8 +77,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `12090` // Estimated: `13506` - // Minimum execution time: 21_170_000 picoseconds. - Weight::from_parts(21_645_000, 0) + // Minimum execution time: 20_748_000 picoseconds. + Weight::from_parts(21_464_000, 0) .saturating_add(Weight::from_parts(0, 13506)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -93,24 +93,34 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `146` // Estimated: `1631` - // Minimum execution time: 10_494_000 picoseconds. - Weight::from_parts(10_942_000, 0) + // Minimum execution time: 10_269_000 picoseconds. + Weight::from_parts(10_508_000, 0) .saturating_add(Weight::from_parts(0, 1631)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Configuration` (r:1 w:0) /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Leases` (r:1 w:1) + /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(81), added: 576, mode: `MaxEncodedLen`) + /// Storage: `Broker::Reservations` (r:1 w:0) + /// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(12021), added: 12516, mode: `MaxEncodedLen`) + /// Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + /// Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + /// Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + /// Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParachainSystem::LastRelayChainBlockNumber` (r:1 w:0) /// Proof: `ParachainSystem::LastRelayChainBlockNumber` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Broker::InstaPoolIo` (r:3 w:3) /// Proof: `Broker::InstaPoolIo` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) - /// Storage: `Broker::Reservations` (r:1 w:0) - /// Proof: `Broker::Reservations` (`max_values`: Some(1), `max_size`: Some(12021), added: 12516, mode: `MaxEncodedLen`) - /// Storage: `Broker::Leases` (r:1 w:1) - /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(81), added: 576, mode: `MaxEncodedLen`) /// Storage: `Broker::SaleInfo` (r:0 w:1) /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) /// Storage: `Broker::Status` (r:0 w:1) @@ -118,15 +128,18 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Workplan` (r:0 w:20) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) /// The range of component `n` is `[0, 1000]`. - fn start_sales(_n: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `12247` - // Estimated: `13732` - // Minimum execution time: 61_014_000 picoseconds. - Weight::from_parts(63_267_651, 0) - .saturating_add(Weight::from_parts(0, 13732)) - .saturating_add(T::DbWeight::get().reads(8)) + fn start_sales(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `12279` + // Estimated: `14805 + n * (1 ±0)` + // Minimum execution time: 41_900_000 picoseconds. + Weight::from_parts(80_392_728, 0) + .saturating_add(Weight::from_parts(0, 14805)) + // Standard Error: 870 + .saturating_add(Weight::from_parts(4_361, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(13)) .saturating_add(T::DbWeight::get().writes(26)) + .saturating_add(Weight::from_parts(0, 1).saturating_mul(n.into())) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) @@ -135,13 +148,13 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:0 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn purchase() -> Weight { // Proof Size summary in bytes: - // Measured: `316` + // Measured: `332` // Estimated: `3593` - // Minimum execution time: 30_931_000 picoseconds. - Weight::from_parts(31_941_000, 0) + // Minimum execution time: 40_911_000 picoseconds. + Weight::from_parts(43_102_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) @@ -152,55 +165,55 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::SaleInfo` (r:1 w:1) /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) - /// Storage: `Broker::AllowedRenewals` (r:1 w:2) - /// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `Broker::PotentialRenewals` (r:1 w:2) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:0 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) fn renew() -> Weight { // Proof Size summary in bytes: - // Measured: `434` + // Measured: `450` // Estimated: `4698` - // Minimum execution time: 57_466_000 picoseconds. - Weight::from_parts(65_042_000, 0) + // Minimum execution time: 70_257_000 picoseconds. + Weight::from_parts(73_889_000, 0) .saturating_add(Weight::from_parts(0, 4698)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn transfer() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 12_799_000 picoseconds. - Weight::from_parts(13_401_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 13_302_000 picoseconds. + Weight::from_parts(13_852_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Regions` (r:1 w:2) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn partition() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 14_107_000 picoseconds. - Weight::from_parts(14_630_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 14_927_000 picoseconds. + Weight::from_parts(15_553_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } /// Storage: `Broker::Regions` (r:1 w:3) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn interlace() -> Weight { // Proof Size summary in bytes: - // Measured: `357` - // Estimated: `3550` - // Minimum execution time: 15_254_000 picoseconds. - Weight::from_parts(16_062_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `358` + // Estimated: `3551` + // Minimum execution time: 16_237_000 picoseconds. + Weight::from_parts(16_995_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -209,15 +222,15 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:1 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) fn assign() -> Weight { // Proof Size summary in bytes: - // Measured: `735` + // Measured: `736` // Estimated: `4681` - // Minimum execution time: 23_557_000 picoseconds. - Weight::from_parts(24_382_000, 0) + // Minimum execution time: 24_621_000 picoseconds. + Weight::from_parts(25_165_000, 0) .saturating_add(Weight::from_parts(0, 4681)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) @@ -225,7 +238,7 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) /// Storage: `Broker::Workplan` (r:1 w:1) /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) /// Storage: `Broker::InstaPoolIo` (r:2 w:2) @@ -234,10 +247,10 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::InstaPoolContribution` (`max_values`: None, `max_size`: Some(68), added: 2543, mode: `MaxEncodedLen`) fn pool() -> Weight { // Proof Size summary in bytes: - // Measured: `801` + // Measured: `802` // Estimated: `5996` - // Minimum execution time: 29_371_000 picoseconds. - Weight::from_parts(30_200_000, 0) + // Minimum execution time: 29_832_000 picoseconds. + Weight::from_parts(30_894_000, 0) .saturating_add(Weight::from_parts(0, 5996)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(5)) @@ -253,11 +266,11 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `652` // Estimated: `6196 + m * (2520 ±0)` - // Minimum execution time: 54_331_000 picoseconds. - Weight::from_parts(55_322_165, 0) + // Minimum execution time: 55_390_000 picoseconds. + Weight::from_parts(56_124_789, 0) .saturating_add(Weight::from_parts(0, 6196)) - // Standard Error: 35_225 - .saturating_add(Weight::from_parts(1_099_614, 0).saturating_mul(m.into())) + // Standard Error: 41_724 + .saturating_add(Weight::from_parts(1_551_266, 0).saturating_mul(m.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(m.into()))) .saturating_add(T::DbWeight::get().writes(5)) @@ -277,25 +290,25 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn purchase_credit() -> Weight { // Proof Size summary in bytes: - // Measured: `215` - // Estimated: `3680` - // Minimum execution time: 53_789_000 picoseconds. - Weight::from_parts(55_439_000, 0) - .saturating_add(Weight::from_parts(0, 3680)) + // Measured: `320` + // Estimated: `3785` + // Minimum execution time: 59_759_000 picoseconds. + Weight::from_parts(61_310_000, 0) + .saturating_add(Weight::from_parts(0, 3785)) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) /// Storage: `Broker::Regions` (r:1 w:1) - /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Proof: `Broker::Regions` (`max_values`: None, `max_size`: Some(86), added: 2561, mode: `MaxEncodedLen`) fn drop_region() -> Weight { // Proof Size summary in bytes: - // Measured: `465` - // Estimated: `3550` - // Minimum execution time: 43_941_000 picoseconds. - Weight::from_parts(49_776_000, 0) - .saturating_add(Weight::from_parts(0, 3550)) + // Measured: `466` + // Estimated: `3551` + // Minimum execution time: 37_007_000 picoseconds. + Weight::from_parts(51_927_000, 0) + .saturating_add(Weight::from_parts(0, 3551)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -309,8 +322,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `463` // Estimated: `3533` - // Minimum execution time: 64_917_000 picoseconds. - Weight::from_parts(70_403_000, 0) + // Minimum execution time: 86_563_000 picoseconds. + Weight::from_parts(91_274_000, 0) .saturating_add(Weight::from_parts(0, 3533)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) @@ -327,22 +340,22 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `857` // Estimated: `3593` - // Minimum execution time: 72_633_000 picoseconds. - Weight::from_parts(79_305_000, 0) + // Minimum execution time: 93_655_000 picoseconds. + Weight::from_parts(98_160_000, 0) .saturating_add(Weight::from_parts(0, 3593)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Status` (r:1 w:0) /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) - /// Storage: `Broker::AllowedRenewals` (r:1 w:1) - /// Proof: `Broker::AllowedRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `Broker::PotentialRenewals` (r:1 w:1) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) fn drop_renewal() -> Weight { // Proof Size summary in bytes: // Measured: `556` // Estimated: `4698` - // Minimum execution time: 36_643_000 picoseconds. - Weight::from_parts(48_218_000, 0) + // Minimum execution time: 33_985_000 picoseconds. + Weight::from_parts(43_618_000, 0) .saturating_add(Weight::from_parts(0, 4698)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -358,13 +371,15 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) /// Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// The range of component `n` is `[0, 1000]`. - fn request_core_count(_n: u32, ) -> Weight { + fn request_core_count(n: u32, ) -> Weight { // Proof Size summary in bytes: // Measured: `74` // Estimated: `3539` - // Minimum execution time: 17_617_000 picoseconds. - Weight::from_parts(18_904_788, 0) + // Minimum execution time: 18_778_000 picoseconds. + Weight::from_parts(19_543_425, 0) .saturating_add(Weight::from_parts(0, 3539)) + // Standard Error: 41 + .saturating_add(Weight::from_parts(33, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -375,26 +390,26 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `266` // Estimated: `1487` - // Minimum execution time: 5_575_000 picoseconds. - Weight::from_parts(5_887_598, 0) + // Minimum execution time: 5_505_000 picoseconds. + Weight::from_parts(5_982_015, 0) .saturating_add(Weight::from_parts(0, 1487)) - // Standard Error: 16 - .saturating_add(Weight::from_parts(41, 0).saturating_mul(n.into())) + // Standard Error: 13 + .saturating_add(Weight::from_parts(44, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) - /// Proof: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) + /// Storage: `Broker::RevenueInbox` (r:1 w:1) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) /// Storage: `Broker::InstaPoolHistory` (r:1 w:1) /// Proof: `Broker::InstaPoolHistory` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`) /// Storage: `System::Account` (r:2 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) fn process_revenue() -> Weight { // Proof Size summary in bytes: - // Measured: `447` + // Measured: `442` // Estimated: `6196` - // Minimum execution time: 36_415_000 picoseconds. - Weight::from_parts(37_588_000, 0) + // Minimum execution time: 38_128_000 picoseconds. + Weight::from_parts(40_979_000, 0) .saturating_add(Weight::from_parts(0, 6196)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(3)) @@ -414,11 +429,11 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `12194` // Estimated: `13506` - // Minimum execution time: 48_362_000 picoseconds. - Weight::from_parts(49_616_106, 0) + // Minimum execution time: 49_041_000 picoseconds. + Weight::from_parts(50_522_788, 0) .saturating_add(Weight::from_parts(0, 13506)) - // Standard Error: 61 - .saturating_add(Weight::from_parts(59, 0).saturating_mul(n.into())) + // Standard Error: 72 + .saturating_add(Weight::from_parts(78, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(25)) } @@ -430,8 +445,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `42` // Estimated: `3493` - // Minimum execution time: 6_148_000 picoseconds. - Weight::from_parts(6_374_000, 0) + // Minimum execution time: 5_903_000 picoseconds. + Weight::from_parts(6_202_000, 0) .saturating_add(Weight::from_parts(0, 3493)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -454,8 +469,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `1321` // Estimated: `4786` - // Minimum execution time: 30_267_000 picoseconds. - Weight::from_parts(30_825_000, 0) + // Minimum execution time: 31_412_000 picoseconds. + Weight::from_parts(31_964_000, 0) .saturating_add(Weight::from_parts(0, 4786)) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(4)) @@ -474,8 +489,8 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `74` // Estimated: `3539` - // Minimum execution time: 13_491_000 picoseconds. - Weight::from_parts(13_949_000, 0) + // Minimum execution time: 14_098_000 picoseconds. + Weight::from_parts(14_554_000, 0) .saturating_add(Weight::from_parts(0, 3539)) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(2)) @@ -486,8 +501,19 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_711_000 picoseconds. - Weight::from_parts(1_913_000, 0) + // Minimum execution time: 1_723_000 picoseconds. + Weight::from_parts(1_822_000, 0) + .saturating_add(Weight::from_parts(0, 0)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `Broker::RevenueInbox` (r:0 w:1) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) + fn notify_revenue() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 1_865_000 picoseconds. + Weight::from_parts(1_983_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -497,19 +523,19 @@ impl pallet_broker::WeightInfo for WeightInfo { /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) /// Storage: `Broker::CoreCountInbox` (r:1 w:0) /// Proof: `Broker::CoreCountInbox` (`max_values`: Some(1), `max_size`: Some(2), added: 497, mode: `MaxEncodedLen`) - /// Storage: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) - /// Proof: UNKNOWN KEY `0xf308d869daf021a7724e69c557dd8dbe` (r:1 w:1) + /// Storage: `Broker::RevenueInbox` (r:1 w:0) + /// Proof: `Broker::RevenueInbox` (`max_values`: Some(1), `max_size`: Some(20), added: 515, mode: `MaxEncodedLen`) /// Storage: `ParachainSystem::ValidationData` (r:1 w:0) /// Proof: `ParachainSystem::ValidationData` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) fn do_tick_base() -> Weight { // Proof Size summary in bytes: - // Measured: `398` - // Estimated: `3863` - // Minimum execution time: 12_035_000 picoseconds. - Weight::from_parts(12_383_000, 0) - .saturating_add(Weight::from_parts(0, 3863)) + // Measured: `408` + // Estimated: `1893` + // Minimum execution time: 10_387_000 picoseconds. + Weight::from_parts(10_819_000, 0) + .saturating_add(Weight::from_parts(0, 1893)) .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(2)) + .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `Broker::Leases` (r:1 w:1) /// Proof: `Broker::Leases` (`max_values`: Some(1), `max_size`: Some(81), added: 576, mode: `MaxEncodedLen`) @@ -517,10 +543,59 @@ impl pallet_broker::WeightInfo for WeightInfo { // Proof Size summary in bytes: // Measured: `150` // Estimated: `1566` - // Minimum execution time: 6_142_000 picoseconds. - Weight::from_parts(6_538_000, 0) + // Minimum execution time: 5_996_000 picoseconds. + Weight::from_parts(6_278_000, 0) .saturating_add(Weight::from_parts(0, 1566)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } + /// Storage: `Broker::SaleInfo` (r:1 w:1) + /// Proof: `Broker::SaleInfo` (`max_values`: Some(1), `max_size`: Some(57), added: 552, mode: `MaxEncodedLen`) + /// Storage: `Broker::PotentialRenewals` (r:1 w:2) + /// Proof: `Broker::PotentialRenewals` (`max_values`: None, `max_size`: Some(1233), added: 3708, mode: `MaxEncodedLen`) + /// Storage: `Broker::Configuration` (r:1 w:0) + /// Proof: `Broker::Configuration` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Status` (r:1 w:0) + /// Proof: `Broker::Status` (`max_values`: Some(1), `max_size`: Some(18), added: 513, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Authorship::Author` (r:1 w:0) + /// Proof: `Authorship::Author` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `System::Digest` (r:1 w:0) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Broker::AutoRenewals` (r:1 w:1) + /// Proof: `Broker::AutoRenewals` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + /// Storage: `Broker::Workplan` (r:0 w:1) + /// Proof: `Broker::Workplan` (`max_values`: None, `max_size`: Some(1216), added: 3691, mode: `MaxEncodedLen`) + fn enable_auto_renew() -> Weight { + // Proof Size summary in bytes: + // Measured: `914` + // Estimated: `4698` + // Minimum execution time: 51_938_000 picoseconds. + Weight::from_parts(55_025_000, 4698) + .saturating_add(T::DbWeight::get().reads(8_u64)) + .saturating_add(T::DbWeight::get().writes(6_u64)) + } + /// Storage: `Broker::AutoRenewals` (r:1 w:1) + /// Proof: `Broker::AutoRenewals` (`max_values`: Some(1), `max_size`: Some(31), added: 526, mode: `MaxEncodedLen`) + fn disable_auto_renew() -> Weight { + // Proof Size summary in bytes: + // Measured: `480` + // Estimated: `1516` + // Minimum execution time: 9_628_000 picoseconds. + Weight::from_parts(10_400_000, 1516) + .saturating_add(T::DbWeight::get().reads(1_u64)) + .saturating_add(T::DbWeight::get().writes(1_u64)) + } + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + fn on_new_timeslice() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `3593` + // Minimum execution time: 2_187_000 picoseconds. + Weight::from_parts(2_372_000, 0) + .saturating_add(Weight::from_parts(0, 3593)) + .saturating_add(T::DbWeight::get().reads(1)) + } } diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/mod.rs index 99af88812da2be05bd9273585ea7d186be9f8b90..f35f7bfc188dce73525b5742345e7eb9ed459385 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/mod.rs @@ -17,10 +17,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 8e1461c4a99e2e95dea078280844a157ab4084de..935636651eb9dcb5ce0580978d9f1340313ef289 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-05-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-unxyhko3-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("coretime-westend-dev"), DB CACHE: 1024 // Executed Command: @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); @@ -54,8 +54,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 26_842_000 picoseconds. - Weight::from_parts(27_606_000, 3593) + // Minimum execution time: 29_866_000 picoseconds. + Weight::from_parts(30_363_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -65,8 +65,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 35_076_000 picoseconds. - Weight::from_parts(36_109_000, 6196) + // Minimum execution time: 39_434_000 picoseconds. + Weight::from_parts(40_274_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -88,8 +88,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `207` // Estimated: `6196` - // Minimum execution time: 56_951_000 picoseconds. - Weight::from_parts(58_286_000, 6196) + // Minimum execution time: 66_303_000 picoseconds. + Weight::from_parts(68_294_000, 6196) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -118,8 +118,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3571` - // Minimum execution time: 23_796_000 picoseconds. - Weight::from_parts(24_692_000, 3571) + // Minimum execution time: 30_523_000 picoseconds. + Weight::from_parts(31_289_000, 3571) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -127,8 +127,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 1_990_000 picoseconds. - Weight::from_parts(2_142_000, 0) + // Minimum execution time: 2_517_000 picoseconds. + Weight::from_parts(2_634_000, 0) } // Storage: `System::Account` (r:1 w:1) // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -136,8 +136,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 19_572_000 picoseconds. - Weight::from_parts(20_017_000, 3593) + // Minimum execution time: 22_151_000 picoseconds. + Weight::from_parts(22_907_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -159,8 +159,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3593` - // Minimum execution time: 49_336_000 picoseconds. - Weight::from_parts(50_507_000, 3593) + // Minimum execution time: 57_763_000 picoseconds. + Weight::from_parts(58_941_000, 3593) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -180,8 +180,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `106` // Estimated: `3571` - // Minimum execution time: 21_230_000 picoseconds. - Weight::from_parts(21_870_000, 3571) + // Minimum execution time: 26_322_000 picoseconds. + Weight::from_parts(27_197_000, 3571) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index 9657fa55c1f2fdd4cf6ffdc4888e13e22a262155..7390f35e3974060abf4efd0e621239fa6a9bead0 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -43,7 +43,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/coretime/coretime-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/coretime/coretime-westend/src/xcm_config.rs index b12765870bfdbbc7eb495a52e9ec4e931dc442da..da8aa1c18bdf44e50643fe6b85cd755051e23c0f 100644 --- a/cumulus/parachains/runtimes/coretime/coretime-westend/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/coretime/coretime-westend/src/xcm_config.rs @@ -43,10 +43,10 @@ use xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, IsConcrete, NonFungibleAdapter, ParentAsSuperuser, ParentIsPreset, - RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, + RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -221,7 +221,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml b/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml index 808bed38732758e546a6a513c4f19cf2b1d50fbc..09b4ef679d244696504761cb4d30216fef9c7807 100644 --- a/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/glutton/glutton-westend/Cargo.toml @@ -10,54 +10,53 @@ description = "Glutton parachain runtime." workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../../../substrate/frame/system/rpc/runtime-api", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -frame-try-runtime = { path = "../../../../../substrate/frame/try-runtime", default-features = false, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-glutton = { path = "../../../../../substrate/frame/glutton", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-glutton = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +pallet-message-queue = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-timestamp = { path = "../../../../primitives/timestamp", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-timestamp = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -109,7 +108,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -138,4 +136,4 @@ try-runtime = [ # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs b/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs index 424fa9cb7e726b697877363f1d7692d674940214..942e11e0b2574e0d7016f452f6808e8ddf633479 100644 --- a/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/glutton/glutton-westend/src/lib.rs @@ -47,6 +47,9 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); pub mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use sp_api::impl_runtime_apis; pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; @@ -57,7 +60,6 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -100,7 +102,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("glutton-westend"), impl_name: create_runtime_str!("glutton-westend"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 1, @@ -208,8 +210,9 @@ impl pallet_message_queue::Config for Runtime { >; type Size = u32; type QueueChangeHandler = (); - type QueuePausedQuery = (); // No XCMP queue pallet deployed. - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + // No XCMP queue pallet deployed. + type QueuePausedQuery = (); + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -295,6 +298,7 @@ pub type SignedExtra = ( frame_system::CheckGenesis, frame_system::CheckEra, frame_system::CheckNonce, + frame_system::CheckWeight, ); /// Unchecked extrinsic type as expected by this runtime. pub type UncheckedExtrinsic = @@ -343,7 +347,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -453,7 +457,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } diff --git a/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml b/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml index 7183be5fc82cc594c6ad2f3738dbfd5b67738a2c..c676587b1de433921b6dba683d2428051f9e5857 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml +++ b/cumulus/parachains/runtimes/people/people-rococo/Cargo.toml @@ -7,73 +7,73 @@ description = "Rococo's People parachain runtime" license = "Apache-2.0" [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -enumflags2 = { version = "0.7.7" } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive"], workspace = true } +enumflags2 = { workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-identity = { path = "../../../../../substrate/frame/identity", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-identity = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-multisig = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../../../../polkadot/xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -rococo-runtime-constants = { path = "../../../../../polkadot/runtime/rococo/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +rococo-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } [features] default = ["std"] @@ -127,7 +127,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -135,6 +134,7 @@ std = [ "testnet-parachains-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -163,6 +163,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -190,3 +191,8 @@ try-runtime = [ "polkadot-runtime-common/try-runtime", "sp-runtime/try-runtime", ] + +# A feature that should be enabled when the runtime should be built for on-chain +# deployment. This will disable stuff that shouldn't be part of the on-chain wasm +# to make it smaller, like logging for example. +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs b/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs index 544b2e78a46950a2abddc61582e727bbed6af93a..77bfb99669c6c2f58d5e6d3398b2d805b4a2ac17 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/lib.rs @@ -22,6 +22,9 @@ pub mod people; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; use frame_support::{ @@ -32,7 +35,7 @@ use frame_support::{ traits::{ ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, Everything, TransformOrigin, }, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -59,17 +62,20 @@ use sp_runtime::{ ApplyExtrinsicResult, }; pub use sp_runtime::{MultiAddress, Perbill, Permill}; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; use testnet_parachains_constants::rococo::{consensus::*, currency::*, fee::WeightToFee, time::*}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; -use xcm::latest::prelude::BodyId; +use xcm::prelude::*; use xcm_config::{ FellowshipLocation, GovernanceLocation, PriceForSiblingParachainDelivery, XcmConfig, XcmOriginToTransactDispatchOrigin, }; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; /// The address format for describing accounts. pub type Address = MultiAddress; @@ -128,7 +134,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("people-rococo"), impl_name: create_runtime_str!("people-rococo"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 1, @@ -281,7 +287,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -308,13 +314,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = RootOrFellows; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + pub const PERIOD: u32 = 6 * HOURS; pub const OFFSET: u32 = 0; @@ -508,7 +523,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -612,6 +627,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -670,7 +739,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/people.rs b/cumulus/parachains/runtimes/people/people-rococo/src/people.rs index 88a89711019d59436c1ca270bbf19781f6dc77f0..8211447d68c8a5a53457d1651cc95754c125f7fd 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/people.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/people.rs @@ -28,7 +28,6 @@ use sp_runtime::{ traits::{AccountIdConversion, Verify}, RuntimeDebug, }; -use sp_std::prelude::*; parameter_types! { // 27 | Min encoded size of `Registration` @@ -94,8 +93,8 @@ pub enum IdentityField { )] #[codec(mel_bound())] pub struct IdentityInfo { - /// A reasonable display name for the controller of the account. This should be whatever the - /// account is typically known as and should not be confusable with other entities, given + /// A reasonable display name for the controller of the account. This should be whatever the + /// account is typically known as and should not be confusable with other entities, given /// reasonable context. /// /// Stored as UTF-8. @@ -151,7 +150,7 @@ impl IdentityInformationProvider for IdentityInfo { #[cfg(feature = "runtime-benchmarks")] fn create_identity_info() -> Self { - let data = Data::Raw(vec![0; 32].try_into().unwrap()); + let data = Data::Raw(alloc::vec![0; 32].try_into().unwrap()); IdentityInfo { display: data.clone(), diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/people/people-rococo/src/weights/cumulus_pallet_parachain_system.rs index fcea5fd1bf679c803509dd4529b45e4994a7438c..5715d56c2186836556973dc6bebbfec77ac99762 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/weights/cumulus_pallet_parachain_system.rs @@ -20,7 +20,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/people/people-rococo/src/weights/pallet_message_queue.rs index fe1911b77a72dbfed0309722a1c59f37b56cb40f..47c67901407366a9f07959e2e22ed5bc83c61a76 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/weights/pallet_message_queue.rs @@ -20,7 +20,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/mod.rs index 4afd65bdcfea18208046edb4cfe693207cada3bb..58007173ae1d505ad5f831e8f4962d2c4e491615 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/mod.rs @@ -5,7 +5,7 @@ // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, @@ -17,10 +17,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { @@ -60,10 +60,8 @@ impl XcmWeightInfo for PeopleRococoXcmWeight { fn withdraw_asset(assets: &Assets) -> Weight { assets.weigh_assets(XcmFungibleWeight::::withdraw_asset()) } - // Currently there is no trusted reserve - fn reserve_asset_deposited(_assets: &Assets) -> Weight { - // TODO: hardcoded - fix https://github.com/paritytech/cumulus/issues/1974 - Weight::from_parts(1_000_000_000_u64, 0) + fn reserve_asset_deposited(assets: &Assets) -> Weight { + assets.weigh_assets(XcmFungibleWeight::::reserve_asset_deposited()) } fn receive_teleported_asset(assets: &Assets) -> Weight { assets.weigh_assets(XcmFungibleWeight::::receive_teleported_asset()) @@ -114,12 +112,8 @@ impl XcmWeightInfo for PeopleRococoXcmWeight { fn report_error(_query_response_info: &QueryResponseInfo) -> Weight { XcmGeneric::::report_error() } - fn deposit_asset(assets: &AssetFilter, _dest: &Location) -> Weight { - // Hardcoded till the XCM pallet is fixed - let hardcoded_weight = Weight::from_parts(1_000_000_000_u64, 0); - let weight = assets.weigh_assets(XcmFungibleWeight::::deposit_asset()); - hardcoded_weight.min(weight) + assets.weigh_assets(XcmFungibleWeight::::deposit_asset()) } fn deposit_reserve_asset(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight { assets.weigh_assets(XcmFungibleWeight::::deposit_reserve_asset()) @@ -132,7 +126,7 @@ impl XcmWeightInfo for PeopleRococoXcmWeight { _reserve: &Location, _xcm: &Xcm<()>, ) -> Weight { - assets.weigh_assets(XcmGeneric::::initiate_reserve_withdraw()) + assets.weigh_assets(XcmFungibleWeight::::initiate_reserve_withdraw()) } fn initiate_teleport(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight { assets.weigh_assets(XcmFungibleWeight::::initiate_teleport()) diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index b279399e7a96b68ac68f7e12ed165efb324fab9b..4dd44e66dd5e3cf0e545fac692cf27257cb075f4 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -1,156 +1,187 @@ // Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 +// This file is part of Cumulus. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `bm4`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("people-kusama-dev"), DB CACHE: 1024 +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: Compiled, CHAIN: Some("people-rococo-dev"), DB CACHE: 1024 // Executed Command: -// ./artifacts/polkadot-parachain +// target/production/polkadot-parachain // benchmark // pallet -// --template=./templates/xcm-bench-template.hbs -// --chain=people-kusama-dev -// --execution=wasm -// --wasm-execution=compiled -// --pallet=pallet_xcm_benchmarks::fungible -// --extrinsic=* // --steps=50 // --repeat=20 -// --json -// --header=./file_header.txt -// --output=./cumulus/parachains/runtimes/people/people-kusama/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_xcm_benchmarks::fungible +// --chain=people-rococo-dev +// --header=./cumulus/file_header.txt +// --template=./cumulus/templates/xcm-bench-template.hbs +// --output=./cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/ #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); impl WeightInfo { - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn withdraw_asset() -> Weight { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 23_309_000 picoseconds. - Weight::from_parts(23_777_000, 3593) + // Minimum execution time: 30_428_000 picoseconds. + Weight::from_parts(31_184_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: System Account (r:2 w:2) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn transfer_asset() -> Weight { // Proof Size summary in bytes: // Measured: `153` // Estimated: `6196` - // Minimum execution time: 48_808_000 picoseconds. - Weight::from_parts(49_427_000, 6196) + // Minimum execution time: 41_912_000 picoseconds. + Weight::from_parts(43_346_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - // Storage: System Account (r:2 w:2) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn transfer_reserve_asset() -> Weight { // Proof Size summary in bytes: // Measured: `223` // Estimated: `6196` - // Minimum execution time: 71_204_000 picoseconds. - Weight::from_parts(72_121_000, 6196) + // Minimum execution time: 67_706_000 picoseconds. + Weight::from_parts(69_671_000, 6196) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(4)) } + // Storage: `Benchmark::Override` (r:0 w:0) + // Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`) + pub fn reserve_asset_deposited() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 18_446_744_073_709_551_000 picoseconds. + Weight::from_parts(18_446_744_073_709_551_000, 0) + } + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + pub fn initiate_reserve_withdraw() -> Weight { + // Proof Size summary in bytes: + // Measured: `70` + // Estimated: `3535` + // Minimum execution time: 29_790_000 picoseconds. + Weight::from_parts(30_655_000, 3535) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(2)) + } pub fn receive_teleported_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_559_000 picoseconds. - Weight::from_parts(3_616_000, 0) + // Minimum execution time: 2_438_000 picoseconds. + Weight::from_parts(2_597_000, 0) } - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn deposit_asset() -> Weight { // Proof Size summary in bytes: // Measured: `52` // Estimated: `3593` - // Minimum execution time: 25_042_000 picoseconds. - Weight::from_parts(25_630_000, 3593) + // Minimum execution time: 24_040_000 picoseconds. + Weight::from_parts(24_538_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn deposit_reserve_asset() -> Weight { // Proof Size summary in bytes: // Measured: `122` // Estimated: `3593` - // Minimum execution time: 49_030_000 picoseconds. - Weight::from_parts(49_828_000, 3593) + // Minimum execution time: 58_275_000 picoseconds. + Weight::from_parts(59_899_000, 3593) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn initiate_teleport() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 27_142_000 picoseconds. - Weight::from_parts(27_416_000, 3535) + // Minimum execution time: 25_638_000 picoseconds. + Weight::from_parts(26_514_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index e2be324ee2d48c42a8d7340c8cbcd3a52b161f19..729a3211704198bf5c59e1e2ac47e03f88fb0340 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -1,70 +1,71 @@ // Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 +// This file is part of Cumulus. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . //! Autogenerated weights for `pallet_xcm_benchmarks::generic` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `bm4`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("people-kusama-dev"), DB CACHE: 1024 +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: Compiled, CHAIN: Some("people-rococo-dev"), DB CACHE: 1024 // Executed Command: -// ./artifacts/polkadot-parachain +// target/production/polkadot-parachain // benchmark // pallet -// --template=./templates/xcm-bench-template.hbs -// --chain=people-kusama-dev -// --execution=wasm -// --wasm-execution=compiled -// --pallet=pallet_xcm_benchmarks::generic -// --extrinsic=* // --steps=50 // --repeat=20 -// --json -// --header=./file_header.txt -// --output=./cumulus/parachains/runtimes/people/people-kusama/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_xcm_benchmarks::generic +// --chain=people-rococo-dev +// --header=./cumulus/file_header.txt +// --template=./cumulus/templates/xcm-bench-template.hbs +// --output=./cumulus/parachains/runtimes/people/people-rococo/src/weights/xcm/ #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); impl WeightInfo { - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_holding() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 30_210_000 picoseconds. - Weight::from_parts(30_864_000, 3535) + // Minimum execution time: 29_430_000 picoseconds. + Weight::from_parts(30_111_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -72,97 +73,97 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_808_000 picoseconds. - Weight::from_parts(2_848_000, 0) + // Minimum execution time: 607_000 picoseconds. + Weight::from_parts(672_000, 0) } - // Storage: PolkadotXcm Queries (r:1 w:0) - // Proof Skipped: PolkadotXcm Queries (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::Queries` (r:1 w:0) + // Proof: `PolkadotXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn query_response() -> Weight { // Proof Size summary in bytes: // Measured: `32` // Estimated: `3497` - // Minimum execution time: 10_353_000 picoseconds. - Weight::from_parts(10_569_000, 3497) + // Minimum execution time: 7_445_000 picoseconds. + Weight::from_parts(7_623_000, 3497) .saturating_add(T::DbWeight::get().reads(1)) } pub fn transact() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 12_074_000 picoseconds. - Weight::from_parts(12_280_000, 0) + // Minimum execution time: 6_749_000 picoseconds. + Weight::from_parts(7_073_000, 0) } pub fn refund_surplus() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_080_000 picoseconds. - Weight::from_parts(3_161_000, 0) + // Minimum execution time: 1_275_000 picoseconds. + Weight::from_parts(1_409_000, 0) } pub fn set_error_handler() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_649_000 picoseconds. - Weight::from_parts(2_732_000, 0) + // Minimum execution time: 670_000 picoseconds. + Weight::from_parts(709_000, 0) } pub fn set_appendix() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_652_000 picoseconds. - Weight::from_parts(2_749_000, 0) + // Minimum execution time: 635_000 picoseconds. + Weight::from_parts(723_000, 0) } pub fn clear_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_642_000 picoseconds. - Weight::from_parts(2_704_000, 0) + // Minimum execution time: 650_000 picoseconds. + Weight::from_parts(699_000, 0) } pub fn descend_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_438_000 picoseconds. - Weight::from_parts(3_508_000, 0) + // Minimum execution time: 678_000 picoseconds. + Weight::from_parts(728_000, 0) } pub fn clear_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_626_000 picoseconds. - Weight::from_parts(2_701_000, 0) + // Minimum execution time: 657_000 picoseconds. + Weight::from_parts(703_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_error() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 24_737_000 picoseconds. - Weight::from_parts(25_106_000, 3535) + // Minimum execution time: 25_795_000 picoseconds. + Weight::from_parts(26_415_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } - // Storage: PolkadotXcm AssetTraps (r:1 w:1) - // Proof Skipped: PolkadotXcm AssetTraps (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::AssetTraps` (r:1 w:1) + // Proof: `PolkadotXcm::AssetTraps` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn claim_asset() -> Weight { // Proof Size summary in bytes: // Measured: `90` // Estimated: `3555` - // Minimum execution time: 14_712_000 picoseconds. - Weight::from_parts(14_976_000, 3555) + // Minimum execution time: 10_792_000 picoseconds. + Weight::from_parts(11_061_000, 3555) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -170,114 +171,93 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_689_000 picoseconds. - Weight::from_parts(2_739_000, 0) + // Minimum execution time: 624_000 picoseconds. + Weight::from_parts(682_000, 0) } - // Storage: PolkadotXcm VersionNotifyTargets (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionNotifyTargets (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `PolkadotXcm::VersionNotifyTargets` (r:1 w:1) + // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn subscribe_version() -> Weight { // Proof Size summary in bytes: // Measured: `38` // Estimated: `3503` - // Minimum execution time: 26_478_000 picoseconds. - Weight::from_parts(26_695_000, 3503) + // Minimum execution time: 23_906_000 picoseconds. + Weight::from_parts(24_740_000, 3503) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(3)) } - // Storage: PolkadotXcm VersionNotifyTargets (r:0 w:1) - // Proof Skipped: PolkadotXcm VersionNotifyTargets (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::VersionNotifyTargets` (r:0 w:1) + // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn unsubscribe_version() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_811_000 picoseconds. - Weight::from_parts(5_062_000, 0) + // Minimum execution time: 2_621_000 picoseconds. + Weight::from_parts(2_788_000, 0) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) - pub fn initiate_reserve_withdraw() -> Weight { - // Proof Size summary in bytes: - // Measured: `70` - // Estimated: `3535` - // Minimum execution time: 26_945_000 picoseconds. - Weight::from_parts(28_093_000, 3535) - .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(2)) - } pub fn burn_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_144_000 picoseconds. - Weight::from_parts(4_217_000, 0) + // Minimum execution time: 954_000 picoseconds. + Weight::from_parts(1_046_000, 0) } pub fn expect_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_726_000 picoseconds. - Weight::from_parts(2_802_000, 0) + // Minimum execution time: 742_000 picoseconds. + Weight::from_parts(790_000, 0) } pub fn expect_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_719_000 picoseconds. - Weight::from_parts(2_790_000, 0) + // Minimum execution time: 664_000 picoseconds. + Weight::from_parts(722_000, 0) } pub fn expect_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_660_000 picoseconds. - Weight::from_parts(2_742_000, 0) + // Minimum execution time: 619_000 picoseconds. + Weight::from_parts(672_000, 0) } pub fn expect_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_874_000 picoseconds. - Weight::from_parts(2_940_000, 0) + // Minimum execution time: 798_000 picoseconds. + Weight::from_parts(851_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn query_pallet() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 27_235_000 picoseconds. - Weight::from_parts(27_811_000, 3535) + // Minimum execution time: 29_580_000 picoseconds. + Weight::from_parts(31_100_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -285,27 +265,27 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_807_000 picoseconds. - Weight::from_parts(4_918_000, 0) + // Minimum execution time: 3_150_000 picoseconds. + Weight::from_parts(3_326_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 24_698_000 picoseconds. - Weight::from_parts(25_077_000, 3535) + // Minimum execution time: 26_152_000 picoseconds. + Weight::from_parts(26_635_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -313,35 +293,35 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_613_000 picoseconds. - Weight::from_parts(2_703_000, 0) + // Minimum execution time: 693_000 picoseconds. + Weight::from_parts(724_000, 0) } pub fn set_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_602_000 picoseconds. - Weight::from_parts(2_661_000, 0) + // Minimum execution time: 632_000 picoseconds. + Weight::from_parts(678_000, 0) } pub fn clear_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_557_000 picoseconds. - Weight::from_parts(2_655_000, 0) + // Minimum execution time: 646_000 picoseconds. + Weight::from_parts(694_000, 0) } pub fn set_fees_mode() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_724_000 picoseconds. - Weight::from_parts(2_760_000, 0) + // Minimum execution time: 622_000 picoseconds. + Weight::from_parts(656_000, 0) } pub fn unpaid_execution() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_764_000 picoseconds. - Weight::from_parts(2_872_000, 0) + // Minimum execution time: 639_000 picoseconds. + Weight::from_parts(679_000, 0) } } diff --git a/cumulus/parachains/runtimes/people/people-rococo/src/xcm_config.rs b/cumulus/parachains/runtimes/people/people-rococo/src/xcm_config.rs index cca964fb2441bbe8bd40d909eb90766907918df2..96ab3eafa785fe0135916d072666d7102e5027c3 100644 --- a/cumulus/parachains/runtimes/people/people-rococo/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/people/people-rococo/src/xcm_config.rs @@ -40,10 +40,10 @@ use xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, DescribeTerminus, EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsConcrete, ParentAsSuperuser, - ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, - SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, - TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + ParentIsPreset, RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, + SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, + SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, + WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -219,7 +219,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/people/people-westend/Cargo.toml b/cumulus/parachains/runtimes/people/people-westend/Cargo.toml index 576c3b1aa4e3eaafafafd0af353580fef7a3c20c..ab7dd04bb78a3be348a5d71343ed14be9d0a96ec 100644 --- a/cumulus/parachains/runtimes/people/people-westend/Cargo.toml +++ b/cumulus/parachains/runtimes/people/people-westend/Cargo.toml @@ -7,73 +7,73 @@ description = "Westend's People parachain runtime" license = "Apache-2.0" [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -enumflags2 = { version = "0.7.7" } -hex-literal = { version = "0.4.1" } +codec = { features = ["derive"], workspace = true } +enumflags2 = { workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.9.0", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-identity = { path = "../../../../../substrate/frame/identity", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -pallet-multisig = { path = "../../../../../substrate/frame/multisig", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-utility = { path = "../../../../../substrate/frame/utility", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-identity = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-multisig = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-utility = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../../../../polkadot/xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -westend-runtime-constants = { path = "../../../../../polkadot/runtime/westend/constants", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +westend-runtime-constants = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["westend"] } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["westend"], workspace = true } [features] default = ["std"] @@ -126,7 +126,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", @@ -135,6 +134,7 @@ std = [ "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -163,6 +163,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ @@ -190,3 +191,8 @@ try-runtime = [ "polkadot-runtime-common/try-runtime", "sp-runtime/try-runtime", ] + +# A feature that should be enabled when the runtime should be built for on-chain +# deployment. This will disable stuff that shouldn't be part of the on-chain wasm +# to make it smaller, like logging for example. +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/people/people-westend/src/lib.rs b/cumulus/parachains/runtimes/people/people-westend/src/lib.rs index 50c818a20226cd9b7cce17c220f23a3a3fb008f5..3343d2be749d6570915afc60fe40b8a1bd5eaf77 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/lib.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/lib.rs @@ -22,6 +22,9 @@ pub mod people; mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; use frame_support::{ @@ -32,7 +35,7 @@ use frame_support::{ traits::{ ConstBool, ConstU32, ConstU64, ConstU8, EitherOfDiverse, Everything, TransformOrigin, }, - weights::{ConstantMultiplier, Weight}, + weights::{ConstantMultiplier, Weight, WeightToFee as _}, PalletId, }; use frame_system::{ @@ -59,17 +62,20 @@ use sp_runtime::{ ApplyExtrinsicResult, }; pub use sp_runtime::{MultiAddress, Perbill, Permill}; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; use testnet_parachains_constants::westend::{consensus::*, currency::*, fee::WeightToFee, time::*}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; -use xcm::latest::prelude::BodyId; +use xcm::prelude::*; use xcm_config::{ FellowshipLocation, GovernanceLocation, PriceForSiblingParachainDelivery, XcmConfig, XcmOriginToTransactDispatchOrigin, }; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; /// The address format for describing accounts. pub type Address = MultiAddress; @@ -128,7 +134,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("people-westend"), impl_name: create_runtime_str!("people-westend"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 1, @@ -281,7 +287,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -308,13 +314,22 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type ChannelInfo = ParachainSystem; type VersionWrapper = PolkadotXcm; type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = RootOrFellows; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = weights::cumulus_pallet_xcmp_queue::WeightInfo; type PriceForSiblingDelivery = PriceForSiblingParachainDelivery; } +impl cumulus_pallet_xcmp_queue::migration::v5::V5Config for Runtime { + // This must be the same as the `ChannelInfo` from the `Config`: + type ChannelList = ParachainSystem; +} + pub const PERIOD: u32 = 6 * HOURS; pub const OFFSET: u32 = 0; @@ -508,7 +523,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -612,6 +627,60 @@ impl_runtime_apis! { } } + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { + let acceptable_assets = vec![AssetId(xcm_config::RelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) + } + + fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } + } + + fn query_xcm_weight(message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_xcm_weight(message) + } + + fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { + PolkadotXcm::query_delivery_fees(destination, message) + } + } + + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_call::(origin, call) + } + + fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { + PolkadotXcm::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationToAccountId, + >::convert_location(location) + } + } + impl cumulus_primitives_core::CollectCollationInfo for Runtime { fn collect_collation_info(header: &::Header) -> cumulus_primitives_core::CollationInfo { ParachainSystem::collect_collation_info(header) @@ -670,7 +739,7 @@ impl_runtime_apis! { use frame_system_benchmarking::Pallet as SystemBench; impl frame_system_benchmarking::Config for Runtime { - fn setup_set_code_requirements(code: &sp_std::vec::Vec) -> Result<(), BenchmarkError> { + fn setup_set_code_requirements(code: &alloc::vec::Vec) -> Result<(), BenchmarkError> { ParachainSystem::initialize_for_set_code_benchmark(code.len() as u32); Ok(()) } diff --git a/cumulus/parachains/runtimes/people/people-westend/src/people.rs b/cumulus/parachains/runtimes/people/people-westend/src/people.rs index a5c0e66a3f882df14cbbd8dba51572834738015e..0255fd074b1119cf6432a2f9b0346e6523c181f8 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/people.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/people.rs @@ -28,7 +28,6 @@ use sp_runtime::{ traits::{AccountIdConversion, Verify}, RuntimeDebug, }; -use sp_std::prelude::*; parameter_types! { // 27 | Min encoded size of `Registration` @@ -151,7 +150,7 @@ impl IdentityInformationProvider for IdentityInfo { #[cfg(feature = "runtime-benchmarks")] fn create_identity_info() -> Self { - let data = Data::Raw(vec![0; 32].try_into().unwrap()); + let data = Data::Raw(alloc::vec![0; 32].try_into().unwrap()); IdentityInfo { display: data.clone(), diff --git a/cumulus/parachains/runtimes/people/people-westend/src/weights/cumulus_pallet_parachain_system.rs b/cumulus/parachains/runtimes/people/people-westend/src/weights/cumulus_pallet_parachain_system.rs index fcea5fd1bf679c803509dd4529b45e4994a7438c..5715d56c2186836556973dc6bebbfec77ac99762 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/weights/cumulus_pallet_parachain_system.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/weights/cumulus_pallet_parachain_system.rs @@ -20,7 +20,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `cumulus_pallet_parachain_system`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/people/people-westend/src/weights/pallet_message_queue.rs b/cumulus/parachains/runtimes/people/people-westend/src/weights/pallet_message_queue.rs index fe1911b77a72dbfed0309722a1c59f37b56cb40f..47c67901407366a9f07959e2e22ed5bc83c61a76 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/weights/pallet_message_queue.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/weights/pallet_message_queue.rs @@ -20,7 +20,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_message_queue`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/mod.rs b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/mod.rs index b2579230c9ed7afaf9d187a9e783992723444b3a..b44e8d4b61b8fe57ea4191b891da6dcbaa962813 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/mod.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/mod.rs @@ -5,7 +5,7 @@ // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // -// http://www.apache.org/licenses/LICENSE-2.0 +// http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, @@ -17,10 +17,10 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::{xcm_config::MaxAssetsIntoHolding, Runtime}; +use alloc::vec::Vec; use frame_support::weights::Weight; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmFungibleWeight; use pallet_xcm_benchmarks_generic::WeightInfo as XcmGeneric; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; trait WeighAssets { @@ -60,10 +60,8 @@ impl XcmWeightInfo for PeopleWestendXcmWeight { fn withdraw_asset(assets: &Assets) -> Weight { assets.weigh_assets(XcmFungibleWeight::::withdraw_asset()) } - // Currently there is no trusted reserve - fn reserve_asset_deposited(_assets: &Assets) -> Weight { - // TODO: hardcoded - fix https://github.com/paritytech/cumulus/issues/1974 - Weight::from_parts(1_000_000_000_u64, 0) + fn reserve_asset_deposited(assets: &Assets) -> Weight { + assets.weigh_assets(XcmFungibleWeight::::reserve_asset_deposited()) } fn receive_teleported_asset(assets: &Assets) -> Weight { assets.weigh_assets(XcmFungibleWeight::::receive_teleported_asset()) @@ -114,12 +112,8 @@ impl XcmWeightInfo for PeopleWestendXcmWeight { fn report_error(_query_response_info: &QueryResponseInfo) -> Weight { XcmGeneric::::report_error() } - fn deposit_asset(assets: &AssetFilter, _dest: &Location) -> Weight { - // Hardcoded till the XCM pallet is fixed - let hardcoded_weight = Weight::from_parts(1_000_000_000_u64, 0); - let weight = assets.weigh_assets(XcmFungibleWeight::::deposit_asset()); - hardcoded_weight.min(weight) + assets.weigh_assets(XcmFungibleWeight::::deposit_asset()) } fn deposit_reserve_asset(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight { assets.weigh_assets(XcmFungibleWeight::::deposit_reserve_asset()) @@ -132,13 +126,10 @@ impl XcmWeightInfo for PeopleWestendXcmWeight { _reserve: &Location, _xcm: &Xcm<()>, ) -> Weight { - assets.weigh_assets(XcmGeneric::::initiate_reserve_withdraw()) + assets.weigh_assets(XcmFungibleWeight::::initiate_reserve_withdraw()) } fn initiate_teleport(assets: &AssetFilter, _dest: &Location, _xcm: &Xcm<()>) -> Weight { - // Hardcoded till the XCM pallet is fixed - let hardcoded_weight = Weight::from_parts(200_000_000_u64, 0); - let weight = assets.weigh_assets(XcmFungibleWeight::::initiate_teleport()); - hardcoded_weight.min(weight) + assets.weigh_assets(XcmFungibleWeight::::initiate_teleport()) } fn report_holding(_response_info: &QueryResponseInfo, _assets: &AssetFilter) -> Weight { XcmGeneric::::report_holding() diff --git a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index efffd318817106baf4e2f7661f4cd0a8c333b722..8f6bfde986bb36c4fd3c90bdfb767727133f8c35 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -1,156 +1,187 @@ // Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 +// This file is part of Cumulus. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `bm4`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("people-polkadot-dev"), DB CACHE: 1024 +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: Compiled, CHAIN: Some("people-westend-dev"), DB CACHE: 1024 // Executed Command: -// ./artifacts/polkadot-parachain +// target/production/polkadot-parachain // benchmark // pallet -// --template=./templates/xcm-bench-template.hbs -// --chain=people-polkadot-dev -// --execution=wasm -// --wasm-execution=compiled -// --pallet=pallet_xcm_benchmarks::fungible -// --extrinsic=* // --steps=50 // --repeat=20 -// --json -// --header=./file_header.txt -// --output=./cumulus/parachains/runtimes/people/people-polkadot/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_xcm_benchmarks::fungible +// --chain=people-westend-dev +// --header=./cumulus/file_header.txt +// --template=./cumulus/templates/xcm-bench-template.hbs +// --output=./cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/ #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::fungible`. pub struct WeightInfo(PhantomData); impl WeightInfo { - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn withdraw_asset() -> Weight { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 23_363_000 picoseconds. - Weight::from_parts(23_663_000, 3593) + // Minimum execution time: 30_040_000 picoseconds. + Weight::from_parts(30_758_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: System Account (r:2 w:2) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn transfer_asset() -> Weight { // Proof Size summary in bytes: // Measured: `153` // Estimated: `6196` - // Minimum execution time: 49_093_000 picoseconds. - Weight::from_parts(49_719_000, 6196) + // Minimum execution time: 42_135_000 picoseconds. + Weight::from_parts(42_970_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - // Storage: System Account (r:2 w:2) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `System::Account` (r:2 w:2) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn transfer_reserve_asset() -> Weight { // Proof Size summary in bytes: // Measured: `223` // Estimated: `6196` - // Minimum execution time: 74_134_000 picoseconds. - Weight::from_parts(74_719_000, 6196) + // Minimum execution time: 67_385_000 picoseconds. + Weight::from_parts(69_776_000, 6196) .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(4)) } + // Storage: `Benchmark::Override` (r:0 w:0) + // Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`) + pub fn reserve_asset_deposited() -> Weight { + // Proof Size summary in bytes: + // Measured: `0` + // Estimated: `0` + // Minimum execution time: 18_446_744_073_709_551_000 picoseconds. + Weight::from_parts(18_446_744_073_709_551_000, 0) + } + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + pub fn initiate_reserve_withdraw() -> Weight { + // Proof Size summary in bytes: + // Measured: `70` + // Estimated: `3535` + // Minimum execution time: 29_804_000 picoseconds. + Weight::from_parts(30_662_000, 3535) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(2)) + } pub fn receive_teleported_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_726_000 picoseconds. - Weight::from_parts(3_881_000, 0) + // Minimum execution time: 2_358_000 picoseconds. + Weight::from_parts(2_497_000, 0) } - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) pub fn deposit_asset() -> Weight { // Proof Size summary in bytes: // Measured: `52` // Estimated: `3593` - // Minimum execution time: 25_903_000 picoseconds. - Weight::from_parts(26_150_000, 3593) + // Minimum execution time: 23_732_000 picoseconds. + Weight::from_parts(24_098_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: System Account (r:1 w:1) - // Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `System::Account` (r:1 w:1) + // Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn deposit_reserve_asset() -> Weight { // Proof Size summary in bytes: // Measured: `122` // Estimated: `3593` - // Minimum execution time: 51_084_000 picoseconds. - Weight::from_parts(51_859_000, 3593) + // Minimum execution time: 58_449_000 picoseconds. + Weight::from_parts(60_235_000, 3593) .saturating_add(T::DbWeight::get().reads(7)) .saturating_add(T::DbWeight::get().writes(3)) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn initiate_teleport() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 28_038_000 picoseconds. - Weight::from_parts(28_438_000, 3535) + // Minimum execution time: 25_708_000 picoseconds. + Weight::from_parts(26_495_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs index d7b10f95c792a9874bd98ccf4eb20bdf87e20bb0..1377d31f2db7df67b58a699253af03498f7f6741 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/pallet_xcm_benchmarks_generic.rs @@ -1,70 +1,71 @@ // Copyright (C) Parity Technologies (UK) Ltd. -// SPDX-License-Identifier: Apache-2.0 +// This file is part of Cumulus. -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . //! Autogenerated weights for `pallet_xcm_benchmarks::generic` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-09, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `bm4`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("people-polkadot-dev"), DB CACHE: 1024 +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: Compiled, CHAIN: Some("people-westend-dev"), DB CACHE: 1024 // Executed Command: -// ./artifacts/polkadot-parachain +// target/production/polkadot-parachain // benchmark // pallet -// --template=./templates/xcm-bench-template.hbs -// --chain=people-polkadot-dev -// --execution=wasm -// --wasm-execution=compiled -// --pallet=pallet_xcm_benchmarks::generic -// --extrinsic=* // --steps=50 // --repeat=20 -// --json -// --header=./file_header.txt -// --output=./cumulus/parachains/runtimes/people/people-polkadot/src/weights/xcm/pallet_xcm_benchmarks_generic.rs +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_xcm_benchmarks::generic +// --chain=people-westend-dev +// --header=./cumulus/file_header.txt +// --template=./cumulus/templates/xcm-bench-template.hbs +// --output=./cumulus/parachains/runtimes/people/people-westend/src/weights/xcm/ #![cfg_attr(rustfmt, rustfmt_skip)] #![allow(unused_parens)] #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `pallet_xcm_benchmarks::generic`. pub struct WeightInfo(PhantomData); impl WeightInfo { - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_holding() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 30_819_000 picoseconds. - Weight::from_parts(31_157_000, 3535) + // Minimum execution time: 29_537_000 picoseconds. + Weight::from_parts(30_513_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -72,97 +73,97 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_869_000 picoseconds. - Weight::from_parts(2_920_000, 0) + // Minimum execution time: 683_000 picoseconds. + Weight::from_parts(738_000, 0) } - // Storage: PolkadotXcm Queries (r:1 w:0) - // Proof Skipped: PolkadotXcm Queries (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::Queries` (r:1 w:0) + // Proof: `PolkadotXcm::Queries` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn query_response() -> Weight { // Proof Size summary in bytes: // Measured: `32` // Estimated: `3497` - // Minimum execution time: 10_268_000 picoseconds. - Weight::from_parts(10_496_000, 3497) + // Minimum execution time: 7_498_000 picoseconds. + Weight::from_parts(7_904_000, 3497) .saturating_add(T::DbWeight::get().reads(1)) } pub fn transact() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 11_990_000 picoseconds. - Weight::from_parts(12_206_000, 0) + // Minimum execution time: 7_029_000 picoseconds. + Weight::from_parts(7_325_000, 0) } pub fn refund_surplus() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_170_000 picoseconds. - Weight::from_parts(3_308_000, 0) + // Minimum execution time: 1_343_000 picoseconds. + Weight::from_parts(1_410_000, 0) } pub fn set_error_handler() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_650_000 picoseconds. - Weight::from_parts(2_783_000, 0) + // Minimum execution time: 696_000 picoseconds. + Weight::from_parts(734_000, 0) } pub fn set_appendix() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_681_000 picoseconds. - Weight::from_parts(2_829_000, 0) + // Minimum execution time: 690_000 picoseconds. + Weight::from_parts(740_000, 0) } pub fn clear_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_622_000 picoseconds. - Weight::from_parts(2_688_000, 0) + // Minimum execution time: 667_000 picoseconds. + Weight::from_parts(697_000, 0) } pub fn descend_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_385_000 picoseconds. - Weight::from_parts(3_538_000, 0) + // Minimum execution time: 692_000 picoseconds. + Weight::from_parts(743_000, 0) } pub fn clear_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_630_000 picoseconds. - Weight::from_parts(2_720_000, 0) + // Minimum execution time: 670_000 picoseconds. + Weight::from_parts(712_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_error() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 24_446_000 picoseconds. - Weight::from_parts(24_854_000, 3535) + // Minimum execution time: 26_405_000 picoseconds. + Weight::from_parts(26_877_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } - // Storage: PolkadotXcm AssetTraps (r:1 w:1) - // Proof Skipped: PolkadotXcm AssetTraps (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::AssetTraps` (r:1 w:1) + // Proof: `PolkadotXcm::AssetTraps` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn claim_asset() -> Weight { // Proof Size summary in bytes: // Measured: `90` // Estimated: `3555` - // Minimum execution time: 14_713_000 picoseconds. - Weight::from_parts(15_010_000, 3555) + // Minimum execution time: 10_953_000 picoseconds. + Weight::from_parts(11_345_000, 3555) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -170,114 +171,93 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_702_000 picoseconds. - Weight::from_parts(2_744_000, 0) + // Minimum execution time: 644_000 picoseconds. + Weight::from_parts(693_000, 0) } - // Storage: PolkadotXcm VersionNotifyTargets (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionNotifyTargets (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `PolkadotXcm::VersionNotifyTargets` (r:1 w:1) + // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn subscribe_version() -> Weight { // Proof Size summary in bytes: // Measured: `38` // Estimated: `3503` - // Minimum execution time: 25_955_000 picoseconds. - Weight::from_parts(26_632_000, 3503) + // Minimum execution time: 24_157_000 picoseconds. + Weight::from_parts(24_980_000, 3503) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(3)) } - // Storage: PolkadotXcm VersionNotifyTargets (r:0 w:1) - // Proof Skipped: PolkadotXcm VersionNotifyTargets (max_values: None, max_size: None, mode: Measured) + // Storage: `PolkadotXcm::VersionNotifyTargets` (r:0 w:1) + // Proof: `PolkadotXcm::VersionNotifyTargets` (`max_values`: None, `max_size`: None, mode: `Measured`) pub fn unsubscribe_version() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_965_000 picoseconds. - Weight::from_parts(5_168_000, 0) + // Minimum execution time: 2_767_000 picoseconds. + Weight::from_parts(2_844_000, 0) .saturating_add(T::DbWeight::get().writes(1)) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) - pub fn initiate_reserve_withdraw() -> Weight { - // Proof Size summary in bytes: - // Measured: `70` - // Estimated: `3535` - // Minimum execution time: 27_707_000 picoseconds. - Weight::from_parts(28_081_000, 3535) - .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(2)) - } pub fn burn_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_215_000 picoseconds. - Weight::from_parts(4_362_000, 0) + // Minimum execution time: 1_079_000 picoseconds. + Weight::from_parts(1_141_000, 0) } pub fn expect_asset() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_843_000 picoseconds. - Weight::from_parts(2_957_000, 0) + // Minimum execution time: 776_000 picoseconds. + Weight::from_parts(829_000, 0) } pub fn expect_origin() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_751_000 picoseconds. - Weight::from_parts(2_809_000, 0) + // Minimum execution time: 696_000 picoseconds. + Weight::from_parts(740_000, 0) } pub fn expect_error() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_674_000 picoseconds. - Weight::from_parts(2_737_000, 0) + // Minimum execution time: 655_000 picoseconds. + Weight::from_parts(684_000, 0) } pub fn expect_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_891_000 picoseconds. - Weight::from_parts(2_952_000, 0) + // Minimum execution time: 825_000 picoseconds. + Weight::from_parts(853_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn query_pallet() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 28_600_000 picoseconds. - Weight::from_parts(29_001_000, 3535) + // Minimum execution time: 30_222_000 picoseconds. + Weight::from_parts(31_110_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -285,27 +265,27 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 4_748_000 picoseconds. - Weight::from_parts(4_813_000, 0) + // Minimum execution time: 3_108_000 picoseconds. + Weight::from_parts(3_325_000, 0) } - // Storage: ParachainInfo ParachainId (r:1 w:0) - // Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - // Storage: PolkadotXcm SupportedVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SupportedVersion (max_values: None, max_size: None, mode: Measured) - // Storage: PolkadotXcm VersionDiscoveryQueue (r:1 w:1) - // Proof Skipped: PolkadotXcm VersionDiscoveryQueue (max_values: Some(1), max_size: None, mode: Measured) - // Storage: PolkadotXcm SafeXcmVersion (r:1 w:0) - // Proof Skipped: PolkadotXcm SafeXcmVersion (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem HostConfiguration (r:1 w:0) - // Proof Skipped: ParachainSystem HostConfiguration (max_values: Some(1), max_size: None, mode: Measured) - // Storage: ParachainSystem PendingUpwardMessages (r:1 w:1) - // Proof Skipped: ParachainSystem PendingUpwardMessages (max_values: Some(1), max_size: None, mode: Measured) + // Storage: `ParachainInfo::ParachainId` (r:1 w:0) + // Proof: `ParachainInfo::ParachainId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + // Storage: `PolkadotXcm::SupportedVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::VersionDiscoveryQueue` (r:1 w:1) + // Proof: `PolkadotXcm::VersionDiscoveryQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `PolkadotXcm::SafeXcmVersion` (r:1 w:0) + // Proof: `PolkadotXcm::SafeXcmVersion` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::HostConfiguration` (r:1 w:0) + // Proof: `ParachainSystem::HostConfiguration` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + // Storage: `ParachainSystem::PendingUpwardMessages` (r:1 w:1) + // Proof: `ParachainSystem::PendingUpwardMessages` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) pub fn report_transact_status() -> Weight { // Proof Size summary in bytes: // Measured: `70` // Estimated: `3535` - // Minimum execution time: 25_483_000 picoseconds. - Weight::from_parts(25_737_000, 3535) + // Minimum execution time: 26_548_000 picoseconds. + Weight::from_parts(26_911_000, 3535) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -313,35 +293,35 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_755_000 picoseconds. - Weight::from_parts(2_817_000, 0) + // Minimum execution time: 684_000 picoseconds. + Weight::from_parts(726_000, 0) } pub fn set_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_700_000 picoseconds. - Weight::from_parts(2_773_000, 0) + // Minimum execution time: 649_000 picoseconds. + Weight::from_parts(700_000, 0) } pub fn clear_topic() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_670_000 picoseconds. - Weight::from_parts(2_711_000, 0) + // Minimum execution time: 650_000 picoseconds. + Weight::from_parts(686_000, 0) } pub fn set_fees_mode() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_710_000 picoseconds. - Weight::from_parts(2_762_000, 0) + // Minimum execution time: 652_000 picoseconds. + Weight::from_parts(703_000, 0) } pub fn unpaid_execution() -> Weight { // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 2_839_000 picoseconds. - Weight::from_parts(2_931_000, 0) + // Minimum execution time: 673_000 picoseconds. + Weight::from_parts(742_000, 0) } } diff --git a/cumulus/parachains/runtimes/people/people-westend/src/xcm_config.rs b/cumulus/parachains/runtimes/people/people-westend/src/xcm_config.rs index 3926ddcf21efe09933e85552b3fc31f368d69e9b..f35e920d7cb752a4e6e8e427294726f1854e5bb4 100644 --- a/cumulus/parachains/runtimes/people/people-westend/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/people/people-westend/src/xcm_config.rs @@ -40,10 +40,10 @@ use xcm_builder::{ AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, DenyReserveTransferToRelayChain, DenyThenTry, DescribeTerminus, EnsureXcmOrigin, FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsConcrete, ParentAsSuperuser, - ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, SiblingParachainConvertsVia, - SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, - TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + ParentIsPreset, RelayChainAsNative, SendXcmFeeToAccount, SiblingParachainAsNative, + SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, + SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, + WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -227,7 +227,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/starters/seedling/Cargo.toml b/cumulus/parachains/runtimes/starters/seedling/Cargo.toml index eb702c9f2cdf30844fbf4ea17534566c038c4880..c76c09a31234e6077f97e38c7e38fe4fbddeae86 100644 --- a/cumulus/parachains/runtimes/starters/seedling/Cargo.toml +++ b/cumulus/parachains/runtimes/starters/seedling/Cargo.toml @@ -10,41 +10,40 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-aura = { workspace = true } +pallet-balances = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-solo-to-para = { path = "../../../../pallets/solo-to-para", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-timestamp = { path = "../../../../primitives/timestamp", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-solo-to-para = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-timestamp = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -74,7 +73,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", diff --git a/cumulus/parachains/runtimes/starters/seedling/src/lib.rs b/cumulus/parachains/runtimes/starters/seedling/src/lib.rs index 461133f6cfc06ad8cea140ea19d6df6c8aebb520..1fe72604d3731eed1dee3d27477e0e829cccfba0 100644 --- a/cumulus/parachains/runtimes/starters/seedling/src/lib.rs +++ b/cumulus/parachains/runtimes/starters/seedling/src/lib.rs @@ -27,6 +27,9 @@ #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use sp_api::impl_runtime_apis; pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; @@ -37,7 +40,6 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -310,7 +312,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } diff --git a/cumulus/parachains/runtimes/starters/shell/Cargo.toml b/cumulus/parachains/runtimes/starters/shell/Cargo.toml index f66d04fec1fdd72eb30f183bb713e88d4fee00e7..8f3b2204cfe34b8bb73c6a9062c9a91df262a8e4 100644 --- a/cumulus/parachains/runtimes/starters/shell/Cargo.toml +++ b/cumulus/parachains/runtimes/starters/shell/Cargo.toml @@ -10,45 +10,44 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-try-runtime = { path = "../../../../../substrate/frame/try-runtime", default-features = false, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-timestamp = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } +pallet-message-queue = { workspace = true } # Polkadot -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-primitives-core = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -77,7 +76,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", diff --git a/cumulus/parachains/runtimes/starters/shell/src/lib.rs b/cumulus/parachains/runtimes/starters/shell/src/lib.rs index a3d1629bbe5eb928f3f78998ed721968f140536d..1dfbe2b6c41c840846e1d64a4d87e7c9c1b0c7cf 100644 --- a/cumulus/parachains/runtimes/starters/shell/src/lib.rs +++ b/cumulus/parachains/runtimes/starters/shell/src/lib.rs @@ -31,6 +31,9 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use codec::{Decode, Encode}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use cumulus_primitives_core::AggregateMessageOrigin; @@ -45,7 +48,6 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -229,7 +231,7 @@ impl pallet_message_queue::Config for Runtime { // These need to be configured to the XCMP pallet - if it is deployed. type QueueChangeHandler = (); type QueuePausedQuery = (); - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -280,7 +282,7 @@ impl sp_runtime::traits::SignedExtension for DisallowSigned { type Pre = (); fn additional_signed( &self, - ) -> sp_std::result::Result<(), sp_runtime::transaction_validity::TransactionValidityError> { + ) -> core::result::Result<(), sp_runtime::transaction_validity::TransactionValidityError> { Ok(()) } fn pre_dispatch( @@ -368,7 +370,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } diff --git a/cumulus/parachains/runtimes/test-utils/Cargo.toml b/cumulus/parachains/runtimes/test-utils/Cargo.toml index eda88beb7dabb41bd4075ec5ab6bf8ec2f42d3c8..01d7fcc2b5c8b77c7daa90d807634193545e95ec 100644 --- a/cumulus/parachains/runtimes/test-utils/Cargo.toml +++ b/cumulus/parachains/runtimes/test-utils/Cargo.toml @@ -10,41 +10,40 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive", "max-encoded-len"] } +codec = { features = ["derive", "max-encoded-len"], workspace = true } # Substrate -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../substrate/frame/system", default-features = false } -pallet-balances = { path = "../../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../../substrate/frame/session", default-features = false } -pallet-timestamp = { path = "../../../../substrate/frame/timestamp", default-features = false } -sp-consensus-aura = { path = "../../../../substrate/primitives/consensus/aura", 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-tracing = { path = "../../../../substrate/primitives/tracing" } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } +pallet-timestamp = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +sp-core = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcmp-queue = { path = "../../../pallets/xcmp-queue", default-features = false } -pallet-collator-selection = { path = "../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../pallets/parachain-info", default-features = false } -cumulus-primitives-core = { path = "../../../primitives/core", default-features = false } -cumulus-primitives-parachain-inherent = { path = "../../../primitives/parachain-inherent", default-features = false } -cumulus-test-relay-sproof-builder = { path = "../../../test/relay-sproof-builder", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-parachain-inherent = { workspace = true } +cumulus-test-relay-sproof-builder = { workspace = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../../polkadot/xcm/xcm-executor", default-features = false } -pallet-xcm = { path = "../../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-parachain-primitives = { path = "../../../../polkadot/parachain", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } +pallet-xcm = { workspace = true } +polkadot-parachain-primitives = { workspace = true } [dev-dependencies] -hex-literal = "0.4.1" +hex-literal = { workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -68,7 +67,6 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-executor/std", "xcm/std", ] diff --git a/cumulus/parachains/runtimes/test-utils/src/lib.rs b/cumulus/parachains/runtimes/test-utils/src/lib.rs index 3c84243306fbe518dd00ee78411d9ec032e90446..940aa1b734dfc856b5a72cf83cc14b5f8980bc5e 100644 --- a/cumulus/parachains/runtimes/test-utils/src/lib.rs +++ b/cumulus/parachains/runtimes/test-utils/src/lib.rs @@ -13,7 +13,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -use sp_std::marker::PhantomData; +use core::marker::PhantomData; use codec::{Decode, DecodeLimit}; use cumulus_primitives_core::{ @@ -242,7 +242,7 @@ impl ExtBuilder { .assimilate_storage(&mut t) .unwrap(); - pallet_session::GenesisConfig:: { keys: self.keys } + pallet_session::GenesisConfig:: { keys: self.keys, ..Default::default() } .assimilate_storage(&mut t) .unwrap(); diff --git a/cumulus/parachains/runtimes/testing/penpal/Cargo.toml b/cumulus/parachains/runtimes/testing/penpal/Cargo.toml index 4ebb95f26cf6ab15b5576a62fe56e2fe626dd6d9..e16629302be6a90c25f365a72edb9dd36baebd75 100644 --- a/cumulus/parachains/runtimes/testing/penpal/Cargo.toml +++ b/cumulus/parachains/runtimes/testing/penpal/Cargo.toml @@ -4,7 +4,7 @@ version = "0.14.0" authors = ["Anonymous"] description = "A parachain for communication back and forth with XCM of assets and uniques." license = "Unlicense" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true edition.workspace = true @@ -15,70 +15,69 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -hex-literal = { version = "0.4.1", optional = true } +codec = { features = ["derive"], workspace = true } +hex-literal = { optional = true, workspace = true, default-features = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -smallvec = "1.11.0" +scale-info = { features = ["derive"], workspace = true } +smallvec = { workspace = true, default-features = true } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -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, optional = true } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-session = { path = "../../../../../substrate/frame/session", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", 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 } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-storage = { path = "../../../../../substrate/primitives/storage", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-session = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-asset-tx-payment = { workspace = true } +pallet-assets = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -polkadot-primitives = { path = "../../../../../polkadot/primitives", default-features = false } -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../../../../polkadot/xcm/xcm-fee-payment-runtime-api", default-features = false } +polkadot-primitives = { workspace = true } +pallet-xcm = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm-runtime-apis = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-session-benchmarking = { path = "../../../../pallets/session-benchmarking", default-features = false } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -pallet-collator-selection = { path = "../../../../pallets/collator-selection", default-features = false } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -assets-common = { path = "../../assets/common", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +pallet-message-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-session-benchmarking = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-utility = { workspace = true } +pallet-collator-selection = { workspace = true } +parachain-info = { workspace = true } +parachains-common = { workspace = true } +assets-common = { workspace = true } [features] default = ["std"] @@ -128,14 +127,13 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-storage/std", "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] @@ -166,7 +164,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ diff --git a/cumulus/parachains/runtimes/testing/penpal/src/lib.rs b/cumulus/parachains/runtimes/testing/penpal/src/lib.rs index 582154fec6d274e048558fec43893aee7d4f2817..bf39c02a3f59460156c37e6c652bc69fa7237a2d 100644 --- a/cumulus/parachains/runtimes/testing/penpal/src/lib.rs +++ b/cumulus/parachains/runtimes/testing/penpal/src/lib.rs @@ -32,6 +32,9 @@ include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); mod weights; pub mod xcm_config; +extern crate alloc; + +use alloc::{vec, vec::Vec}; use codec::Encode; use cumulus_pallet_parachain_system::RelayNumberStrictlyIncreases; use cumulus_primitives_core::{AggregateMessageOrigin, ParaId}; @@ -64,12 +67,11 @@ pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; use sp_runtime::{ create_runtime_str, generic, impl_opaque_keys, - traits::{AccountIdLookup, BlakeTwo256, Block as BlockT}, + traits::{AccountIdLookup, BlakeTwo256, Block as BlockT, Dispatchable}, transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, }; pub use sp_runtime::{traits::ConvertInto, MultiAddress, Perbill, Permill}; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -83,10 +85,10 @@ use polkadot_runtime_common::{BlockHashCount, SlowAdjustingFeeUpdate}; use weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight}; use xcm::{ latest::prelude::{AssetId as AssetLocationId, BodyId}, - IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, + VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm, }; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects}, +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::Error as XcmPaymentApiError, }; @@ -541,7 +543,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = MessageQueueServiceWeight; @@ -569,7 +571,11 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type VersionWrapper = PolkadotXcm; // Enqueue XCMP messages from siblings for later processing. type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = (); @@ -733,7 +739,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -843,26 +849,27 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { - if !matches!(xcm_version, 3 | 4) { - return Err(XcmPaymentApiError::UnhandledXcmVersion); - } - Ok([VersionedAssetId::V4(xcm_config::RelayLocation::get().into())] - .into_iter() - .filter_map(|asset| asset.into_version(xcm_version).ok()) - .collect()) + let acceptable_assets = vec![AssetLocationId(xcm_config::RelayLocation::get())]; + PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets) } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { - let local_asset = VersionedAssetId::V4(xcm_config::RelayLocation::get().into()); - let asset = asset - .into_version(4) - .map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?; - - if asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); } - - Ok(WeightToFee::weight_to_fee(&weight)) + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == xcm_config::RelayLocation::get() => { + // for native token + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } } fn query_xcm_weight(message: VersionedXcm<()>) -> Result { @@ -874,26 +881,20 @@ impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { use xcm_builder::InspectMessageQueues; use xcm_executor::RecordXcm; use xcm::prelude::*; - pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; + frame_system::Pallet::::reset_events(); // To make sure we only record events from current call. + let result = call.dispatch(origin.into()); + pallet_xcm::Pallet::::set_record_xcm(false); let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); let forwarded_xcms = xcm_config::XcmRouter::get_messages(); let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), + Ok(CallDryRunEffects { + local_xcm: local_xcm.map(VersionedXcm::<()>::from), forwarded_xcms, emitted_events: events, execution_result: result, @@ -906,7 +907,7 @@ impl_runtime_apis! { let origin_location: Location = origin_location.try_into().map_err(|error| { log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", + target: "xcm::DryRunApi::dry_run_xcm", "Location version conversion failed with error: {:?}", error, ); @@ -914,13 +915,14 @@ impl_runtime_apis! { })?; let program: Xcm = program.try_into().map_err(|error| { log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", + target: "xcm::DryRunApi::dry_run_xcm", "Xcm version conversion failed with error {:?}", error, ); XcmDryRunApiError::VersionedConversionFailed })?; let mut hash = program.using_encoded(sp_core::hashing::blake2_256); + frame_system::Pallet::::reset_events(); // To make sure we only record events from current call. let result = xcm_executor::XcmExecutor::::prepare_and_execute( origin_location, program, diff --git a/cumulus/parachains/runtimes/testing/penpal/src/xcm_config.rs b/cumulus/parachains/runtimes/testing/penpal/src/xcm_config.rs index 08a2da260c57e67b17eecf55f3845049e371b996..d0c421bccaf89c8a54e348c3ff04950be444a233 100644 --- a/cumulus/parachains/runtimes/testing/penpal/src/xcm_config.rs +++ b/cumulus/parachains/runtimes/testing/penpal/src/xcm_config.rs @@ -47,11 +47,11 @@ use xcm_builder::{ AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, AsPrefixedGeneralIndex, ConvertedConcreteId, EnsureXcmOrigin, FixedWeightBounds, FrameTransactionalProcessor, FungibleAdapter, FungiblesAdapter, IsConcrete, LocalMint, NativeAsset, NoChecking, - ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, SiblingParachainAsNative, - SiblingParachainConvertsVia, SignedAccountId32AsNative, SignedToAccountId32, - SovereignSignedViaLocation, StartsWith, TakeWeightCredit, TrailingSetTopicAsId, - UsingComponents, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, - XcmFeeToAccount, + ParentAsSuperuser, ParentIsPreset, RelayChainAsNative, SendXcmFeeToAccount, + SiblingParachainAsNative, SiblingParachainConvertsVia, SignedAccountId32AsNative, + SignedToAccountId32, SovereignSignedViaLocation, StartsWith, TakeWeightCredit, + TrailingSetTopicAsId, UsingComponents, WithComputedOrigin, WithUniqueTopic, + XcmFeeManagerFromComponents, }; use xcm_executor::{traits::JustTry, XcmExecutor}; @@ -282,6 +282,10 @@ parameter_types! { 1, [Parachain(ASSET_HUB_ID), PalletInstance(ASSETS_PALLET_ID), GeneralIndex(RESERVABLE_ASSET_ID.into())] ); + pub UsdtFromAssetHub: Location = Location::new( + 1, + [Parachain(ASSET_HUB_ID), PalletInstance(ASSETS_PALLET_ID), GeneralIndex(1984)] + ); /// The Penpal runtime is utilized for testing with various environment setups. /// This storage item provides the opportunity to customize testing scenarios @@ -351,7 +355,7 @@ impl xcm_executor::Config for XcmConfig { type AssetExchanger = (); type FeeManager = XcmFeeManagerFromComponents< (), - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml b/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml index df3aaa92c79e78e5dfb9043db69778db051b3053..9c905c8762778447809acb3f7592585223aca865 100644 --- a/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml +++ b/cumulus/parachains/runtimes/testing/rococo-parachain/Cargo.toml @@ -10,60 +10,59 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-benchmarking = { path = "../../../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-executive = { path = "../../../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../../../substrate/frame/system/rpc/runtime-api", default-features = false } -pallet-assets = { path = "../../../../../substrate/frame/assets", default-features = false } -pallet-aura = { path = "../../../../../substrate/frame/aura", default-features = false } -pallet-balances = { path = "../../../../../substrate/frame/balances", default-features = false } -pallet-sudo = { path = "../../../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -sp-api = { path = "../../../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../../../substrate/primitives/block-builder", default-features = false } -sp-consensus-aura = { path = "../../../../../substrate/primitives/consensus/aura", default-features = false } -sp-core = { path = "../../../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../../../substrate/primitives/genesis-builder", default-features = false } -sp-inherents = { path = "../../../../../substrate/primitives/inherents", default-features = false } -sp-offchain = { path = "../../../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../../../substrate/primitives/session", default-features = false } -sp-std = { path = "../../../../../substrate/primitives/std", default-features = false } -sp-transaction-pool = { path = "../../../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../../../substrate/primitives/version", default-features = false } +frame-benchmarking = { optional = true, workspace = true } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +pallet-assets = { workspace = true } +pallet-aura = { workspace = true } +pallet-balances = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Polkadot -pallet-xcm = { path = "../../../../../polkadot/xcm/pallet-xcm", default-features = false } -polkadot-parachain-primitives = { path = "../../../../../polkadot/parachain", default-features = false } -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-executor = { package = "staging-xcm-executor", path = "../../../../../polkadot/xcm/xcm-executor", default-features = false } -polkadot-runtime-common = { path = "../../../../../polkadot/runtime/common", default-features = false } +pallet-xcm = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +polkadot-runtime-common = { workspace = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../../../pallets/aura-ext", default-features = false } -pallet-message-queue = { path = "../../../../../substrate/frame/message-queue", default-features = false } -cumulus-pallet-parachain-system = { path = "../../../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-pallet-xcm = { path = "../../../../pallets/xcm", default-features = false } -cumulus-pallet-xcmp-queue = { path = "../../../../pallets/xcmp-queue", default-features = false } -cumulus-ping = { path = "../../../pallets/ping", default-features = false } -cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } -cumulus-primitives-core = { path = "../../../../primitives/core", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../../../primitives/storage-weight-reclaim", default-features = false } -cumulus-primitives-utility = { path = "../../../../primitives/utility", default-features = false } -parachains-common = { path = "../../../common", default-features = false } -testnet-parachains-constants = { path = "../../constants", default-features = false, features = ["rococo"] } -parachain-info = { package = "staging-parachain-info", path = "../../../pallets/parachain-info", default-features = false } +cumulus-pallet-aura-ext = { workspace = true } +pallet-message-queue = { workspace = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-pallet-xcm = { workspace = true } +cumulus-pallet-xcmp-queue = { workspace = true } +cumulus-ping = { workspace = true } +cumulus-primitives-aura = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } +cumulus-primitives-utility = { workspace = true } +parachains-common = { workspace = true } +testnet-parachains-constants = { features = ["rococo"], workspace = true } +parachain-info = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -106,7 +105,6 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", @@ -136,3 +134,8 @@ runtime-benchmarks = [ "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", ] + +# A feature that should be enabled when the runtime should be built for on-chain +# deployment. This will disable stuff that shouldn't be part of the on-chain wasm +# to make it smaller, like logging for example. +on-chain-release-build = [] diff --git a/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs b/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs index f22e900ba9efd66f4abe5561442755e5ce0b5b78..dff7046f1972614d30210b6ac6d21c24e0350aea 100644 --- a/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs +++ b/cumulus/parachains/runtimes/testing/rococo-parachain/src/lib.rs @@ -22,6 +22,9 @@ #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +extern crate alloc; + +use alloc::{vec, vec::Vec}; use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases; use polkadot_runtime_common::xcm_sender::NoPriceForMessageDelivery; use sp_api::impl_runtime_apis; @@ -32,7 +35,6 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -107,7 +109,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("test-parachain"), impl_name: create_runtime_str!("test-parachain"), authoring_version: 1, - spec_version: 1_011_000, + spec_version: 1_014_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, transaction_version: 6, @@ -317,7 +319,7 @@ impl pallet_message_queue::Config for Runtime { // The XCMP queue pallet is only ever able to handle the `Sibling(ParaId)` origin: type QueueChangeHandler = NarrowOriginToSibling; type QueuePausedQuery = NarrowOriginToSibling; - type HeapSize = sp_core::ConstU32<{ 64 * 1024 }>; + type HeapSize = sp_core::ConstU32<{ 103 * 1024 }>; type MaxStale = sp_core::ConstU32<8>; type ServiceWeight = MessageQueueServiceWeight; type IdleMaxServiceWeight = (); @@ -542,7 +544,11 @@ impl cumulus_pallet_xcmp_queue::Config for Runtime { type VersionWrapper = (); // Enqueue XCMP messages from siblings for later processing. type XcmpQueue = TransformOrigin; - type MaxInboundSuspended = sp_core::ConstU32<1_000>; + type MaxInboundSuspended = ConstU32<1_000>; + type MaxActiveOutboundChannels = ConstU32<128>; + // Most on-chain HRMP channels are configured to use 102400 bytes of max message size, so we + // need to set the page size larger than that until we reduce the channel size on-chain. + type MaxPageSize = ConstU32<{ 103 * 1024 }>; type ControllerOrigin = EnsureRoot; type ControllerOriginConverter = XcmOriginToTransactDispatchOrigin; type WeightInfo = cumulus_pallet_xcmp_queue::weights::SubstrateWeight; @@ -707,7 +713,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } diff --git a/cumulus/polkadot-parachain/Cargo.toml b/cumulus/polkadot-parachain/Cargo.toml index f21a5baf973bd7bb9362691333f6fadeec8970bb..383e0f158bf49b30e743dc0fe530f5e84560fdf0 100644 --- a/cumulus/polkadot-parachain/Cargo.toml +++ b/cumulus/polkadot-parachain/Cargo.toml @@ -2,9 +2,9 @@ name = "polkadot-parachain-bin" version = "4.0.0" authors.workspace = true -build = "build.rs" edition.workspace = true -description = "Runs a polkadot parachain node which could be a collator." +build = "build.rs" +description = "Runs a polkadot parachain node" license = "Apache-2.0" [lints] @@ -15,117 +15,62 @@ name = "polkadot-parachain" path = "src/main.rs" [dependencies] -async-trait = "0.1.79" -clap = { version = "4.5.3", features = ["derive"] } -codec = { package = "parity-scale-codec", version = "3.0.0" } -futures = "0.3.28" -hex-literal = "0.4.1" +color-eyre = { workspace = true } +hex-literal = { workspace = true, default-features = true } log = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } # Local -rococo-parachain-runtime = { path = "../parachains/runtimes/testing/rococo-parachain" } -shell-runtime = { path = "../parachains/runtimes/starters/shell" } -glutton-westend-runtime = { path = "../parachains/runtimes/glutton/glutton-westend" } -seedling-runtime = { path = "../parachains/runtimes/starters/seedling" } -asset-hub-rococo-runtime = { path = "../parachains/runtimes/assets/asset-hub-rococo" } -asset-hub-westend-runtime = { path = "../parachains/runtimes/assets/asset-hub-westend" } -collectives-westend-runtime = { path = "../parachains/runtimes/collectives/collectives-westend" } -contracts-rococo-runtime = { path = "../parachains/runtimes/contracts/contracts-rococo" } -bridge-hub-rococo-runtime = { path = "../parachains/runtimes/bridge-hubs/bridge-hub-rococo" } -coretime-rococo-runtime = { path = "../parachains/runtimes/coretime/coretime-rococo" } -coretime-westend-runtime = { path = "../parachains/runtimes/coretime/coretime-westend" } -bridge-hub-westend-runtime = { path = "../parachains/runtimes/bridge-hubs/bridge-hub-westend" } -penpal-runtime = { path = "../parachains/runtimes/testing/penpal" } -jsonrpsee = { version = "0.22", features = ["server"] } -people-rococo-runtime = { path = "../parachains/runtimes/people/people-rococo" } -people-westend-runtime = { path = "../parachains/runtimes/people/people-westend" } -parachains-common = { path = "../parachains/common" } -testnet-parachains-constants = { path = "../parachains/runtimes/constants", default-features = false, features = [ +polkadot-parachain-lib = { features = ["rococo-native", "westend-native"], workspace = true } +rococo-parachain-runtime = { workspace = true } +shell-runtime = { workspace = true } +glutton-westend-runtime = { workspace = true } +seedling-runtime = { workspace = true } +asset-hub-rococo-runtime = { workspace = true, default-features = true } +asset-hub-westend-runtime = { workspace = true } +collectives-westend-runtime = { workspace = true } +contracts-rococo-runtime = { workspace = true } +bridge-hub-rococo-runtime = { workspace = true, default-features = true } +coretime-rococo-runtime = { workspace = true } +coretime-westend-runtime = { workspace = true } +bridge-hub-westend-runtime = { workspace = true, default-features = true } +penpal-runtime = { workspace = true } +people-rococo-runtime = { workspace = true } +people-westend-runtime = { workspace = true } +parachains-common = { workspace = true, default-features = true } +testnet-parachains-constants = { features = [ "rococo", "westend", -] } +], workspace = true } # Substrate -frame-benchmarking = { path = "../../substrate/frame/benchmarking" } -frame-benchmarking-cli = { path = "../../substrate/utils/frame/benchmarking-cli" } -sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false } -sp-io = { path = "../../substrate/primitives/io" } -sp-core = { path = "../../substrate/primitives/core" } -sp-session = { path = "../../substrate/primitives/session" } -frame-try-runtime = { path = "../../substrate/frame/try-runtime", optional = true } -sc-consensus = { path = "../../substrate/client/consensus/common" } -sp-tracing = { path = "../../substrate/primitives/tracing" } -frame-support = { path = "../../substrate/frame/support" } -sc-cli = { path = "../../substrate/client/cli" } -sc-client-api = { path = "../../substrate/client/api" } -sc-executor = { path = "../../substrate/client/executor" } -sc-service = { path = "../../substrate/client/service" } -sc-telemetry = { path = "../../substrate/client/telemetry" } -sc-transaction-pool = { path = "../../substrate/client/transaction-pool" } -sp-transaction-pool = { path = "../../substrate/primitives/transaction-pool" } -sc-network = { path = "../../substrate/client/network" } -sc-network-sync = { path = "../../substrate/client/network/sync" } -sc-basic-authorship = { path = "../../substrate/client/basic-authorship" } -sp-timestamp = { path = "../../substrate/primitives/timestamp" } -sp-blockchain = { path = "../../substrate/primitives/blockchain" } -sp-genesis-builder = { path = "../../substrate/primitives/genesis-builder", default-features = false } -sp-block-builder = { path = "../../substrate/primitives/block-builder" } -sp-keystore = { path = "../../substrate/primitives/keystore" } -sc-chain-spec = { path = "../../substrate/client/chain-spec" } -sc-rpc = { path = "../../substrate/client/rpc" } -sp-version = { path = "../../substrate/primitives/version" } -sc-tracing = { path = "../../substrate/client/tracing" } -sp-offchain = { path = "../../substrate/primitives/offchain" } -frame-system-rpc-runtime-api = { path = "../../substrate/frame/system/rpc/runtime-api" } -pallet-transaction-payment = { path = "../../substrate/frame/transaction-payment" } -pallet-transaction-payment-rpc-runtime-api = { path = "../../substrate/frame/transaction-payment/rpc/runtime-api" } -sp-std = { path = "../../substrate/primitives/std" } -sp-inherents = { path = "../../substrate/primitives/inherents" } -sp-api = { path = "../../substrate/primitives/api" } -sp-consensus-aura = { path = "../../substrate/primitives/consensus/aura" } -sc-sysinfo = { path = "../../substrate/client/sysinfo" } -substrate-prometheus-endpoint = { path = "../../substrate/utils/prometheus" } -sc-transaction-pool-api = { path = "../../substrate/client/transaction-pool/api" } -frame-rpc-system = { package = "substrate-frame-rpc-system", path = "../../substrate/utils/frame/rpc/system" } -pallet-transaction-payment-rpc = { path = "../../substrate/frame/transaction-payment/rpc" } -substrate-state-trie-migration-rpc = { path = "../../substrate/utils/frame/rpc/state-trie-migration-rpc" } +sp-runtime = { workspace = true } +sp-core = { workspace = true, default-features = true } +sc-cli = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } # Polkadot -# Use rococo-native as this is currently the default "local" relay chain -polkadot-cli = { path = "../../polkadot/cli", features = ["rococo-native"] } -polkadot-primitives = { path = "../../polkadot/primitives" } -polkadot-service = { path = "../../polkadot/node/service" } -xcm = { package = "staging-xcm", path = "../../polkadot/xcm" } +polkadot-service = { workspace = true, default-features = true } +xcm = { workspace = true, default-features = true } # Cumulus -cumulus-client-cli = { path = "../client/cli" } -cumulus-client-collator = { path = "../client/collator" } -cumulus-client-consensus-aura = { path = "../client/consensus/aura" } -cumulus-client-consensus-relay-chain = { path = "../client/consensus/relay-chain" } -cumulus-client-consensus-common = { path = "../client/consensus/common" } -cumulus-client-consensus-proposer = { path = "../client/consensus/proposer" } -cumulus-client-parachain-inherent = { path = "../client/parachain-inherent" } -cumulus-client-service = { path = "../client/service" } -cumulus-primitives-aura = { path = "../primitives/aura" } -cumulus-primitives-core = { path = "../primitives/core" } -cumulus-relay-chain-interface = { path = "../client/relay-chain-interface" } -color-print = "0.3.4" +cumulus-primitives-core = { workspace = true, default-features = true } [build-dependencies] -substrate-build-script-utils = { path = "../../substrate/utils/build-script-utils" } - -[dev-dependencies] -assert_cmd = "2.0" -nix = { version = "0.27.1", features = ["signal"] } -tempfile = "3.8.0" -tokio = { version = "1.32.0", features = ["macros", "parking_lot", "time"] } -wait-timeout = "0.2" +substrate-build-script-utils = { workspace = true, default-features = true } [features] default = [] runtime-benchmarks = [ + "cumulus-primitives-core/runtime-benchmarks", + "parachains-common/runtime-benchmarks", + "polkadot-parachain-lib/runtime-benchmarks", + "polkadot-service/runtime-benchmarks", + "sc-service/runtime-benchmarks", + "sp-runtime/runtime-benchmarks", + "asset-hub-rococo-runtime/runtime-benchmarks", "asset-hub-westend-runtime/runtime-benchmarks", "bridge-hub-rococo-runtime/runtime-benchmarks", @@ -134,23 +79,17 @@ runtime-benchmarks = [ "contracts-rococo-runtime/runtime-benchmarks", "coretime-rococo-runtime/runtime-benchmarks", "coretime-westend-runtime/runtime-benchmarks", - "cumulus-primitives-core/runtime-benchmarks", - "frame-benchmarking-cli/runtime-benchmarks", - "frame-benchmarking/runtime-benchmarks", - "frame-support/runtime-benchmarks", "glutton-westend-runtime/runtime-benchmarks", - "parachains-common/runtime-benchmarks", "penpal-runtime/runtime-benchmarks", "people-rococo-runtime/runtime-benchmarks", "people-westend-runtime/runtime-benchmarks", - "polkadot-cli/runtime-benchmarks", - "polkadot-primitives/runtime-benchmarks", - "polkadot-service/runtime-benchmarks", "rococo-parachain-runtime/runtime-benchmarks", - "sc-service/runtime-benchmarks", - "sp-runtime/runtime-benchmarks", ] try-runtime = [ + "polkadot-parachain-lib/try-runtime", + "polkadot-service/try-runtime", + "sp-runtime/try-runtime", + "asset-hub-rococo-runtime/try-runtime", "asset-hub-westend-runtime/try-runtime", "bridge-hub-rococo-runtime/try-runtime", @@ -159,17 +98,15 @@ try-runtime = [ "contracts-rococo-runtime/try-runtime", "coretime-rococo-runtime/try-runtime", "coretime-westend-runtime/try-runtime", - "frame-support/try-runtime", - "frame-try-runtime/try-runtime", "glutton-westend-runtime/try-runtime", - "pallet-transaction-payment/try-runtime", "penpal-runtime/try-runtime", "people-rococo-runtime/try-runtime", "people-westend-runtime/try-runtime", - "polkadot-cli/try-runtime", - "polkadot-service/try-runtime", "shell-runtime/try-runtime", - "sp-runtime/try-runtime", ] -fast-runtime = ["bridge-hub-rococo-runtime/fast-runtime"] -elastic-scaling-experimental = ["polkadot-service/elastic-scaling-experimental"] +fast-runtime = [ + "bridge-hub-rococo-runtime/fast-runtime", + "bridge-hub-westend-runtime/fast-runtime", + "coretime-rococo-runtime/fast-runtime", + "coretime-westend-runtime/fast-runtime", +] diff --git a/cumulus/polkadot-parachain/chain-specs/contracts-rococo.json b/cumulus/polkadot-parachain/chain-specs/contracts-rococo.json deleted file mode 120000 index b9f8e8f31e84587c8bb148b96eefff3d7f87d682..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/chain-specs/contracts-rococo.json +++ /dev/null @@ -1 +0,0 @@ -../../parachains/chain-specs/contracts-rococo.json \ No newline at end of file diff --git a/cumulus/polkadot-parachain/chain-specs/coretime-polkadot.json b/cumulus/polkadot-parachain/chain-specs/coretime-polkadot.json new file mode 120000 index 0000000000000000000000000000000000000000..f6f2bc6869177d6a0b57dab1df23784b88733b01 --- /dev/null +++ b/cumulus/polkadot-parachain/chain-specs/coretime-polkadot.json @@ -0,0 +1 @@ +../../parachains/chain-specs/coretime-polkadot.json \ No newline at end of file diff --git a/cumulus/polkadot-parachain/chain-specs/people-polkadot.json b/cumulus/polkadot-parachain/chain-specs/people-polkadot.json new file mode 120000 index 0000000000000000000000000000000000000000..44fead1c49e05610ad5f5eac76e6e7ee8b862587 --- /dev/null +++ b/cumulus/polkadot-parachain/chain-specs/people-polkadot.json @@ -0,0 +1 @@ +../../parachains/chain-specs/people-polkadot.json \ No newline at end of file diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/Cargo.toml b/cumulus/polkadot-parachain/polkadot-parachain-lib/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..066cbfae53ae7021664cb60305d6eb5b38d94f6a --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/Cargo.toml @@ -0,0 +1,119 @@ +[package] +name = "polkadot-parachain-lib" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +description = "Helper library that can be used to build a parachain node" +license = "Apache-2.0" + +[lints] +workspace = true + +[lib] +path = "src/lib.rs" + +[dependencies] +async-trait = { workspace = true } +clap = { features = ["derive"], workspace = true } +codec = { workspace = true, default-features = true } +color-print = { workspace = true } +futures = { workspace = true } +log = { workspace = true, default-features = true } +serde = { features = ["derive"], workspace = true, default-features = true } +serde_json = { workspace = true, default-features = true } +docify = { workspace = true } + +# Local +jsonrpsee = { features = ["server"], workspace = true } +parachains-common = { workspace = true, default-features = true } + +# Substrate +frame-benchmarking = { optional = true, workspace = true, default-features = true } +frame-benchmarking-cli = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-core = { workspace = true, default-features = true } +sp-session = { workspace = true, default-features = true } +frame-try-runtime = { optional = true, workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +frame-support = { optional = true, workspace = true, default-features = true } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-client-db = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sp-transaction-pool = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-basic-authorship = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-genesis-builder = { workspace = true } +sp-block-builder = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } +sp-weights = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +frame-system-rpc-runtime-api = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +sc-sysinfo = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +substrate-frame-rpc-system = { workspace = true, default-features = true } +pallet-transaction-payment-rpc = { workspace = true, default-features = true } +substrate-state-trie-migration-rpc = { workspace = true, default-features = true } + +# Polkadot +polkadot-cli = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } + +# Cumulus +cumulus-client-cli = { workspace = true, default-features = true } +cumulus-client-collator = { workspace = true, default-features = true } +cumulus-client-consensus-aura = { workspace = true, default-features = true } +cumulus-client-consensus-relay-chain = { workspace = true, default-features = true } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-client-consensus-proposer = { workspace = true, default-features = true } +cumulus-client-parachain-inherent = { workspace = true, default-features = true } +cumulus-client-service = { workspace = true, default-features = true } +cumulus-primitives-aura = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } + +[dev-dependencies] +assert_cmd = { workspace = true } +nix = { features = ["signal"], workspace = true } +tokio = { version = "1.32.0", features = ["macros", "parking_lot", "time"] } +wait-timeout = { workspace = true } + +[features] +default = [] +rococo-native = [ + "polkadot-cli/rococo-native", +] +westend-native = [ + "polkadot-cli/westend-native", +] +runtime-benchmarks = [ + "cumulus-primitives-core/runtime-benchmarks", + "frame-benchmarking-cli/runtime-benchmarks", + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "parachains-common/runtime-benchmarks", + "polkadot-cli/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", + "sc-client-db/runtime-benchmarks", + "sc-service/runtime-benchmarks", + "sp-runtime/runtime-benchmarks", +] +try-runtime = [ + "frame-support/try-runtime", + "frame-try-runtime/try-runtime", + "pallet-transaction-payment/try-runtime", + "polkadot-cli/try-runtime", + "sp-runtime/try-runtime", +] diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/cli.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/cli.rs new file mode 100644 index 0000000000000000000000000000000000000000..15d21235d1a15207203c950c515c65678ce4c932 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/cli.rs @@ -0,0 +1,396 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use crate::{ + chain_spec::DiskChainSpecLoader, + common::{ + chain_spec::{Extensions, LoadSpec}, + NodeExtraArgs, + }, +}; +use clap::{Command, CommandFactory, FromArgMatches}; +use sc_chain_spec::ChainSpec; +use sc_cli::{ + CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams, NetworkParams, + RpcEndpoint, SharedParams, SubstrateCli, +}; +use sc_service::{config::PrometheusConfig, BasePath}; +use std::{fmt::Debug, marker::PhantomData, path::PathBuf}; + +/// Trait that can be used to customize some of the customer-facing info related to the node binary +/// that is being built using this library. +/// +/// The related info is shown to the customer as part of logs or help messages. +/// It does not impact functionality. +pub trait CliConfig { + /// The version of the resulting node binary. + fn impl_version() -> String; + + /// The description of the resulting node binary. + fn description(executable_name: String) -> String { + format!( + "The command-line arguments provided first will be passed to the parachain node, \n\ + and the arguments provided after -- will be passed to the relay chain node. \n\ + \n\ + Example: \n\ + \n\ + {} [parachain-args] -- [relay-chain-args]", + executable_name + ) + } + + /// The author of the resulting node binary. + fn author() -> String; + + /// The support URL for the resulting node binary. + fn support_url() -> String; + + /// The starting copyright year of the resulting node binary. + fn copyright_start_year() -> u16; +} + +/// Sub-commands supported by the collator. +#[derive(Debug, clap::Subcommand)] +pub enum Subcommand { + /// Key management CLI utilities + #[command(subcommand)] + Key(sc_cli::KeySubcommand), + + /// Build a chain specification. + BuildSpec(sc_cli::BuildSpecCmd), + + /// Validate blocks. + CheckBlock(sc_cli::CheckBlockCmd), + + /// Export blocks. + ExportBlocks(sc_cli::ExportBlocksCmd), + + /// Export the state of a given block into a chain spec. + ExportState(sc_cli::ExportStateCmd), + + /// Import blocks. + ImportBlocks(sc_cli::ImportBlocksCmd), + + /// Revert the chain to a previous state. + Revert(sc_cli::RevertCmd), + + /// Remove the whole chain. + PurgeChain(cumulus_client_cli::PurgeChainCmd), + + /// Export the genesis state of the parachain. + #[command(alias = "export-genesis-state")] + ExportGenesisHead(cumulus_client_cli::ExportGenesisHeadCommand), + + /// Export the genesis wasm of the parachain. + ExportGenesisWasm(cumulus_client_cli::ExportGenesisWasmCommand), + + /// Sub-commands concerned with benchmarking. + /// The pallet benchmarking moved to the `pallet` sub-command. + #[command(subcommand)] + Benchmark(frame_benchmarking_cli::BenchmarkCmd), +} + +#[derive(clap::Parser)] +#[command( + propagate_version = true, + args_conflicts_with_subcommands = true, + subcommand_negates_reqs = true +)] +pub struct Cli { + #[arg(skip)] + pub(crate) chain_spec_loader: Option>, + + #[command(subcommand)] + pub subcommand: Option, + + #[command(flatten)] + pub run: cumulus_client_cli::RunCmd, + + /// EXPERIMENTAL: Use slot-based collator which can handle elastic scaling. + /// + /// Use with care, this flag is unstable and subject to change. + #[arg(long)] + pub experimental_use_slot_based: bool, + + /// Disable automatic hardware benchmarks. + /// + /// By default these benchmarks are automatically ran at startup and measure + /// the CPU speed, the memory bandwidth and the disk speed. + /// + /// The results are then printed out in the logs, and also sent as part of + /// telemetry, if telemetry is enabled. + #[arg(long)] + pub no_hardware_benchmarks: bool, + + /// Export all `PoVs` build by this collator to the given folder. + /// + /// This is useful for debugging issues that are occurring while validating these `PoVs` on the + /// relay chain. + #[arg(long)] + pub export_pov_to_path: Option, + + /// Relay chain arguments + #[arg(raw = true)] + pub relay_chain_args: Vec, + + #[arg(skip)] + pub(crate) _phantom: PhantomData, +} + +impl Cli { + pub(crate) fn node_extra_args(&self) -> NodeExtraArgs { + NodeExtraArgs { + use_slot_based_consensus: self.experimental_use_slot_based, + export_pov: self.export_pov_to_path.clone(), + } + } +} + +impl SubstrateCli for Cli { + fn impl_name() -> String { + Self::executable_name() + } + + fn impl_version() -> String { + Config::impl_version() + } + + fn description() -> String { + Config::description(Self::executable_name()) + } + + fn author() -> String { + Config::author() + } + + fn support_url() -> String { + Config::support_url() + } + + fn copyright_start_year() -> i32 { + Config::copyright_start_year() as i32 + } + + fn load_spec(&self, id: &str) -> Result, String> { + match &self.chain_spec_loader { + Some(chain_spec_loader) => chain_spec_loader.load_spec(id), + None => DiskChainSpecLoader.load_spec(id), + } + } +} + +#[derive(Debug)] +pub struct RelayChainCli { + /// The actual relay chain cli object. + pub base: polkadot_cli::RunCmd, + + /// Optional chain id that should be passed to the relay chain. + pub chain_id: Option, + + /// The base path that should be used by the relay chain. + pub base_path: Option, + + _phantom: PhantomData, +} + +impl RelayChainCli { + fn polkadot_cmd() -> Command { + let help_template = color_print::cformat!( + "The arguments that are passed to the relay chain node. \n\ + \n\ + RELAY_CHAIN_ARGS: \n\ + {{options}}", + ); + + polkadot_cli::RunCmd::command() + .no_binary_name(true) + .help_template(help_template) + } + + /// Parse the relay chain CLI parameters using the parachain `Configuration`. + pub fn new<'a>( + para_config: &sc_service::Configuration, + relay_chain_args: impl Iterator, + ) -> Self { + let polkadot_cmd = Self::polkadot_cmd(); + let matches = polkadot_cmd.get_matches_from(relay_chain_args); + let base = FromArgMatches::from_arg_matches(&matches).unwrap_or_else(|e| e.exit()); + + let extension = Extensions::try_get(&*para_config.chain_spec); + let chain_id = extension.map(|e| e.relay_chain.clone()); + + let base_path = para_config.base_path.path().join("polkadot"); + Self { base, chain_id, base_path: Some(base_path), _phantom: Default::default() } + } +} + +impl SubstrateCli for RelayChainCli { + fn impl_name() -> String { + Cli::::impl_name() + } + + fn impl_version() -> String { + Cli::::impl_version() + } + + fn description() -> String { + Cli::::description() + } + + fn author() -> String { + Cli::::author() + } + + fn support_url() -> String { + Cli::::support_url() + } + + fn copyright_start_year() -> i32 { + Cli::::copyright_start_year() + } + + fn load_spec(&self, id: &str) -> std::result::Result, String> { + polkadot_cli::Cli::from_iter([Self::executable_name()].iter()).load_spec(id) + } +} + +impl DefaultConfigurationValues for RelayChainCli { + fn p2p_listen_port() -> u16 { + 30334 + } + + fn rpc_listen_port() -> u16 { + 9945 + } + + fn prometheus_listen_port() -> u16 { + 9616 + } +} + +impl CliConfiguration for RelayChainCli { + fn shared_params(&self) -> &SharedParams { + self.base.base.shared_params() + } + + fn import_params(&self) -> Option<&ImportParams> { + self.base.base.import_params() + } + + fn network_params(&self) -> Option<&NetworkParams> { + self.base.base.network_params() + } + + fn keystore_params(&self) -> Option<&KeystoreParams> { + self.base.base.keystore_params() + } + + fn base_path(&self) -> sc_cli::Result> { + Ok(self + .shared_params() + .base_path()? + .or_else(|| self.base_path.clone().map(Into::into))) + } + + fn rpc_addr(&self, default_listen_port: u16) -> sc_cli::Result>> { + self.base.base.rpc_addr(default_listen_port) + } + + fn prometheus_config( + &self, + default_listen_port: u16, + chain_spec: &Box, + ) -> sc_cli::Result> { + self.base.base.prometheus_config(default_listen_port, chain_spec) + } + + fn init( + &self, + _support_url: &String, + _impl_version: &String, + _logger_hook: F, + _config: &sc_service::Configuration, + ) -> sc_cli::Result<()> + where + F: FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration), + { + unreachable!("PolkadotCli is never initialized; qed"); + } + + fn chain_id(&self, is_dev: bool) -> sc_cli::Result { + let chain_id = self.base.base.chain_id(is_dev)?; + + Ok(if chain_id.is_empty() { self.chain_id.clone().unwrap_or_default() } else { chain_id }) + } + + fn role(&self, is_dev: bool) -> sc_cli::Result { + self.base.base.role(is_dev) + } + + fn transaction_pool( + &self, + is_dev: bool, + ) -> sc_cli::Result { + self.base.base.transaction_pool(is_dev) + } + + fn trie_cache_maximum_size(&self) -> sc_cli::Result> { + self.base.base.trie_cache_maximum_size() + } + + fn rpc_methods(&self) -> sc_cli::Result { + self.base.base.rpc_methods() + } + + fn rpc_max_connections(&self) -> sc_cli::Result { + self.base.base.rpc_max_connections() + } + + fn rpc_cors(&self, is_dev: bool) -> sc_cli::Result>> { + self.base.base.rpc_cors(is_dev) + } + + fn default_heap_pages(&self) -> sc_cli::Result> { + self.base.base.default_heap_pages() + } + + fn force_authoring(&self) -> sc_cli::Result { + self.base.base.force_authoring() + } + + fn disable_grandpa(&self) -> sc_cli::Result { + self.base.base.disable_grandpa() + } + + fn max_runtime_instances(&self) -> sc_cli::Result> { + self.base.base.max_runtime_instances() + } + + fn announce_block(&self) -> sc_cli::Result { + self.base.base.announce_block() + } + + fn telemetry_endpoints( + &self, + chain_spec: &Box, + ) -> sc_cli::Result> { + self.base.base.telemetry_endpoints(chain_spec) + } + + fn node_name(&self) -> sc_cli::Result { + self.base.base.node_name() + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/command.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/command.rs new file mode 100644 index 0000000000000000000000000000000000000000..320511ece5e51f36fc00f3bf365abe02861761c0 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/command.rs @@ -0,0 +1,315 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use crate::{ + cli::{Cli, RelayChainCli, Subcommand}, + common::{ + chain_spec::{Extensions, LoadSpec}, + runtime::{ + AuraConsensusId, Consensus, Runtime, RuntimeResolver as RuntimeResolverT, + RuntimeResolver, + }, + spec::DynNodeSpec, + types::Block, + NodeBlock, NodeExtraArgs, + }, + fake_runtime_api, + runtime::BlockNumber, + service::ShellNode, +}; +#[cfg(feature = "runtime-benchmarks")] +use cumulus_client_service::storage_proof_size::HostFunctions as ReclaimHostFunctions; +use cumulus_primitives_core::ParaId; +use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE}; +use log::info; +use sc_cli::{Result, SubstrateCli}; +use sp_runtime::traits::AccountIdConversion; +#[cfg(feature = "runtime-benchmarks")] +use sp_runtime::traits::HashingFor; +use std::panic::{RefUnwindSafe, UnwindSafe}; + +/// Structure that can be used in order to provide customizers for different functionalities of the +/// node binary that is being built using this library. +pub struct RunConfig { + /// A custom chain spec loader. + pub chain_spec_loader: Box, + /// A custom runtime resolver. + pub runtime_resolver: Box, +} + +pub fn new_aura_node_spec( + aura_id: AuraConsensusId, + extra_args: &NodeExtraArgs, +) -> Box +where + Block: NodeBlock + UnwindSafe + RefUnwindSafe, + Block::BoundedHeader: UnwindSafe + RefUnwindSafe, +{ + match aura_id { + AuraConsensusId::Sr25519 => crate::service::new_aura_node_spec::< + Block, + fake_runtime_api::aura_sr25519::RuntimeApi, + sp_consensus_aura::sr25519::AuthorityId, + >(extra_args), + AuraConsensusId::Ed25519 => crate::service::new_aura_node_spec::< + Block, + fake_runtime_api::aura_ed25519::RuntimeApi, + sp_consensus_aura::ed25519::AuthorityId, + >(extra_args), + } +} + +fn new_node_spec( + config: &sc_service::Configuration, + runtime_resolver: &Box, + extra_args: &NodeExtraArgs, +) -> std::result::Result, sc_cli::Error> { + let runtime = runtime_resolver.runtime(config.chain_spec.as_ref())?; + + Ok(match runtime { + Runtime::Shell => Box::new(ShellNode), + Runtime::Omni(block_number, consensus) => match (block_number, consensus) { + (BlockNumber::U32, Consensus::Aura(aura_id)) => + new_aura_node_spec::>(aura_id, extra_args), + (BlockNumber::U64, Consensus::Aura(aura_id)) => + new_aura_node_spec::>(aura_id, extra_args), + }, + }) +} + +/// Parse command line arguments into service configuration. +pub fn run(cmd_config: RunConfig) -> Result<()> { + let mut cli = Cli::::from_args(); + cli.chain_spec_loader = Some(cmd_config.chain_spec_loader); + + match &cli.subcommand { + Some(Subcommand::BuildSpec(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.sync_run(|config| cmd.run(config.chain_spec, config.network)) + }, + Some(Subcommand::CheckBlock(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.prepare_check_block_cmd(config, cmd) + }) + }, + Some(Subcommand::ExportBlocks(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.prepare_export_blocks_cmd(config, cmd) + }) + }, + Some(Subcommand::ExportState(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.prepare_export_state_cmd(config, cmd) + }) + }, + Some(Subcommand::ImportBlocks(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.prepare_import_blocks_cmd(config, cmd) + }) + }, + Some(Subcommand::Revert(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.prepare_revert_cmd(config, cmd) + }) + }, + Some(Subcommand::PurgeChain(cmd)) => { + let runner = cli.create_runner(cmd)?; + let polkadot_cli = + RelayChainCli::::new(runner.config(), cli.relay_chain_args.iter()); + + runner.sync_run(|config| { + let polkadot_config = SubstrateCli::create_configuration( + &polkadot_cli, + &polkadot_cli, + config.tokio_handle.clone(), + ) + .map_err(|err| format!("Relay chain argument error: {}", err))?; + + cmd.run(config, polkadot_config) + }) + }, + Some(Subcommand::ExportGenesisHead(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.sync_run(|config| { + let node = + new_node_spec(&config, &cmd_config.runtime_resolver, &cli.node_extra_args())?; + node.run_export_genesis_head_cmd(config, cmd) + }) + }, + Some(Subcommand::ExportGenesisWasm(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.sync_run(|_config| { + let spec = cli.load_spec(&cmd.shared_params.chain.clone().unwrap_or_default())?; + cmd.run(&*spec) + }) + }, + Some(Subcommand::Benchmark(cmd)) => { + let runner = cli.create_runner(cmd)?; + + // Switch on the concrete benchmark sub-command- + match cmd { + #[cfg(feature = "runtime-benchmarks")] + BenchmarkCmd::Pallet(cmd) => runner.sync_run(|config| { + cmd.run_with_spec::>, ReclaimHostFunctions>(Some( + config.chain_spec, + )) + }), + BenchmarkCmd::Block(cmd) => runner.sync_run(|config| { + let node = new_node_spec( + &config, + &cmd_config.runtime_resolver, + &cli.node_extra_args(), + )?; + node.run_benchmark_block_cmd(config, cmd) + }), + #[cfg(feature = "runtime-benchmarks")] + BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| { + let node = new_node_spec( + &config, + &cmd_config.runtime_resolver, + &cli.node_extra_args(), + )?; + node.run_benchmark_storage_cmd(config, cmd) + }), + BenchmarkCmd::Machine(cmd) => + runner.sync_run(|config| cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone())), + #[allow(unreachable_patterns)] + _ => Err("Benchmarking sub-command unsupported or compilation feature missing. \ + Make sure to compile with --features=runtime-benchmarks \ + to enable all supported benchmarks." + .into()), + } + }, + Some(Subcommand::Key(cmd)) => Ok(cmd.run(&cli)?), + None => { + let runner = cli.create_runner(&cli.run.normalize())?; + let polkadot_cli = + RelayChainCli::::new(runner.config(), cli.relay_chain_args.iter()); + let collator_options = cli.run.collator_options(); + + runner.run_node_until_exit(|config| async move { + // If Statemint (Statemine, Westmint, Rockmine) DB exists and we're using the + // asset-hub chain spec, then rename the base path to the new chain ID. In the case + // that both file paths exist, the node will exit, as the user must decide (by + // deleting one path) the information that they want to use as their DB. + let old_name = match config.chain_spec.id() { + "asset-hub-polkadot" => Some("statemint"), + "asset-hub-kusama" => Some("statemine"), + "asset-hub-westend" => Some("westmint"), + "asset-hub-rococo" => Some("rockmine"), + _ => None, + }; + + if let Some(old_name) = old_name { + let new_path = config.base_path.config_dir(config.chain_spec.id()); + let old_path = config.base_path.config_dir(old_name); + + if old_path.exists() && new_path.exists() { + return Err(format!( + "Found legacy {} path {} and new Asset Hub path {}. \ + Delete one path such that only one exists.", + old_name, + old_path.display(), + new_path.display() + ) + .into()); + } + + if old_path.exists() { + std::fs::rename(old_path.clone(), new_path.clone())?; + info!( + "{} was renamed to Asset Hub. The filepath with associated data on disk \ + has been renamed from {} to {}.", + old_name, + old_path.display(), + new_path.display() + ); + } + } + + let hwbench = (!cli.no_hardware_benchmarks) + .then_some(config.database.path().map(|database_path| { + let _ = std::fs::create_dir_all(database_path); + sc_sysinfo::gather_hwbench(Some(database_path)) + })) + .flatten(); + + let para_id = Extensions::try_get(&*config.chain_spec) + .map(|e| e.para_id) + .ok_or("Could not find parachain extension in chain-spec.")?; + + let id = ParaId::from(para_id); + + let parachain_account = + AccountIdConversion::::into_account_truncating( + &id, + ); + + let tokio_handle = config.tokio_handle.clone(); + let polkadot_config = + SubstrateCli::create_configuration(&polkadot_cli, &polkadot_cli, tokio_handle) + .map_err(|err| format!("Relay chain argument error: {}", err))?; + + info!("🪪 Parachain id: {:?}", id); + info!("🧾 Parachain Account: {}", parachain_account); + info!("✍️ Is collating: {}", if config.role.is_authority() { "yes" } else { "no" }); + + start_node( + config, + &cmd_config.runtime_resolver, + polkadot_config, + collator_options, + id, + cli.node_extra_args(), + hwbench, + ) + .await + }) + }, + } +} + +#[sc_tracing::logging::prefix_logs_with("Parachain")] +async fn start_node( + config: sc_service::Configuration, + runtime_resolver: &Box, + polkadot_config: sc_service::Configuration, + collator_options: cumulus_client_cli::CollatorOptions, + id: ParaId, + extra_args: NodeExtraArgs, + hwbench: Option, +) -> Result { + let node_spec = new_node_spec(&config, runtime_resolver, &extra_args)?; + node_spec + .start_node(config, polkadot_config, collator_options, id, hwbench, extra_args) + .await + .map_err(Into::into) +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/aura.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/aura.rs new file mode 100644 index 0000000000000000000000000000000000000000..9e8837de7f878c0a1566ac5f8aac84ef68b63f71 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/aura.rs @@ -0,0 +1,70 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Aura-related primitives for cumulus parachain collators. + +use codec::Codec; +use cumulus_primitives_aura::AuraUnincludedSegmentApi; +use sp_consensus_aura::AuraApi; +use sp_runtime::{ + app_crypto::{AppCrypto, AppPair, AppSignature, Pair}, + traits::Block as BlockT, +}; + +/// Convenience trait for defining the basic bounds of an `AuraId`. +pub trait AuraIdT: AppCrypto + Codec + Send { + /// Extra bounds for the `Pair`. + type BoundedPair: AppPair + AppCrypto; + + /// Extra bounds for the `Signature`. + type BoundedSignature: AppSignature + + TryFrom> + + std::hash::Hash + + sp_runtime::traits::Member + + Codec; +} + +impl AuraIdT for T +where + T: AppCrypto + Codec + Send + Sync, + <::Pair as AppCrypto>::Signature: + TryFrom> + std::hash::Hash + sp_runtime::traits::Member + Codec, +{ + type BoundedPair = ::Pair; + type BoundedSignature = <::Pair as AppCrypto>::Signature; +} + +/// Convenience trait for defining the basic bounds of a parachain runtime that supports +/// the Aura consensus. +pub trait AuraRuntimeApi: + sp_api::ApiExt + + AuraApi::Public> + + AuraUnincludedSegmentApi + + Sized +{ + /// Check if the runtime has the Aura API. + fn has_aura_api(&self, at: Block::Hash) -> bool { + self.has_api::::Public>>(at) + .unwrap_or(false) + } +} + +impl AuraRuntimeApi for T where + T: sp_api::ApiExt + + AuraApi::Public> + + AuraUnincludedSegmentApi +{ +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/chain_spec.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/chain_spec.rs new file mode 100644 index 0000000000000000000000000000000000000000..974d6ef2b611275735c657674193ef0eae76c9ae --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/chain_spec.rs @@ -0,0 +1,77 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Chain spec primitives. + +pub use sc_chain_spec::ChainSpec; +use sc_chain_spec::ChainSpecExtension; +use serde::{Deserialize, Serialize}; +use std::fmt::Debug; + +/// Helper trait used for loading/building a chain spec starting from the chain ID. +pub trait LoadSpec { + /// Load/Build a chain spec starting from the chain ID. + fn load_spec(&self, id: &str) -> Result, String>; +} + +/// Default implementation for `LoadSpec` that just reads a chain spec from the disk. +pub struct DiskChainSpecLoader; + +impl LoadSpec for DiskChainSpecLoader { + fn load_spec(&self, path: &str) -> Result, String> { + Ok(Box::new(GenericChainSpec::from_json_file(path.into())?)) + } +} + +/// Generic extensions for Parachain ChainSpecs. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecExtension)] +pub struct Extensions { + /// The relay chain of the Parachain. + #[serde(alias = "relayChain", alias = "RelayChain")] + pub relay_chain: String, + /// The id of the Parachain. + #[serde(alias = "paraId", alias = "ParaId")] + pub para_id: u32, +} + +impl Extensions { + /// Try to get the extension from the given `ChainSpec`. + pub fn try_get(chain_spec: &dyn sc_service::ChainSpec) -> Option<&Self> { + sc_chain_spec::get_extension(chain_spec.extensions()) + } +} + +/// Generic chain spec for all polkadot-parachain runtimes +pub type GenericChainSpec = sc_service::GenericChainSpec; + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn can_decode_extension_camel_and_snake_case() { + let camel_case = r#"{"relayChain":"relay","paraId":1}"#; + let snake_case = r#"{"relay_chain":"relay","para_id":1}"#; + let pascal_case = r#"{"RelayChain":"relay","ParaId":1}"#; + + let camel_case_extension: Extensions = serde_json::from_str(camel_case).unwrap(); + let snake_case_extension: Extensions = serde_json::from_str(snake_case).unwrap(); + let pascal_case_extension: Extensions = serde_json::from_str(pascal_case).unwrap(); + + assert_eq!(camel_case_extension, snake_case_extension); + assert_eq!(snake_case_extension, pascal_case_extension); + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/command.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/command.rs new file mode 100644 index 0000000000000000000000000000000000000000..e2826826d40ed556973ab057865f706a09a6f4ae --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/command.rs @@ -0,0 +1,161 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use crate::common::spec::NodeSpec; +use cumulus_client_cli::ExportGenesisHeadCommand; +use frame_benchmarking_cli::BlockCmd; +#[cfg(any(feature = "runtime-benchmarks"))] +use frame_benchmarking_cli::StorageCmd; +use sc_cli::{CheckBlockCmd, ExportBlocksCmd, ExportStateCmd, ImportBlocksCmd, RevertCmd}; +use sc_service::{Configuration, TaskManager}; +use std::{future::Future, pin::Pin}; + +type SyncCmdResult = sc_cli::Result<()>; + +type AsyncCmdResult<'a> = + sc_cli::Result<(Pin + 'a>>, TaskManager)>; + +pub trait NodeCommandRunner { + fn prepare_check_block_cmd( + self: Box, + config: Configuration, + cmd: &CheckBlockCmd, + ) -> AsyncCmdResult<'_>; + + fn prepare_export_blocks_cmd( + self: Box, + config: Configuration, + cmd: &ExportBlocksCmd, + ) -> AsyncCmdResult<'_>; + + fn prepare_export_state_cmd( + self: Box, + config: Configuration, + cmd: &ExportStateCmd, + ) -> AsyncCmdResult<'_>; + + fn prepare_import_blocks_cmd( + self: Box, + config: Configuration, + cmd: &ImportBlocksCmd, + ) -> AsyncCmdResult<'_>; + + fn prepare_revert_cmd( + self: Box, + config: Configuration, + cmd: &RevertCmd, + ) -> AsyncCmdResult<'_>; + + fn run_export_genesis_head_cmd( + self: Box, + config: Configuration, + cmd: &ExportGenesisHeadCommand, + ) -> SyncCmdResult; + + fn run_benchmark_block_cmd( + self: Box, + config: Configuration, + cmd: &BlockCmd, + ) -> SyncCmdResult; + + #[cfg(any(feature = "runtime-benchmarks"))] + fn run_benchmark_storage_cmd( + self: Box, + config: Configuration, + cmd: &StorageCmd, + ) -> SyncCmdResult; +} + +impl NodeCommandRunner for T +where + T: NodeSpec, +{ + fn prepare_check_block_cmd( + self: Box, + config: Configuration, + cmd: &CheckBlockCmd, + ) -> AsyncCmdResult<'_> { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + Ok((Box::pin(cmd.run(partial.client, partial.import_queue)), partial.task_manager)) + } + + fn prepare_export_blocks_cmd( + self: Box, + config: Configuration, + cmd: &ExportBlocksCmd, + ) -> AsyncCmdResult<'_> { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + Ok((Box::pin(cmd.run(partial.client, config.database)), partial.task_manager)) + } + + fn prepare_export_state_cmd( + self: Box, + config: Configuration, + cmd: &ExportStateCmd, + ) -> AsyncCmdResult<'_> { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + Ok((Box::pin(cmd.run(partial.client, config.chain_spec)), partial.task_manager)) + } + + fn prepare_import_blocks_cmd( + self: Box, + config: Configuration, + cmd: &ImportBlocksCmd, + ) -> AsyncCmdResult<'_> { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + Ok((Box::pin(cmd.run(partial.client, partial.import_queue)), partial.task_manager)) + } + + fn prepare_revert_cmd( + self: Box, + config: Configuration, + cmd: &RevertCmd, + ) -> AsyncCmdResult<'_> { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + Ok((Box::pin(cmd.run(partial.client, partial.backend, None)), partial.task_manager)) + } + + fn run_export_genesis_head_cmd( + self: Box, + config: Configuration, + cmd: &ExportGenesisHeadCommand, + ) -> SyncCmdResult { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + cmd.run(partial.client) + } + + fn run_benchmark_block_cmd( + self: Box, + config: Configuration, + cmd: &BlockCmd, + ) -> SyncCmdResult { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + cmd.run(partial.client) + } + + #[cfg(any(feature = "runtime-benchmarks"))] + fn run_benchmark_storage_cmd( + self: Box, + config: Configuration, + cmd: &StorageCmd, + ) -> SyncCmdResult { + let partial = T::new_partial(&config).map_err(sc_cli::Error::Service)?; + let db = partial.backend.expose_db(); + let storage = partial.backend.expose_storage(); + + cmd.run(config, partial.client, db, storage) + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/mod.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..907f09263fc1cc4acd1e33a6a4c564ea7060b8b2 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/mod.rs @@ -0,0 +1,106 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Cumulus parachain collator primitives. + +#![warn(missing_docs)] + +pub(crate) mod aura; +pub mod chain_spec; +pub mod command; +pub mod rpc; +pub mod runtime; +pub mod spec; +pub mod types; + +use cumulus_primitives_core::CollectCollationInfo; +use sc_client_db::DbHash; +use sp_api::{ApiExt, CallApiAt, ConstructRuntimeApi, Metadata}; +use sp_block_builder::BlockBuilder; +use sp_runtime::{ + traits::{Block as BlockT, BlockNumber, Header as HeaderT, NumberFor}, + OpaqueExtrinsic, +}; +use sp_session::SessionKeys; +use sp_transaction_pool::runtime_api::TaggedTransactionQueue; +use std::{fmt::Debug, path::PathBuf, str::FromStr}; + +pub trait NodeBlock: + BlockT + + for<'de> serde::Deserialize<'de> +{ + type BoundedFromStrErr: Debug; + type BoundedNumber: FromStr + BlockNumber; + type BoundedHeader: HeaderT + Unpin; +} + +impl NodeBlock for T +where + T: BlockT + for<'de> serde::Deserialize<'de>, + ::Header: Unpin, + as FromStr>::Err: Debug, +{ + type BoundedFromStrErr = as FromStr>::Err; + type BoundedNumber = NumberFor; + type BoundedHeader = ::Header; +} + +/// Convenience trait that defines the basic bounds for the `RuntimeApi` of a parachain node. +pub trait NodeRuntimeApi: + ApiExt + + Metadata + + SessionKeys + + BlockBuilder + + TaggedTransactionQueue + + CollectCollationInfo + + Sized +{ +} + +impl NodeRuntimeApi for T where + T: ApiExt + + Metadata + + SessionKeys + + BlockBuilder + + TaggedTransactionQueue + + CollectCollationInfo +{ +} + +/// Convenience trait that defines the basic bounds for the `ConstructRuntimeApi` of a parachain +/// node. +pub trait ConstructNodeRuntimeApi>: + ConstructRuntimeApi + Send + Sync + 'static +{ + /// Basic bounds for the `RuntimeApi` of a parachain node. + type BoundedRuntimeApi: NodeRuntimeApi; +} + +impl> ConstructNodeRuntimeApi for T +where + T: ConstructRuntimeApi + Send + Sync + 'static, + T::RuntimeApi: NodeRuntimeApi, +{ + type BoundedRuntimeApi = T::RuntimeApi; +} + +/// Extra args that are passed when creating a new node spec. +pub struct NodeExtraArgs { + pub use_slot_based_consensus: bool, + + /// If set, each `PoV` build by the node will be exported to this folder. + pub export_pov: Option, +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/rpc.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/rpc.rs new file mode 100644 index 0000000000000000000000000000000000000000..a4e157e87216e12f88b178740478f396424bdde3 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/rpc.rs @@ -0,0 +1,95 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Parachain-specific RPCs implementation. + +#![warn(missing_docs)] + +use crate::common::{ + types::{AccountId, Balance, Nonce, ParachainBackend, ParachainClient}, + ConstructNodeRuntimeApi, +}; +use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; +use sc_rpc::dev::{Dev, DevApiServer}; +use sp_runtime::traits::Block as BlockT; +use std::{marker::PhantomData, sync::Arc}; +use substrate_frame_rpc_system::{System, SystemApiServer}; +use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer}; + +/// A type representing all RPC extensions. +pub type RpcExtension = jsonrpsee::RpcModule<()>; + +pub(crate) trait BuildRpcExtensions { + fn build_rpc_extensions( + client: Arc, + backend: Arc, + pool: Arc, + ) -> sc_service::error::Result; +} + +pub(crate) struct BuildEmptyRpcExtensions(PhantomData<(Block, RuntimeApi)>); + +impl + BuildRpcExtensions< + ParachainClient, + ParachainBackend, + sc_transaction_pool::FullPool>, + > for BuildEmptyRpcExtensions +where + RuntimeApi: + ConstructNodeRuntimeApi> + Send + Sync + 'static, +{ + fn build_rpc_extensions( + _client: Arc>, + _backend: Arc>, + _pool: Arc>>, + ) -> sc_service::error::Result { + Ok(RpcExtension::new(())) + } +} + +pub(crate) struct BuildParachainRpcExtensions(PhantomData<(Block, RuntimeApi)>); + +impl + BuildRpcExtensions< + ParachainClient, + ParachainBackend, + sc_transaction_pool::FullPool>, + > for BuildParachainRpcExtensions +where + RuntimeApi: + ConstructNodeRuntimeApi> + Send + Sync + 'static, + RuntimeApi::RuntimeApi: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi + + substrate_frame_rpc_system::AccountNonceApi, +{ + fn build_rpc_extensions( + client: Arc>, + backend: Arc>, + pool: Arc>>, + ) -> sc_service::error::Result { + let build = || -> Result> { + let mut module = RpcExtension::new(()); + + module.merge(System::new(client.clone(), pool).into_rpc())?; + module.merge(TransactionPayment::new(client.clone()).into_rpc())?; + module.merge(StateMigration::new(client.clone(), backend).into_rpc())?; + module.merge(Dev::new(client).into_rpc())?; + + Ok(module) + }; + build().map_err(Into::into) + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/runtime.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/runtime.rs new file mode 100644 index 0000000000000000000000000000000000000000..bddbb0a85d0365feb4a337673aab65081b676098 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/runtime.rs @@ -0,0 +1,70 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Runtime parameters. + +use sc_chain_spec::ChainSpec; + +/// The Aura ID used by the Aura consensus +#[derive(PartialEq)] +pub enum AuraConsensusId { + /// Ed25519 + Ed25519, + /// Sr25519 + Sr25519, +} + +/// The choice of consensus for the parachain omni-node. +#[derive(PartialEq)] +pub enum Consensus { + /// Aura consensus. + Aura(AuraConsensusId), +} + +/// The choice of block number for the parachain omni-node. +#[derive(PartialEq)] +pub enum BlockNumber { + /// u32 + U32, + /// u64 + U64, +} + +/// Helper enum listing the supported Runtime types +#[derive(PartialEq)] +pub enum Runtime { + /// None of the system-chain runtimes, rather the node will act agnostic to the runtime ie. be + /// an omni-node, and simply run a node with the given consensus algorithm. + Omni(BlockNumber, Consensus), + /// Shell + Shell, +} + +/// Helper trait used for extracting the Runtime variant from the chain spec ID. +pub trait RuntimeResolver { + /// Extract the Runtime variant from the chain spec ID. + fn runtime(&self, chain_spec: &dyn ChainSpec) -> sc_cli::Result; +} + +/// Default implementation for `RuntimeResolver` that just returns +/// `Runtime::Omni(BlockNumber::U32, Consensus::Aura(AuraConsensusId::Sr25519))`. +pub struct DefaultRuntimeResolver; + +impl RuntimeResolver for DefaultRuntimeResolver { + fn runtime(&self, _chain_spec: &dyn ChainSpec) -> sc_cli::Result { + Ok(Runtime::Omni(BlockNumber::U32, Consensus::Aura(AuraConsensusId::Sr25519))) + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/spec.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/spec.rs new file mode 100644 index 0000000000000000000000000000000000000000..55e042aed87e7d3879eb3e4c412d52f13d4ca358 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/spec.rs @@ -0,0 +1,392 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use crate::common::{ + command::NodeCommandRunner, + rpc::BuildRpcExtensions, + types::{ + ParachainBackend, ParachainBlockImport, ParachainClient, ParachainHostFunctions, + ParachainService, + }, + ConstructNodeRuntimeApi, NodeBlock, NodeExtraArgs, +}; +use cumulus_client_cli::CollatorOptions; +use cumulus_client_service::{ + build_network, build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks, + BuildNetworkParams, CollatorSybilResistance, DARecoveryProfile, StartRelayChainTasksParams, +}; +use cumulus_primitives_core::{BlockT, ParaId}; +use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface}; +use parachains_common::Hash; +use polkadot_primitives::CollatorPair; +use prometheus_endpoint::Registry; +use sc_consensus::DefaultImportQueue; +use sc_executor::{HeapAllocStrategy, DEFAULT_HEAP_ALLOC_STRATEGY}; +use sc_network::{config::FullNetworkConfiguration, NetworkBackend, NetworkBlock}; +use sc_service::{Configuration, ImportQueue, PartialComponents, TaskManager}; +use sc_sysinfo::HwBench; +use sc_telemetry::{TelemetryHandle, TelemetryWorker}; +use sc_transaction_pool::FullPool; +use sp_keystore::KeystorePtr; +use std::{future::Future, pin::Pin, sync::Arc, time::Duration}; + +pub(crate) trait BuildImportQueue { + fn build_import_queue( + client: Arc>, + block_import: ParachainBlockImport, + config: &Configuration, + telemetry_handle: Option, + task_manager: &TaskManager, + ) -> sc_service::error::Result>; +} + +pub(crate) trait StartConsensus +where + RuntimeApi: ConstructNodeRuntimeApi>, +{ + fn start_consensus( + client: Arc>, + block_import: ParachainBlockImport, + prometheus_registry: Option<&Registry>, + telemetry: Option, + task_manager: &TaskManager, + relay_chain_interface: Arc, + transaction_pool: Arc>>, + keystore: KeystorePtr, + relay_chain_slot_duration: Duration, + para_id: ParaId, + collator_key: CollatorPair, + overseer_handle: OverseerHandle, + announce_block: Arc>) + Send + Sync>, + backend: Arc>, + node_extra_args: NodeExtraArgs, + ) -> Result<(), sc_service::Error>; +} + +/// Checks that the hardware meets the requirements and print a warning otherwise. +fn warn_if_slow_hardware(hwbench: &sc_sysinfo::HwBench) { + // Polkadot para-chains should generally use these requirements to ensure that the relay-chain + // will not take longer than expected to import its blocks. + if let Err(err) = frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE.check_hardware(hwbench) { + log::warn!( + "⚠️ The hardware does not meet the minimal requirements {} for role 'Authority' find out more at:\n\ + https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware", + err + ); + } +} + +pub(crate) trait NodeSpec { + type Block: NodeBlock; + + type RuntimeApi: ConstructNodeRuntimeApi< + Self::Block, + ParachainClient, + >; + + type BuildImportQueue: BuildImportQueue; + + type BuildRpcExtensions: BuildRpcExtensions< + ParachainClient, + ParachainBackend, + FullPool>, + >; + + type StartConsensus: StartConsensus; + + const SYBIL_RESISTANCE: CollatorSybilResistance; + + /// Starts a `ServiceBuilder` for a full service. + /// + /// Use this macro if you don't actually need the full service, but just the builder in order to + /// be able to perform chain operations. + fn new_partial( + config: &Configuration, + ) -> sc_service::error::Result> { + let telemetry = config + .telemetry_endpoints + .clone() + .filter(|x| !x.is_empty()) + .map(|endpoints| -> Result<_, sc_telemetry::Error> { + let worker = TelemetryWorker::new(16)?; + let telemetry = worker.handle().new_telemetry(endpoints); + Ok((worker, telemetry)) + }) + .transpose()?; + + let heap_pages = config.default_heap_pages.map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| { + HeapAllocStrategy::Static { extra_pages: h as _ } + }); + + let executor = sc_executor::WasmExecutor::::builder() + .with_execution_method(config.wasm_method) + .with_max_runtime_instances(config.max_runtime_instances) + .with_runtime_cache_size(config.runtime_cache_size) + .with_onchain_heap_alloc_strategy(heap_pages) + .with_offchain_heap_alloc_strategy(heap_pages) + .build(); + + let (client, backend, keystore_container, task_manager) = + sc_service::new_full_parts_record_import::( + config, + telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()), + executor, + true, + )?; + let client = Arc::new(client); + + let telemetry_worker_handle = telemetry.as_ref().map(|(worker, _)| worker.handle()); + + let telemetry = telemetry.map(|(worker, telemetry)| { + task_manager.spawn_handle().spawn("telemetry", None, worker.run()); + telemetry + }); + + let transaction_pool = sc_transaction_pool::BasicPool::new_full( + config.transaction_pool.clone(), + config.role.is_authority().into(), + config.prometheus_registry(), + task_manager.spawn_essential_handle(), + client.clone(), + ); + + let block_import = ParachainBlockImport::new(client.clone(), backend.clone()); + + let import_queue = Self::BuildImportQueue::build_import_queue( + client.clone(), + block_import.clone(), + config, + telemetry.as_ref().map(|telemetry| telemetry.handle()), + &task_manager, + )?; + + Ok(PartialComponents { + backend, + client, + import_queue, + keystore_container, + task_manager, + transaction_pool, + select_chain: (), + other: (block_import, telemetry, telemetry_worker_handle), + }) + } + + /// Start a node with the given parachain spec. + /// + /// This is the actual implementation that is abstract over the executor and the runtime api. + fn start_node( + parachain_config: Configuration, + polkadot_config: Configuration, + collator_options: CollatorOptions, + para_id: ParaId, + hwbench: Option, + node_extra_args: NodeExtraArgs, + ) -> Pin>>> + where + Net: NetworkBackend, + { + Box::pin(async move { + let parachain_config = prepare_node_config(parachain_config); + + let params = Self::new_partial(¶chain_config)?; + let (block_import, mut telemetry, telemetry_worker_handle) = params.other; + + let client = params.client.clone(); + let backend = params.backend.clone(); + + let mut task_manager = params.task_manager; + let (relay_chain_interface, collator_key) = build_relay_chain_interface( + polkadot_config, + ¶chain_config, + telemetry_worker_handle, + &mut task_manager, + collator_options.clone(), + hwbench.clone(), + ) + .await + .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?; + + let validator = parachain_config.role.is_authority(); + let prometheus_registry = parachain_config.prometheus_registry().cloned(); + let transaction_pool = params.transaction_pool.clone(); + let import_queue_service = params.import_queue.service(); + let net_config = FullNetworkConfiguration::<_, _, Net>::new( + ¶chain_config.network, + prometheus_registry.clone(), + ); + + let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) = + build_network(BuildNetworkParams { + parachain_config: ¶chain_config, + net_config, + client: client.clone(), + transaction_pool: transaction_pool.clone(), + para_id, + spawn_handle: task_manager.spawn_handle(), + relay_chain_interface: relay_chain_interface.clone(), + import_queue: params.import_queue, + sybil_resistance_level: Self::SYBIL_RESISTANCE, + }) + .await?; + + let rpc_builder = { + let client = client.clone(); + let transaction_pool = transaction_pool.clone(); + let backend_for_rpc = backend.clone(); + + Box::new(move |_| { + Self::BuildRpcExtensions::build_rpc_extensions( + client.clone(), + backend_for_rpc.clone(), + transaction_pool.clone(), + ) + }) + }; + + sc_service::spawn_tasks(sc_service::SpawnTasksParams { + rpc_builder, + client: client.clone(), + transaction_pool: transaction_pool.clone(), + task_manager: &mut task_manager, + config: parachain_config, + keystore: params.keystore_container.keystore(), + backend: backend.clone(), + network: network.clone(), + sync_service: sync_service.clone(), + system_rpc_tx, + tx_handler_controller, + telemetry: telemetry.as_mut(), + })?; + + if let Some(hwbench) = hwbench { + sc_sysinfo::print_hwbench(&hwbench); + if validator { + warn_if_slow_hardware(&hwbench); + } + + if let Some(ref mut telemetry) = telemetry { + let telemetry_handle = telemetry.handle(); + task_manager.spawn_handle().spawn( + "telemetry_hwbench", + None, + sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench), + ); + } + } + + let announce_block = { + let sync_service = sync_service.clone(); + Arc::new(move |hash, data| sync_service.announce_block(hash, data)) + }; + + let relay_chain_slot_duration = Duration::from_secs(6); + + let overseer_handle = relay_chain_interface + .overseer_handle() + .map_err(|e| sc_service::Error::Application(Box::new(e)))?; + + start_relay_chain_tasks(StartRelayChainTasksParams { + client: client.clone(), + announce_block: announce_block.clone(), + para_id, + relay_chain_interface: relay_chain_interface.clone(), + task_manager: &mut task_manager, + da_recovery_profile: if validator { + DARecoveryProfile::Collator + } else { + DARecoveryProfile::FullNode + }, + import_queue: import_queue_service, + relay_chain_slot_duration, + recovery_handle: Box::new(overseer_handle.clone()), + sync_service, + })?; + + if validator { + Self::StartConsensus::start_consensus( + client.clone(), + block_import, + prometheus_registry.as_ref(), + telemetry.as_ref().map(|t| t.handle()), + &task_manager, + relay_chain_interface.clone(), + transaction_pool, + params.keystore_container.keystore(), + relay_chain_slot_duration, + para_id, + collator_key.expect("Command line arguments do not allow this. qed"), + overseer_handle, + announce_block, + backend.clone(), + node_extra_args, + )?; + } + + start_network.start_network(); + + Ok(task_manager) + }) + } +} + +pub(crate) trait DynNodeSpec: NodeCommandRunner { + fn start_node( + self: Box, + parachain_config: Configuration, + polkadot_config: Configuration, + collator_options: CollatorOptions, + para_id: ParaId, + hwbench: Option, + node_extra_args: NodeExtraArgs, + ) -> Pin>>>; +} + +impl DynNodeSpec for T +where + T: NodeSpec + NodeCommandRunner, +{ + fn start_node( + self: Box, + parachain_config: Configuration, + polkadot_config: Configuration, + collator_options: CollatorOptions, + para_id: ParaId, + hwbench: Option, + node_extra_args: NodeExtraArgs, + ) -> Pin>>> { + match parachain_config.network.network_backend { + sc_network::config::NetworkBackendType::Libp2p => + ::start_node::>( + parachain_config, + polkadot_config, + collator_options, + para_id, + hwbench, + node_extra_args, + ), + sc_network::config::NetworkBackendType::Litep2p => + ::start_node::( + parachain_config, + polkadot_config, + collator_options, + para_id, + hwbench, + node_extra_args, + ), + } + } +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/types.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/types.rs new file mode 100644 index 0000000000000000000000000000000000000000..9cfdcb22451c722edf8a839e4d7232c1bb245dc0 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/common/types.rs @@ -0,0 +1,56 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use cumulus_client_consensus_common::ParachainBlockImport as TParachainBlockImport; +use cumulus_primitives_core::relay_chain::UncheckedExtrinsic; +use sc_consensus::DefaultImportQueue; +use sc_executor::WasmExecutor; +use sc_service::{PartialComponents, TFullBackend, TFullClient}; +use sc_telemetry::{Telemetry, TelemetryWorkerHandle}; +use sc_transaction_pool::FullPool; +use sp_runtime::{generic, traits::BlakeTwo256}; +use std::sync::Arc; + +pub use parachains_common::{AccountId, Balance, Hash, Nonce}; + +type Header = generic::Header; +pub type Block = generic::Block, UncheckedExtrinsic>; + +#[cfg(not(feature = "runtime-benchmarks"))] +pub type ParachainHostFunctions = cumulus_client_service::ParachainHostFunctions; +#[cfg(feature = "runtime-benchmarks")] +pub type ParachainHostFunctions = ( + cumulus_client_service::ParachainHostFunctions, + frame_benchmarking::benchmarking::HostFunctions, +); + +pub type ParachainClient = + TFullClient>; + +pub type ParachainBackend = TFullBackend; + +pub type ParachainBlockImport = + TParachainBlockImport>, ParachainBackend>; + +/// Assembly of PartialComponents (enough to run chain ops subcommands) +pub type ParachainService = PartialComponents< + ParachainClient, + ParachainBackend, + (), + DefaultImportQueue, + FullPool>, + (ParachainBlockImport, Option, Option), +>; diff --git a/cumulus/polkadot-parachain/src/fake_runtime_api/mod.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/mod.rs similarity index 67% rename from cumulus/polkadot-parachain/src/fake_runtime_api/mod.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/mod.rs index 29e2736b06ff3a1092211224abd73092bd7ee46c..02aa867d70fecd45cb73e38eed734da8400eccda 100644 --- a/cumulus/polkadot-parachain/src/fake_runtime_api/mod.rs +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/mod.rs @@ -17,5 +17,19 @@ //! In an ideal world this would be one runtime which would simplify the code massively. //! This is not an ideal world - Polkadot Asset Hub has a different key type. -pub mod asset_hub_polkadot_aura; -pub mod aura; +mod utils; + +use utils::{impl_node_runtime_apis, imports::*}; + +type CustomBlock = crate::common::types::Block; +pub mod aura_sr25519 { + use super::*; + struct FakeRuntime; + impl_node_runtime_apis!(FakeRuntime, CustomBlock, sp_consensus_aura::sr25519::AuthorityId); +} + +pub mod aura_ed25519 { + use super::*; + struct FakeRuntime; + impl_node_runtime_apis!(FakeRuntime, CustomBlock, sp_consensus_aura::ed25519::AuthorityId); +} diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/utils.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/utils.rs new file mode 100644 index 0000000000000000000000000000000000000000..442b87b5d77523150b4464739c23bbb7b80522e5 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/fake_runtime_api/utils.rs @@ -0,0 +1,220 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +pub(crate) mod imports { + pub use parachains_common::{AccountId, Balance, Nonce}; + pub use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; + pub use sp_runtime::{ + traits::Block as BlockT, + transaction_validity::{TransactionSource, TransactionValidity}, + ApplyExtrinsicResult, + }; + pub use sp_weights::Weight; +} + +macro_rules! impl_node_runtime_apis { + ($runtime: ty, $block: tt, $aura_id: ty) => { + sp_api::impl_runtime_apis! { + impl sp_api::Core<$block> for $runtime { + fn version() -> sp_version::RuntimeVersion { + unimplemented!() + } + + fn execute_block(_: $block) { + unimplemented!() + } + + fn initialize_block( + _: &<$block as BlockT>::Header + ) -> sp_runtime::ExtrinsicInclusionMode { + unimplemented!() + } + } + + impl sp_api::Metadata<$block> for $runtime { + fn metadata() -> OpaqueMetadata { + unimplemented!() + } + + fn metadata_at_version(_: u32) -> Option { + unimplemented!() + } + + fn metadata_versions() -> Vec { + unimplemented!() + } + } + + impl sp_consensus_aura::AuraApi<$block, $aura_id> for $runtime { + fn slot_duration() -> sp_consensus_aura::SlotDuration { + unimplemented!() + } + + fn authorities() -> Vec<$aura_id> { + unimplemented!() + } + } + + impl cumulus_primitives_aura::AuraUnincludedSegmentApi<$block> for $runtime { + fn can_build_upon( + _: <$block as BlockT>::Hash, + _: cumulus_primitives_aura::Slot, + ) -> bool { + unimplemented!() + } + } + + impl sp_block_builder::BlockBuilder<$block> for $runtime { + fn apply_extrinsic(_: <$block as BlockT>::Extrinsic) -> ApplyExtrinsicResult { + unimplemented!() + } + + fn finalize_block() -> <$block as BlockT>::Header { + unimplemented!() + } + + fn inherent_extrinsics( + _: sp_inherents::InherentData + ) -> Vec<<$block as BlockT>::Extrinsic> { + unimplemented!() + } + + fn check_inherents( + _: $block, + _: sp_inherents::InherentData + ) -> sp_inherents::CheckInherentsResult { + unimplemented!() + } + } + + impl sp_transaction_pool::runtime_api::TaggedTransactionQueue<$block> for $runtime { + fn validate_transaction( + _: TransactionSource, + _: <$block as BlockT>::Extrinsic, + _: <$block as BlockT>::Hash, + ) -> TransactionValidity { + unimplemented!() + } + } + + impl sp_session::SessionKeys<$block> for $runtime { + fn generate_session_keys(_: Option>) -> Vec { + unimplemented!() + } + + fn decode_session_keys( + _: Vec, + ) -> Option, KeyTypeId)>> { + unimplemented!() + } + } + + impl + pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi< + $block, + Balance, + > for $runtime + { + fn query_info( + _: <$block as BlockT>::Extrinsic, + _: u32, + ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo { + unimplemented!() + } + fn query_fee_details( + _: <$block as BlockT>::Extrinsic, + _: u32, + ) -> pallet_transaction_payment::FeeDetails { + unimplemented!() + } + fn query_weight_to_fee(_: Weight) -> Balance { + unimplemented!() + } + fn query_length_to_fee(_: u32) -> Balance { + unimplemented!() + } + } + + impl cumulus_primitives_core::CollectCollationInfo<$block> for $runtime { + fn collect_collation_info( + _: &<$block as BlockT>::Header + ) -> cumulus_primitives_core::CollationInfo { + unimplemented!() + } + } + + #[cfg(feature = "try-runtime")] + impl frame_try_runtime::TryRuntime<$block> for $runtime { + fn on_runtime_upgrade( + _: frame_try_runtime::UpgradeCheckSelect + ) -> (Weight, Weight) { + unimplemented!() + } + + fn execute_block( + _: $block, + _: bool, + _: bool, + _: frame_try_runtime::TryStateSelect, + ) -> Weight { + unimplemented!() + } + } + + impl frame_system_rpc_runtime_api::AccountNonceApi< + $block, + AccountId, + Nonce + > for $runtime { + fn account_nonce(_: AccountId) -> Nonce { + unimplemented!() + } + } + + #[cfg(feature = "runtime-benchmarks")] + impl frame_benchmarking::Benchmark<$block> for $runtime { + fn benchmark_metadata(_: bool) -> ( + Vec, + Vec, + ) { + unimplemented!() + } + + fn dispatch_benchmark( + _: frame_benchmarking::BenchmarkConfig + ) -> Result, sp_runtime::RuntimeString> { + unimplemented!() + } + } + + impl sp_genesis_builder::GenesisBuilder<$block> for $runtime { + fn build_state(_: Vec) -> sp_genesis_builder::Result { + unimplemented!() + } + + fn get_preset(_id: &Option) -> Option> { + unimplemented!() + } + + fn preset_names() -> Vec { + unimplemented!() + } + } + } + }; +} + +pub(crate) use impl_node_runtime_apis; diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/lib.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..6aa2f656a48ba626c432871f85d44c2965c462a3 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/lib.rs @@ -0,0 +1,52 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +//! Helper library that can be used to run a parachain node. +//! +//! ## Overview +//! +//! This library can be used to run a parachain node while also customizing the chain specs +//! that are supported by default by the `--chain-spec` argument of the node's `CLI` +//! and the parameters of the runtime that is associated with each of these chain specs. +//! +//! ## API +//! +//! The library exposes the possibility to provide a [`RunConfig`]. Through this structure +//! 2 optional configurations can be provided: +//! - a chain spec loader (an implementation of [`chain_spec::LoadSpec`]): this can be used for +//! providing the chain specs that are supported by default by the `--chain-spec` argument of the +//! node's `CLI` and the actual chain config associated with each one. +//! - a runtime resolver (an implementation of [`runtime::RuntimeResolver`]): this can be used for +//! providing the parameters of the runtime that is associated with each of the chain specs +//! +//! Apart from this, a [`CliConfig`] can also be provided, that can be used to customize some +//! user-facing binary author, support url, etc. +//! +//! ## Examples +//! +//! For an example, see the `polkadot-parachain-bin` crate. + +#![deny(missing_docs)] + +mod cli; +mod command; +mod common; +mod fake_runtime_api; +mod service; + +pub use cli::CliConfig; +pub use command::{run, RunConfig}; +pub use common::{chain_spec, runtime}; diff --git a/cumulus/polkadot-parachain/polkadot-parachain-lib/src/service.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/service.rs new file mode 100644 index 0000000000000000000000000000000000000000..303ec1e3b298bf551bfbdbd118bb077fbb2dfa77 --- /dev/null +++ b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/service.rs @@ -0,0 +1,552 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Cumulus. + +// Cumulus 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. + +// Cumulus 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 Cumulus. If not, see . + +use crate::{ + common::{ + aura::{AuraIdT, AuraRuntimeApi}, + rpc::{BuildEmptyRpcExtensions, BuildParachainRpcExtensions}, + spec::{BuildImportQueue, DynNodeSpec, NodeSpec, StartConsensus}, + types::{ + AccountId, Balance, Block, Hash, Nonce, ParachainBackend, ParachainBlockImport, + ParachainClient, + }, + ConstructNodeRuntimeApi, NodeBlock, NodeExtraArgs, + }, + fake_runtime_api::aura_sr25519::RuntimeApi as FakeRuntimeApi, +}; +use cumulus_client_collator::service::{ + CollatorService, ServiceInterface as CollatorServiceInterface, +}; +use cumulus_client_consensus_aura::collators::lookahead::{self as aura, Params as AuraParams}; +#[docify::export(slot_based_colator_import)] +use cumulus_client_consensus_aura::collators::slot_based::{ + self as slot_based, Params as SlotBasedParams, +}; +use cumulus_client_consensus_proposer::{Proposer, ProposerInterface}; +use cumulus_client_consensus_relay_chain::Verifier as RelayChainVerifier; +#[allow(deprecated)] +use cumulus_client_service::old_consensus; +use cumulus_client_service::CollatorSybilResistance; +use cumulus_primitives_core::{relay_chain::ValidationCode, ParaId}; +use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface}; +use futures::prelude::*; +use polkadot_primitives::CollatorPair; +use prometheus_endpoint::Registry; +use sc_client_api::BlockchainEvents; +use sc_client_db::DbHash; +use sc_consensus::{ + import_queue::{BasicQueue, Verifier as VerifierT}, + BlockImportParams, DefaultImportQueue, +}; +use sc_service::{Configuration, Error, TaskManager}; +use sc_telemetry::TelemetryHandle; +use sc_transaction_pool::FullPool; +use sp_api::ProvideRuntimeApi; +use sp_inherents::CreateInherentDataProviders; +use sp_keystore::KeystorePtr; +use sp_runtime::{ + app_crypto::AppCrypto, + traits::{Block as BlockT, Header as HeaderT}, +}; +use std::{marker::PhantomData, sync::Arc, time::Duration}; + +/// Build the import queue for the shell runtime. +pub(crate) struct BuildShellImportQueue; + +impl BuildImportQueue, FakeRuntimeApi> for BuildShellImportQueue { + fn build_import_queue( + client: Arc, FakeRuntimeApi>>, + block_import: ParachainBlockImport, FakeRuntimeApi>, + config: &Configuration, + _telemetry_handle: Option, + task_manager: &TaskManager, + ) -> sc_service::error::Result>> { + cumulus_client_consensus_relay_chain::import_queue( + client, + block_import, + |_, _| async { Ok(()) }, + &task_manager.spawn_essential_handle(), + config.prometheus_registry(), + ) + .map_err(Into::into) + } +} + +pub(crate) struct ShellNode; + +impl NodeSpec for ShellNode { + type Block = Block; + type RuntimeApi = FakeRuntimeApi; + type BuildImportQueue = BuildShellImportQueue; + type BuildRpcExtensions = BuildEmptyRpcExtensions, Self::RuntimeApi>; + type StartConsensus = StartRelayChainConsensus; + + const SYBIL_RESISTANCE: CollatorSybilResistance = CollatorSybilResistance::Unresistant; +} + +struct Verifier { + client: Arc, + aura_verifier: Box>, + relay_chain_verifier: Box>, + _phantom: PhantomData, +} + +#[async_trait::async_trait] +impl VerifierT for Verifier +where + Client: ProvideRuntimeApi + Send + Sync, + Client::Api: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + async fn verify( + &self, + block_import: BlockImportParams, + ) -> Result, String> { + if self.client.runtime_api().has_aura_api(*block_import.header.parent_hash()) { + self.aura_verifier.verify(block_import).await + } else { + self.relay_chain_verifier.verify(block_import).await + } + } +} + +/// Build the import queue for parachain runtimes that started with relay chain consensus and +/// switched to aura. +pub(crate) struct BuildRelayToAuraImportQueue( + PhantomData<(Block, RuntimeApi, AuraId)>, +); + +impl BuildImportQueue + for BuildRelayToAuraImportQueue +where + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + fn build_import_queue( + client: Arc>, + block_import: ParachainBlockImport, + config: &Configuration, + telemetry_handle: Option, + task_manager: &TaskManager, + ) -> sc_service::error::Result> { + let verifier_client = client.clone(); + + let aura_verifier = cumulus_client_consensus_aura::build_verifier::< + ::Pair, + _, + _, + _, + >(cumulus_client_consensus_aura::BuildVerifierParams { + client: verifier_client.clone(), + create_inherent_data_providers: move |parent_hash, _| { + let cidp_client = verifier_client.clone(); + async move { + let slot_duration = cumulus_client_consensus_aura::slot_duration_at( + &*cidp_client, + parent_hash, + )?; + let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); + + let slot = + sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration( + *timestamp, + slot_duration, + ); + + Ok((slot, timestamp)) + } + }, + telemetry: telemetry_handle, + }); + + let relay_chain_verifier = + Box::new(RelayChainVerifier::new(client.clone(), |_, _| async { Ok(()) })); + + let verifier = Verifier { + client, + relay_chain_verifier, + aura_verifier: Box::new(aura_verifier), + _phantom: PhantomData, + }; + + let registry = config.prometheus_registry(); + let spawner = task_manager.spawn_essential_handle(); + + Ok(BasicQueue::new(verifier, Box::new(block_import), None, &spawner, registry)) + } +} + +/// Uses the lookahead collator to support async backing. +/// +/// Start an aura powered parachain node. Some system chains use this. +pub(crate) struct AuraNode( + pub PhantomData<(Block, RuntimeApi, AuraId, StartConsensus)>, +); + +impl Default + for AuraNode +{ + fn default() -> Self { + Self(Default::default()) + } +} + +impl NodeSpec + for AuraNode +where + Block: NodeBlock, + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi + + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi + + substrate_frame_rpc_system::AccountNonceApi, + AuraId: AuraIdT + Sync, + StartConsensus: self::StartConsensus + 'static, +{ + type Block = Block; + type RuntimeApi = RuntimeApi; + type BuildImportQueue = BuildRelayToAuraImportQueue; + type BuildRpcExtensions = BuildParachainRpcExtensions; + type StartConsensus = StartConsensus; + const SYBIL_RESISTANCE: CollatorSybilResistance = CollatorSybilResistance::Resistant; +} + +pub fn new_aura_node_spec( + extra_args: &NodeExtraArgs, +) -> Box +where + Block: NodeBlock, + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi + + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi + + substrate_frame_rpc_system::AccountNonceApi, + AuraId: AuraIdT + Sync, +{ + if extra_args.use_slot_based_consensus { + Box::new(AuraNode::< + Block, + RuntimeApi, + AuraId, + StartSlotBasedAuraConsensus, + >::default()) + } else { + Box::new(AuraNode::< + Block, + RuntimeApi, + AuraId, + StartLookaheadAuraConsensus, + >::default()) + } +} + +/// Start relay-chain consensus that is free for all. Everyone can submit a block, the relay-chain +/// decides what is backed and included. +pub(crate) struct StartRelayChainConsensus; + +impl StartConsensus, FakeRuntimeApi> for StartRelayChainConsensus { + fn start_consensus( + client: Arc, FakeRuntimeApi>>, + block_import: ParachainBlockImport, FakeRuntimeApi>, + prometheus_registry: Option<&Registry>, + telemetry: Option, + task_manager: &TaskManager, + relay_chain_interface: Arc, + transaction_pool: Arc, ParachainClient, FakeRuntimeApi>>>, + _keystore: KeystorePtr, + _relay_chain_slot_duration: Duration, + para_id: ParaId, + collator_key: CollatorPair, + overseer_handle: OverseerHandle, + announce_block: Arc>) + Send + Sync>, + _backend: Arc>>, + _node_extra_args: NodeExtraArgs, + ) -> Result<(), Error> { + let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( + task_manager.spawn_handle(), + client.clone(), + transaction_pool, + prometheus_registry, + telemetry, + ); + + let free_for_all = cumulus_client_consensus_relay_chain::build_relay_chain_consensus( + cumulus_client_consensus_relay_chain::BuildRelayChainConsensusParams { + para_id, + proposer_factory, + block_import, + relay_chain_interface: relay_chain_interface.clone(), + create_inherent_data_providers: move |_, (relay_parent, validation_data)| { + let relay_chain_interface = relay_chain_interface.clone(); + async move { + let parachain_inherent = + cumulus_client_parachain_inherent::ParachainInherentDataProvider::create_at( + relay_parent, + &relay_chain_interface, + &validation_data, + para_id, + ).await; + let parachain_inherent = parachain_inherent.ok_or_else(|| { + Box::::from( + "Failed to create parachain inherent", + ) + })?; + Ok(parachain_inherent) + } + }, + }, + ); + + let spawner = task_manager.spawn_handle(); + + // Required for free-for-all consensus + #[allow(deprecated)] + old_consensus::start_collator_sync(old_consensus::StartCollatorParams { + para_id, + block_status: client.clone(), + announce_block, + overseer_handle, + spawner, + key: collator_key, + parachain_consensus: free_for_all, + runtime_api: client.clone(), + }); + + Ok(()) + } +} + +/// Start consensus using the lookahead aura collator. +pub(crate) struct StartSlotBasedAuraConsensus( + PhantomData<(Block, RuntimeApi, AuraId)>, +); + +impl, RuntimeApi, AuraId> + StartSlotBasedAuraConsensus +where + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + #[docify::export_content] + fn launch_slot_based_collator( + params: SlotBasedParams< + ParachainBlockImport, + CIDP, + ParachainClient, + ParachainBackend, + Arc, + CHP, + Proposer, + CS, + >, + task_manager: &TaskManager, + ) where + CIDP: CreateInherentDataProviders + 'static, + CIDP::InherentDataProviders: Send, + CHP: cumulus_client_consensus_common::ValidationCodeHashProvider + Send + 'static, + Proposer: ProposerInterface + Send + Sync + 'static, + CS: CollatorServiceInterface + Send + Sync + Clone + 'static, + { + let (collation_future, block_builder_future) = + slot_based::run::::Pair, _, _, _, _, _, _, _, _>(params); + + task_manager.spawn_essential_handle().spawn( + "collation-task", + Some("parachain-block-authoring"), + collation_future, + ); + task_manager.spawn_essential_handle().spawn( + "block-builder-task", + Some("parachain-block-authoring"), + block_builder_future, + ); + } +} + +impl, RuntimeApi, AuraId> StartConsensus + for StartSlotBasedAuraConsensus +where + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + fn start_consensus( + client: Arc>, + block_import: ParachainBlockImport, + prometheus_registry: Option<&Registry>, + telemetry: Option, + task_manager: &TaskManager, + relay_chain_interface: Arc, + transaction_pool: Arc>>, + keystore: KeystorePtr, + relay_chain_slot_duration: Duration, + para_id: ParaId, + collator_key: CollatorPair, + _overseer_handle: OverseerHandle, + announce_block: Arc>) + Send + Sync>, + backend: Arc>, + _node_extra_args: NodeExtraArgs, + ) -> Result<(), Error> { + let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( + task_manager.spawn_handle(), + client.clone(), + transaction_pool, + prometheus_registry, + telemetry.clone(), + ); + + let proposer = Proposer::new(proposer_factory); + let collator_service = CollatorService::new( + client.clone(), + Arc::new(task_manager.spawn_handle()), + announce_block, + client.clone(), + ); + + let client_for_aura = client.clone(); + let params = SlotBasedParams { + create_inherent_data_providers: move |_, ()| async move { Ok(()) }, + block_import, + para_client: client.clone(), + para_backend: backend.clone(), + relay_client: relay_chain_interface, + code_hash_provider: move |block_hash| { + client_for_aura.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) + }, + keystore, + collator_key, + para_id, + relay_chain_slot_duration, + proposer, + collator_service, + authoring_duration: Duration::from_millis(2000), + reinitialize: false, + slot_drift: Duration::from_secs(1), + }; + + // We have a separate function only to be able to use `docify::export` on this piece of + // code. + Self::launch_slot_based_collator(params, task_manager); + + Ok(()) + } +} + +/// Wait for the Aura runtime API to appear on chain. +/// This is useful for chains that started out without Aura. Components that +/// are depending on Aura functionality will wait until Aura appears in the runtime. +async fn wait_for_aura( + client: Arc>, +) where + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + let finalized_hash = client.chain_info().finalized_hash; + if client.runtime_api().has_aura_api(finalized_hash) { + return; + }; + + let mut stream = client.finality_notification_stream(); + while let Some(notification) = stream.next().await { + if client.runtime_api().has_aura_api(notification.hash) { + return; + } + } +} + +/// Start consensus using the lookahead aura collator. +pub(crate) struct StartLookaheadAuraConsensus( + PhantomData<(Block, RuntimeApi, AuraId)>, +); + +impl, RuntimeApi, AuraId> StartConsensus + for StartLookaheadAuraConsensus +where + RuntimeApi: ConstructNodeRuntimeApi>, + RuntimeApi::RuntimeApi: AuraRuntimeApi, + AuraId: AuraIdT + Sync, +{ + fn start_consensus( + client: Arc>, + block_import: ParachainBlockImport, + prometheus_registry: Option<&Registry>, + telemetry: Option, + task_manager: &TaskManager, + relay_chain_interface: Arc, + transaction_pool: Arc>>, + keystore: KeystorePtr, + relay_chain_slot_duration: Duration, + para_id: ParaId, + collator_key: CollatorPair, + overseer_handle: OverseerHandle, + announce_block: Arc>) + Send + Sync>, + backend: Arc>, + node_extra_args: NodeExtraArgs, + ) -> Result<(), Error> { + let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( + task_manager.spawn_handle(), + client.clone(), + transaction_pool, + prometheus_registry, + telemetry.clone(), + ); + + let collator_service = CollatorService::new( + client.clone(), + Arc::new(task_manager.spawn_handle()), + announce_block, + client.clone(), + ); + + let params = aura::ParamsWithExport { + export_pov: node_extra_args.export_pov, + params: AuraParams { + create_inherent_data_providers: move |_, ()| async move { Ok(()) }, + block_import, + para_client: client.clone(), + para_backend: backend, + relay_client: relay_chain_interface, + code_hash_provider: { + let client = client.clone(); + move |block_hash| { + client.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) + } + }, + keystore, + collator_key, + para_id, + overseer_handle, + relay_chain_slot_duration, + proposer: Proposer::new(proposer_factory), + collator_service, + authoring_duration: Duration::from_millis(2000), + reinitialize: false, + }, + }; + + let fut = async move { + wait_for_aura(client).await; + aura::run_with_export::::Pair, _, _, _, _, _, _, _, _>( + params, + ) + .await; + }; + task_manager.spawn_essential_handle().spawn("aura", None, fut); + + Ok(()) + } +} diff --git a/cumulus/polkadot-parachain/tests/benchmark_storage_works.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/benchmark_storage_works.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/benchmark_storage_works.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/benchmark_storage_works.rs diff --git a/cumulus/polkadot-parachain/tests/common.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/common.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/common.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/common.rs diff --git a/cumulus/polkadot-parachain/tests/polkadot_argument_parsing.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/polkadot_argument_parsing.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/polkadot_argument_parsing.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/polkadot_argument_parsing.rs diff --git a/cumulus/polkadot-parachain/tests/polkadot_mdns_issue.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/polkadot_mdns_issue.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/polkadot_mdns_issue.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/polkadot_mdns_issue.rs diff --git a/cumulus/polkadot-parachain/tests/purge_chain_works.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/purge_chain_works.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/purge_chain_works.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/purge_chain_works.rs diff --git a/cumulus/polkadot-parachain/tests/running_the_node_and_interrupt.rs b/cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/running_the_node_and_interrupt.rs similarity index 100% rename from cumulus/polkadot-parachain/tests/running_the_node_and_interrupt.rs rename to cumulus/polkadot-parachain/polkadot-parachain-lib/src/tests/running_the_node_and_interrupt.rs diff --git a/cumulus/polkadot-parachain/src/chain_spec/asset_hubs.rs b/cumulus/polkadot-parachain/src/chain_spec/asset_hubs.rs index 45920cdb6146b01765fb568506ef861c220b5792..f6bf6375a35331a2b4079c6c1a499c3d39549251 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/asset_hubs.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/asset_hubs.rs @@ -14,13 +14,11 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, -}; +use crate::chain_spec::{get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION}; use cumulus_primitives_core::ParaId; use hex_literal::hex; use parachains_common::{AccountId, AuraId, Balance as AssetHubBalance}; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use sp_core::{crypto::UncheckedInto, sr25519}; @@ -389,6 +387,7 @@ fn asset_hub_rococo_genesis( ) }) .collect(), + ..Default::default() }, "polkadotXcm": asset_hub_rococo_runtime::PolkadotXcmConfig { safe_xcm_version: Some(SAFE_XCM_VERSION), diff --git a/cumulus/polkadot-parachain/src/chain_spec/bridge_hubs.rs b/cumulus/polkadot-parachain/src/chain_spec/bridge_hubs.rs index 15e8a1bf11a055e6c5b4950ad07d78cad72f81a8..754bd851b40ad326aa1e199152b458153b525202 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/bridge_hubs.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/bridge_hubs.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{get_account_id_from_seed, get_collator_keys_from_seed, GenericChainSpec}; +use crate::chain_spec::{get_account_id_from_seed, get_collator_keys_from_seed}; use cumulus_primitives_core::ParaId; use parachains_common::Balance as BridgeHubBalance; +use polkadot_parachain_lib::chain_spec::GenericChainSpec; use sc_chain_spec::ChainSpec; use sp_core::sr25519; use std::str::FromStr; @@ -129,8 +130,9 @@ fn ensure_id(id: &str) -> Result<&str, String> { /// Sub-module for Rococo setup pub mod rococo { use super::{get_account_id_from_seed, get_collator_keys_from_seed, sr25519, ParaId}; - use crate::chain_spec::{Extensions, GenericChainSpec, SAFE_XCM_VERSION}; + use crate::chain_spec::SAFE_XCM_VERSION; use parachains_common::{AccountId, AuraId}; + use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_chain_spec::ChainType; use super::BridgeHubBalance; @@ -254,8 +256,9 @@ pub mod kusama { /// Sub-module for Westend setup. pub mod westend { use super::{get_account_id_from_seed, get_collator_keys_from_seed, sr25519, ParaId}; - use crate::chain_spec::{Extensions, GenericChainSpec, SAFE_XCM_VERSION}; + use crate::chain_spec::SAFE_XCM_VERSION; use parachains_common::{AccountId, AuraId}; + use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_chain_spec::ChainType; use super::BridgeHubBalance; @@ -357,6 +360,10 @@ pub mod westend { }, "bridgeRococoMessages": { "owner": bridges_pallet_owner.clone(), + }, + "ethereumSystem": { + "paraId": id, + "assetHubParaId": 1000 } }) } diff --git a/cumulus/polkadot-parachain/src/chain_spec/collectives.rs b/cumulus/polkadot-parachain/src/chain_spec/collectives.rs index c0a9f195d89bc1a3b56001e8e60ad1834660959c..865a2a917086ea212aeb8faa4c8fc11ee95457d3 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/collectives.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/collectives.rs @@ -14,12 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, -}; +use crate::chain_spec::{get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION}; use cumulus_primitives_core::ParaId; use parachains_common::{AccountId, AuraId, Balance as CollectivesBalance}; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use sp_core::sr25519; diff --git a/cumulus/polkadot-parachain/src/chain_spec/contracts.rs b/cumulus/polkadot-parachain/src/chain_spec/contracts.rs deleted file mode 100644 index 4e89b81d1be40fb5b0bc5d5f689a8883ba612fa1..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/chain_spec/contracts.rs +++ /dev/null @@ -1,241 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, -}; -use cumulus_primitives_core::ParaId; -use hex_literal::hex; -use parachains_common::{AccountId, AuraId}; -use sc_service::ChainType; -use sp_core::{crypto::UncheckedInto, sr25519}; - -/// No relay chain suffix because the id is the same over all relay chains. -const CONTRACTS_PARACHAIN_ID: u32 = 1002; - -/// The existential deposit is determined by the runtime "contracts-rococo". -const CONTRACTS_ROCOCO_ED: contracts_rococo_runtime::Balance = - testnet_parachains_constants::rococo::currency::EXISTENTIAL_DEPOSIT; - -pub fn contracts_rococo_development_config() -> GenericChainSpec { - let mut properties = sc_chain_spec::Properties::new(); - properties.insert("tokenSymbol".into(), "ROC".into()); - properties.insert("tokenDecimals".into(), 12.into()); - - GenericChainSpec::builder( - contracts_rococo_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), - Extensions { - relay_chain: "rococo-local".into(), // You MUST set this to the correct network! - para_id: CONTRACTS_PARACHAIN_ID, - }, - ) - .with_name("Contracts on Rococo Development") - .with_id("contracts-rococo-dev") - .with_chain_type(ChainType::Development) - .with_genesis_config_patch(contracts_rococo_genesis( - // initial collators. - vec![ - ( - get_account_id_from_seed::("Alice"), - get_collator_keys_from_seed::("Alice"), - ), - ( - get_account_id_from_seed::("Bob"), - get_collator_keys_from_seed::("Bob"), - ), - ], - vec![ - get_account_id_from_seed::("Alice"), - get_account_id_from_seed::("Bob"), - get_account_id_from_seed::("Charlie"), - get_account_id_from_seed::("Dave"), - get_account_id_from_seed::("Eve"), - get_account_id_from_seed::("Ferdie"), - get_account_id_from_seed::("Alice//stash"), - get_account_id_from_seed::("Bob//stash"), - get_account_id_from_seed::("Charlie//stash"), - get_account_id_from_seed::("Dave//stash"), - get_account_id_from_seed::("Eve//stash"), - get_account_id_from_seed::("Ferdie//stash"), - ], - CONTRACTS_PARACHAIN_ID.into(), - )) - .with_boot_nodes(Vec::new()) - .build() -} - -pub fn contracts_rococo_local_config() -> GenericChainSpec { - let mut properties = sc_chain_spec::Properties::new(); - properties.insert("tokenSymbol".into(), "ROC".into()); - properties.insert("tokenDecimals".into(), 12.into()); - - GenericChainSpec::builder( - contracts_rococo_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), - Extensions { - relay_chain: "rococo-local".into(), // You MUST set this to the correct network! - para_id: CONTRACTS_PARACHAIN_ID, - }, - ) - .with_name("Contracts on Rococo") - .with_id("contracts-rococo-local") - .with_chain_type(ChainType::Local) - .with_genesis_config_patch(contracts_rococo_genesis( - // initial collators. - vec![ - ( - get_account_id_from_seed::("Alice"), - get_collator_keys_from_seed::("Alice"), - ), - ( - get_account_id_from_seed::("Bob"), - get_collator_keys_from_seed::("Bob"), - ), - ], - vec![ - get_account_id_from_seed::("Alice"), - get_account_id_from_seed::("Bob"), - get_account_id_from_seed::("Charlie"), - get_account_id_from_seed::("Dave"), - get_account_id_from_seed::("Eve"), - get_account_id_from_seed::("Ferdie"), - get_account_id_from_seed::("Alice//stash"), - get_account_id_from_seed::("Bob//stash"), - get_account_id_from_seed::("Charlie//stash"), - get_account_id_from_seed::("Dave//stash"), - get_account_id_from_seed::("Eve//stash"), - get_account_id_from_seed::("Ferdie//stash"), - ], - CONTRACTS_PARACHAIN_ID.into(), - )) - .with_properties(properties) - .build() -} - -pub fn contracts_rococo_config() -> GenericChainSpec { - // Give your base currency a unit name and decimal places - let mut properties = sc_chain_spec::Properties::new(); - properties.insert("tokenSymbol".into(), "ROC".into()); - properties.insert("tokenDecimals".into(), 12.into()); - - GenericChainSpec::builder( - contracts_rococo_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), - Extensions { relay_chain: "rococo".into(), para_id: CONTRACTS_PARACHAIN_ID } - ) - .with_name("Contracts on Rococo") - .with_id("contracts-rococo") - .with_chain_type(ChainType::Live) - .with_genesis_config_patch(contracts_rococo_genesis( - vec![ - // 5GKFbTTgrVS4Vz1UWWHPqMZQNFWZtqo7H2KpCDyYhEL3aS26 - ( - hex!["bc09354c12c054c8f6b3da208485eacec4ac648bad348895273b37bab5a0937c"] - .into(), - hex!["bc09354c12c054c8f6b3da208485eacec4ac648bad348895273b37bab5a0937c"] - .unchecked_into(), - ), - // 5EPRJHm2GpABVWcwnAujcrhnrjFZyDGd5TwKFzkBoGgdRyv2 - ( - hex!["66be63b7bcbfb91040e5248e2d1ceb822cf219c57848c5924ffa3a1f8e67ba72"] - .into(), - hex!["66be63b7bcbfb91040e5248e2d1ceb822cf219c57848c5924ffa3a1f8e67ba72"] - .unchecked_into(), - ), - // 5GH62vrJrVZxLREcHzm2PR5uTLAT5RQMJitoztCGyaP4o3uM - ( - hex!["ba62886472a0a9f66b5e39f1469ce1c5b3d8cad6be39078daf16f111e89d1e44"] - .into(), - hex!["ba62886472a0a9f66b5e39f1469ce1c5b3d8cad6be39078daf16f111e89d1e44"] - .unchecked_into(), - ), - // 5FHfoJDLdjRYX5KXLRqMDYBbWrwHLMtti21uK4QByUoUAbJF - ( - hex!["8e97f65cda001976311df9bed39e8d0c956089093e94a75ef76fe9347a0eda7b"] - .into(), - hex!["8e97f65cda001976311df9bed39e8d0c956089093e94a75ef76fe9347a0eda7b"] - .unchecked_into(), - ), - ], - // Warning: The configuration for a production chain should not contain - // any endowed accounts here, otherwise it'll be minting extra native tokens - // from the relay chain on the parachain. - vec![ - // NOTE: Remove endowed accounts if deployed on other relay chains. - // Endowed accounts - hex!["baa78c7154c7f82d6d377177e20bcab65d327eca0086513f9964f5a0f6bdad56"].into(), - // AccountId of an account which `ink-waterfall` uses for automated testing - hex!["0e47e2344d523c3cc5c34394b0d58b9a4200e813a038e6c5a6163cc07d70b069"].into(), - ], - CONTRACTS_PARACHAIN_ID.into(), - )) - .with_boot_nodes(vec![ - "/dns/contracts-collator-0.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWKg3Rpxcr9oJ8n6khoxpGKWztCZydtUZk2cojHqnfLrpj" - .parse() - .expect("MultiaddrWithPeerId"), - "/dns/contracts-collator-1.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWPEXYrz8tHU3nDtPoPw4V7ou5dzMEWSTuUj7vaWiYVAVh" - .parse() - .expect("MultiaddrWithPeerId"), - "/dns/contracts-collator-2.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWEVU8AFNary4nP4qEnEcwJaRuy59Wefekzdu9pKbnVEhk" - .parse() - .expect("MultiaddrWithPeerId"), - "/dns/contracts-collator-3.parity-testnet.parity.io/tcp/30333/p2p/12D3KooWP6pV3ZmcXzGDjv8ZMgA6nZxfAKDxSz4VNiLx6vVCQgJX" - .parse() - .expect("MultiaddrWithPeerId"), - ]) - .with_properties(properties) - .build() -} - -fn contracts_rococo_genesis( - invulnerables: Vec<(AccountId, AuraId)>, - endowed_accounts: Vec, - id: ParaId, -) -> serde_json::Value { - serde_json::json!( { - "balances": { - "balances": endowed_accounts.iter().cloned().map(|k| (k, 1u64 << 60)).collect::>(), - }, - "parachainInfo": { - "parachainId": id, - }, - "collatorSelection": { - "invulnerables": invulnerables.iter().cloned().map(|(acc, _)| acc).collect::>(), - "candidacyBond": CONTRACTS_ROCOCO_ED * 16, - }, - "session": { - "keys": invulnerables - .into_iter() - .map(|(acc, aura)| { - ( - acc.clone(), // account id - acc, // validator id - contracts_rococo_runtime::SessionKeys { aura }, // session keys - ) - }) - .collect::>(), - }, - // no need to pass anything to aura, in fact it will panic if we do. Session will take care - // of this. - "polkadotXcm": { - "safeXcmVersion": Some(SAFE_XCM_VERSION), - }, - "sudo": { - "key": Some(sp_runtime::AccountId32::from(hex![ - "2681a28014e7d3a5bfb32a003b3571f53c408acbc28d351d6bf58f5028c4ef14" - ])), - }, - }) -} diff --git a/cumulus/polkadot-parachain/src/chain_spec/coretime.rs b/cumulus/polkadot-parachain/src/chain_spec/coretime.rs index fe60b09fd8b21715286f5fd40018be06ba978c06..fec3f56e6d3520ddcee8985f6be388117df5756e 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/coretime.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/coretime.rs @@ -14,8 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::GenericChainSpec; use cumulus_primitives_core::ParaId; +use polkadot_parachain_lib::chain_spec::GenericChainSpec; use sc_chain_spec::{ChainSpec, ChainType}; use std::{borrow::Cow, str::FromStr}; @@ -107,8 +107,9 @@ impl CoretimeRuntimeType { CoretimeRuntimeType::Kusama => Ok(Box::new(GenericChainSpec::from_json_bytes( &include_bytes!("../../chain-specs/coretime-kusama.json")[..], )?)), - CoretimeRuntimeType::Polkadot => - todo!("Generate chain-spec: ../../chain-specs/coretime-polkadot.json"), + CoretimeRuntimeType::Polkadot => Ok(Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/coretime-polkadot.json")[..], + )?)), CoretimeRuntimeType::Rococo => Ok(Box::new(GenericChainSpec::from_json_bytes( &include_bytes!("../../chain-specs/coretime-rococo.json")[..], )?)), @@ -144,11 +145,12 @@ pub fn chain_type_name(chain_type: &ChainType) -> Cow { /// Sub-module for Rococo setup. pub mod rococo { - use super::{chain_type_name, CoretimeRuntimeType, GenericChainSpec, ParaId}; + use super::{chain_type_name, CoretimeRuntimeType, ParaId}; use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, SAFE_XCM_VERSION, + get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION, }; use parachains_common::{AccountId, AuraId, Balance}; + use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_chain_spec::ChainType; use sp_core::sr25519; @@ -243,9 +245,10 @@ pub mod rococo { pub mod westend { use super::{chain_type_name, CoretimeRuntimeType, GenericChainSpec, ParaId}; use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, SAFE_XCM_VERSION, + get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION, }; use parachains_common::{AccountId, AuraId, Balance}; + use polkadot_parachain_lib::chain_spec::Extensions; use sp_core::sr25519; pub(crate) const CORETIME_WESTEND: &str = "coretime-westend"; diff --git a/cumulus/polkadot-parachain/src/chain_spec/glutton.rs b/cumulus/polkadot-parachain/src/chain_spec/glutton.rs index 77a4123b13ee11b0f158332c26a1695cfe37a668..136411b93e8bcc73a3bbf72510abb1f13ae4d20b 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/glutton.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/glutton.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{get_account_id_from_seed, Extensions, GenericChainSpec}; +use crate::chain_spec::get_account_id_from_seed; use cumulus_primitives_core::ParaId; use parachains_common::AuraId; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use sp_core::sr25519; diff --git a/cumulus/polkadot-parachain/src/chain_spec/mod.rs b/cumulus/polkadot-parachain/src/chain_spec/mod.rs index bbda334e4c66e0d9f8fcb7434bc4f218d81dc6e5..82aec951704f1c3e7dac7cf6b0636e8b72e758bb 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/mod.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/mod.rs @@ -14,16 +14,21 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . +use cumulus_primitives_core::ParaId; use parachains_common::{AccountId, Signature}; -use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup}; -use serde::{Deserialize, Serialize}; +use polkadot_parachain_lib::{ + chain_spec::{GenericChainSpec, LoadSpec}, + runtime::{ + AuraConsensusId, BlockNumber, Consensus, Runtime, RuntimeResolver as RuntimeResolverT, + }, +}; +use sc_chain_spec::ChainSpec; use sp_core::{Pair, Public}; use sp_runtime::traits::{IdentifyAccount, Verify}; pub mod asset_hubs; pub mod bridge_hubs; pub mod collectives; -pub mod contracts; pub mod coretime; pub mod glutton; pub mod penpal; @@ -35,26 +40,6 @@ pub mod shell; /// The default XCM version to set in genesis config. const SAFE_XCM_VERSION: u32 = xcm::prelude::XCM_VERSION; -/// Generic extensions for Parachain ChainSpecs. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension)] -#[serde(deny_unknown_fields)] -pub struct Extensions { - /// The relay chain of the Parachain. - pub relay_chain: String, - /// The id of the Parachain. - pub para_id: u32, -} - -impl Extensions { - /// Try to get the extension from the given `ChainSpec`. - pub fn try_get(chain_spec: &dyn sc_service::ChainSpec) -> Option<&Self> { - sc_chain_spec::get_extension(chain_spec.extensions()) - } -} - -/// Generic chain spec for all polkadot-parachain runtimes -pub type GenericChainSpec = sc_service::GenericChainSpec<(), Extensions>; - /// Helper function to generate a crypto pair from seed pub fn get_from_seed(seed: &str) -> ::Public { TPublic::Pair::from_string(&format!("//{}", seed), None) @@ -78,3 +63,317 @@ where pub fn get_collator_keys_from_seed(seed: &str) -> ::Public { get_from_seed::(seed) } + +/// Extracts the normalized chain id and parachain id from the input chain id. +/// (H/T to Phala for the idea) +/// E.g. "penpal-kusama-2004" yields ("penpal-kusama", Some(2004)) +fn extract_parachain_id<'a>( + id: &'a str, + para_prefixes: &[&str], +) -> (&'a str, &'a str, Option) { + for para_prefix in para_prefixes { + if let Some(suffix) = id.strip_prefix(para_prefix) { + let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); + return (&id[..para_prefix.len() - 1], id, Some(para_id.into())); + } + } + + (id, id, None) +} + +#[derive(Debug)] +pub(crate) struct ChainSpecLoader; + +impl LoadSpec for ChainSpecLoader { + fn load_spec(&self, id: &str) -> Result, String> { + Ok(match id { + // - Default-like + "staging" => Box::new(rococo_parachain::staging_rococo_parachain_local_config()), + "tick" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/tick.json")[..], + )?), + "trick" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/trick.json")[..], + )?), + "track" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/track.json")[..], + )?), + + // -- Starters + "shell" => Box::new(shell::get_shell_chain_spec()), + "seedling" => Box::new(seedling::get_seedling_chain_spec()), + + // -- Asset Hub Polkadot + "asset-hub-polkadot" | "statemint" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/asset-hub-polkadot.json")[..], + )?), + + // -- Asset Hub Kusama + "asset-hub-kusama" | "statemine" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/asset-hub-kusama.json")[..], + )?), + + // -- Asset Hub Rococo + "asset-hub-rococo-dev" => Box::new(asset_hubs::asset_hub_rococo_development_config()), + "asset-hub-rococo-local" => Box::new(asset_hubs::asset_hub_rococo_local_config()), + // the chain spec as used for generating the upgrade genesis values + "asset-hub-rococo-genesis" => Box::new(asset_hubs::asset_hub_rococo_genesis_config()), + "asset-hub-rococo" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/asset-hub-rococo.json")[..], + )?), + + // -- Asset Hub Westend + "asset-hub-westend-dev" | "westmint-dev" => + Box::new(asset_hubs::asset_hub_westend_development_config()), + "asset-hub-westend-local" | "westmint-local" => + Box::new(asset_hubs::asset_hub_westend_local_config()), + // the chain spec as used for generating the upgrade genesis values + "asset-hub-westend-genesis" | "westmint-genesis" => + Box::new(asset_hubs::asset_hub_westend_config()), + // the shell-based chain spec as used for syncing + "asset-hub-westend" | "westmint" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/asset-hub-westend.json")[..], + )?), + + // -- Polkadot Collectives + "collectives-polkadot" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/collectives-polkadot.json")[..], + )?), + + // -- Westend Collectives + "collectives-westend-dev" => + Box::new(collectives::collectives_westend_development_config()), + "collectives-westend-local" => + Box::new(collectives::collectives_westend_local_config()), + "collectives-westend" => Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/collectives-westend.json")[..], + )?), + + // -- BridgeHub + bridge_like_id + if bridge_like_id.starts_with(bridge_hubs::BridgeHubRuntimeType::ID_PREFIX) => + bridge_like_id + .parse::() + .expect("invalid value") + .load_config()?, + + // -- Coretime + coretime_like_id + if coretime_like_id.starts_with(coretime::CoretimeRuntimeType::ID_PREFIX) => + coretime_like_id + .parse::() + .expect("invalid value") + .load_config()?, + + // -- Penpal + id if id.starts_with("penpal-rococo") => { + let (_, _, para_id) = extract_parachain_id(&id, &["penpal-rococo-"]); + Box::new(penpal::get_penpal_chain_spec( + para_id.expect("Must specify parachain id"), + "rococo-local", + )) + }, + id if id.starts_with("penpal-westend") => { + let (_, _, para_id) = extract_parachain_id(&id, &["penpal-westend-"]); + Box::new(penpal::get_penpal_chain_spec( + para_id.expect("Must specify parachain id"), + "westend-local", + )) + }, + + // -- Glutton Westend + id if id.starts_with("glutton-westend-dev") => { + let (_, _, para_id) = extract_parachain_id(&id, &["glutton-westend-dev-"]); + Box::new(glutton::glutton_westend_development_config( + para_id.expect("Must specify parachain id"), + )) + }, + id if id.starts_with("glutton-westend-local") => { + let (_, _, para_id) = extract_parachain_id(&id, &["glutton-westend-local-"]); + Box::new(glutton::glutton_westend_local_config( + para_id.expect("Must specify parachain id"), + )) + }, + // the chain spec as used for generating the upgrade genesis values + id if id.starts_with("glutton-westend-genesis") => { + let (_, _, para_id) = extract_parachain_id(&id, &["glutton-westend-genesis-"]); + Box::new(glutton::glutton_westend_config( + para_id.expect("Must specify parachain id"), + )) + }, + + // -- People + people_like_id if people_like_id.starts_with(people::PeopleRuntimeType::ID_PREFIX) => + people_like_id + .parse::() + .expect("invalid value") + .load_config()?, + + // -- Fallback (generic chainspec) + "" => { + log::warn!("No ChainSpec.id specified, so using default one, based on rococo-parachain runtime"); + Box::new(rococo_parachain::rococo_parachain_local_config()) + }, + + // -- Loading a specific spec from disk + path => Box::new(GenericChainSpec::from_json_file(path.into())?), + }) + } +} + +/// Helper enum that is used for better distinction of different parachain/runtime configuration +/// (it is based/calculated on ChainSpec's ID attribute) +#[derive(Debug, PartialEq)] +enum LegacyRuntime { + Omni, + Shell, + Seedling, + AssetHubPolkadot, + AssetHub, + Penpal, + Collectives, + Glutton, + BridgeHub(bridge_hubs::BridgeHubRuntimeType), + Coretime(coretime::CoretimeRuntimeType), + People(people::PeopleRuntimeType), +} + +impl LegacyRuntime { + fn from_id(id: &str) -> LegacyRuntime { + let id = id.replace('_', "-"); + + if id.starts_with("shell") { + LegacyRuntime::Shell + } else if id.starts_with("seedling") { + LegacyRuntime::Seedling + } else if id.starts_with("asset-hub-polkadot") | id.starts_with("statemint") { + LegacyRuntime::AssetHubPolkadot + } else if id.starts_with("asset-hub-kusama") | + id.starts_with("statemine") | + id.starts_with("asset-hub-rococo") | + id.starts_with("rockmine") | + id.starts_with("asset-hub-westend") | + id.starts_with("westmint") + { + LegacyRuntime::AssetHub + } else if id.starts_with("penpal") { + LegacyRuntime::Penpal + } else if id.starts_with("collectives-polkadot") || id.starts_with("collectives-westend") { + LegacyRuntime::Collectives + } else if id.starts_with(bridge_hubs::BridgeHubRuntimeType::ID_PREFIX) { + LegacyRuntime::BridgeHub( + id.parse::().expect("Invalid value"), + ) + } else if id.starts_with(coretime::CoretimeRuntimeType::ID_PREFIX) { + LegacyRuntime::Coretime( + id.parse::().expect("Invalid value"), + ) + } else if id.starts_with("glutton") { + LegacyRuntime::Glutton + } else if id.starts_with(people::PeopleRuntimeType::ID_PREFIX) { + LegacyRuntime::People(id.parse::().expect("Invalid value")) + } else { + log::warn!( + "No specific runtime was recognized for ChainSpec's id: '{}', \ + so Runtime::Omni(Consensus::Aura) will be used", + id + ); + LegacyRuntime::Omni + } + } +} + +#[derive(Debug)] +pub(crate) struct RuntimeResolver; + +impl RuntimeResolverT for RuntimeResolver { + fn runtime(&self, chain_spec: &dyn ChainSpec) -> sc_cli::Result { + let legacy_runtime = LegacyRuntime::from_id(chain_spec.id()); + Ok(match legacy_runtime { + LegacyRuntime::AssetHubPolkadot => + Runtime::Omni(BlockNumber::U32, Consensus::Aura(AuraConsensusId::Ed25519)), + LegacyRuntime::AssetHub | + LegacyRuntime::BridgeHub(_) | + LegacyRuntime::Collectives | + LegacyRuntime::Coretime(_) | + LegacyRuntime::People(_) | + LegacyRuntime::Glutton | + LegacyRuntime::Penpal | + LegacyRuntime::Omni => + Runtime::Omni(BlockNumber::U32, Consensus::Aura(AuraConsensusId::Sr25519)), + LegacyRuntime::Shell | LegacyRuntime::Seedling => Runtime::Shell, + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup, ChainType, Extension}; + use serde::{Deserialize, Serialize}; + use sp_core::sr25519; + + #[derive( + Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension, Default, + )] + #[serde(deny_unknown_fields)] + pub struct Extensions1 { + pub attribute1: String, + pub attribute2: u32, + } + + #[derive( + Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension, Default, + )] + #[serde(deny_unknown_fields)] + pub struct Extensions2 { + pub attribute_x: String, + pub attribute_y: String, + pub attribute_z: u32, + } + + pub type DummyChainSpec = sc_service::GenericChainSpec; + + pub fn create_default_with_extensions( + id: &str, + extension: E, + ) -> DummyChainSpec { + DummyChainSpec::builder( + rococo_parachain_runtime::WASM_BINARY + .expect("WASM binary was not built, please build it!"), + extension, + ) + .with_name("Dummy local testnet") + .with_id(id) + .with_chain_type(ChainType::Local) + .with_genesis_config_patch(crate::chain_spec::rococo_parachain::testnet_genesis( + get_account_id_from_seed::("Alice"), + vec![ + get_from_seed::("Alice"), + get_from_seed::("Bob"), + ], + vec![get_account_id_from_seed::("Alice")], + 1000.into(), + )) + .build() + } + + #[test] + fn test_legacy_runtime_for_different_chain_specs() { + let chain_spec = create_default_with_extensions("shell-1", Extensions1::default()); + assert_eq!(LegacyRuntime::Shell, LegacyRuntime::from_id(chain_spec.id())); + + let chain_spec = create_default_with_extensions("shell-2", Extensions2::default()); + assert_eq!(LegacyRuntime::Shell, LegacyRuntime::from_id(chain_spec.id())); + + let chain_spec = create_default_with_extensions("seedling", Extensions2::default()); + assert_eq!(LegacyRuntime::Seedling, LegacyRuntime::from_id(chain_spec.id())); + + let chain_spec = + create_default_with_extensions("penpal-rococo-1000", Extensions2::default()); + assert_eq!(LegacyRuntime::Penpal, LegacyRuntime::from_id(chain_spec.id())); + + let chain_spec = crate::chain_spec::rococo_parachain::rococo_parachain_local_config(); + assert_eq!(LegacyRuntime::Omni, LegacyRuntime::from_id(chain_spec.id())); + } +} diff --git a/cumulus/polkadot-parachain/src/chain_spec/penpal.rs b/cumulus/polkadot-parachain/src/chain_spec/penpal.rs index cb1cb632d63843681a121261be4b83bf5fb88e32..5645bf06b67b22ae9f799fb1796131a4ebca0950 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/penpal.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/penpal.rs @@ -14,12 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, -}; +use crate::chain_spec::{get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION}; use cumulus_primitives_core::ParaId; use parachains_common::{AccountId, AuraId}; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use sp_core::sr25519; diff --git a/cumulus/polkadot-parachain/src/chain_spec/people.rs b/cumulus/polkadot-parachain/src/chain_spec/people.rs index db8756e68819b3f7abaeeea9e8b684f75beda5dc..3c1150d95422b7016c86dfcf3f4c48ac8f60f0b1 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/people.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/people.rs @@ -14,9 +14,9 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::GenericChainSpec; use cumulus_primitives_core::ParaId; use parachains_common::Balance as PeopleBalance; +use polkadot_parachain_lib::chain_spec::GenericChainSpec; use sc_chain_spec::ChainSpec; use std::str::FromStr; @@ -63,8 +63,9 @@ impl PeopleRuntimeType { PeopleRuntimeType::Kusama => Ok(Box::new(GenericChainSpec::from_json_bytes( &include_bytes!("../../chain-specs/people-kusama.json")[..], )?)), - PeopleRuntimeType::Polkadot => - todo!("Generate chain-spec: ../../chain-specs/people-polkadot.json"), + PeopleRuntimeType::Polkadot => Ok(Box::new(GenericChainSpec::from_json_bytes( + &include_bytes!("../../chain-specs/people-polkadot.json")[..], + )?)), PeopleRuntimeType::Rococo => Ok(Box::new(GenericChainSpec::from_json_bytes( &include_bytes!("../../chain-specs/people-rococo.json")[..], )?)), @@ -120,10 +121,10 @@ fn ensure_id(id: &str) -> Result<&str, String> { pub mod rococo { use super::{ParaId, PeopleBalance}; use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, + get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION, }; use parachains_common::{AccountId, AuraId}; + use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_chain_spec::ChainType; use sp_core::sr25519; @@ -230,10 +231,10 @@ pub mod rococo { pub mod westend { use super::{ParaId, PeopleBalance}; use crate::chain_spec::{ - get_account_id_from_seed, get_collator_keys_from_seed, Extensions, GenericChainSpec, - SAFE_XCM_VERSION, + get_account_id_from_seed, get_collator_keys_from_seed, SAFE_XCM_VERSION, }; use parachains_common::{AccountId, AuraId}; + use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_chain_spec::ChainType; use sp_core::sr25519; diff --git a/cumulus/polkadot-parachain/src/chain_spec/rococo_parachain.rs b/cumulus/polkadot-parachain/src/chain_spec/rococo_parachain.rs index 0434e5f7be8fb3ffb5f93cbb639f5c90469cf763..9f4a162e67f8d74f1df7a59dc3c1f1b10e10e9a1 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/rococo_parachain.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/rococo_parachain.rs @@ -16,10 +16,11 @@ //! ChainSpecs dedicated to Rococo parachain setups (for testing and example purposes) -use crate::chain_spec::{get_from_seed, Extensions, GenericChainSpec, SAFE_XCM_VERSION}; +use crate::chain_spec::{get_from_seed, SAFE_XCM_VERSION}; use cumulus_primitives_core::ParaId; use hex_literal::hex; use parachains_common::AccountId; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use polkadot_service::chain_spec::get_account_id_from_seed; use rococo_parachain_runtime::AuraId; use sc_chain_spec::ChainType; diff --git a/cumulus/polkadot-parachain/src/chain_spec/seedling.rs b/cumulus/polkadot-parachain/src/chain_spec/seedling.rs index 32d51622054575d103cb5c3684a216a9dbde6556..a104b58db5d2f03ac5c67ed39ab7246b48df9f7f 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/seedling.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/seedling.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{get_account_id_from_seed, Extensions, GenericChainSpec}; +use crate::chain_spec::get_account_id_from_seed; use cumulus_primitives_core::ParaId; use parachains_common::{AccountId, AuraId}; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use sp_core::sr25519; diff --git a/cumulus/polkadot-parachain/src/chain_spec/shell.rs b/cumulus/polkadot-parachain/src/chain_spec/shell.rs index e0a9875fb96f28870a726073d3c8b8cb249628a9..0a7816ab31932998e17e1d0ce4e04c5c6659e877 100644 --- a/cumulus/polkadot-parachain/src/chain_spec/shell.rs +++ b/cumulus/polkadot-parachain/src/chain_spec/shell.rs @@ -14,9 +14,9 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use crate::chain_spec::{Extensions, GenericChainSpec}; use cumulus_primitives_core::ParaId; use parachains_common::AuraId; +use polkadot_parachain_lib::chain_spec::{Extensions, GenericChainSpec}; use sc_service::ChainType; use super::get_collator_keys_from_seed; diff --git a/cumulus/polkadot-parachain/src/cli.rs b/cumulus/polkadot-parachain/src/cli.rs deleted file mode 100644 index f7d2fd0f0be3c938ac5a9376d6896a0b073fa364..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/cli.rs +++ /dev/null @@ -1,125 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -use std::path::PathBuf; - -/// Sub-commands supported by the collator. -#[derive(Debug, clap::Subcommand)] -pub enum Subcommand { - /// Key management CLI utilities - #[command(subcommand)] - Key(sc_cli::KeySubcommand), - - /// Build a chain specification. - BuildSpec(sc_cli::BuildSpecCmd), - - /// Validate blocks. - CheckBlock(sc_cli::CheckBlockCmd), - - /// Export blocks. - ExportBlocks(sc_cli::ExportBlocksCmd), - - /// Export the state of a given block into a chain spec. - ExportState(sc_cli::ExportStateCmd), - - /// Import blocks. - ImportBlocks(sc_cli::ImportBlocksCmd), - - /// Revert the chain to a previous state. - Revert(sc_cli::RevertCmd), - - /// Remove the whole chain. - PurgeChain(cumulus_client_cli::PurgeChainCmd), - - /// Export the genesis state of the parachain. - #[command(alias = "export-genesis-state")] - ExportGenesisHead(cumulus_client_cli::ExportGenesisHeadCommand), - - /// Export the genesis wasm of the parachain. - ExportGenesisWasm(cumulus_client_cli::ExportGenesisWasmCommand), - - /// Sub-commands concerned with benchmarking. - /// The pallet benchmarking moved to the `pallet` sub-command. - #[command(subcommand)] - Benchmark(frame_benchmarking_cli::BenchmarkCmd), -} - -const AFTER_HELP_EXAMPLE: &str = color_print::cstr!( - r#"Examples: - polkadot-parachain --chain asset-hub-polkadot --sync warp -- --chain polkadot --sync warp - Launch a warp-syncing full node of the Asset Hub parachain on the Polkadot Relay Chain. - polkadot-parachain --chain asset-hub-polkadot --sync warp --relay-chain-rpc-url ws://rpc.example.com -- --chain polkadot - Launch a warp-syncing full node of the Asset Hub parachain on the Polkadot Relay Chain. - Uses ws://rpc.example.com as remote relay chain node. - "# -); -#[derive(Debug, clap::Parser)] -#[command( - propagate_version = true, - args_conflicts_with_subcommands = true, - subcommand_negates_reqs = true -)] -#[clap(after_help = AFTER_HELP_EXAMPLE)] -pub struct Cli { - #[command(subcommand)] - pub subcommand: Option, - - #[command(flatten)] - pub run: cumulus_client_cli::RunCmd, - - /// Disable automatic hardware benchmarks. - /// - /// By default these benchmarks are automatically ran at startup and measure - /// the CPU speed, the memory bandwidth and the disk speed. - /// - /// The results are then printed out in the logs, and also sent as part of - /// telemetry, if telemetry is enabled. - #[arg(long)] - pub no_hardware_benchmarks: bool, - - /// Relay chain arguments - #[arg(raw = true)] - pub relaychain_args: Vec, -} - -#[derive(Debug)] -pub struct RelayChainCli { - /// The actual relay chain cli object. - pub base: polkadot_cli::RunCmd, - - /// Optional chain id that should be passed to the relay chain. - pub chain_id: Option, - - /// The base path that should be used by the relay chain. - pub base_path: Option, -} - -impl RelayChainCli { - /// Parse the relay chain CLI parameters using the para chain `Configuration`. - pub fn new<'a>( - para_config: &sc_service::Configuration, - relay_chain_args: impl Iterator, - ) -> Self { - let extension = crate::chain_spec::Extensions::try_get(&*para_config.chain_spec); - let chain_id = extension.map(|e| e.relay_chain.clone()); - let base_path = para_config.base_path.path().join("polkadot"); - Self { - base_path: Some(base_path), - chain_id, - base: clap::Parser::parse_from(relay_chain_args), - } - } -} diff --git a/cumulus/polkadot-parachain/src/command.rs b/cumulus/polkadot-parachain/src/command.rs deleted file mode 100644 index 041187de488f33c2c0fe65e4464d165a46c0333e..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/command.rs +++ /dev/null @@ -1,1080 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -use crate::{ - chain_spec, - chain_spec::GenericChainSpec, - cli::{Cli, RelayChainCli, Subcommand}, - fake_runtime_api::{ - asset_hub_polkadot_aura::RuntimeApi as AssetHubPolkadotRuntimeApi, aura::RuntimeApi, - }, - service::{new_partial, Block, Hash}, -}; -use cumulus_client_service::storage_proof_size::HostFunctions as ReclaimHostFunctions; -use cumulus_primitives_core::ParaId; -use frame_benchmarking_cli::{BenchmarkCmd, SUBSTRATE_REFERENCE_HARDWARE}; -use log::info; -use parachains_common::{AssetHubPolkadotAuraId, AuraId}; -use sc_cli::{ - ChainSpec, CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams, - NetworkParams, Result, SharedParams, SubstrateCli, -}; -use sc_service::config::{BasePath, PrometheusConfig}; -use sp_runtime::traits::AccountIdConversion; -use std::{net::SocketAddr, path::PathBuf}; - -/// Helper enum that is used for better distinction of different parachain/runtime configuration -/// (it is based/calculated on ChainSpec's ID attribute) -#[derive(Debug, PartialEq, Default)] -enum Runtime { - /// This is the default runtime (actually based on rococo) - #[default] - Default, - Shell, - Seedling, - AssetHubPolkadot, - AssetHubKusama, - AssetHubRococo, - AssetHubWestend, - Penpal(ParaId), - ContractsRococo, - CollectivesPolkadot, - CollectivesWestend, - Glutton, - GluttonWestend, - BridgeHub(chain_spec::bridge_hubs::BridgeHubRuntimeType), - Coretime(chain_spec::coretime::CoretimeRuntimeType), - People(chain_spec::people::PeopleRuntimeType), -} - -trait RuntimeResolver { - fn runtime(&self) -> Result; -} - -impl RuntimeResolver for dyn ChainSpec { - fn runtime(&self) -> Result { - Ok(runtime(self.id())) - } -} - -/// Implementation, that can resolve [`Runtime`] from any json configuration file -impl RuntimeResolver for PathBuf { - fn runtime(&self) -> Result { - #[derive(Debug, serde::Deserialize)] - struct EmptyChainSpecWithId { - id: String, - } - - let file = std::fs::File::open(self)?; - let reader = std::io::BufReader::new(file); - let chain_spec: EmptyChainSpecWithId = - serde_json::from_reader(reader).map_err(|e| sc_cli::Error::Application(Box::new(e)))?; - - Ok(runtime(&chain_spec.id)) - } -} - -fn runtime(id: &str) -> Runtime { - let id = id.replace('_', "-"); - let (_, id, para_id) = extract_parachain_id(&id); - - if id.starts_with("shell") { - Runtime::Shell - } else if id.starts_with("seedling") { - Runtime::Seedling - } else if id.starts_with("asset-hub-polkadot") | id.starts_with("statemint") { - Runtime::AssetHubPolkadot - } else if id.starts_with("asset-hub-kusama") | id.starts_with("statemine") { - Runtime::AssetHubKusama - } else if id.starts_with("asset-hub-rococo") { - Runtime::AssetHubRococo - } else if id.starts_with("asset-hub-westend") | id.starts_with("westmint") { - Runtime::AssetHubWestend - } else if id.starts_with("penpal") { - Runtime::Penpal(para_id.unwrap_or(ParaId::new(0))) - } else if id.starts_with("contracts-rococo") { - Runtime::ContractsRococo - } else if id.starts_with("collectives-polkadot") { - Runtime::CollectivesPolkadot - } else if id.starts_with("collectives-westend") { - Runtime::CollectivesWestend - } else if id.starts_with(chain_spec::bridge_hubs::BridgeHubRuntimeType::ID_PREFIX) { - Runtime::BridgeHub( - id.parse::() - .expect("Invalid value"), - ) - } else if id.starts_with(chain_spec::coretime::CoretimeRuntimeType::ID_PREFIX) { - Runtime::Coretime( - id.parse::().expect("Invalid value"), - ) - } else if id.starts_with("glutton-westend") { - Runtime::GluttonWestend - } else if id.starts_with("glutton") { - Runtime::Glutton - } else if id.starts_with(chain_spec::people::PeopleRuntimeType::ID_PREFIX) { - Runtime::People(id.parse::().expect("Invalid value")) - } else { - log::warn!("No specific runtime was recognized for ChainSpec's id: '{}', so Runtime::default() will be used", id); - Runtime::default() - } -} - -fn load_spec(id: &str) -> std::result::Result, String> { - let (id, _, para_id) = extract_parachain_id(id); - Ok(match id { - // - Default-like - "staging" => - Box::new(chain_spec::rococo_parachain::staging_rococo_parachain_local_config()), - "tick" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/tick.json")[..], - )?), - "trick" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/trick.json")[..], - )?), - "track" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/track.json")[..], - )?), - - // -- Starters - "shell" => Box::new(chain_spec::shell::get_shell_chain_spec()), - "seedling" => Box::new(chain_spec::seedling::get_seedling_chain_spec()), - - // -- Asset Hub Polkadot - "asset-hub-polkadot" | "statemint" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/asset-hub-polkadot.json")[..], - )?), - - // -- Asset Hub Kusama - "asset-hub-kusama" | "statemine" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/asset-hub-kusama.json")[..], - )?), - - // -- Asset Hub Rococo - "asset-hub-rococo-dev" => - Box::new(chain_spec::asset_hubs::asset_hub_rococo_development_config()), - "asset-hub-rococo-local" => - Box::new(chain_spec::asset_hubs::asset_hub_rococo_local_config()), - // the chain spec as used for generating the upgrade genesis values - "asset-hub-rococo-genesis" => - Box::new(chain_spec::asset_hubs::asset_hub_rococo_genesis_config()), - "asset-hub-rococo" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/asset-hub-rococo.json")[..], - )?), - - // -- Asset Hub Westend - "asset-hub-westend-dev" | "westmint-dev" => - Box::new(chain_spec::asset_hubs::asset_hub_westend_development_config()), - "asset-hub-westend-local" | "westmint-local" => - Box::new(chain_spec::asset_hubs::asset_hub_westend_local_config()), - // the chain spec as used for generating the upgrade genesis values - "asset-hub-westend-genesis" | "westmint-genesis" => - Box::new(chain_spec::asset_hubs::asset_hub_westend_config()), - // the shell-based chain spec as used for syncing - "asset-hub-westend" | "westmint" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/asset-hub-westend.json")[..], - )?), - - // -- Polkadot Collectives - "collectives-polkadot" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/collectives-polkadot.json")[..], - )?), - - // -- Westend Collectives - "collectives-westend-dev" => - Box::new(chain_spec::collectives::collectives_westend_development_config()), - "collectives-westend-local" => - Box::new(chain_spec::collectives::collectives_westend_local_config()), - "collectives-westend" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/collectives-westend.json")[..], - )?), - - // -- Contracts on Rococo - "contracts-rococo-dev" => - Box::new(chain_spec::contracts::contracts_rococo_development_config()), - "contracts-rococo-local" => - Box::new(chain_spec::contracts::contracts_rococo_local_config()), - "contracts-rococo-genesis" => Box::new(chain_spec::contracts::contracts_rococo_config()), - "contracts-rococo" => Box::new(GenericChainSpec::from_json_bytes( - &include_bytes!("../chain-specs/contracts-rococo.json")[..], - )?), - - // -- BridgeHub - bridge_like_id - if bridge_like_id - .starts_with(chain_spec::bridge_hubs::BridgeHubRuntimeType::ID_PREFIX) => - bridge_like_id - .parse::() - .expect("invalid value") - .load_config()?, - - // -- Coretime - coretime_like_id - if coretime_like_id - .starts_with(chain_spec::coretime::CoretimeRuntimeType::ID_PREFIX) => - coretime_like_id - .parse::() - .expect("invalid value") - .load_config()?, - - // -- Penpal - "penpal-rococo" => Box::new(chain_spec::penpal::get_penpal_chain_spec( - para_id.expect("Must specify parachain id"), - "rococo-local", - )), - "penpal-westend" => Box::new(chain_spec::penpal::get_penpal_chain_spec( - para_id.expect("Must specify parachain id"), - "westend-local", - )), - - // -- Glutton Westend - "glutton-westend-dev" => Box::new(chain_spec::glutton::glutton_westend_development_config( - para_id.expect("Must specify parachain id"), - )), - "glutton-westend-local" => Box::new(chain_spec::glutton::glutton_westend_local_config( - para_id.expect("Must specify parachain id"), - )), - // the chain spec as used for generating the upgrade genesis values - "glutton-westend-genesis" => Box::new(chain_spec::glutton::glutton_westend_config( - para_id.expect("Must specify parachain id"), - )), - - // -- People - people_like_id - if people_like_id.starts_with(chain_spec::people::PeopleRuntimeType::ID_PREFIX) => - people_like_id - .parse::() - .expect("invalid value") - .load_config()?, - - // -- Fallback (generic chainspec) - "" => { - log::warn!("No ChainSpec.id specified, so using default one, based on rococo-parachain runtime"); - Box::new(chain_spec::rococo_parachain::rococo_parachain_local_config()) - }, - - // -- Loading a specific spec from disk - path => Box::new(GenericChainSpec::from_json_file(path.into())?), - }) -} - -/// Extracts the normalized chain id and parachain id from the input chain id. -/// (H/T to Phala for the idea) -/// E.g. "penpal-kusama-2004" yields ("penpal-kusama", Some(2004)) -fn extract_parachain_id(id: &str) -> (&str, &str, Option) { - const ROCOCO_TEST_PARA_PREFIX: &str = "penpal-rococo-"; - const KUSAMA_TEST_PARA_PREFIX: &str = "penpal-kusama-"; - const POLKADOT_TEST_PARA_PREFIX: &str = "penpal-polkadot-"; - - const GLUTTON_PARA_DEV_PREFIX: &str = "glutton-kusama-dev-"; - const GLUTTON_PARA_LOCAL_PREFIX: &str = "glutton-kusama-local-"; - const GLUTTON_PARA_GENESIS_PREFIX: &str = "glutton-kusama-genesis-"; - - const GLUTTON_WESTEND_PARA_DEV_PREFIX: &str = "glutton-westend-dev-"; - const GLUTTON_WESTEND_PARA_LOCAL_PREFIX: &str = "glutton-westend-local-"; - const GLUTTON_WESTEND_PARA_GENESIS_PREFIX: &str = "glutton-westend-genesis-"; - - let (norm_id, orig_id, para) = if let Some(suffix) = id.strip_prefix(ROCOCO_TEST_PARA_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..ROCOCO_TEST_PARA_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(KUSAMA_TEST_PARA_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..KUSAMA_TEST_PARA_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(POLKADOT_TEST_PARA_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..POLKADOT_TEST_PARA_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_PARA_DEV_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_PARA_DEV_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_PARA_LOCAL_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_PARA_LOCAL_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_PARA_GENESIS_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_PARA_GENESIS_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_WESTEND_PARA_DEV_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_WESTEND_PARA_DEV_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_WESTEND_PARA_LOCAL_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_WESTEND_PARA_LOCAL_PREFIX.len() - 1], id, Some(para_id)) - } else if let Some(suffix) = id.strip_prefix(GLUTTON_WESTEND_PARA_GENESIS_PREFIX) { - let para_id: u32 = suffix.parse().expect("Invalid parachain-id suffix"); - (&id[..GLUTTON_WESTEND_PARA_GENESIS_PREFIX.len() - 1], id, Some(para_id)) - } else { - (id, id, None) - }; - - (norm_id, orig_id, para.map(Into::into)) -} - -impl SubstrateCli for Cli { - fn impl_name() -> String { - "Polkadot parachain".into() - } - - fn impl_version() -> String { - env!("SUBSTRATE_CLI_IMPL_VERSION").into() - } - - fn description() -> String { - format!( - "Polkadot parachain\n\nThe command-line arguments provided first will be \ - passed to the parachain node, while the arguments provided after -- will be passed \ - to the relaychain node.\n\n\ - {} [parachain-args] -- [relaychain-args]", - Self::executable_name() - ) - } - - fn author() -> String { - env!("CARGO_PKG_AUTHORS").into() - } - - fn support_url() -> String { - "https://github.com/paritytech/polkadot-sdk/issues/new".into() - } - - fn copyright_start_year() -> i32 { - 2017 - } - - fn load_spec(&self, id: &str) -> std::result::Result, String> { - load_spec(id) - } -} - -impl SubstrateCli for RelayChainCli { - fn impl_name() -> String { - "Polkadot parachain".into() - } - - fn impl_version() -> String { - env!("SUBSTRATE_CLI_IMPL_VERSION").into() - } - - fn description() -> String { - format!( - "Polkadot parachain\n\nThe command-line arguments provided first will be \ - passed to the parachain node, while the arguments provided after -- will be passed \ - to the relay chain node.\n\n\ - {} [parachain-args] -- [relay_chain-args]", - Self::executable_name() - ) - } - - fn author() -> String { - env!("CARGO_PKG_AUTHORS").into() - } - - fn support_url() -> String { - "https://github.com/paritytech/polkadot-sdk/issues/new".into() - } - - fn copyright_start_year() -> i32 { - 2017 - } - - fn load_spec(&self, id: &str) -> std::result::Result, String> { - polkadot_cli::Cli::from_iter([RelayChainCli::executable_name()].iter()).load_spec(id) - } -} - -/// Creates partial components for the runtimes that are supported by the benchmarks. -macro_rules! construct_partials { - ($config:expr, |$partials:ident| $code:expr) => { - match $config.chain_spec.runtime()? { - Runtime::AssetHubPolkadot => { - let $partials = new_partial::( - &$config, - crate::service::build_relay_to_aura_import_queue::<_, AssetHubPolkadotAuraId>, - )?; - $code - }, - Runtime::AssetHubKusama | - Runtime::AssetHubRococo | - Runtime::AssetHubWestend | - Runtime::BridgeHub(_) | - Runtime::CollectivesPolkadot | - Runtime::CollectivesWestend | - Runtime::Coretime(_) | - Runtime::People(_) => { - let $partials = new_partial::( - &$config, - crate::service::build_relay_to_aura_import_queue::<_, AuraId>, - )?; - $code - }, - Runtime::GluttonWestend | Runtime::Glutton | Runtime::Shell | Runtime::Seedling => { - let $partials = new_partial::( - &$config, - crate::service::build_shell_import_queue, - )?; - $code - }, - Runtime::ContractsRococo | Runtime::Penpal(_) | Runtime::Default => { - let $partials = new_partial::( - &$config, - crate::service::build_aura_import_queue, - )?; - $code - }, - } - }; -} - -macro_rules! construct_async_run { - (|$components:ident, $cli:ident, $cmd:ident, $config:ident| $( $code:tt )* ) => {{ - let runner = $cli.create_runner($cmd)?; - match runner.config().chain_spec.runtime()? { - Runtime::AssetHubPolkadot => { - runner.async_run(|$config| { - let $components = new_partial::( - &$config, - crate::service::build_relay_to_aura_import_queue::<_, AssetHubPolkadotAuraId>, - )?; - let task_manager = $components.task_manager; - { $( $code )* }.map(|v| (v, task_manager)) - }) - }, - Runtime::AssetHubKusama | - Runtime::AssetHubRococo | - Runtime::AssetHubWestend | - Runtime::BridgeHub(_) | - Runtime::CollectivesPolkadot | - Runtime::CollectivesWestend | - Runtime::Coretime(_) | - Runtime::People(_) => { - runner.async_run(|$config| { - let $components = new_partial::( - &$config, - crate::service::build_relay_to_aura_import_queue::<_, AuraId>, - )?; - let task_manager = $components.task_manager; - { $( $code )* }.map(|v| (v, task_manager)) - }) - }, - Runtime::Shell | - Runtime::Seedling | - Runtime::GluttonWestend | - Runtime::Glutton => { - runner.async_run(|$config| { - let $components = new_partial::( - &$config, - crate::service::build_shell_import_queue, - )?; - let task_manager = $components.task_manager; - { $( $code )* }.map(|v| (v, task_manager)) - }) - } - Runtime::ContractsRococo | Runtime::Penpal(_) | Runtime::Default => { - runner.async_run(|$config| { - let $components = new_partial::< - RuntimeApi, - _, - >( - &$config, - crate::service::build_aura_import_queue, - )?; - let task_manager = $components.task_manager; - { $( $code )* }.map(|v| (v, task_manager)) - }) - }, - } - }} -} - -/// Parse command line arguments into service configuration. -pub fn run() -> Result<()> { - let cli = Cli::from_args(); - - match &cli.subcommand { - Some(Subcommand::BuildSpec(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.sync_run(|config| cmd.run(config.chain_spec, config.network)) - }, - Some(Subcommand::CheckBlock(cmd)) => { - construct_async_run!(|components, cli, cmd, config| { - Ok(cmd.run(components.client, components.import_queue)) - }) - }, - Some(Subcommand::ExportBlocks(cmd)) => { - construct_async_run!(|components, cli, cmd, config| { - Ok(cmd.run(components.client, config.database)) - }) - }, - Some(Subcommand::ExportState(cmd)) => { - construct_async_run!(|components, cli, cmd, config| { - Ok(cmd.run(components.client, config.chain_spec)) - }) - }, - Some(Subcommand::ImportBlocks(cmd)) => { - construct_async_run!(|components, cli, cmd, config| { - Ok(cmd.run(components.client, components.import_queue)) - }) - }, - Some(Subcommand::Revert(cmd)) => construct_async_run!(|components, cli, cmd, config| { - Ok(cmd.run(components.client, components.backend, None)) - }), - Some(Subcommand::PurgeChain(cmd)) => { - let runner = cli.create_runner(cmd)?; - - runner.sync_run(|config| { - let polkadot_cli = RelayChainCli::new( - &config, - [RelayChainCli::executable_name()].iter().chain(cli.relaychain_args.iter()), - ); - - let polkadot_config = SubstrateCli::create_configuration( - &polkadot_cli, - &polkadot_cli, - config.tokio_handle.clone(), - ) - .map_err(|err| format!("Relay chain argument error: {}", err))?; - - cmd.run(config, polkadot_config) - }) - }, - Some(Subcommand::ExportGenesisHead(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner - .sync_run(|config| construct_partials!(config, |partials| cmd.run(partials.client))) - }, - Some(Subcommand::ExportGenesisWasm(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.sync_run(|_config| { - let spec = cli.load_spec(&cmd.shared_params.chain.clone().unwrap_or_default())?; - cmd.run(&*spec) - }) - }, - Some(Subcommand::Benchmark(cmd)) => { - let runner = cli.create_runner(cmd)?; - - // Switch on the concrete benchmark sub-command- - match cmd { - BenchmarkCmd::Pallet(cmd) => - if cfg!(feature = "runtime-benchmarks") { - runner.sync_run(|config| cmd.run_with_spec::, ReclaimHostFunctions>(Some(config.chain_spec))) - } else { - Err("Benchmarking wasn't enabled when building the node. \ - You can enable it with `--features runtime-benchmarks`." - .into()) - }, - BenchmarkCmd::Block(cmd) => runner.sync_run(|config| { - construct_partials!(config, |partials| cmd.run(partials.client)) - }), - #[cfg(not(feature = "runtime-benchmarks"))] - BenchmarkCmd::Storage(_) => - return Err(sc_cli::Error::Input( - "Compile with --features=runtime-benchmarks \ - to enable storage benchmarks." - .into(), - ) - .into()), - #[cfg(feature = "runtime-benchmarks")] - BenchmarkCmd::Storage(cmd) => runner.sync_run(|config| { - construct_partials!(config, |partials| { - let db = partials.backend.expose_db(); - let storage = partials.backend.expose_storage(); - - cmd.run(config, partials.client.clone(), db, storage) - }) - }), - BenchmarkCmd::Machine(cmd) => - runner.sync_run(|config| cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone())), - // NOTE: this allows the Client to leniently implement - // new benchmark commands without requiring a companion MR. - #[allow(unreachable_patterns)] - _ => Err("Benchmarking sub-command unsupported".into()), - } - }, - Some(Subcommand::Key(cmd)) => Ok(cmd.run(&cli)?), - None => { - let runner = cli.create_runner(&cli.run.normalize())?; - let collator_options = cli.run.collator_options(); - - runner.run_node_until_exit(|config| async move { - // If Statemint (Statemine, Westmint, Rockmine) DB exists and we're using the - // asset-hub chain spec, then rename the base path to the new chain ID. In the case - // that both file paths exist, the node will exit, as the user must decide (by - // deleting one path) the information that they want to use as their DB. - let old_name = match config.chain_spec.id() { - "asset-hub-polkadot" => Some("statemint"), - "asset-hub-kusama" => Some("statemine"), - "asset-hub-westend" => Some("westmint"), - "asset-hub-rococo" => Some("rockmine"), - _ => None, - }; - - if let Some(old_name) = old_name { - let new_path = config.base_path.config_dir(config.chain_spec.id()); - let old_path = config.base_path.config_dir(old_name); - - if old_path.exists() && new_path.exists() { - return Err(format!( - "Found legacy {} path {} and new asset-hub path {}. Delete one path such that only one exists.", - old_name, old_path.display(), new_path.display() - ).into()) - } - - if old_path.exists() { - std::fs::rename(old_path.clone(), new_path.clone())?; - info!( - "Statemint renamed to Asset Hub. The filepath with associated data on disk has been renamed from {} to {}.", - old_path.display(), new_path.display() - ); - } - } - - let hwbench = (!cli.no_hardware_benchmarks).then_some( - config.database.path().map(|database_path| { - let _ = std::fs::create_dir_all(database_path); - sc_sysinfo::gather_hwbench(Some(database_path)) - })).flatten(); - - let para_id = chain_spec::Extensions::try_get(&*config.chain_spec) - .map(|e| e.para_id) - .ok_or("Could not find parachain extension in chain-spec.")?; - - let polkadot_cli = RelayChainCli::new( - &config, - [RelayChainCli::executable_name()].iter().chain(cli.relaychain_args.iter()), - ); - - let id = ParaId::from(para_id); - - let parachain_account = - AccountIdConversion::::into_account_truncating(&id); - - let tokio_handle = config.tokio_handle.clone(); - let polkadot_config = - SubstrateCli::create_configuration(&polkadot_cli, &polkadot_cli, tokio_handle) - .map_err(|err| format!("Relay chain argument error: {}", err))?; - - info!("Parachain id: {:?}", id); - info!("Parachain Account: {}", parachain_account); - info!("Is collating: {}", if config.role.is_authority() { "yes" } else { "no" }); - - match polkadot_config.network.network_backend { - sc_network::config::NetworkBackendType::Libp2p => - start_node::>( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await, - sc_network::config::NetworkBackendType::Litep2p => - start_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await, - } - }) - }, - } -} - -async fn start_node>( - config: sc_service::Configuration, - polkadot_config: sc_service::Configuration, - collator_options: cumulus_client_cli::CollatorOptions, - id: ParaId, - hwbench: Option, -) -> Result { - match config.chain_spec.runtime()? { - Runtime::AssetHubPolkadot => crate::service::start_asset_hub_lookahead_node::< - AssetHubPolkadotRuntimeApi, - AssetHubPolkadotAuraId, - Network, - >(config, polkadot_config, collator_options, id, hwbench) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::AssetHubRococo | Runtime::AssetHubWestend | Runtime::AssetHubKusama => - crate::service::start_asset_hub_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::CollectivesWestend | Runtime::CollectivesPolkadot => - crate::service::start_generic_aura_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::Seedling | Runtime::Shell => crate::service::start_shell_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::ContractsRococo => crate::service::start_contracts_rococo_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::BridgeHub(bridge_hub_runtime_type) => match bridge_hub_runtime_type { - chain_spec::bridge_hubs::BridgeHubRuntimeType::Polkadot | - chain_spec::bridge_hubs::BridgeHubRuntimeType::PolkadotLocal | - chain_spec::bridge_hubs::BridgeHubRuntimeType::Kusama | - chain_spec::bridge_hubs::BridgeHubRuntimeType::KusamaLocal | - chain_spec::bridge_hubs::BridgeHubRuntimeType::Westend | - chain_spec::bridge_hubs::BridgeHubRuntimeType::WestendLocal | - chain_spec::bridge_hubs::BridgeHubRuntimeType::WestendDevelopment | - chain_spec::bridge_hubs::BridgeHubRuntimeType::Rococo | - chain_spec::bridge_hubs::BridgeHubRuntimeType::RococoLocal | - chain_spec::bridge_hubs::BridgeHubRuntimeType::RococoDevelopment => - crate::service::start_generic_aura_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0), - } - .map_err(Into::into), - - Runtime::Coretime(coretime_runtime_type) => match coretime_runtime_type { - chain_spec::coretime::CoretimeRuntimeType::Kusama | - chain_spec::coretime::CoretimeRuntimeType::KusamaLocal | - chain_spec::coretime::CoretimeRuntimeType::Polkadot | - chain_spec::coretime::CoretimeRuntimeType::PolkadotLocal | - chain_spec::coretime::CoretimeRuntimeType::Rococo | - chain_spec::coretime::CoretimeRuntimeType::RococoLocal | - chain_spec::coretime::CoretimeRuntimeType::RococoDevelopment | - chain_spec::coretime::CoretimeRuntimeType::Westend | - chain_spec::coretime::CoretimeRuntimeType::WestendLocal | - chain_spec::coretime::CoretimeRuntimeType::WestendDevelopment => - crate::service::start_generic_aura_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0), - } - .map_err(Into::into), - - Runtime::Penpal(_) | Runtime::Default => - crate::service::start_rococo_parachain_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::Glutton | Runtime::GluttonWestend => - crate::service::start_basic_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0) - .map_err(Into::into), - - Runtime::People(people_runtime_type) => match people_runtime_type { - chain_spec::people::PeopleRuntimeType::Kusama | - chain_spec::people::PeopleRuntimeType::KusamaLocal | - chain_spec::people::PeopleRuntimeType::Polkadot | - chain_spec::people::PeopleRuntimeType::PolkadotLocal | - chain_spec::people::PeopleRuntimeType::Rococo | - chain_spec::people::PeopleRuntimeType::RococoLocal | - chain_spec::people::PeopleRuntimeType::RococoDevelopment | - chain_spec::people::PeopleRuntimeType::Westend | - chain_spec::people::PeopleRuntimeType::WestendLocal | - chain_spec::people::PeopleRuntimeType::WestendDevelopment => - crate::service::start_generic_aura_lookahead_node::( - config, - polkadot_config, - collator_options, - id, - hwbench, - ) - .await - .map(|r| r.0), - } - .map_err(Into::into), - } -} - -impl DefaultConfigurationValues for RelayChainCli { - fn p2p_listen_port() -> u16 { - 30334 - } - - fn rpc_listen_port() -> u16 { - 9945 - } - - fn prometheus_listen_port() -> u16 { - 9616 - } -} - -impl CliConfiguration for RelayChainCli { - fn shared_params(&self) -> &SharedParams { - self.base.base.shared_params() - } - - fn import_params(&self) -> Option<&ImportParams> { - self.base.base.import_params() - } - - fn network_params(&self) -> Option<&NetworkParams> { - self.base.base.network_params() - } - - fn keystore_params(&self) -> Option<&KeystoreParams> { - self.base.base.keystore_params() - } - - fn base_path(&self) -> Result> { - Ok(self - .shared_params() - .base_path()? - .or_else(|| self.base_path.clone().map(Into::into))) - } - - fn rpc_addr(&self, default_listen_port: u16) -> Result> { - self.base.base.rpc_addr(default_listen_port) - } - - fn prometheus_config( - &self, - default_listen_port: u16, - chain_spec: &Box, - ) -> Result> { - self.base.base.prometheus_config(default_listen_port, chain_spec) - } - - fn init( - &self, - _support_url: &String, - _impl_version: &String, - _logger_hook: F, - _config: &sc_service::Configuration, - ) -> Result<()> - where - F: FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration), - { - unreachable!("PolkadotCli is never initialized; qed"); - } - - fn chain_id(&self, is_dev: bool) -> Result { - let chain_id = self.base.base.chain_id(is_dev)?; - - Ok(if chain_id.is_empty() { self.chain_id.clone().unwrap_or_default() } else { chain_id }) - } - - fn role(&self, is_dev: bool) -> Result { - self.base.base.role(is_dev) - } - - fn transaction_pool(&self, is_dev: bool) -> Result { - self.base.base.transaction_pool(is_dev) - } - - fn trie_cache_maximum_size(&self) -> Result> { - self.base.base.trie_cache_maximum_size() - } - - fn rpc_methods(&self) -> Result { - self.base.base.rpc_methods() - } - - fn rpc_max_connections(&self) -> Result { - self.base.base.rpc_max_connections() - } - - fn rpc_cors(&self, is_dev: bool) -> Result>> { - self.base.base.rpc_cors(is_dev) - } - - fn default_heap_pages(&self) -> Result> { - self.base.base.default_heap_pages() - } - - fn force_authoring(&self) -> Result { - self.base.base.force_authoring() - } - - fn disable_grandpa(&self) -> Result { - self.base.base.disable_grandpa() - } - - fn max_runtime_instances(&self) -> Result> { - self.base.base.max_runtime_instances() - } - - fn announce_block(&self) -> Result { - self.base.base.announce_block() - } - - fn telemetry_endpoints( - &self, - chain_spec: &Box, - ) -> Result> { - self.base.base.telemetry_endpoints(chain_spec) - } - - fn node_name(&self) -> Result { - self.base.base.node_name() - } -} - -#[cfg(test)] -mod tests { - use crate::{ - chain_spec::{get_account_id_from_seed, get_from_seed}, - command::{Runtime, RuntimeResolver}, - }; - use sc_chain_spec::{ChainSpec, ChainSpecExtension, ChainSpecGroup, ChainType, Extension}; - use serde::{Deserialize, Serialize}; - use sp_core::sr25519; - use std::path::PathBuf; - use tempfile::TempDir; - - #[derive( - Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension, Default, - )] - #[serde(deny_unknown_fields)] - pub struct Extensions1 { - pub attribute1: String, - pub attribute2: u32, - } - - #[derive( - Debug, Clone, PartialEq, Serialize, Deserialize, ChainSpecGroup, ChainSpecExtension, Default, - )] - #[serde(deny_unknown_fields)] - pub struct Extensions2 { - pub attribute_x: String, - pub attribute_y: String, - pub attribute_z: u32, - } - - fn store_configuration(dir: &TempDir, spec: Box) -> PathBuf { - let raw_output = true; - let json = sc_service::chain_ops::build_spec(&*spec, raw_output) - .expect("Failed to build json string"); - let mut cfg_file_path = dir.path().to_path_buf(); - cfg_file_path.push(spec.id()); - cfg_file_path.set_extension("json"); - std::fs::write(&cfg_file_path, json).expect("Failed to write to json file"); - cfg_file_path - } - - pub type DummyChainSpec = sc_service::GenericChainSpec<(), E>; - - pub fn create_default_with_extensions( - id: &str, - extension: E, - ) -> DummyChainSpec { - DummyChainSpec::builder( - rococo_parachain_runtime::WASM_BINARY - .expect("WASM binary was not built, please build it!"), - extension, - ) - .with_name("Dummy local testnet") - .with_id(id) - .with_chain_type(ChainType::Local) - .with_genesis_config_patch(crate::chain_spec::rococo_parachain::testnet_genesis( - get_account_id_from_seed::("Alice"), - vec![ - get_from_seed::("Alice"), - get_from_seed::("Bob"), - ], - vec![get_account_id_from_seed::("Alice")], - 1000.into(), - )) - .build() - } - - #[test] - fn test_resolve_runtime_for_different_configuration_files() { - let temp_dir = tempfile::tempdir().expect("Failed to access tempdir"); - - let path = store_configuration( - &temp_dir, - Box::new(create_default_with_extensions("shell-1", Extensions1::default())), - ); - assert_eq!(Runtime::Shell, path.runtime().unwrap()); - - let path = store_configuration( - &temp_dir, - Box::new(create_default_with_extensions("shell-2", Extensions2::default())), - ); - assert_eq!(Runtime::Shell, path.runtime().unwrap()); - - let path = store_configuration( - &temp_dir, - Box::new(create_default_with_extensions("seedling", Extensions2::default())), - ); - assert_eq!(Runtime::Seedling, path.runtime().unwrap()); - - let path = store_configuration( - &temp_dir, - Box::new(crate::chain_spec::rococo_parachain::rococo_parachain_local_config()), - ); - assert_eq!(Runtime::Default, path.runtime().unwrap()); - - let path = store_configuration( - &temp_dir, - Box::new(crate::chain_spec::contracts::contracts_rococo_local_config()), - ); - assert_eq!(Runtime::ContractsRococo, path.runtime().unwrap()); - } -} diff --git a/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs b/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs deleted file mode 100644 index 82c02943c5fc9ee8337cca377ddf2271b454cdda..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/fake_runtime_api/asset_hub_polkadot_aura.rs +++ /dev/null @@ -1,204 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -//! These are used to provide a type that implements these runtime APIs without requiring to import -//! the native runtimes. - -use frame_support::weights::Weight; -use parachains_common::{AccountId, AssetHubPolkadotAuraId, Balance, Nonce}; -use polkadot_primitives::Block; -use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; -use sp_runtime::{ - traits::Block as BlockT, - transaction_validity::{TransactionSource, TransactionValidity}, - ApplyExtrinsicResult, -}; - -pub struct Runtime; - -sp_api::impl_runtime_apis! { - impl sp_api::Core for Runtime { - fn version() -> sp_version::RuntimeVersion { - unimplemented!() - } - - fn execute_block(_: Block) { - unimplemented!() - } - - fn initialize_block(_: &::Header) -> sp_runtime::ExtrinsicInclusionMode { - unimplemented!() - } - } - - impl sp_api::Metadata for Runtime { - fn metadata() -> OpaqueMetadata { - unimplemented!() - } - - fn metadata_at_version(_: u32) -> Option { - unimplemented!() - } - - fn metadata_versions() -> sp_std::vec::Vec { - unimplemented!() - } - } - - impl sp_consensus_aura::AuraApi for Runtime { - fn slot_duration() -> sp_consensus_aura::SlotDuration { - unimplemented!() - } - - fn authorities() -> Vec { - unimplemented!() - } - } - - impl cumulus_primitives_aura::AuraUnincludedSegmentApi for Runtime { - fn can_build_upon( - _: ::Hash, - _: cumulus_primitives_aura::Slot, - ) -> bool { - unimplemented!() - } - } - - impl sp_block_builder::BlockBuilder for Runtime { - fn apply_extrinsic(_: ::Extrinsic) -> ApplyExtrinsicResult { - unimplemented!() - } - - fn finalize_block() -> ::Header { - unimplemented!() - } - - fn inherent_extrinsics(_: sp_inherents::InherentData) -> Vec<::Extrinsic> { - unimplemented!() - } - - fn check_inherents(_: Block, _: sp_inherents::InherentData) -> sp_inherents::CheckInherentsResult { - unimplemented!() - } - } - - impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { - fn validate_transaction( - _: TransactionSource, - _: ::Extrinsic, - _: ::Hash, - ) -> TransactionValidity { - unimplemented!() - } - } - - impl sp_offchain::OffchainWorkerApi for Runtime { - fn offchain_worker(_: &::Header) { - unimplemented!() - } - } - - impl sp_session::SessionKeys for Runtime { - fn generate_session_keys(_: Option>) -> Vec { - unimplemented!() - } - - fn decode_session_keys( - _: Vec, - ) -> Option, KeyTypeId)>> { - unimplemented!() - } - } - - impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi for Runtime { - fn query_info( - _: ::Extrinsic, - _: u32, - ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo { - unimplemented!() - } - fn query_fee_details( - _: ::Extrinsic, - _: u32, - ) -> pallet_transaction_payment::FeeDetails { - unimplemented!() - } - fn query_weight_to_fee(_: Weight) -> Balance { - unimplemented!() - } - fn query_length_to_fee(_: u32) -> Balance { - unimplemented!() - } - } - - impl cumulus_primitives_core::CollectCollationInfo for Runtime { - fn collect_collation_info(_: &::Header) -> cumulus_primitives_core::CollationInfo { - unimplemented!() - } - } - - #[cfg(feature = "try-runtime")] - impl frame_try_runtime::TryRuntime for Runtime { - fn on_runtime_upgrade(_: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) { - unimplemented!() - } - - fn execute_block( - _: Block, - _: bool, - _: bool, - _: frame_try_runtime::TryStateSelect, - ) -> Weight { - unimplemented!() - } - } - - impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { - fn account_nonce(_: AccountId) -> Nonce { - unimplemented!() - } - } - - #[cfg(feature = "runtime-benchmarks")] - impl frame_benchmarking::Benchmark for Runtime { - fn benchmark_metadata(_: bool) -> ( - Vec, - Vec, - ) { - unimplemented!() - } - - fn dispatch_benchmark( - _: frame_benchmarking::BenchmarkConfig - ) -> Result, sp_runtime::RuntimeString> { - unimplemented!() - } - } - - impl sp_genesis_builder::GenesisBuilder for Runtime { - fn build_state(_: Vec) -> sp_genesis_builder::Result { - unimplemented!() - } - - fn get_preset(_id: &Option) -> Option> { - unimplemented!() - } - - fn preset_names() -> Vec { - unimplemented!() - } - } -} diff --git a/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs b/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs deleted file mode 100644 index 6b718e9121642e37640ad09ee9364974a3d0aa38..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/fake_runtime_api/aura.rs +++ /dev/null @@ -1,204 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -//! These are used to provide a type that implements these runtime APIs without requiring to import -//! the native runtimes. - -use frame_support::weights::Weight; -use parachains_common::{AccountId, AuraId, Balance, Nonce}; -use polkadot_primitives::Block; -use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; -use sp_runtime::{ - traits::Block as BlockT, - transaction_validity::{TransactionSource, TransactionValidity}, - ApplyExtrinsicResult, -}; - -pub struct Runtime; - -sp_api::impl_runtime_apis! { - impl sp_api::Core for Runtime { - fn version() -> sp_version::RuntimeVersion { - unimplemented!() - } - - fn execute_block(_: Block) { - unimplemented!() - } - - fn initialize_block(_: &::Header) -> sp_runtime::ExtrinsicInclusionMode { - unimplemented!() - } - } - - impl sp_api::Metadata for Runtime { - fn metadata() -> OpaqueMetadata { - unimplemented!() - } - - fn metadata_at_version(_: u32) -> Option { - unimplemented!() - } - - fn metadata_versions() -> sp_std::vec::Vec { - unimplemented!() - } - } - - impl sp_consensus_aura::AuraApi for Runtime { - fn slot_duration() -> sp_consensus_aura::SlotDuration { - unimplemented!() - } - - fn authorities() -> Vec { - unimplemented!() - } - } - - impl cumulus_primitives_aura::AuraUnincludedSegmentApi for Runtime { - fn can_build_upon( - _: ::Hash, - _: cumulus_primitives_aura::Slot, - ) -> bool { - unimplemented!() - } - } - - impl sp_block_builder::BlockBuilder for Runtime { - fn apply_extrinsic(_: ::Extrinsic) -> ApplyExtrinsicResult { - unimplemented!() - } - - fn finalize_block() -> ::Header { - unimplemented!() - } - - fn inherent_extrinsics(_: sp_inherents::InherentData) -> Vec<::Extrinsic> { - unimplemented!() - } - - fn check_inherents(_: Block, _: sp_inherents::InherentData) -> sp_inherents::CheckInherentsResult { - unimplemented!() - } - } - - impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { - fn validate_transaction( - _: TransactionSource, - _: ::Extrinsic, - _: ::Hash, - ) -> TransactionValidity { - unimplemented!() - } - } - - impl sp_offchain::OffchainWorkerApi for Runtime { - fn offchain_worker(_: &::Header) { - unimplemented!() - } - } - - impl sp_session::SessionKeys for Runtime { - fn generate_session_keys(_: Option>) -> Vec { - unimplemented!() - } - - fn decode_session_keys( - _: Vec, - ) -> Option, KeyTypeId)>> { - unimplemented!() - } - } - - impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi for Runtime { - fn query_info( - _: ::Extrinsic, - _: u32, - ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo { - unimplemented!() - } - fn query_fee_details( - _: ::Extrinsic, - _: u32, - ) -> pallet_transaction_payment::FeeDetails { - unimplemented!() - } - fn query_weight_to_fee(_: Weight) -> Balance { - unimplemented!() - } - fn query_length_to_fee(_: u32) -> Balance { - unimplemented!() - } - } - - impl cumulus_primitives_core::CollectCollationInfo for Runtime { - fn collect_collation_info(_: &::Header) -> cumulus_primitives_core::CollationInfo { - unimplemented!() - } - } - - #[cfg(feature = "try-runtime")] - impl frame_try_runtime::TryRuntime for Runtime { - fn on_runtime_upgrade(_: frame_try_runtime::UpgradeCheckSelect) -> (Weight, Weight) { - unimplemented!() - } - - fn execute_block( - _: Block, - _: bool, - _: bool, - _: frame_try_runtime::TryStateSelect, - ) -> Weight { - unimplemented!() - } - } - - impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { - fn account_nonce(_: AccountId) -> Nonce { - unimplemented!() - } - } - - #[cfg(feature = "runtime-benchmarks")] - impl frame_benchmarking::Benchmark for Runtime { - fn benchmark_metadata(_: bool) -> ( - Vec, - Vec, - ) { - unimplemented!() - } - - fn dispatch_benchmark( - _: frame_benchmarking::BenchmarkConfig - ) -> Result, sp_runtime::RuntimeString> { - unimplemented!() - } - } - - impl sp_genesis_builder::GenesisBuilder for Runtime { - fn build_state(_: Vec) -> sp_genesis_builder::Result { - unimplemented!() - } - - fn get_preset(_id: &Option) -> Option> { - unimplemented!() - } - - fn preset_names() -> Vec { - unimplemented!() - } - } -} diff --git a/cumulus/polkadot-parachain/src/main.rs b/cumulus/polkadot-parachain/src/main.rs index 0757bea84aae83b64ec24982874c28f095057e75..f2dce552c51a1b5ed95e31f516f25cf978adc67e 100644 --- a/cumulus/polkadot-parachain/src/main.rs +++ b/cumulus/polkadot-parachain/src/main.rs @@ -14,18 +14,41 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -//! Cumulus test parachain collator +//! Polkadot parachain node. #![warn(missing_docs)] #![warn(unused_extern_crates)] mod chain_spec; -mod cli; -mod command; -mod fake_runtime_api; -mod rpc; -mod service; - -fn main() -> sc_cli::Result<()> { - command::run() + +use polkadot_parachain_lib::{run, CliConfig as CliConfigT, RunConfig}; + +struct CliConfig; + +impl CliConfigT for CliConfig { + fn impl_version() -> String { + env!("SUBSTRATE_CLI_IMPL_VERSION").into() + } + + fn author() -> String { + env!("CARGO_PKG_AUTHORS").into() + } + + fn support_url() -> String { + "https://github.com/paritytech/polkadot-sdk/issues/new".into() + } + + fn copyright_start_year() -> u16 { + 2017 + } +} + +fn main() -> color_eyre::eyre::Result<()> { + color_eyre::install()?; + + let config = RunConfig { + chain_spec_loader: Box::new(chain_spec::ChainSpecLoader), + runtime_resolver: Box::new(chain_spec::RuntimeResolver), + }; + Ok(run::(config)?) } diff --git a/cumulus/polkadot-parachain/src/rpc.rs b/cumulus/polkadot-parachain/src/rpc.rs deleted file mode 100644 index caee14e555220fc0e704b5edbe93a5ad76762eff..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/rpc.rs +++ /dev/null @@ -1,108 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -//! Parachain-specific RPCs implementation. - -#![warn(missing_docs)] - -use std::sync::Arc; - -use parachains_common::{AccountId, Balance, Block, Nonce}; -use sc_client_api::AuxStore; -pub use sc_rpc::DenyUnsafe; -use sc_transaction_pool_api::TransactionPool; -use sp_api::ProvideRuntimeApi; -use sp_block_builder::BlockBuilder; -use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; - -/// A type representing all RPC extensions. -pub type RpcExtension = jsonrpsee::RpcModule<()>; - -/// Full client dependencies -pub struct FullDeps { - /// The client instance to use. - pub client: Arc, - /// Transaction pool instance. - pub pool: Arc

, - /// Whether to deny unsafe calls - pub deny_unsafe: DenyUnsafe, -} - -/// Instantiate all RPC extensions. -pub fn create_full( - deps: FullDeps, - backend: Arc, -) -> Result> -where - C: ProvideRuntimeApi - + HeaderBackend - + AuxStore - + HeaderMetadata - + Send - + Sync - + 'static, - C::Api: frame_rpc_system::AccountNonceApi, - C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, - C::Api: BlockBuilder, - P: TransactionPool + Sync + Send + 'static, - B: sc_client_api::Backend + Send + Sync + 'static, - B::State: sc_client_api::backend::StateBackend>, -{ - use frame_rpc_system::{System, SystemApiServer}; - use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; - use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer}; - - let mut module = RpcExtension::new(()); - let FullDeps { client, pool, deny_unsafe } = deps; - - module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?; - module.merge(TransactionPayment::new(client.clone()).into_rpc())?; - module.merge(StateMigration::new(client, backend, deny_unsafe).into_rpc())?; - - Ok(module) -} - -/// Instantiate all RPCs we want at the contracts-rococo chain. -pub fn create_contracts_rococo( - deps: FullDeps, -) -> Result> -where - C: ProvideRuntimeApi - + sc_client_api::BlockBackend - + HeaderBackend - + AuxStore - + HeaderMetadata - + Send - + Sync - + 'static, - C::Api: frame_rpc_system::AccountNonceApi, - C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, - C::Api: BlockBuilder, - P: TransactionPool + Sync + Send + 'static, -{ - use frame_rpc_system::{System, SystemApiServer}; - use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; - use sc_rpc::dev::{Dev, DevApiServer}; - - let mut module = RpcExtension::new(()); - let FullDeps { client, pool, deny_unsafe } = deps; - - module.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?; - module.merge(TransactionPayment::new(client.clone()).into_rpc())?; - module.merge(Dev::new(client, deny_unsafe).into_rpc())?; - - Ok(module) -} diff --git a/cumulus/polkadot-parachain/src/service.rs b/cumulus/polkadot-parachain/src/service.rs deleted file mode 100644 index 12eda3e8a9cbe21f528398125e50ed57a4bc1933..0000000000000000000000000000000000000000 --- a/cumulus/polkadot-parachain/src/service.rs +++ /dev/null @@ -1,1049 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Cumulus. - -// Cumulus 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. - -// Cumulus 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 Cumulus. If not, see . - -use codec::{Codec, Decode}; -use cumulus_client_cli::CollatorOptions; -use cumulus_client_collator::service::CollatorService; -use cumulus_client_consensus_aura::collators::lookahead::{self as aura, Params as AuraParams}; -use cumulus_client_consensus_common::{ - ParachainBlockImport as TParachainBlockImport, ParachainCandidate, ParachainConsensus, -}; -use cumulus_client_consensus_proposer::Proposer; -#[allow(deprecated)] -use cumulus_client_service::old_consensus; -use cumulus_client_service::{ - build_network, build_relay_chain_interface, prepare_node_config, start_relay_chain_tasks, - BuildNetworkParams, CollatorSybilResistance, DARecoveryProfile, StartRelayChainTasksParams, -}; -use cumulus_primitives_core::{ - relay_chain::{Hash as PHash, PersistedValidationData, ValidationCode}, - ParaId, -}; -use cumulus_relay_chain_interface::{OverseerHandle, RelayChainInterface}; -use sc_rpc::DenyUnsafe; -use sp_core::Pair; - -use jsonrpsee::RpcModule; - -use crate::{fake_runtime_api::aura::RuntimeApi as FakeRuntimeApi, rpc}; -pub use parachains_common::{AccountId, AuraId, Balance, Block, Hash, Header, Nonce}; - -use cumulus_client_consensus_relay_chain::Verifier as RelayChainVerifier; -use futures::{lock::Mutex, prelude::*}; -use sc_consensus::{ - import_queue::{BasicQueue, Verifier as VerifierT}, - BlockImportParams, ImportQueue, -}; -use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY}; -use sc_network::{config::FullNetworkConfiguration, service::traits::NetworkBackend, NetworkBlock}; -use sc_network_sync::SyncingService; -use sc_service::{Configuration, PartialComponents, TFullBackend, TFullClient, TaskManager}; -use sc_telemetry::{Telemetry, TelemetryHandle, TelemetryWorker, TelemetryWorkerHandle}; -use sp_api::{ApiExt, ConstructRuntimeApi, ProvideRuntimeApi}; -use sp_consensus_aura::AuraApi; -use sp_core::traits::SpawnEssentialNamed; -use sp_keystore::KeystorePtr; -use sp_runtime::{ - app_crypto::AppCrypto, - traits::{Block as BlockT, Header as HeaderT}, -}; -use std::{marker::PhantomData, sync::Arc, time::Duration}; -use substrate_prometheus_endpoint::Registry; - -use polkadot_primitives::CollatorPair; - -#[cfg(not(feature = "runtime-benchmarks"))] -type HostFunctions = cumulus_client_service::ParachainHostFunctions; - -#[cfg(feature = "runtime-benchmarks")] -type HostFunctions = ( - cumulus_client_service::ParachainHostFunctions, - frame_benchmarking::benchmarking::HostFunctions, -); - -type ParachainClient = TFullClient>; - -type ParachainBackend = TFullBackend; - -type ParachainBlockImport = - TParachainBlockImport>, ParachainBackend>; - -/// Assembly of PartialComponents (enough to run chain ops subcommands) -pub type Service = PartialComponents< - ParachainClient, - ParachainBackend, - (), - sc_consensus::DefaultImportQueue, - sc_transaction_pool::FullPool>, - (ParachainBlockImport, Option, Option), ->; - -/// Starts a `ServiceBuilder` for a full service. -/// -/// Use this macro if you don't actually need the full service, but just the builder in order to -/// be able to perform chain operations. -pub fn new_partial( - config: &Configuration, - build_import_queue: BIQ, -) -> Result, sc_service::Error> -where - RuntimeApi: ConstructRuntimeApi> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue - + sp_api::Metadata - + sp_session::SessionKeys - + sp_api::ApiExt - + sp_offchain::OffchainWorkerApi - + sp_block_builder::BlockBuilder, - BIQ: FnOnce( - Arc>, - ParachainBlockImport, - &Configuration, - Option, - &TaskManager, - ) -> Result, sc_service::Error>, -{ - let telemetry = config - .telemetry_endpoints - .clone() - .filter(|x| !x.is_empty()) - .map(|endpoints| -> Result<_, sc_telemetry::Error> { - let worker = TelemetryWorker::new(16)?; - let telemetry = worker.handle().new_telemetry(endpoints); - Ok((worker, telemetry)) - }) - .transpose()?; - - let heap_pages = config - .default_heap_pages - .map_or(DEFAULT_HEAP_ALLOC_STRATEGY, |h| HeapAllocStrategy::Static { extra_pages: h as _ }); - - let executor = sc_executor::WasmExecutor::::builder() - .with_execution_method(config.wasm_method) - .with_max_runtime_instances(config.max_runtime_instances) - .with_runtime_cache_size(config.runtime_cache_size) - .with_onchain_heap_alloc_strategy(heap_pages) - .with_offchain_heap_alloc_strategy(heap_pages) - .build(); - - let (client, backend, keystore_container, task_manager) = - sc_service::new_full_parts_record_import::( - config, - telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()), - executor, - true, - )?; - let client = Arc::new(client); - - let telemetry_worker_handle = telemetry.as_ref().map(|(worker, _)| worker.handle()); - - let telemetry = telemetry.map(|(worker, telemetry)| { - task_manager.spawn_handle().spawn("telemetry", None, worker.run()); - telemetry - }); - - let transaction_pool = sc_transaction_pool::BasicPool::new_full( - config.transaction_pool.clone(), - config.role.is_authority().into(), - config.prometheus_registry(), - task_manager.spawn_essential_handle(), - client.clone(), - ); - - let block_import = ParachainBlockImport::new(client.clone(), backend.clone()); - - let import_queue = build_import_queue( - client.clone(), - block_import.clone(), - config, - telemetry.as_ref().map(|telemetry| telemetry.handle()), - &task_manager, - )?; - - Ok(PartialComponents { - backend, - client, - import_queue, - keystore_container, - task_manager, - transaction_pool, - select_chain: (), - other: (block_import, telemetry, telemetry_worker_handle), - }) -} - -/// Start a node with the given parachain `Configuration` and relay chain `Configuration`. -/// -/// This is the actual implementation that is abstract over the executor and the runtime api. -#[sc_tracing::logging::prefix_logs_with("Parachain")] -async fn start_node_impl( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - sybil_resistance_level: CollatorSybilResistance, - para_id: ParaId, - rpc_ext_builder: RB, - build_import_queue: BIQ, - start_consensus: SC, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> -where - RuntimeApi: ConstructRuntimeApi> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue - + sp_api::Metadata - + sp_session::SessionKeys - + sp_api::ApiExt - + sp_offchain::OffchainWorkerApi - + sp_block_builder::BlockBuilder - + cumulus_primitives_core::CollectCollationInfo - + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi - + frame_rpc_system::AccountNonceApi, - RB: Fn( - DenyUnsafe, - Arc>, - Arc, - Arc>>, - ) -> Result, sc_service::Error> - + 'static, - BIQ: FnOnce( - Arc>, - ParachainBlockImport, - &Configuration, - Option, - &TaskManager, - ) -> Result, sc_service::Error>, - SC: FnOnce( - Arc>, - ParachainBlockImport, - Option<&Registry>, - Option, - &TaskManager, - Arc, - Arc>>, - Arc>, - KeystorePtr, - Duration, - ParaId, - CollatorPair, - OverseerHandle, - Arc>) + Send + Sync>, - Arc, - ) -> Result<(), sc_service::Error>, - Net: NetworkBackend, -{ - let parachain_config = prepare_node_config(parachain_config); - - let params = new_partial::(¶chain_config, build_import_queue)?; - let (block_import, mut telemetry, telemetry_worker_handle) = params.other; - - let client = params.client.clone(); - let backend = params.backend.clone(); - - let mut task_manager = params.task_manager; - let (relay_chain_interface, collator_key) = build_relay_chain_interface( - polkadot_config, - ¶chain_config, - telemetry_worker_handle, - &mut task_manager, - collator_options.clone(), - hwbench.clone(), - ) - .await - .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?; - - let validator = parachain_config.role.is_authority(); - let prometheus_registry = parachain_config.prometheus_registry().cloned(); - let transaction_pool = params.transaction_pool.clone(); - let import_queue_service = params.import_queue.service(); - let net_config = FullNetworkConfiguration::<_, _, Net>::new(¶chain_config.network); - - let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) = - build_network(BuildNetworkParams { - parachain_config: ¶chain_config, - net_config, - client: client.clone(), - transaction_pool: transaction_pool.clone(), - para_id, - spawn_handle: task_manager.spawn_handle(), - relay_chain_interface: relay_chain_interface.clone(), - import_queue: params.import_queue, - sybil_resistance_level, - }) - .await?; - - let rpc_builder = { - let client = client.clone(); - let transaction_pool = transaction_pool.clone(); - let backend_for_rpc = backend.clone(); - - Box::new(move |deny_unsafe, _| { - rpc_ext_builder( - deny_unsafe, - client.clone(), - backend_for_rpc.clone(), - transaction_pool.clone(), - ) - }) - }; - - sc_service::spawn_tasks(sc_service::SpawnTasksParams { - rpc_builder, - client: client.clone(), - transaction_pool: transaction_pool.clone(), - task_manager: &mut task_manager, - config: parachain_config, - keystore: params.keystore_container.keystore(), - backend: backend.clone(), - network: network.clone(), - sync_service: sync_service.clone(), - system_rpc_tx, - tx_handler_controller, - telemetry: telemetry.as_mut(), - })?; - - if let Some(hwbench) = hwbench { - sc_sysinfo::print_hwbench(&hwbench); - if validator { - warn_if_slow_hardware(&hwbench); - } - - if let Some(ref mut telemetry) = telemetry { - let telemetry_handle = telemetry.handle(); - task_manager.spawn_handle().spawn( - "telemetry_hwbench", - None, - sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench), - ); - } - } - - let announce_block = { - let sync_service = sync_service.clone(); - Arc::new(move |hash, data| sync_service.announce_block(hash, data)) - }; - - let relay_chain_slot_duration = Duration::from_secs(6); - - let overseer_handle = relay_chain_interface - .overseer_handle() - .map_err(|e| sc_service::Error::Application(Box::new(e)))?; - - start_relay_chain_tasks(StartRelayChainTasksParams { - client: client.clone(), - announce_block: announce_block.clone(), - para_id, - relay_chain_interface: relay_chain_interface.clone(), - task_manager: &mut task_manager, - da_recovery_profile: if validator { - DARecoveryProfile::Collator - } else { - DARecoveryProfile::FullNode - }, - import_queue: import_queue_service, - relay_chain_slot_duration, - recovery_handle: Box::new(overseer_handle.clone()), - sync_service: sync_service.clone(), - })?; - - if validator { - start_consensus( - client.clone(), - block_import, - prometheus_registry.as_ref(), - telemetry.as_ref().map(|t| t.handle()), - &task_manager, - relay_chain_interface.clone(), - transaction_pool, - sync_service.clone(), - params.keystore_container.keystore(), - relay_chain_slot_duration, - para_id, - collator_key.expect("Command line arguments do not allow this. qed"), - overseer_handle, - announce_block, - backend.clone(), - )?; - } - - start_network.start_network(); - - Ok((task_manager, client)) -} - -/// Build the import queue for Aura-based runtimes. -pub fn build_aura_import_queue( - client: Arc>, - block_import: ParachainBlockImport, - config: &Configuration, - telemetry: Option, - task_manager: &TaskManager, -) -> Result, sc_service::Error> { - let slot_duration = cumulus_client_consensus_aura::slot_duration(&*client)?; - - cumulus_client_consensus_aura::import_queue::< - sp_consensus_aura::sr25519::AuthorityPair, - _, - _, - _, - _, - _, - >(cumulus_client_consensus_aura::ImportQueueParams { - block_import, - client, - create_inherent_data_providers: move |_, _| async move { - let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); - - let slot = - sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration( - *timestamp, - slot_duration, - ); - - Ok((slot, timestamp)) - }, - registry: config.prometheus_registry(), - spawner: &task_manager.spawn_essential_handle(), - telemetry, - }) - .map_err(Into::into) -} - -/// Start a rococo parachain node. -pub async fn start_rococo_parachain_node>( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> { - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Resistant, // Aura - para_id, - build_parachain_rpc_extensions::, - build_aura_import_queue, - start_lookahead_aura_consensus, - hwbench, - ) - .await -} - -/// Build the import queue for the shell runtime. -pub fn build_shell_import_queue( - client: Arc>, - block_import: ParachainBlockImport, - config: &Configuration, - _: Option, - task_manager: &TaskManager, -) -> Result, sc_service::Error> { - cumulus_client_consensus_relay_chain::import_queue( - client, - block_import, - |_, _| async { Ok(()) }, - &task_manager.spawn_essential_handle(), - config.prometheus_registry(), - ) - .map_err(Into::into) -} - -fn build_parachain_rpc_extensions( - deny_unsafe: sc_rpc::DenyUnsafe, - client: Arc>, - backend: Arc, - pool: Arc>>, -) -> Result, sc_service::Error> -where - RuntimeApi: ConstructRuntimeApi> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue - + sp_block_builder::BlockBuilder - + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi - + frame_rpc_system::AccountNonceApi, -{ - let deps = rpc::FullDeps { client, pool, deny_unsafe }; - - rpc::create_full(deps, backend).map_err(Into::into) -} - -fn build_contracts_rpc_extensions( - deny_unsafe: sc_rpc::DenyUnsafe, - client: Arc>, - _backend: Arc, - pool: Arc>>, -) -> Result, sc_service::Error> { - let deps = crate::rpc::FullDeps { client: client.clone(), pool: pool.clone(), deny_unsafe }; - - crate::rpc::create_contracts_rococo(deps).map_err(Into::into) -} - -/// Start a polkadot-shell parachain node. -pub async fn start_shell_node>( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> { - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Unresistant, // free-for-all consensus - para_id, - |_, _, _, _| Ok(RpcModule::new(())), - build_shell_import_queue, - start_relay_chain_consensus, - hwbench, - ) - .await -} - -enum BuildOnAccess { - Uninitialized(Option R + Send + Sync>>), - Initialized(R), -} - -impl BuildOnAccess { - fn get_mut(&mut self) -> &mut R { - loop { - match self { - Self::Uninitialized(f) => { - *self = Self::Initialized((f.take().unwrap())()); - }, - Self::Initialized(ref mut r) => return r, - } - } - } -} - -/// Special [`ParachainConsensus`] implementation that waits for the upgrade from -/// shell to a parachain runtime that implements Aura. -struct WaitForAuraConsensus { - client: Arc, - aura_consensus: Arc>>>>, - relay_chain_consensus: Arc>>>, - _phantom: PhantomData, -} - -impl Clone for WaitForAuraConsensus { - fn clone(&self) -> Self { - Self { - client: self.client.clone(), - aura_consensus: self.aura_consensus.clone(), - relay_chain_consensus: self.relay_chain_consensus.clone(), - _phantom: PhantomData, - } - } -} - -#[async_trait::async_trait] -impl ParachainConsensus for WaitForAuraConsensus -where - Client: sp_api::ProvideRuntimeApi + Send + Sync, - Client::Api: AuraApi, - AuraId: Send + Codec + Sync, -{ - async fn produce_candidate( - &mut self, - parent: &Header, - relay_parent: PHash, - validation_data: &PersistedValidationData, - ) -> Option> { - if self - .client - .runtime_api() - .has_api::>(parent.hash()) - .unwrap_or(false) - { - self.aura_consensus - .lock() - .await - .get_mut() - .produce_candidate(parent, relay_parent, validation_data) - .await - } else { - self.relay_chain_consensus - .lock() - .await - .produce_candidate(parent, relay_parent, validation_data) - .await - } - } -} - -struct Verifier { - client: Arc, - aura_verifier: BuildOnAccess>>, - relay_chain_verifier: Box>, - _phantom: PhantomData, -} - -#[async_trait::async_trait] -impl VerifierT for Verifier -where - Client: sp_api::ProvideRuntimeApi + Send + Sync, - Client::Api: AuraApi, - AuraId: Send + Sync + Codec, -{ - async fn verify( - &mut self, - block_import: BlockImportParams, - ) -> Result, String> { - if self - .client - .runtime_api() - .has_api::>(*block_import.header.parent_hash()) - .unwrap_or(false) - { - self.aura_verifier.get_mut().verify(block_import).await - } else { - self.relay_chain_verifier.verify(block_import).await - } - } -} - -/// Build the import queue for parachain runtimes that started with relay chain consensus and -/// switched to aura. -pub fn build_relay_to_aura_import_queue( - client: Arc>, - block_import: ParachainBlockImport, - config: &Configuration, - telemetry_handle: Option, - task_manager: &TaskManager, -) -> Result, sc_service::Error> -where - RuntimeApi: ConstructRuntimeApi> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue - + sp_api::Metadata - + sp_session::SessionKeys - + sp_api::ApiExt - + sp_offchain::OffchainWorkerApi - + sp_block_builder::BlockBuilder - + sp_consensus_aura::AuraApi::Pair as Pair>::Public>, - <::Pair as Pair>::Signature: - TryFrom> + std::hash::Hash + sp_runtime::traits::Member + Codec, -{ - let verifier_client = client.clone(); - - let aura_verifier = move || { - Box::new(cumulus_client_consensus_aura::build_verifier::< - ::Pair, - _, - _, - _, - >(cumulus_client_consensus_aura::BuildVerifierParams { - client: verifier_client.clone(), - create_inherent_data_providers: move |parent_hash, _| { - let cidp_client = verifier_client.clone(); - async move { - let slot_duration = cumulus_client_consensus_aura::slot_duration_at( - &*cidp_client, - parent_hash, - )?; - let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); - - let slot = - sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration( - *timestamp, - slot_duration, - ); - - Ok((slot, timestamp)) - } - }, - telemetry: telemetry_handle, - })) as Box<_> - }; - - let relay_chain_verifier = - Box::new(RelayChainVerifier::new(client.clone(), |_, _| async { Ok(()) })) as Box<_>; - - let verifier = Verifier { - client, - relay_chain_verifier, - aura_verifier: BuildOnAccess::Uninitialized(Some(Box::new(aura_verifier))), - _phantom: PhantomData, - }; - - let registry = config.prometheus_registry(); - let spawner = task_manager.spawn_essential_handle(); - - Ok(BasicQueue::new(verifier, Box::new(block_import), None, &spawner, registry)) -} - -/// Uses the lookahead collator to support async backing. -/// -/// Start an aura powered parachain node. Some system chains use this. -pub async fn start_generic_aura_lookahead_node>( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> { - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Resistant, // Aura - para_id, - build_parachain_rpc_extensions::, - build_relay_to_aura_import_queue::<_, AuraId>, - start_lookahead_aura_consensus, - hwbench, - ) - .await -} - -/// Start a shell node which should later transition into an Aura powered parachain node. Asset Hub -/// uses this because at genesis, Asset Hub was on the `shell` runtime which didn't have Aura and -/// needs to sync and upgrade before it can run `AuraApi` functions. -/// -/// Uses the lookahead collator to support async backing. -#[sc_tracing::logging::prefix_logs_with("Parachain")] -pub async fn start_asset_hub_lookahead_node< - RuntimeApi, - AuraId: AppCrypto + Send + Codec + Sync, - Net, ->( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> -where - RuntimeApi: ConstructRuntimeApi> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: sp_transaction_pool::runtime_api::TaggedTransactionQueue - + sp_api::Metadata - + sp_session::SessionKeys - + sp_api::ApiExt - + sp_offchain::OffchainWorkerApi - + sp_block_builder::BlockBuilder - + cumulus_primitives_core::CollectCollationInfo - + sp_consensus_aura::AuraApi::Pair as Pair>::Public> - + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi - + frame_rpc_system::AccountNonceApi - + cumulus_primitives_aura::AuraUnincludedSegmentApi, - <::Pair as Pair>::Signature: - TryFrom> + std::hash::Hash + sp_runtime::traits::Member + Codec, - Net: NetworkBackend, -{ - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Resistant, // Aura - para_id, - build_parachain_rpc_extensions::, - build_relay_to_aura_import_queue::<_, AuraId>, - |client, - block_import, - prometheus_registry, - telemetry, - task_manager, - relay_chain_interface, - transaction_pool, - sync_oracle, - keystore, - relay_chain_slot_duration, - para_id, - collator_key, - overseer_handle, - announce_block, - backend| { - let relay_chain_interface2 = relay_chain_interface.clone(); - - let collator_service = CollatorService::new( - client.clone(), - Arc::new(task_manager.spawn_handle()), - announce_block, - client.clone(), - ); - - let spawner = task_manager.spawn_handle(); - - let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( - spawner, - client.clone(), - transaction_pool, - prometheus_registry, - telemetry.clone(), - ); - - let collation_future = Box::pin(async move { - // Start collating with the `shell` runtime while waiting for an upgrade to an Aura - // compatible runtime. - let mut request_stream = cumulus_client_collator::relay_chain_driven::init( - collator_key.clone(), - para_id, - overseer_handle.clone(), - ) - .await; - while let Some(request) = request_stream.next().await { - let pvd = request.persisted_validation_data().clone(); - let last_head_hash = - match ::Header::decode(&mut &pvd.parent_head.0[..]) { - Ok(header) => header.hash(), - Err(e) => { - log::error!("Could not decode the head data: {e}"); - request.complete(None); - continue - }, - }; - - // Check if we have upgraded to an Aura compatible runtime and transition if - // necessary. - if client - .runtime_api() - .has_api::>(last_head_hash) - .unwrap_or(false) - { - // Respond to this request before transitioning to Aura. - request.complete(None); - break - } - } - - // Move to Aura consensus. - let proposer = Proposer::new(proposer_factory); - - let params = AuraParams { - create_inherent_data_providers: move |_, ()| async move { Ok(()) }, - block_import, - para_client: client.clone(), - para_backend: backend, - relay_client: relay_chain_interface2, - code_hash_provider: move |block_hash| { - client.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) - }, - sync_oracle, - keystore, - collator_key, - para_id, - overseer_handle, - relay_chain_slot_duration, - proposer, - collator_service, - authoring_duration: Duration::from_millis(1500), - reinitialize: true, /* we need to always re-initialize for asset-hub moving - * to aura */ - }; - - aura::run::::Pair, _, _, _, _, _, _, _, _, _>(params) - .await - }); - - let spawner = task_manager.spawn_essential_handle(); - spawner.spawn_essential("cumulus-asset-hub-collator", None, collation_future); - - Ok(()) - }, - hwbench, - ) - .await -} - -/// Start relay-chain consensus that is free for all. Everyone can submit a block, the relay-chain -/// decides what is backed and included. -fn start_relay_chain_consensus( - client: Arc>, - block_import: ParachainBlockImport, - prometheus_registry: Option<&Registry>, - telemetry: Option, - task_manager: &TaskManager, - relay_chain_interface: Arc, - transaction_pool: Arc>>, - _sync_oracle: Arc>, - _keystore: KeystorePtr, - _relay_chain_slot_duration: Duration, - para_id: ParaId, - collator_key: CollatorPair, - overseer_handle: OverseerHandle, - announce_block: Arc>) + Send + Sync>, - _backend: Arc, -) -> Result<(), sc_service::Error> { - let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( - task_manager.spawn_handle(), - client.clone(), - transaction_pool, - prometheus_registry, - telemetry, - ); - - let free_for_all = cumulus_client_consensus_relay_chain::build_relay_chain_consensus( - cumulus_client_consensus_relay_chain::BuildRelayChainConsensusParams { - para_id, - proposer_factory, - block_import, - relay_chain_interface: relay_chain_interface.clone(), - create_inherent_data_providers: move |_, (relay_parent, validation_data)| { - let relay_chain_interface = relay_chain_interface.clone(); - async move { - let parachain_inherent = - cumulus_client_parachain_inherent::ParachainInherentDataProvider::create_at( - relay_parent, - &relay_chain_interface, - &validation_data, - para_id, - ).await; - let parachain_inherent = parachain_inherent.ok_or_else(|| { - Box::::from( - "Failed to create parachain inherent", - ) - })?; - Ok(parachain_inherent) - } - }, - }, - ); - - let spawner = task_manager.spawn_handle(); - - // Required for free-for-all consensus - #[allow(deprecated)] - old_consensus::start_collator_sync(old_consensus::StartCollatorParams { - para_id, - block_status: client.clone(), - announce_block, - overseer_handle, - spawner, - key: collator_key, - parachain_consensus: free_for_all, - runtime_api: client.clone(), - }); - - Ok(()) -} - -/// Start consensus using the lookahead aura collator. -fn start_lookahead_aura_consensus( - client: Arc>, - block_import: ParachainBlockImport, - prometheus_registry: Option<&Registry>, - telemetry: Option, - task_manager: &TaskManager, - relay_chain_interface: Arc, - transaction_pool: Arc>>, - sync_oracle: Arc>, - keystore: KeystorePtr, - relay_chain_slot_duration: Duration, - para_id: ParaId, - collator_key: CollatorPair, - overseer_handle: OverseerHandle, - announce_block: Arc>) + Send + Sync>, - backend: Arc, -) -> Result<(), sc_service::Error> { - let proposer_factory = sc_basic_authorship::ProposerFactory::with_proof_recording( - task_manager.spawn_handle(), - client.clone(), - transaction_pool, - prometheus_registry, - telemetry.clone(), - ); - - let collator_service = CollatorService::new( - client.clone(), - Arc::new(task_manager.spawn_handle()), - announce_block, - client.clone(), - ); - - let params = AuraParams { - create_inherent_data_providers: move |_, ()| async move { Ok(()) }, - block_import, - para_client: client.clone(), - para_backend: backend, - relay_client: relay_chain_interface, - code_hash_provider: move |block_hash| { - client.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) - }, - sync_oracle, - keystore, - collator_key, - para_id, - overseer_handle, - relay_chain_slot_duration, - proposer: Proposer::new(proposer_factory), - collator_service, - authoring_duration: Duration::from_millis(1500), - reinitialize: false, - }; - - let fut = aura::run::::Pair, _, _, _, _, _, _, _, _, _>(params); - task_manager.spawn_essential_handle().spawn("aura", None, fut); - - Ok(()) -} - -/// Start an aura powered parachain node which uses the lookahead collator to support async backing. -/// This node is basic in the sense that its runtime api doesn't include common contents such as -/// transaction payment. Used for aura glutton. -pub async fn start_basic_lookahead_node>( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> { - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Resistant, // Aura - para_id, - |_, _, _, _| Ok(RpcModule::new(())), - build_relay_to_aura_import_queue::<_, AuraId>, - start_lookahead_aura_consensus, - hwbench, - ) - .await -} - -/// Start a parachain node for Rococo Contracts. -pub async fn start_contracts_rococo_node>( - parachain_config: Configuration, - polkadot_config: Configuration, - collator_options: CollatorOptions, - para_id: ParaId, - hwbench: Option, -) -> sc_service::error::Result<(TaskManager, Arc>)> { - start_node_impl::( - parachain_config, - polkadot_config, - collator_options, - CollatorSybilResistance::Resistant, // Aura - para_id, - build_contracts_rpc_extensions, - build_aura_import_queue, - start_lookahead_aura_consensus, - hwbench, - ) - .await -} - -/// Checks that the hardware meets the requirements and print a warning otherwise. -fn warn_if_slow_hardware(hwbench: &sc_sysinfo::HwBench) { - // Polkadot para-chains should generally use these requirements to ensure that the relay-chain - // will not take longer than expected to import its blocks. - if let Err(err) = frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE.check_hardware(hwbench) { - log::warn!( - "⚠️ The hardware does not meet the minimal requirements {} for role 'Authority' find out more at:\n\ - https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware", - err - ); - } -} diff --git a/cumulus/primitives/aura/Cargo.toml b/cumulus/primitives/aura/Cargo.toml index 21c06ef22d9a13bf8361156ea5e1af1216aa3e28..185b2d40833f0614a0856b79015eb90f0c57c30a 100644 --- a/cumulus/primitives/aura/Cargo.toml +++ b/cumulus/primitives/aura/Cargo.toml @@ -10,26 +10,14 @@ description = "Core primitives for Aura in Cumulus" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } # Substrate -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } - -# Polkadot -polkadot-core-primitives = { path = "../../../polkadot/core-primitives", default-features = false } -polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false } +sp-api = { workspace = true } +sp-consensus-aura = { workspace = true } [features] default = ["std"] std = [ - "codec/std", - "polkadot-core-primitives/std", - "polkadot-primitives/std", "sp-api/std", "sp-consensus-aura/std", - "sp-runtime/std", - "sp-std/std", ] diff --git a/cumulus/primitives/core/Cargo.toml b/cumulus/primitives/core/Cargo.toml index 62c3f6751917ad4aaaaec6509c852a5cfd75d7f8..533d368d3b00ed883b1996d376a80f4d5d970570 100644 --- a/cumulus/primitives/core/Cargo.toml +++ b/cumulus/primitives/core/Cargo.toml @@ -10,20 +10,19 @@ description = "Cumulus related core primitive types and traits" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -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 } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } +sp-api = { workspace = true } +sp-runtime = { workspace = true } +sp-trie = { workspace = true } # Polkadot -polkadot-core-primitives = { path = "../../../polkadot/core-primitives", default-features = false } -polkadot-parachain-primitives = { path = "../../../polkadot/parachain", default-features = false } -polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } +polkadot-core-primitives = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-primitives = { workspace = true } +xcm = { workspace = true } [features] default = ["std"] @@ -35,7 +34,6 @@ std = [ "scale-info/std", "sp-api/std", "sp-runtime/std", - "sp-std/std", "sp-trie/std", "xcm/std", ] diff --git a/cumulus/primitives/core/src/lib.rs b/cumulus/primitives/core/src/lib.rs index 7f7353685657e7bf6bfb2c05faba32315bbbb706..6eafecfc3ff574689b5dd3125b97c0e5bade844a 100644 --- a/cumulus/primitives/core/src/lib.rs +++ b/cumulus/primitives/core/src/lib.rs @@ -18,11 +18,13 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::vec::Vec; use codec::{Decode, Encode, MaxEncodedLen}; use polkadot_parachain_primitives::primitives::HeadData; use scale_info::TypeInfo; use sp_runtime::RuntimeDebug; -use sp_std::prelude::*; pub use polkadot_core_primitives::InboundDownwardMessage; pub use polkadot_parachain_primitives::primitives::{ @@ -64,6 +66,8 @@ pub enum MessageSendError { TooBig, /// Some other error. Other, + /// There are too many channels open at once. + TooManyChannels, } impl From for &'static str { @@ -74,6 +78,7 @@ impl From for &'static str { NoChannel => "NoChannel", TooBig => "TooBig", Other => "Other", + TooManyChannels => "TooManyChannels", } } } @@ -135,6 +140,11 @@ pub trait GetChannelInfo { fn get_channel_info(id: ParaId) -> Option; } +/// List all open outgoing channels. +pub trait ListChannelInfos { + fn outgoing_channels() -> Vec; +} + /// Something that should be called when sending an upward message. pub trait UpwardMessageSender { /// Send the given UMP message; return the expected number of blocks before the message will @@ -194,7 +204,7 @@ pub struct ParachainBlockData { /// The header of the parachain block. header: B::Header, /// The extrinsics of the parachain block. - extrinsics: sp_std::vec::Vec, + extrinsics: alloc::vec::Vec, /// The data that is required to emulate the storage accesses executed by all extrinsics. storage_proof: sp_trie::CompactProof, } @@ -203,7 +213,7 @@ impl ParachainBlockData { /// Creates a new instance of `Self`. pub fn new( header: ::Header, - extrinsics: sp_std::vec::Vec<::Extrinsic>, + extrinsics: alloc::vec::Vec<::Extrinsic>, storage_proof: sp_trie::CompactProof, ) -> Self { Self { header, extrinsics, storage_proof } @@ -235,7 +245,7 @@ impl ParachainBlockData { } /// Deconstruct into the inner parts. - pub fn deconstruct(self) -> (B::Header, sp_std::vec::Vec, sp_trie::CompactProof) { + pub fn deconstruct(self) -> (B::Header, alloc::vec::Vec, sp_trie::CompactProof) { (self.header, self.extrinsics, self.storage_proof) } } diff --git a/cumulus/primitives/parachain-inherent/Cargo.toml b/cumulus/primitives/parachain-inherent/Cargo.toml index 4da561661b6b312d8d89a9f0f5ae5b7359e79a82..a4271d3fd9cc34ac9a32787c3cce16d4cffc38ab 100644 --- a/cumulus/primitives/parachain-inherent/Cargo.toml +++ b/cumulus/primitives/parachain-inherent/Cargo.toml @@ -10,20 +10,17 @@ license = "Apache-2.0" workspace = true [dependencies] -async-trait = { version = "0.1.79", optional = true } -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +async-trait = { optional = true, workspace = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } # Substrate -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", optional = true, default-features = false } -sp-state-machine = { path = "../../../substrate/primitives/state-machine", optional = true, default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } +sp-core = { workspace = true } +sp-inherents = { workspace = true } +sp-trie = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] @@ -34,8 +31,5 @@ std = [ "scale-info/std", "sp-core/std", "sp-inherents/std", - "sp-runtime?/std", - "sp-state-machine?/std", - "sp-std/std", "sp-trie/std", ] diff --git a/cumulus/primitives/parachain-inherent/src/lib.rs b/cumulus/primitives/parachain-inherent/src/lib.rs index 75a56693958e6a982e21851384535217157b9c82..ad4b39b547c5f24f123e8abfd5a352dd1008adae 100644 --- a/cumulus/primitives/parachain-inherent/src/lib.rs +++ b/cumulus/primitives/parachain-inherent/src/lib.rs @@ -27,14 +27,16 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + use cumulus_primitives_core::{ relay_chain::{BlakeTwo256, Hash as RelayHash, HashT as _}, InboundDownwardMessage, InboundHrmpMessage, ParaId, PersistedValidationData, }; +use alloc::{collections::btree_map::BTreeMap, vec::Vec}; use scale_info::TypeInfo; use sp_inherents::InherentIdentifier; -use sp_std::{collections::btree_map::BTreeMap, vec::Vec}; /// The identifier for the parachain inherent. pub const INHERENT_IDENTIFIER: InherentIdentifier = *b"sysi1337"; diff --git a/cumulus/primitives/proof-size-hostfunction/Cargo.toml b/cumulus/primitives/proof-size-hostfunction/Cargo.toml index dd584ce86b2e3172563848f028730709e1b1600d..e61c865d05fb07aaff931f0ecd59a09c2592a0fa 100644 --- a/cumulus/primitives/proof-size-hostfunction/Cargo.toml +++ b/cumulus/primitives/proof-size-hostfunction/Cargo.toml @@ -10,14 +10,14 @@ license = "Apache-2.0" workspace = true [dependencies] -sp-runtime-interface = { path = "../../../substrate/primitives/runtime-interface", default-features = false } -sp-externalities = { path = "../../../substrate/primitives/externalities", default-features = false } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } +sp-runtime-interface = { workspace = true } +sp-externalities = { workspace = true } +sp-trie = { workspace = true } [dev-dependencies] -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-io = { path = "../../../substrate/primitives/io" } +sp-state-machine = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/cumulus/primitives/storage-weight-reclaim/Cargo.toml b/cumulus/primitives/storage-weight-reclaim/Cargo.toml index 6dbf7904bf796e81415b967637d9770356142603..3a98fdd017aef9b7e411ef59d56fecc89bf0c897 100644 --- a/cumulus/primitives/storage-weight-reclaim/Cargo.toml +++ b/cumulus/primitives/storage-weight-reclaim/Cargo.toml @@ -10,24 +10,23 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } +frame-support = { workspace = true } +frame-system = { workspace = true } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } +sp-runtime = { workspace = true } -cumulus-primitives-core = { path = "../core", default-features = false } -cumulus-primitives-proof-size-hostfunction = { path = "../proof-size-hostfunction", default-features = false } -docify = "0.2.8" +cumulus-primitives-core = { workspace = true } +cumulus-primitives-proof-size-hostfunction = { workspace = true } +docify = { workspace = true } [dev-dependencies] -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -cumulus-test-runtime = { path = "../../test/runtime" } +sp-trie = { workspace = true } +sp-io = { workspace = true } +cumulus-test-runtime = { workspace = true } [features] default = ["std"] @@ -41,6 +40,5 @@ std = [ "scale-info/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "sp-trie/std", ] diff --git a/cumulus/primitives/storage-weight-reclaim/src/lib.rs b/cumulus/primitives/storage-weight-reclaim/src/lib.rs index c09c12d7a0abf8ac3c64974390d47880af6ec6e9..a557e881e26b5f012363dc4b893566b45b8ae58c 100644 --- a/cumulus/primitives/storage-weight-reclaim/src/lib.rs +++ b/cumulus/primitives/storage-weight-reclaim/src/lib.rs @@ -18,6 +18,7 @@ #![cfg_attr(not(feature = "std"), no_std)] use codec::{Decode, Encode}; +use core::marker::PhantomData; use cumulus_primitives_core::Weight; use cumulus_primitives_proof_size_hostfunction::{ storage_proof_size::storage_proof_size, PROOF_RECORDING_DISABLED, @@ -33,7 +34,6 @@ use sp_runtime::{ transaction_validity::TransactionValidityError, DispatchResult, }; -use sp_std::marker::PhantomData; const LOG_TARGET: &'static str = "runtime::storage_reclaim"; @@ -165,15 +165,17 @@ where ); return Ok(()) }; - let benchmarked_weight = info.weight.proof_size(); - let consumed_weight = post_dispatch_proof_size.saturating_sub(pre_dispatch_proof_size); - // Unspent weight according to the `actual_weight` from `PostDispatchInfo` // This unspent weight will be refunded by the `CheckWeight` extension, so we need to // account for that. let unspent = post_info.calc_unspent(info).proof_size(); - let storage_size_diff = - benchmarked_weight.saturating_sub(unspent).abs_diff(consumed_weight as u64); + let benchmarked_weight = info.weight.proof_size().saturating_sub(unspent); + let consumed_weight = post_dispatch_proof_size.saturating_sub(pre_dispatch_proof_size); + + let storage_size_diff = benchmarked_weight.abs_diff(consumed_weight as u64); + + let extrinsic_len = frame_system::AllExtrinsicsLen::::get().unwrap_or(0); + let node_side_pov_size = post_dispatch_proof_size.saturating_add(extrinsic_len.into()); // This value will be reclaimed by [`frame_system::CheckWeight`], so we need to calculate // that in. @@ -191,6 +193,19 @@ where ); current.reduce(Weight::from_parts(0, storage_size_diff), info.class) } + + // If we encounter a situation where the node-side proof size is already higher than + // what we have in the runtime bookkeeping, we add the difference to the `BlockWeight`. + // This prevents that the proof size grows faster than the runtime proof size. + let block_weight_proof_size = current.total().proof_size(); + let missing_from_node = node_side_pov_size.saturating_sub(block_weight_proof_size); + if missing_from_node > 0 { + log::warn!( + target: LOG_TARGET, + "Node-side PoV size higher than runtime proof size weight. node-side: {node_side_pov_size} extrinsic_len: {extrinsic_len} runtime: {block_weight_proof_size}, missing: {missing_from_node}. Setting to node-side proof size." + ); + current.accrue(Weight::from_parts(0, missing_from_node), info.class); + } }); Ok(()) } @@ -199,14 +214,14 @@ where #[cfg(test)] mod tests { use super::*; + use core::marker::PhantomData; use frame_support::{ assert_ok, - dispatch::DispatchClass, + dispatch::{DispatchClass, PerDispatchClass}, weights::{Weight, WeightMeter}, }; use frame_system::{BlockWeight, CheckWeight}; use sp_runtime::{AccountId32, BuildStorage}; - use sp_std::marker::PhantomData; use sp_trie::proof_size_extension::ProofSizeExt; type Test = cumulus_test_runtime::Runtime; @@ -215,7 +230,7 @@ mod tests { pages: 0u64, }); const ALICE: AccountId32 = AccountId32::new([1u8; 32]); - const LEN: usize = 0; + const LEN: usize = 150; pub fn new_test_ext() -> sp_io::TestExternalities { let ext: sp_io::TestExternalities = cumulus_test_runtime::RuntimeGenesisConfig::default() @@ -256,6 +271,10 @@ mod tests { }); } + fn get_storage_weight() -> PerDispatchClass { + BlockWeight::::get() + } + #[test] fn basic_refund() { // The real cost will be 100 bytes of storage size @@ -268,6 +287,9 @@ mod tests { let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() }; let post_info = PostDispatchInfo::default(); + // Should add 500 + 150 (len) to weight. + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -283,10 +305,125 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 600); + assert_eq!(get_storage_weight().total().proof_size(), 1250); }) } + #[test] + fn underestimating_refund() { + // We fixed a bug where `pre dispatch info weight > consumed weight > post info weight` + // resulted in error. + + // The real cost will be 100 bytes of storage size + let mut test_ext = setup_test_externalities(&[0, 100]); + + test_ext.execute_with(|| { + set_current_storage_weight(1000); + + // Benchmarked storage weight: 500 + let info = DispatchInfo { weight: Weight::from_parts(0, 101), ..Default::default() }; + let post_info = PostDispatchInfo { + actual_weight: Some(Weight::from_parts(0, 99)), + pays_fee: Default::default(), + }; + + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + + let pre = StorageWeightReclaim::(PhantomData) + .pre_dispatch(&ALICE, CALL, &info, LEN) + .unwrap(); + assert_eq!(pre, Some(0)); + + assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); + // We expect an accrue of 1 + assert_ok!(StorageWeightReclaim::::post_dispatch( + Some(pre), + &info, + &post_info, + LEN, + &Ok(()) + )); + + assert_eq!(get_storage_weight().total().proof_size(), 1250); + }) + } + + #[test] + fn sets_to_node_storage_proof_if_higher() { + // The storage proof reported by the proof recorder is higher than what is stored on + // the runtime side. + { + let mut test_ext = setup_test_externalities(&[1000, 1005]); + + test_ext.execute_with(|| { + // Stored in BlockWeight is 5 + set_current_storage_weight(5); + + // Benchmarked storage weight: 10 + let info = DispatchInfo { weight: Weight::from_parts(0, 10), ..Default::default() }; + let post_info = PostDispatchInfo::default(); + + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + + let pre = StorageWeightReclaim::(PhantomData) + .pre_dispatch(&ALICE, CALL, &info, LEN) + .unwrap(); + assert_eq!(pre, Some(1000)); + + assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); + assert_ok!(StorageWeightReclaim::::post_dispatch( + Some(pre), + &info, + &post_info, + LEN, + &Ok(()) + )); + + // We expect that the storage weight was set to the node-side proof size (1005) + + // extrinsics length (150) + assert_eq!(get_storage_weight().total().proof_size(), 1155); + }) + } + + // In this second scenario the proof size on the node side is only lower + // after reclaim happened. + { + let mut test_ext = setup_test_externalities(&[175, 180]); + test_ext.execute_with(|| { + set_current_storage_weight(85); + + // Benchmarked storage weight: 100 + let info = + DispatchInfo { weight: Weight::from_parts(0, 100), ..Default::default() }; + let post_info = PostDispatchInfo::default(); + + // After this pre_dispatch, the BlockWeight proof size will be + // 85 (initial) + 100 (benched) + 150 (tx length) = 335 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + + let pre = StorageWeightReclaim::(PhantomData) + .pre_dispatch(&ALICE, CALL, &info, LEN) + .unwrap(); + assert_eq!(pre, Some(175)); + + assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); + + // First we will reclaim 95, which leaves us with 240 BlockWeight. This is lower + // than 180 (proof size hf) + 150 (length), so we expect it to be set to 330. + assert_ok!(StorageWeightReclaim::::post_dispatch( + Some(pre), + &info, + &post_info, + LEN, + &Ok(()) + )); + + // We expect that the storage weight was set to the node-side proof weight + assert_eq!(get_storage_weight().total().proof_size(), 330); + }) + } + } + #[test] fn does_nothing_without_extension() { let mut test_ext = new_test_ext(); @@ -299,6 +436,9 @@ mod tests { let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() }; let post_info = PostDispatchInfo::default(); + // Adds 500 + 150 (len) weight + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -313,7 +453,7 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 1000); + assert_eq!(get_storage_weight().total().proof_size(), 1650); }) } @@ -327,6 +467,9 @@ mod tests { let info = DispatchInfo { weight: Weight::from_parts(0, 100), ..Default::default() }; let post_info = PostDispatchInfo::default(); + // Weight added should be 100 + 150 (len) + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -342,7 +485,10 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 1100); + assert_eq!( + get_storage_weight().total().proof_size(), + 1100 + LEN as u64 + info.weight.proof_size() + ); }) } @@ -354,6 +500,8 @@ mod tests { let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() }; let post_info = PostDispatchInfo::default(); + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -368,7 +516,8 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 0); + // Proof size should be exactly equal to extrinsic length + assert_eq!(get_storage_weight().total().proof_size(), LEN as u64); }); } @@ -382,12 +531,17 @@ mod tests { let info = DispatchInfo { weight: Weight::from_parts(0, 500), ..Default::default() }; let post_info = PostDispatchInfo::default(); + // Adds 500 + 150 (len) weight, total weight is 1950 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); assert_eq!(pre, Some(300)); + // Refund 500 unspent weight according to `post_info`, total weight is now 1650 assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); + // Recorded proof size is negative -200, total weight is now 1450 assert_ok!(StorageWeightReclaim::::post_dispatch( Some(pre), &info, @@ -396,7 +550,7 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 800); + assert_eq!(get_storage_weight().total().proof_size(), 1450); }); } @@ -416,6 +570,9 @@ mod tests { pays_fee: Default::default(), }; + // Should add 300 + 150 (len) of weight + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -432,7 +589,8 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 900); + // Reclaimed 100 + assert_eq!(get_storage_weight().total().proof_size(), 1350); }) } @@ -451,6 +609,9 @@ mod tests { pays_fee: Default::default(), }; + // Adds 50 + 150 (len) weight, total weight 1200 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); @@ -458,7 +619,56 @@ mod tests { // The `CheckWeight` extension will refund `actual_weight` from `PostDispatchInfo` // we always need to call `post_dispatch` to verify that they interoperate correctly. + + // Refunds unspent 25 weight according to `post_info`, 1175 assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); + // Adds 200 - 25 (unspent) == 175 weight, total weight 1350 + assert_ok!(StorageWeightReclaim::::post_dispatch( + Some(pre), + &info, + &post_info, + LEN, + &Ok(()) + )); + + assert_eq!(get_storage_weight().total().proof_size(), 1350); + }) + } + + #[test] + fn test_nothing_relcaimed() { + let mut test_ext = setup_test_externalities(&[0, 100]); + + test_ext.execute_with(|| { + set_current_storage_weight(0); + // Benchmarked storage weight: 100 + let info = DispatchInfo { weight: Weight::from_parts(100, 100), ..Default::default() }; + + // Actual proof size is 100 + let post_info = PostDispatchInfo { + actual_weight: Some(Weight::from_parts(50, 100)), + pays_fee: Default::default(), + }; + + // Adds benchmarked weight 100 + 150 (len), total weight is now 250 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + + // Weight should go up by 150 len + 100 proof size weight, total weight 250 + assert_eq!(get_storage_weight().total().proof_size(), 250); + + let pre = StorageWeightReclaim::(PhantomData) + .pre_dispatch(&ALICE, CALL, &info, LEN) + .unwrap(); + // Should return `setup_test_externalities` proof recorder value: 100. + assert_eq!(pre, Some(0)); + + // The `CheckWeight` extension will refund `actual_weight` from `PostDispatchInfo` + // we always need to call `post_dispatch` to verify that they interoperate correctly. + // Nothing to refund, unspent is 0, total weight 250 + assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, LEN, &Ok(()))); + // `setup_test_externalities` proof recorder value: 200, so this means the extrinsic + // actually used 100 proof size. + // Nothing to refund or add, weight matches proof recorder assert_ok!(StorageWeightReclaim::::post_dispatch( Some(pre), &info, @@ -467,7 +677,9 @@ mod tests { &Ok(()) )); - assert_eq!(BlockWeight::::get().total().proof_size(), 1150); + // Check block len weight was not reclaimed: + // 100 weight + 150 extrinsic len == 250 proof size + assert_eq!(get_storage_weight().total().proof_size(), 250); }) } @@ -487,11 +699,15 @@ mod tests { pays_fee: Default::default(), }; + // Adds 300 + 150 (len) weight, total weight 1450 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); assert_eq!(pre, Some(100)); + // This refunds 100 - 50(unspent), total weight is now 1400 assert_ok!(StorageWeightReclaim::::post_dispatch( Some(pre), &info, @@ -504,7 +720,8 @@ mod tests { // we always need to call `post_dispatch` to verify that they interoperate correctly. assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); - assert_eq!(BlockWeight::::get().total().proof_size(), 900); + // Above call refunds 50 (unspent), total weight is 1350 now + assert_eq!(get_storage_weight().total().proof_size(), 1350); }) } @@ -523,11 +740,15 @@ mod tests { pays_fee: Default::default(), }; + // Adds 50 + 150 (len) weight, total weight is 1200 + assert_ok!(CheckWeight::::do_pre_dispatch(&info, LEN)); + let pre = StorageWeightReclaim::(PhantomData) .pre_dispatch(&ALICE, CALL, &info, LEN) .unwrap(); assert_eq!(pre, Some(100)); + // Adds additional 150 weight recorded assert_ok!(StorageWeightReclaim::::post_dispatch( Some(pre), &info, @@ -540,7 +761,7 @@ mod tests { // we always need to call `post_dispatch` to verify that they interoperate correctly. assert_ok!(CheckWeight::::post_dispatch(None, &info, &post_info, 0, &Ok(()))); - assert_eq!(BlockWeight::::get().total().proof_size(), 1150); + assert_eq!(get_storage_weight().total().proof_size(), 1350); }) } @@ -644,7 +865,7 @@ mod tests { // We reclaimed 3 bytes of storage size! assert_eq!(reclaimed, Some(Weight::from_parts(0, 3))); - assert_eq!(BlockWeight::::get().total().proof_size(), 10); + assert_eq!(get_storage_weight().total().proof_size(), 10); assert_eq!(remaining_weight_meter.remaining(), Weight::from_parts(10, 8)); } } diff --git a/cumulus/primitives/timestamp/Cargo.toml b/cumulus/primitives/timestamp/Cargo.toml index 59f327b2642a292db56708f5770ebb35b1b82d1d..cb328e2f2cc6f1b79293179a238449754dfbab98 100644 --- a/cumulus/primitives/timestamp/Cargo.toml +++ b/cumulus/primitives/timestamp/Cargo.toml @@ -10,23 +10,17 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -futures = "0.3.28" - # Substrate -sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-timestamp = { path = "../../../substrate/primitives/timestamp", default-features = false } +sp-inherents = { workspace = true } +sp-timestamp = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] std = [ - "codec/std", "cumulus-primitives-core/std", "sp-inherents/std", - "sp-std/std", "sp-timestamp/std", ] diff --git a/cumulus/primitives/timestamp/src/lib.rs b/cumulus/primitives/timestamp/src/lib.rs index e6aba6d0bb74043c134400387d84429cf0a712d1..5365f83efdf1111eaf727a4a8fe87ec4f2065726 100644 --- a/cumulus/primitives/timestamp/src/lib.rs +++ b/cumulus/primitives/timestamp/src/lib.rs @@ -27,9 +27,9 @@ #![cfg_attr(not(feature = "std"), no_std)] +use core::time::Duration; use cumulus_primitives_core::relay_chain::Slot; use sp_inherents::{Error, InherentData}; -use sp_std::time::Duration; pub use sp_timestamp::{InherentType, INHERENT_IDENTIFIER}; diff --git a/cumulus/primitives/utility/Cargo.toml b/cumulus/primitives/utility/Cargo.toml index 1e2c300b9ba257d2c8fb998689ae45847099dd63..2ca8b82001d5ad0146d2b686a9a93f4ee5996385 100644 --- a/cumulus/primitives/utility/Cargo.toml +++ b/cumulus/primitives/utility/Cargo.toml @@ -10,25 +10,22 @@ description = "Helper datatypes for Cumulus" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } log = { workspace = true } # Substrate -frame-support = { path = "../../../substrate/frame/support", 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 } -pallet-asset-conversion = { path = "../../../substrate/frame/asset-conversion", default-features = false } +frame-support = { workspace = true } +sp-runtime = { workspace = true } +pallet-asset-conversion = { workspace = true } # Polkadot -polkadot-runtime-common = { path = "../../../polkadot/runtime/common", default-features = false } -polkadot-runtime-parachains = { path = "../../../polkadot/runtime/parachains", default-features = false } -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm/xcm-executor", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../polkadot/xcm/xcm-builder", default-features = false } +polkadot-runtime-common = { workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-builder = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] @@ -39,10 +36,7 @@ std = [ "log/std", "pallet-asset-conversion/std", "polkadot-runtime-common/std", - "polkadot-runtime-parachains/std", - "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", @@ -53,7 +47,6 @@ runtime-benchmarks = [ "frame-support/runtime-benchmarks", "pallet-asset-conversion/runtime-benchmarks", "polkadot-runtime-common/runtime-benchmarks", - "polkadot-runtime-parachains/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", diff --git a/cumulus/primitives/utility/src/lib.rs b/cumulus/primitives/utility/src/lib.rs index 64784eb36f846f7b325aaaa5ed72966e3d59a1b8..3ebcb44fa439480762f4a667b3aac2ad35ef5b60 100644 --- a/cumulus/primitives/utility/src/lib.rs +++ b/cumulus/primitives/utility/src/lib.rs @@ -19,7 +19,11 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::{vec, vec::Vec}; use codec::Encode; +use core::marker::PhantomData; use cumulus_primitives_core::{MessageSendError, UpwardMessageSender}; use frame_support::{ defensive, @@ -33,7 +37,6 @@ use sp_runtime::{ traits::{Saturating, Zero}, SaturatedConversion, }; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm, WrapVersion}; use xcm_builder::{InspectMessageQueues, TakeRevenue}; use xcm_executor::{ @@ -404,10 +407,22 @@ impl< let first_asset: Asset = payment.fungible.pop_first().ok_or(XcmError::AssetNotFound)?.into(); let (fungibles_asset, balance) = FungiblesAssetMatcher::matches_fungibles(&first_asset) - .map_err(|_| XcmError::AssetNotFound)?; + .map_err(|error| { + log::trace!( + target: "xcm::weight", + "SwapFirstAssetTrader::buy_weight asset {:?} didn't match. Error: {:?}", + first_asset, + error, + ); + XcmError::AssetNotFound + })?; let swap_asset = fungibles_asset.clone().into(); if Target::get().eq(&swap_asset) { + log::trace!( + target: "xcm::weight", + "SwapFirstAssetTrader::buy_weight Asset was same as Target, swap not needed.", + ); // current trader is not applicable. return Err(XcmError::FeesNotMet) } @@ -421,7 +436,12 @@ impl< credit_in, fee, ) - .map_err(|(credit_in, _)| { + .map_err(|(credit_in, error)| { + log::trace!( + target: "xcm::weight", + "SwapFirstAssetTrader::buy_weight swap couldn't be done. Error was: {:?}", + error, + ); drop(credit_in); XcmError::FeesNotMet })?; @@ -803,7 +823,7 @@ mod test_trader { /// needed. #[cfg(feature = "runtime-benchmarks")] pub struct ToParentDeliveryHelper( - sp_std::marker::PhantomData<(XcmConfig, ExistentialDeposit, PriceForDelivery)>, + core::marker::PhantomData<(XcmConfig, ExistentialDeposit, PriceForDelivery)>, ); #[cfg(feature = "runtime-benchmarks")] diff --git a/cumulus/templates/xcm-bench-template.hbs b/cumulus/templates/xcm-bench-template.hbs index 5d0ded403f63496e93c4b118ea4137830c8a9b0d..119924bca2ee1fc1d4b568a63930bb13128c77e5 100644 --- a/cumulus/templates/xcm-bench-template.hbs +++ b/cumulus/templates/xcm-bench-template.hbs @@ -17,7 +17,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weights for `{{pallet}}`. pub struct WeightInfo(PhantomData); diff --git a/cumulus/test/client/Cargo.toml b/cumulus/test/client/Cargo.toml index 254361e85420de982a984f76d76b96a5c7d3b4a4..fbbaab73ce7695c62cfbe1e6ce62d67ba5a68509 100644 --- a/cumulus/test/client/Cargo.toml +++ b/cumulus/test/client/Cargo.toml @@ -9,43 +9,43 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } # Substrate -sc-service = { path = "../../../substrate/client/service" } -sc-consensus = { path = "../../../substrate/client/consensus/common" } -sc-consensus-aura = { path = "../../../substrate/client/consensus/aura" } -sc-block-builder = { path = "../../../substrate/client/block-builder" } -sc-executor = { path = "../../../substrate/client/executor" } -sc-executor-common = { path = "../../../substrate/client/executor/common" } -substrate-test-client = { path = "../../../substrate/test-utils/client" } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-inherents = { path = "../../../substrate/primitives/inherents" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-timestamp = { path = "../../../substrate/primitives/timestamp" } -frame-system = { path = "../../../substrate/frame/system" } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment" } -pallet-balances = { path = "../../../substrate/frame/balances" } +sc-service = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-aura = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-executor-common = { workspace = true, default-features = true } +substrate-test-client = { workspace = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives" } -polkadot-parachain-primitives = { path = "../../../polkadot/parachain" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } # Cumulus -cumulus-test-runtime = { path = "../runtime" } -cumulus-test-service = { path = "../service" } -cumulus-test-relay-sproof-builder = { path = "../relay-sproof-builder" } -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-primitives-proof-size-hostfunction = { path = "../../primitives/proof-size-hostfunction" } -cumulus-primitives-parachain-inherent = { path = "../../primitives/parachain-inherent" } -cumulus-primitives-storage-weight-reclaim = { path = "../../primitives/storage-weight-reclaim" } +cumulus-test-runtime = { workspace = true } +cumulus-test-service = { workspace = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-primitives-proof-size-hostfunction = { workspace = true, default-features = true } +cumulus-primitives-parachain-inherent = { workspace = true, default-features = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true, default-features = true } [features] runtime-benchmarks = [ diff --git a/cumulus/test/client/src/lib.rs b/cumulus/test/client/src/lib.rs index d233ad2691768c0c1d563c3a0f4c62b44f4c9b23..f26413e441e72b7fca558043f0507de91db4746f 100644 --- a/cumulus/test/client/src/lib.rs +++ b/cumulus/test/client/src/lib.rs @@ -79,6 +79,7 @@ impl substrate_test_client::GenesisInit for GenesisParameters { cumulus_test_service::chain_spec::get_chain_spec_with_extra_endowed( None, self.endowed_accounts.clone(), + cumulus_test_runtime::WASM_BINARY.expect("WASM binary not compiled!"), ) .build_storage() .expect("Builds test runtime genesis storage") diff --git a/cumulus/test/relay-sproof-builder/Cargo.toml b/cumulus/test/relay-sproof-builder/Cargo.toml index ff5c4bd66b9742383bcd170f0012695d7f0c72d2..e266b5807081aa1bc3dd8d5793d1f03342f094fc 100644 --- a/cumulus/test/relay-sproof-builder/Cargo.toml +++ b/cumulus/test/relay-sproof-builder/Cargo.toml @@ -10,19 +10,18 @@ description = "Mocked relay state proof builder for testing Cumulus." workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } # Substrate -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-state-machine = { path = "../../../substrate/primitives/state-machine", default-features = false } -sp-trie = { path = "../../../substrate/primitives/trie", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } +sp-runtime = { workspace = true } +sp-state-machine = { workspace = true } +sp-trie = { workspace = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives", default-features = false } +polkadot-primitives = { workspace = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } +cumulus-primitives-core = { workspace = true } [features] default = ["std"] @@ -32,6 +31,5 @@ std = [ "polkadot-primitives/std", "sp-runtime/std", "sp-state-machine/std", - "sp-std/std", "sp-trie/std", ] diff --git a/cumulus/test/relay-sproof-builder/src/lib.rs b/cumulus/test/relay-sproof-builder/src/lib.rs index fbd2692a36b466827376e0917adfc93aac10a739..d1016085c8073d67f2b8d50a224dce39711403f3 100644 --- a/cumulus/test/relay-sproof-builder/src/lib.rs +++ b/cumulus/test/relay-sproof-builder/src/lib.rs @@ -14,12 +14,14 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . +extern crate alloc; + +use alloc::collections::btree_map::BTreeMap; use cumulus_primitives_core::{ relay_chain, AbridgedHostConfiguration, AbridgedHrmpChannel, ParaId, }; use polkadot_primitives::UpgradeGoAhead; use sp_runtime::traits::HashingFor; -use sp_std::collections::btree_map::BTreeMap; use sp_trie::PrefixedMemoryDB; /// Builds a sproof (portmanteau of 'spoof' and 'proof') of the relay chain state. diff --git a/cumulus/test/runtime/Cargo.toml b/cumulus/test/runtime/Cargo.toml index 1969045640ed1e8c95b828fb5f4073875c3e63b0..54b83e2dfedae35583a7c8baf5308a9d709c1f4a 100644 --- a/cumulus/test/runtime/Cargo.toml +++ b/cumulus/test/runtime/Cargo.toml @@ -9,49 +9,47 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", 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 } # Substrate -frame-executive = { path = "../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -pallet-sudo = { path = "../../../substrate/frame/sudo", default-features = false } -pallet-aura = { path = "../../../substrate/frame/aura", default-features = false } -pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-glutton = { path = "../../../substrate/frame/glutton", default-features = false } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -sp-block-builder = { path = "../../../substrate/primitives/block-builder", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", 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-offchain = { path = "../../../substrate/primitives/offchain", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool", default-features = false } -sp-version = { path = "../../../substrate/primitives/version", default-features = false } +frame-executive = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +pallet-balances = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-sudo = { workspace = true } +pallet-aura = { workspace = true } +pallet-authorship = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-glutton = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-session = { workspace = true } +sp-api = { workspace = true } +sp-block-builder = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-offchain = { workspace = true } +sp-runtime = { workspace = true } +sp-session = { workspace = true } +sp-consensus-aura = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-version = { workspace = true } # Cumulus -cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false, features = [ - "parameterized-consensus-hook", -] } -cumulus-primitives-aura = { path = "../../primitives/aura", default-features = false } -pallet-collator-selection = { path = "../../pallets/collator-selection", default-features = false } -cumulus-pallet-aura-ext = { path = "../../pallets/aura-ext", default-features = false } -cumulus-primitives-core = { path = "../../primitives/core", default-features = false } -cumulus-primitives-storage-weight-reclaim = { path = "../../primitives/storage-weight-reclaim", default-features = false } +cumulus-pallet-parachain-system = { workspace = true } +parachain-info = { workspace = true } +cumulus-primitives-aura = { workspace = true } +pallet-collator-selection = { workspace = true } +cumulus-pallet-aura-ext = { workspace = true } +cumulus-primitives-core = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -76,6 +74,7 @@ std = [ "pallet-sudo/std", "pallet-timestamp/std", "pallet-transaction-payment/std", + "parachain-info/std", "scale-info/std", "sp-api/std", "sp-block-builder/std", @@ -87,9 +86,9 @@ std = [ "sp-offchain/std", "sp-runtime/std", "sp-session/std", - "sp-std/std", "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", ] increment-spec-version = [] +elastic-scaling = [] diff --git a/cumulus/test/runtime/build.rs b/cumulus/test/runtime/build.rs index ebd5c178cba07e2889b6501a9be490344467d228..bf579f4121e5f6b48fa5ba310c76f7cdd02fa7a0 100644 --- a/cumulus/test/runtime/build.rs +++ b/cumulus/test/runtime/build.rs @@ -24,6 +24,13 @@ fn main() { .enable_feature("increment-spec-version") .set_file_name("wasm_binary_spec_version_incremented.rs") .build(); + + WasmBuilder::new() + .with_current_project() + .enable_feature("elastic-scaling") + .import_memory() + .set_file_name("wasm_binary_elastic_scaling.rs") + .build(); } #[cfg(not(feature = "std"))] diff --git a/cumulus/test/runtime/src/lib.rs b/cumulus/test/runtime/src/lib.rs index 22dc5d857b7c07a7285d3ad2b76f87b15dc5718d..274f16ab630d6c0f9cff092b0ed79624e2a27a67 100644 --- a/cumulus/test/runtime/src/lib.rs +++ b/cumulus/test/runtime/src/lib.rs @@ -27,7 +27,16 @@ pub mod wasm_spec_version_incremented { include!(concat!(env!("OUT_DIR"), "/wasm_binary_spec_version_incremented.rs")); } +pub mod elastic_scaling { + #[cfg(feature = "std")] + include!(concat!(env!("OUT_DIR"), "/wasm_binary_elastic_scaling.rs")); +} + mod test_pallet; + +extern crate alloc; + +use alloc::{vec, vec::Vec}; use frame_support::{derive_impl, traits::OnRuntimeUpgrade, PalletId}; use sp_api::{decl_runtime_apis, impl_runtime_apis}; pub use sp_consensus_aura::sr25519::AuthorityId as AuraId; @@ -39,7 +48,6 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, MultiSignature, }; -use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -66,7 +74,7 @@ use frame_system::{ pub use pallet_balances::Call as BalancesCall; pub use pallet_glutton::Call as GluttonCall; pub use pallet_sudo::Call as SudoCall; -pub use pallet_timestamp::Call as TimestampCall; +pub use pallet_timestamp::{Call as TimestampCall, Now}; #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; pub use sp_runtime::{Perbill, Permill}; @@ -83,8 +91,23 @@ impl_opaque_keys! { /// The para-id used in this runtime. pub const PARACHAIN_ID: u32 = 100; -const UNINCLUDED_SEGMENT_CAPACITY: u32 = 3; +#[cfg(not(feature = "elastic-scaling"))] +const UNINCLUDED_SEGMENT_CAPACITY: u32 = 4; +#[cfg(not(feature = "elastic-scaling"))] const BLOCK_PROCESSING_VELOCITY: u32 = 1; + +#[cfg(feature = "elastic-scaling")] +const UNINCLUDED_SEGMENT_CAPACITY: u32 = 7; +#[cfg(feature = "elastic-scaling")] +const BLOCK_PROCESSING_VELOCITY: u32 = 4; + +#[cfg(not(feature = "elastic-scaling"))] +pub const MILLISECS_PER_BLOCK: u64 = 6000; +#[cfg(feature = "elastic-scaling")] +pub const MILLISECS_PER_BLOCK: u64 = 2000; + +pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; + const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000; // The only difference between the two declarations below is the `spec_version`. With the @@ -126,10 +149,6 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { state_version: 1, }; -pub const MILLISECS_PER_BLOCK: u64 = 6000; - -pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; - pub const EPOCH_DURATION_IN_BLOCKS: u32 = 10 * MINUTES; // These time units are defined in number of blocks. @@ -280,7 +299,7 @@ type ConsensusHook = cumulus_pallet_aura_ext::FixedVelocityConsensusHook< >; impl cumulus_pallet_parachain_system::Config for Runtime { type WeightInfo = (); - type SelfParaId = ParachainId; + type SelfParaId = parachain_info::Pallet; type RuntimeEvent = RuntimeEvent; type OnSystemEvent = (); type OutboundXcmpMessageSource = (); @@ -294,6 +313,8 @@ impl cumulus_pallet_parachain_system::Config for Runtime { type ConsensusHook = ConsensusHook; } +impl parachain_info::Config for Runtime {} + impl pallet_aura::Config for Runtime { type AuthorityId = AuraId; type DisabledValidators = (); @@ -302,11 +323,6 @@ impl pallet_aura::Config for Runtime { type SlotDuration = ConstU64; } -parameter_types! { - // will be set by test_pallet during genesis init - pub storage ParachainId: cumulus_primitives_core::ParaId = PARACHAIN_ID.into(); -} - impl test_pallet::Config for Runtime {} construct_runtime! { @@ -315,6 +331,7 @@ construct_runtime! { System: frame_system, ParachainSystem: cumulus_pallet_parachain_system, Timestamp: pallet_timestamp, + ParachainInfo: parachain_info, Balances: pallet_balances, Sudo: pallet_sudo, TransactionPayment: pallet_transaction_payment, @@ -440,7 +457,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> Vec { Runtime::metadata_versions() } } @@ -501,7 +518,7 @@ impl_runtime_apis! { impl crate::GetLastTimestamp for Runtime { fn get_last_timestamp() -> u64 { - Timestamp::now() + Now::::get() } } diff --git a/cumulus/test/runtime/src/test_pallet.rs b/cumulus/test/runtime/src/test_pallet.rs index 5d11b7f490c68351ea0612e809872a0f217681d3..61195386ae79d2501965a8048a08c12143407348 100644 --- a/cumulus/test/runtime/src/test_pallet.rs +++ b/cumulus/test/runtime/src/test_pallet.rs @@ -42,7 +42,7 @@ pub mod pallet { #[pallet::weight(0)] pub fn set_custom_validation_head_data( _: OriginFor, - custom_header: sp_std::vec::Vec, + custom_header: alloc::vec::Vec, ) -> DispatchResult { cumulus_pallet_parachain_system::Pallet::::set_custom_validation_head_data( custom_header, @@ -78,18 +78,14 @@ pub mod pallet { #[derive(frame_support::DefaultNoBound)] #[pallet::genesis_config] pub struct GenesisConfig { - pub self_para_id: Option, #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, } #[pallet::genesis_build] impl BuildGenesisConfig for GenesisConfig { fn build(&self) { sp_io::storage::set(TEST_RUNTIME_UPGRADE_KEY, &[1, 2, 3, 4]); - self.self_para_id.map(|para_id| { - crate::ParachainId::set(¶_id); - }); } } } diff --git a/cumulus/test/service/Cargo.toml b/cumulus/test/service/Cargo.toml index 18213b2f6326c4d755e07d66cb13ed4424226fc7..f766d123632096a4af578fcf87bdb0b299008028 100644 --- a/cumulus/test/service/Cargo.toml +++ b/cumulus/test/service/Cargo.toml @@ -13,96 +13,94 @@ name = "test-parachain" path = "src/main.rs" [dependencies] -async-trait = "0.1.79" -clap = { version = "4.5.3", features = ["derive"] } -codec = { package = "parity-scale-codec", version = "3.0.0" } -criterion = { version = "0.5.1", features = ["async_tokio"] } -jsonrpsee = { version = "0.22", features = ["server"] } -rand = "0.8.5" +async-trait = { workspace = true } +clap = { features = ["derive"], workspace = true } +codec = { workspace = true, default-features = true } +criterion = { features = ["async_tokio"], workspace = true, default-features = true } +jsonrpsee = { features = ["server"], workspace = true } +rand = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -tokio = { version = "1.32.0", features = ["macros"] } -tracing = "0.1.37" -url = "2.4.0" -tempfile = "3.8.0" +tokio = { features = ["macros"], workspace = true, default-features = true } +tracing = { workspace = true, default-features = true } +url = { workspace = true } +tempfile = { workspace = true } # Substrate -frame-system = { path = "../../../substrate/frame/system" } -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api" } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment" } -sc-basic-authorship = { path = "../../../substrate/client/basic-authorship" } -sc-chain-spec = { path = "../../../substrate/client/chain-spec" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-consensus = { path = "../../../substrate/client/consensus/common" } -sc-consensus-aura = { path = "../../../substrate/client/consensus/aura" } -sc-executor = { path = "../../../substrate/client/executor" } -sc-network = { path = "../../../substrate/client/network" } -sc-service = { path = "../../../substrate/client/service" } -sc-tracing = { path = "../../../substrate/client/tracing" } -sc-transaction-pool = { path = "../../../substrate/client/transaction-pool" } -sc-transaction-pool-api = { path = "../../../substrate/client/transaction-pool/api" } -sc-telemetry = { path = "../../../substrate/client/telemetry" } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -sp-timestamp = { path = "../../../substrate/primitives/timestamp" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -sp-consensus-aura = { path = "../../../substrate/primitives/consensus/aura" } -substrate-test-client = { path = "../../../substrate/test-utils/client" } -sc-cli = { path = "../../../substrate/client/cli" } -sc-block-builder = { path = "../../../substrate/client/block-builder" } -sc-executor-wasmtime = { path = "../../../substrate/client/executor/wasmtime" } -sc-executor-common = { path = "../../../substrate/client/executor/common" } +frame-system = { workspace = true, default-features = true } +frame-system-rpc-runtime-api = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +sc-basic-authorship = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-aura = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-state-machine = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +substrate-test-client = { workspace = true } +sc-cli = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-executor-wasmtime = { workspace = true, default-features = true } +sc-executor-common = { workspace = true, default-features = true } # Polkadot -polkadot-primitives = { path = "../../../polkadot/primitives" } -polkadot-service = { path = "../../../polkadot/node/service" } -polkadot-test-service = { path = "../../../polkadot/node/test/service" } -polkadot-cli = { path = "../../../polkadot/cli" } -polkadot-node-subsystem = { path = "../../../polkadot/node/subsystem" } -polkadot-overseer = { path = "../../../polkadot/node/overseer" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-service = { workspace = true, default-features = true } +polkadot-test-service = { workspace = true } +polkadot-cli = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } # Cumulus -cumulus-client-cli = { path = "../../client/cli" } -parachains-common = { path = "../../parachains/common" } -cumulus-client-consensus-common = { path = "../../client/consensus/common" } -cumulus-client-consensus-proposer = { path = "../../client/consensus/proposer" } -cumulus-client-consensus-aura = { path = "../../client/consensus/aura" } -cumulus-client-consensus-relay-chain = { path = "../../client/consensus/relay-chain" } -cumulus-client-parachain-inherent = { path = "../../client/parachain-inherent" } -cumulus-client-service = { path = "../../client/service" } -cumulus-client-collator = { path = "../../client/collator" } -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-relay-chain-inprocess-interface = { path = "../../client/relay-chain-inprocess-interface" } -cumulus-relay-chain-interface = { path = "../../client/relay-chain-interface" } -cumulus-test-runtime = { path = "../runtime" } -cumulus-relay-chain-minimal-node = { path = "../../client/relay-chain-minimal-node" } -cumulus-client-pov-recovery = { path = "../../client/pov-recovery" } -cumulus-test-relay-sproof-builder = { path = "../relay-sproof-builder" } -cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system", default-features = false, features = ["parameterized-consensus-hook"] } -cumulus-primitives-storage-weight-reclaim = { path = "../../primitives/storage-weight-reclaim" } -pallet-timestamp = { path = "../../../substrate/frame/timestamp" } +cumulus-client-cli = { workspace = true, default-features = true } +parachains-common = { workspace = true, default-features = true } +cumulus-client-consensus-common = { workspace = true, default-features = true } +cumulus-client-consensus-proposer = { workspace = true, default-features = true } +cumulus-client-consensus-aura = { workspace = true, default-features = true } +cumulus-client-consensus-relay-chain = { workspace = true, default-features = true } +cumulus-client-parachain-inherent = { workspace = true, default-features = true } +cumulus-client-service = { workspace = true, default-features = true } +cumulus-client-collator = { workspace = true, default-features = true } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-relay-chain-inprocess-interface = { workspace = true, default-features = true } +cumulus-relay-chain-interface = { workspace = true, default-features = true } +cumulus-test-runtime = { workspace = true } +cumulus-relay-chain-minimal-node = { workspace = true, default-features = true } +cumulus-client-pov-recovery = { workspace = true, default-features = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true, default-features = true } +pallet-timestamp = { workspace = true, default-features = true } [dev-dependencies] -futures = "0.3.28" -portpicker = "0.1.1" -rococo-parachain-runtime = { path = "../../parachains/runtimes/testing/rococo-parachain" } -sp-consensus-grandpa = { path = "../../../substrate/primitives/consensus/grandpa" } -sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery" } -cumulus-test-client = { path = "../client" } +futures = { workspace = true } +portpicker = { workspace = true } +sp-authority-discovery = { workspace = true, default-features = true } +cumulus-test-client = { workspace = true } # Polkadot dependencies -polkadot-test-service = { path = "../../../polkadot/node/test/service" } +polkadot-test-service = { workspace = true } # Substrate dependencies -sc-cli = { path = "../../../substrate/client/cli" } -substrate-test-utils = { path = "../../../substrate/test-utils" } +sc-cli = { workspace = true, default-features = true } +substrate-test-utils = { workspace = true } [features] runtime-benchmarks = [ @@ -116,7 +114,6 @@ runtime-benchmarks = [ "polkadot-primitives/runtime-benchmarks", "polkadot-service/runtime-benchmarks", "polkadot-test-service/runtime-benchmarks", - "rococo-parachain-runtime/runtime-benchmarks", "sc-service/runtime-benchmarks", "sp-runtime/runtime-benchmarks", ] diff --git a/cumulus/test/service/benches/validate_block_glutton.rs b/cumulus/test/service/benches/validate_block_glutton.rs index 6ec338c7f14280fc0de6f1067e94e3f5e77de77c..6fe26519a3ebdc96c45d90f2f2f990b4ac154e38 100644 --- a/cumulus/test/service/benches/validate_block_glutton.rs +++ b/cumulus/test/service/benches/validate_block_glutton.rs @@ -43,7 +43,7 @@ use sp_runtime::traits::Header as HeaderT; use cumulus_test_service::bench_utils as utils; async fn import_block( - mut client: &cumulus_test_client::Client, + client: &cumulus_test_client::Client, built: cumulus_test_runtime::Block, import_existing: bool, ) { diff --git a/cumulus/test/service/src/bench_utils.rs b/cumulus/test/service/src/bench_utils.rs index 4ace894b392aa2393741572249ed35f0a7101845..67ffbdd1d2129921782626300292d2267f26a8a0 100644 --- a/cumulus/test/service/src/bench_utils.rs +++ b/cumulus/test/service/src/bench_utils.rs @@ -111,7 +111,7 @@ pub fn extrinsic_set_validation_data( } /// Import block into the given client and make sure the import was successful -pub async fn import_block(mut client: &TestClient, block: &NodeBlock, import_existing: bool) { +pub async fn import_block(client: &TestClient, block: &NodeBlock, import_existing: bool) { let mut params = BlockImportParams::new(BlockOrigin::File, block.header.clone()); params.body = Some(block.extrinsics.clone()); params.state_action = StateAction::Execute; diff --git a/cumulus/test/service/src/chain_spec.rs b/cumulus/test/service/src/chain_spec.rs index 4db2513e2b6311675c8d3b565a817d1b7ce95f8b..ae71028ad486a46f32347f925e645ff0980bd652 100644 --- a/cumulus/test/service/src/chain_spec.rs +++ b/cumulus/test/service/src/chain_spec.rs @@ -17,7 +17,7 @@ #![allow(missing_docs)] use cumulus_primitives_core::ParaId; -use cumulus_test_runtime::{AccountId, RuntimeGenesisConfig, Signature}; +use cumulus_test_runtime::{AccountId, Signature}; use parachains_common::AuraId; use sc_chain_spec::{ChainSpecExtension, ChainSpecGroup}; use sc_service::ChainType; @@ -26,7 +26,7 @@ use sp_core::{sr25519, Pair, Public}; use sp_runtime::traits::{IdentifyAccount, Verify}; /// Specialized `ChainSpec` for the normal parachain runtime. -pub type ChainSpec = sc_service::GenericChainSpec; +pub type ChainSpec = sc_service::GenericChainSpec; /// Helper function to generate a crypto pair from seed pub fn get_from_seed(seed: &str) -> ::Public { @@ -66,9 +66,10 @@ where pub fn get_chain_spec_with_extra_endowed( id: Option, extra_endowed_accounts: Vec, + code: &[u8], ) -> ChainSpec { ChainSpec::builder( - cumulus_test_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), + code, Extensions { para_id: id.unwrap_or(cumulus_test_runtime::PARACHAIN_ID.into()).into() }, ) .with_name("Local Testnet") @@ -83,7 +84,21 @@ pub fn get_chain_spec_with_extra_endowed( /// Get the chain spec for a specific parachain ID. pub fn get_chain_spec(id: Option) -> ChainSpec { - get_chain_spec_with_extra_endowed(id, Default::default()) + get_chain_spec_with_extra_endowed( + id, + Default::default(), + cumulus_test_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), + ) +} + +/// Get the chain spec for a specific parachain ID. +pub fn get_elastic_scaling_chain_spec(id: Option) -> ChainSpec { + get_chain_spec_with_extra_endowed( + id, + Default::default(), + cumulus_test_runtime::elastic_scaling::WASM_BINARY + .expect("WASM binary was not built, please build it!"), + ) } /// Local testnet genesis for testing. @@ -142,7 +157,9 @@ pub fn testnet_genesis( balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 60)).collect(), }, "sudo": cumulus_test_runtime::SudoConfig { key: Some(root_key) }, - "testPallet": cumulus_test_runtime::TestPalletConfig { self_para_id: Some(self_para_id), ..Default::default() }, + "parachainInfo": { + "parachainId": self_para_id, + }, "aura": cumulus_test_runtime::AuraConfig { authorities: invulnerables } }) } diff --git a/cumulus/test/service/src/cli.rs b/cumulus/test/service/src/cli.rs index 87d1d4af8a95e0edf12efc454d5505a6c1ad7544..739c2d4bda160e588db43a82082b459db6f3dab9 100644 --- a/cumulus/test/service/src/cli.rs +++ b/cumulus/test/service/src/cli.rs @@ -14,13 +14,13 @@ // You should have received a copy of the GNU General Public License // along with Cumulus. If not, see . -use std::{net::SocketAddr, path::PathBuf}; +use std::path::PathBuf; use cumulus_client_cli::{ExportGenesisHeadCommand, ExportGenesisWasmCommand}; use polkadot_service::{ChainSpec, ParaId, PrometheusConfig}; use sc_cli::{ CliConfiguration, DefaultConfigurationValues, ImportParams, KeystoreParams, NetworkParams, - Result as CliResult, SharedParams, SubstrateCli, + Result as CliResult, RpcEndpoint, SharedParams, SubstrateCli, }; use sc_service::BasePath; @@ -50,6 +50,12 @@ pub struct TestCollatorCli { #[arg(long)] pub fail_pov_recovery: bool, + + /// EXPERIMENTAL: Use slot-based collator which can handle elastic scaling. + /// + /// Use with care, this flag is unstable and subject to change. + #[arg(long)] + pub experimental_use_slot_based: bool, } #[derive(Debug, clap::Subcommand)] @@ -116,7 +122,7 @@ impl CliConfiguration for RelayChainCli { .or_else(|| self.base_path.clone().map(Into::into))) } - fn rpc_addr(&self, default_listen_port: u16) -> CliResult> { + fn rpc_addr(&self, default_listen_port: u16) -> CliResult>> { self.base.base.rpc_addr(default_listen_port) } @@ -253,8 +259,16 @@ impl SubstrateCli for TestCollatorCli { fn load_spec(&self, id: &str) -> std::result::Result, String> { Ok(match id { - "" => - Box::new(cumulus_test_service::get_chain_spec(Some(ParaId::from(2000)))) as Box<_>, + "" => { + tracing::info!("Using default test service chain spec."); + Box::new(cumulus_test_service::get_chain_spec(Some(ParaId::from(2000)))) as Box<_> + }, + "elastic-scaling" => { + tracing::info!("Using elastic-scaling chain spec."); + Box::new(cumulus_test_service::get_elastic_scaling_chain_spec(Some(ParaId::from( + 2100, + )))) as Box<_> + }, path => { let chain_spec = cumulus_test_service::chain_spec::ChainSpec::from_json_file(path.into())?; diff --git a/cumulus/test/service/src/lib.rs b/cumulus/test/service/src/lib.rs index f2a612803861ce143aa08d6ae7abbf8963c31ef3..bc0fe9090d38ed533c784b58598f856ed5738e10 100644 --- a/cumulus/test/service/src/lib.rs +++ b/cumulus/test/service/src/lib.rs @@ -25,7 +25,10 @@ pub mod chain_spec; use cumulus_client_collator::service::CollatorService; use cumulus_client_consensus_aura::{ - collators::lookahead::{self as aura, Params as AuraParams}, + collators::{ + lookahead::{self as aura, Params as AuraParams}, + slot_based::{self as slot_based, Params as SlotBasedParams}, + }, ImportQueueParams, }; use cumulus_client_consensus_proposer::Proposer; @@ -35,7 +38,7 @@ use sp_consensus_aura::sr25519::AuthorityPair; use std::{ collections::HashSet, future::Future, - net::{IpAddr, Ipv4Addr, SocketAddr}, + net::{Ipv4Addr, SocketAddr, SocketAddrV4}, time::Duration, }; use url::Url; @@ -45,7 +48,7 @@ use cumulus_client_cli::{CollatorOptions, RelayChainMode}; use cumulus_client_consensus_common::{ ParachainBlockImport as TParachainBlockImport, ParachainCandidate, ParachainConsensus, }; -use cumulus_client_pov_recovery::RecoveryHandle; +use cumulus_client_pov_recovery::{RecoveryDelayRange, RecoveryHandle}; #[allow(deprecated)] use cumulus_client_service::old_consensus; use cumulus_client_service::{ @@ -76,7 +79,7 @@ use sc_network::{ use sc_service::{ config::{ BlocksPruning, DatabaseSource, KeystoreConfig, MultiaddrWithPeerId, NetworkConfiguration, - OffchainWorkerConfig, PruningMode, RpcBatchRequestConfig, WasmExecutionMethod, + OffchainWorkerConfig, PruningMode, RpcBatchRequestConfig, RpcEndpoint, WasmExecutionMethod, }, BasePath, ChainSpec as ChainSpecService, Configuration, Error as ServiceError, PartialComponents, Role, RpcHandlers, TFullBackend, TFullClient, TaskManager, @@ -152,7 +155,7 @@ impl RecoveryHandle for FailingRecoveryHandle { message: AvailabilityRecoveryMessage, origin: &'static str, ) { - let AvailabilityRecoveryMessage::RecoverAvailableData(ref receipt, _, _, _) = message; + let AvailabilityRecoveryMessage::RecoverAvailableData(ref receipt, _, _, _, _) = message; let candidate_hash = receipt.hash(); // For every 3rd block we immediately signal unavailability to trigger @@ -160,7 +163,8 @@ impl RecoveryHandle for FailingRecoveryHandle { if self.counter % 3 == 0 && self.failed_hashes.insert(candidate_hash) { tracing::info!(target: LOG_TARGET, ?candidate_hash, "Failing pov recovery."); - let AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, back_sender) = message; + let AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, back_sender) = + message; back_sender .send(Err(RecoveryError::Unavailable)) .expect("Return channel should work here."); @@ -303,7 +307,7 @@ async fn build_relay_chain_interface( /// Start a node with the given parachain `Configuration` and relay chain `Configuration`. /// /// This is the actual implementation that is abstract over the executor and the runtime api. -#[sc_tracing::logging::prefix_logs_with(parachain_config.network.node_name.as_str())] +#[sc_tracing::logging::prefix_logs_with("Parachain")] pub async fn start_node_impl>( parachain_config: Configuration, collator_key: Option, @@ -315,6 +319,7 @@ pub async fn start_node_impl>( consensus: Consensus, collator_options: CollatorOptions, proof_recording_during_import: bool, + use_slot_based_collator: bool, ) -> sc_service::error::Result<( TaskManager, Arc, @@ -348,7 +353,11 @@ where .map_err(|e| sc_service::Error::Application(Box::new(e) as Box<_>))?; let import_queue_service = params.import_queue.service(); - let net_config = FullNetworkConfiguration::::new(¶chain_config.network); + let prometheus_registry = parachain_config.prometheus_registry().cloned(); + let net_config = FullNetworkConfiguration::::new( + ¶chain_config.network, + prometheus_registry.clone(), + ); let (network, system_rpc_tx, tx_handler_controller, start_network, sync_service) = build_network(BuildNetworkParams { @@ -367,12 +376,10 @@ where }) .await?; - let prometheus_registry = parachain_config.prometheus_registry().cloned(); - let keystore = params.keystore_container.keystore(); let rpc_builder = { let client = client.clone(); - Box::new(move |_, _| rpc_ext_builder(client.clone())) + Box::new(move |_| rpc_ext_builder(client.clone())) }; let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams { @@ -408,7 +415,6 @@ where } else { Box::new(overseer_handle.clone()) }; - let is_collator = collator_key.is_some(); let relay_chain_slot_duration = Duration::from_secs(6); start_relay_chain_tasks(StartRelayChainTasksParams { @@ -417,11 +423,11 @@ where para_id, relay_chain_interface: relay_chain_interface.clone(), task_manager: &mut task_manager, - da_recovery_profile: if is_collator { - DARecoveryProfile::Collator - } else { - DARecoveryProfile::FullNode - }, + // Increase speed of recovery for testing purposes. + da_recovery_profile: DARecoveryProfile::Other(RecoveryDelayRange { + min: Duration::from_secs(1), + max: Duration::from_secs(5), + }), import_queue: import_queue_service, relay_chain_slot_duration, recovery_handle, @@ -460,29 +466,72 @@ where ); let client_for_aura = client.clone(); - let params = AuraParams { - create_inherent_data_providers: move |_, ()| async move { Ok(()) }, - block_import, - para_client: client.clone(), - para_backend: backend.clone(), - relay_client: relay_chain_interface, - code_hash_provider: move |block_hash| { - client_for_aura.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) - }, - sync_oracle: sync_service, - keystore, - collator_key, - para_id, - overseer_handle, - relay_chain_slot_duration, - proposer, - collator_service, - authoring_duration: Duration::from_millis(2000), - reinitialize: false, - }; - let fut = aura::run::(params); - task_manager.spawn_essential_handle().spawn("aura", None, fut); + if use_slot_based_collator { + tracing::info!(target: LOG_TARGET, "Starting block authoring with slot based authoring."); + let params = SlotBasedParams { + create_inherent_data_providers: move |_, ()| async move { Ok(()) }, + block_import, + para_client: client.clone(), + para_backend: backend.clone(), + relay_client: relay_chain_interface, + code_hash_provider: move |block_hash| { + client_for_aura + .code_at(block_hash) + .ok() + .map(|c| ValidationCode::from(c).hash()) + }, + keystore, + collator_key, + para_id, + relay_chain_slot_duration, + proposer, + collator_service, + authoring_duration: Duration::from_millis(2000), + reinitialize: false, + slot_drift: Duration::from_secs(1), + }; + + let (collation_future, block_builer_future) = + slot_based::run::(params); + task_manager.spawn_essential_handle().spawn( + "collation-task", + None, + collation_future, + ); + task_manager.spawn_essential_handle().spawn( + "block-builder-task", + None, + block_builer_future, + ); + } else { + tracing::info!(target: LOG_TARGET, "Starting block authoring with lookahead collator."); + let params = AuraParams { + create_inherent_data_providers: move |_, ()| async move { Ok(()) }, + block_import, + para_client: client.clone(), + para_backend: backend.clone(), + relay_client: relay_chain_interface, + code_hash_provider: move |block_hash| { + client_for_aura + .code_at(block_hash) + .ok() + .map(|c| ValidationCode::from(c).hash()) + }, + keystore, + collator_key, + para_id, + overseer_handle, + relay_chain_slot_duration, + proposer, + collator_service, + authoring_duration: Duration::from_millis(2000), + reinitialize: false, + }; + + let fut = aura::run::(params); + task_manager.spawn_essential_handle().spawn("aura", None, fut); + } } } @@ -719,6 +768,7 @@ impl TestNodeBuilder { self.consensus, collator_options, self.record_proof_during_import, + false, ) .await .expect("could not create Cumulus test service"), @@ -734,6 +784,7 @@ impl TestNodeBuilder { self.consensus, collator_options, self.record_proof_during_import, + false, ) .await .expect("could not create Cumulus test service"), @@ -765,8 +816,11 @@ pub fn node_config( let root = base_path.path().join(format!("cumulus_test_service_{}", key)); let role = if is_collator { Role::Authority } else { Role::Full }; let key_seed = key.to_seed(); - let mut spec = - Box::new(chain_spec::get_chain_spec_with_extra_endowed(Some(para_id), endowed_accounts)); + let mut spec = Box::new(chain_spec::get_chain_spec_with_extra_endowed( + Some(para_id), + endowed_accounts, + cumulus_test_runtime::WASM_BINARY.expect("WASM binary was not built, please build it!"), + )); let mut storage = spec.as_storage_builder().build_storage().expect("could not build storage"); @@ -839,7 +893,6 @@ pub fn node_config( announce_block: true, data_path: root, base_path, - informant_output_format: Default::default(), wasm_runtime_overrides: None, runtime_cache_size: 2, }) @@ -953,7 +1006,22 @@ pub fn run_relay_chain_validator_node( ); if let Some(port) = port { - config.rpc_addr = Some(SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), port)); + config.rpc_addr = Some(vec![RpcEndpoint { + batch_config: config.rpc_batch_config, + cors: config.rpc_cors.clone(), + listen_addr: SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, port)), + max_connections: config.rpc_max_connections, + max_payload_in_mb: config.rpc_max_request_size, + max_payload_out_mb: config.rpc_max_response_size, + max_subscriptions_per_connection: config.rpc_max_subs_per_conn, + max_buffer_capacity_per_connection: config.rpc_message_buffer_capacity, + rpc_methods: config.rpc_methods, + rate_limit: config.rpc_rate_limit, + rate_limit_trust_proxy_headers: config.rpc_rate_limit_trust_proxy_headers, + rate_limit_whitelisted_ips: config.rpc_rate_limit_whitelisted_ips.clone(), + retry_random_port: true, + is_optional: false, + }]); } let mut workers_path = std::env::current_exe().unwrap(); diff --git a/cumulus/test/service/src/main.rs b/cumulus/test/service/src/main.rs index 90d37173dd5907ebf1f4a136a284ef50dda816e8..9357978b769a4e8ec6c4f850d37290e3dee1b1e5 100644 --- a/cumulus/test/service/src/main.rs +++ b/cumulus/test/service/src/main.rs @@ -118,6 +118,7 @@ fn main() -> Result<(), sc_cli::Error> { consensus, collator_options, true, + cli.experimental_use_slot_based, ) .await, sc_network::config::NetworkBackendType::Litep2p => @@ -135,6 +136,7 @@ fn main() -> Result<(), sc_cli::Error> { consensus, collator_options, true, + cli.experimental_use_slot_based, ) .await, } diff --git a/cumulus/xcm/xcm-emulator/Cargo.toml b/cumulus/xcm/xcm-emulator/Cargo.toml index 6b45770a8e3df47cb083dba5a8a0eeed1759e338..ba1097fba075696e9d40dffc3c4753d9956615b1 100644 --- a/cumulus/xcm/xcm-emulator/Cargo.toml +++ b/cumulus/xcm/xcm-emulator/Cargo.toml @@ -10,36 +10,36 @@ license = "Apache-2.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0" } -paste = "1.0.14" +codec = { workspace = true, default-features = true } +paste = { workspace = true, default-features = true } log = { workspace = true } -lazy_static = "1.4.0" -impl-trait-for-tuples = "0.2.2" +lazy_static = { workspace = true } +impl-trait-for-tuples = { workspace = true } # Substrate -frame-support = { path = "../../../substrate/frame/support" } -frame-system = { path = "../../../substrate/frame/system" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-crypto-hashing = { path = "../../../substrate/primitives/crypto/hashing" } -sp-std = { path = "../../../substrate/primitives/std" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -pallet-balances = { path = "../../../substrate/frame/balances" } -pallet-message-queue = { path = "../../../substrate/frame/message-queue" } +frame-support = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-message-queue = { workspace = true, default-features = true } # Cumulus -cumulus-primitives-core = { path = "../../primitives/core" } -cumulus-pallet-xcmp-queue = { path = "../../pallets/xcmp-queue" } -cumulus-pallet-parachain-system = { path = "../../pallets/parachain-system" } -cumulus-primitives-parachain-inherent = { path = "../../primitives/parachain-inherent" } -cumulus-test-relay-sproof-builder = { path = "../../test/relay-sproof-builder" } -parachains-common = { path = "../../parachains/common" } +cumulus-primitives-core = { workspace = true, default-features = true } +cumulus-pallet-xcmp-queue = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true, default-features = true } +cumulus-primitives-parachain-inherent = { workspace = true, default-features = true } +cumulus-test-relay-sproof-builder = { workspace = true, default-features = true } +parachains-common = { workspace = true, default-features = true } # Polkadot -xcm = { package = "staging-xcm", path = "../../../polkadot/xcm" } -xcm-executor = { package = "staging-xcm-executor", path = "../../../polkadot/xcm/xcm-executor" } -polkadot-primitives = { path = "../../../polkadot/primitives" } -polkadot-parachain-primitives = { path = "../../../polkadot/parachain" } -polkadot-runtime-parachains = { path = "../../../polkadot/runtime/parachains" } +xcm = { workspace = true, default-features = true } +xcm-executor = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } diff --git a/cumulus/xcm/xcm-emulator/src/lib.rs b/cumulus/xcm/xcm-emulator/src/lib.rs index babb318a99500932dd8a2e42a2b443944751d286..8de3660c223627155a27f5ecc659a3ea030d7b02 100644 --- a/cumulus/xcm/xcm-emulator/src/lib.rs +++ b/cumulus/xcm/xcm-emulator/src/lib.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +extern crate alloc; + pub use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; pub use lazy_static::lazy_static; pub use log; @@ -24,6 +26,8 @@ pub use std::{ }; // Substrate +pub use alloc::collections::vec_deque::VecDeque; +pub use core::{cell::RefCell, fmt::Debug}; pub use cumulus_primitives_core::AggregateMessageOrigin as CumulusAggregateMessageOrigin; pub use frame_support::{ assert_ok, @@ -34,7 +38,9 @@ pub use frame_support::{ }, weights::{Weight, WeightMeter}, }; -pub use frame_system::{Config as SystemConfig, Pallet as SystemPallet}; +pub use frame_system::{ + pallet_prelude::BlockNumberFor, Config as SystemConfig, Pallet as SystemPallet, +}; pub use pallet_balances::AccountData; pub use pallet_message_queue; pub use sp_arithmetic::traits::Bounded; @@ -42,7 +48,6 @@ pub use sp_core::{parameter_types, sr25519, storage::Storage, Pair}; pub use sp_crypto_hashing::blake2_256; pub use sp_io::TestExternalities; pub use sp_runtime::BoundedSlice; -pub use sp_std::{cell::RefCell, collections::vec_deque::VecDeque, fmt::Debug}; pub use sp_tracing; // Cumulus @@ -54,7 +59,7 @@ pub use cumulus_primitives_core::{ pub use cumulus_primitives_parachain_inherent::ParachainInherentData; pub use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder; pub use pallet_message_queue::{Config as MessageQueueConfig, Pallet as MessageQueuePallet}; -pub use parachains_common::{AccountId, Balance, BlockNumber}; +pub use parachains_common::{AccountId, Balance}; pub use polkadot_primitives; pub use polkadot_runtime_parachains::inclusion::{AggregateMessageOrigin, UmpQueueId}; @@ -213,6 +218,7 @@ pub trait Chain: TestExt { type RuntimeOrigin; type RuntimeEvent; type System; + type OriginCaller; fn account_id_of(seed: &str) -> AccountId { helpers::get_account_id_from_seed::(seed) @@ -364,6 +370,7 @@ macro_rules! decl_test_relay_chains { type RuntimeOrigin = $runtime::RuntimeOrigin; type RuntimeEvent = $runtime::RuntimeEvent; type System = $crate::SystemPallet::; + type OriginCaller = $runtime::OriginCaller; fn account_data_of(account: $crate::AccountIdOf) -> $crate::AccountData<$crate::Balance> { ::ext_wrapper(|| $crate::SystemPallet::::account(account).data.into()) @@ -598,6 +605,7 @@ macro_rules! decl_test_parachains { type RuntimeOrigin = $runtime::RuntimeOrigin; type RuntimeEvent = $runtime::RuntimeEvent; type System = $crate::SystemPallet::; + type OriginCaller = $runtime::OriginCaller; type Network = N; fn account_data_of(account: $crate::AccountIdOf) -> $crate::AccountData<$crate::Balance> { @@ -657,7 +665,7 @@ macro_rules! decl_test_parachains { .clone() ); ::System::initialize(&block_number, &parent_head_data.hash(), &Default::default()); - <::ParachainSystem as Hooks<$crate::BlockNumber>>::on_initialize(block_number); + <::ParachainSystem as Hooks<$crate::BlockNumberFor>>::on_initialize(block_number); let _ = ::ParachainSystem::set_validation_data( ::RuntimeOrigin::none(), diff --git a/cumulus/zombienet/tests/0002-pov_recovery.zndsl b/cumulus/zombienet/tests/0002-pov_recovery.zndsl index b05285c87bff5a69312552d13b9b652bbd9d1bc1..dc7095ced252de497afd0fcd2cedadf460b412d1 100644 --- a/cumulus/zombienet/tests/0002-pov_recovery.zndsl +++ b/cumulus/zombienet/tests/0002-pov_recovery.zndsl @@ -2,7 +2,9 @@ Description: PoV recovery test Network: ./0002-pov_recovery.toml Creds: config -# wait 20 blocks and register parachain +# Wait 20 blocks and register parachain. This part is important for pov-recovery. +# We need to make sure that the recovering node is able to see all relay-chain +# notifications containing the candidates to recover. validator-3: reports block height is at least 20 within 250 seconds validator-0: js-script ./register-para.js with "2000" within 240 seconds validator-0: parachain 2000 is registered within 300 seconds diff --git a/cumulus/zombienet/tests/0003-full_node_catching_up.zndsl b/cumulus/zombienet/tests/0003-full_node_catching_up.zndsl index 49b6d9e94fd16d73ce7de3cf102fc2bfad1a6e76..e1e8442f30509c72c49673288920e6d5336a8bfb 100644 --- a/cumulus/zombienet/tests/0003-full_node_catching_up.zndsl +++ b/cumulus/zombienet/tests/0003-full_node_catching_up.zndsl @@ -6,3 +6,6 @@ alice: parachain 2000 is registered within 225 seconds dave: reports block height is at least 7 within 250 seconds eve: reports block height is at least 7 within 250 seconds ferdie: reports block height is at least 7 within 250 seconds + +# We want to make sure that none of the consensus hook checks fail, even if the chain makes progress +charlie: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds diff --git a/cumulus/zombienet/tests/0006-rpc_collator_builds_blocks.zndsl b/cumulus/zombienet/tests/0006-rpc_collator_builds_blocks.zndsl index 7da8416d0161a23f84184d288cb14fdcd3094fd5..b14c15ed5e5b90f8fed878c5c8c82eefbe71b624 100644 --- a/cumulus/zombienet/tests/0006-rpc_collator_builds_blocks.zndsl +++ b/cumulus/zombienet/tests/0006-rpc_collator_builds_blocks.zndsl @@ -13,3 +13,7 @@ two: restart after 1 seconds three: restart after 20 seconds dave: is up dave: reports block height is at least 30 within 200 seconds + +# We want to make sure that none of the consensus hook checks fail, even if the chain makes progress +dave: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds +eve: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds diff --git a/cumulus/zombienet/tests/0008-elastic_authoring.toml b/cumulus/zombienet/tests/0008-elastic_authoring.toml new file mode 100644 index 0000000000000000000000000000000000000000..f2e2010a9e4582feefaebdaa355ab96b6a8f7695 --- /dev/null +++ b/cumulus/zombienet/tests/0008-elastic_authoring.toml @@ -0,0 +1,50 @@ +[settings] +timeout = 1000 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params] + max_candidate_depth = 6 + allowed_ancestry_len = 3 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] + max_validators_per_core = 1 + num_cores = 4 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params] + max_approval_coalesce_count = 5 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +command = "polkadot" + + [[relaychain.nodes]] + name = "alice" + args = ["" ] + + [[relaychain.node_groups]] + name = "validator" + args = ["-lruntime=debug,parachain=trace" ] + count = 8 + +# Slot based authoring with 3 cores and 2s slot duration +[[parachains]] +id = 2100 +chain = "elastic-scaling" +add_to_genesis = true + + [[parachains.collators]] + name = "collator-elastic" + image = "{{COL_IMAGE}}" + command = "test-parachain" + args = ["-laura=trace,runtime=info,cumulus-consensus=trace,consensus::common=trace,parachain::collation-generation=trace,parachain::collator-protocol=trace,parachain=debug", "--force-authoring", "--experimental-use-slot-based"] + +# Slot based authoring with 1 core and 6s slot duration +[[parachains]] +id = 2000 +add_to_genesis = true + + [[parachains.collators]] + name = "collator-single-core" + image = "{{COL_IMAGE}}" + command = "test-parachain" + args = ["-laura=trace,runtime=info,cumulus-consensus=trace,consensus::common=trace,parachain::collation-generation=trace,parachain::collator-protocol=trace,parachain=debug", "--force-authoring", "--experimental-use-slot-based"] diff --git a/cumulus/zombienet/tests/0008-elastic_authoring.zndsl b/cumulus/zombienet/tests/0008-elastic_authoring.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..a06ffd24fefd2bab46de4c80b210959a62660da1 --- /dev/null +++ b/cumulus/zombienet/tests/0008-elastic_authoring.zndsl @@ -0,0 +1,19 @@ +Description: Slot based authoring for elastic scaling +Network: ./0008-elastic_authoring.toml +Creds: config + +alice: is up +collator-elastic: is up +collator-single-core: is up + + +# configure relay chain +alice: js-script ./assign-core.js with "2100,0" return is 0 within 600 seconds +alice: js-script ./assign-core.js with "2100,1" return is 0 within 600 seconds + +collator-single-core: reports block height is at least 20 within 225 seconds +collator-elastic: reports block height is at least 40 within 225 seconds + +# We want to make sure that none of the consensus hook checks fail, even if the chain makes progress +collator-elastic: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds +collator-single-core: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds diff --git a/cumulus/zombienet/tests/0009-elastic_pov_recovery.toml b/cumulus/zombienet/tests/0009-elastic_pov_recovery.toml new file mode 100644 index 0000000000000000000000000000000000000000..b695f8aa937653340534d9366a5eab210888e416 --- /dev/null +++ b/cumulus/zombienet/tests/0009-elastic_pov_recovery.toml @@ -0,0 +1,48 @@ +[settings] +timeout = 1000 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params] + max_candidate_depth = 6 + allowed_ancestry_len = 3 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] + max_validators_per_core = 1 + num_cores = 4 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params] + max_approval_coalesce_count = 5 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +command = "polkadot" + + [[relaychain.nodes]] + name = "alice" + args = ["" ] + + [[relaychain.node_groups]] + name = "validator" + args = ["-lruntime=debug,parachain=trace", "--reserved-only", "--reserved-nodes {{'alice'|zombie('multiAddress')}}"] + count = 8 + +# Slot based authoring with 3 cores and 2s slot duration +[[parachains]] +id = 2100 +chain = "elastic-scaling" +add_to_genesis = false + + # Slot based authoring with 3 cores and 2s slot duration + [[parachains.collators]] + name = "collator-elastic" + image = "{{COL_IMAGE}}" + command = "test-parachain" + args = ["--disable-block-announcements", "-laura=trace,runtime=info,cumulus-consensus=trace,consensus::common=trace,parachain::collation-generation=trace,parachain::collator-protocol=trace,parachain=debug", "--force-authoring", "--experimental-use-slot-based"] + + # run 'recovery-target' as a parachain full node + [[parachains.collators]] + name = "recovery-target" + validator = false # full node + image = "{{COL_IMAGE}}" + command = "test-parachain" + args = ["-lparachain::availability=trace,sync=debug,parachain=debug,cumulus-pov-recovery=debug,cumulus-consensus=debug", "--disable-block-announcements", "--bootnodes {{'collator-elastic'|zombie('multiAddress')}}", "--in-peers 0", "--out-peers 0", "--", "--reserved-only", "--reserved-nodes {{'alice'|zombie('multiAddress')}}"] diff --git a/cumulus/zombienet/tests/0009-elastic_pov_recovery.zndsl b/cumulus/zombienet/tests/0009-elastic_pov_recovery.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..5cca6120ff3a37dbff4d3d93c8ad977e5404f645 --- /dev/null +++ b/cumulus/zombienet/tests/0009-elastic_pov_recovery.zndsl @@ -0,0 +1,24 @@ +Description: Elastic scaling PoV recovery test +Network: ./0009-elastic_pov_recovery.toml +Creds: config + +alice: is up +collator-elastic: is up + +# configure relay chain +alice: js-script ./assign-core.js with "2100,0" return is 0 within 200 seconds +alice: js-script ./assign-core.js with "2100,1" return is 0 within 200 seconds + +# Wait 20 blocks and register parachain. This part is important for pov-recovery. +# We need to make sure that the recovering node is able to see all relay-chain +# notifications containing the candidates to recover. +alice: reports block height is at least 20 within 250 seconds +alice: js-script ./register-para.js with "2100" within 240 seconds +alice: parachain 2100 is registered within 300 seconds + + +# check block production +collator-elastic: reports block height is at least 40 within 225 seconds +collator-elastic: count of log lines containing "set_validation_data inherent needs to be present in every block" is 0 within 10 seconds + +recovery-target: count of log lines containing "Importing block retrieved using pov_recovery" is greater than 35 within 10 seconds diff --git a/cumulus/zombienet/tests/assign-core.js b/cumulus/zombienet/tests/assign-core.js new file mode 100644 index 0000000000000000000000000000000000000000..4179b68b2e3cb139bb48d937b472258e943ddce2 --- /dev/null +++ b/cumulus/zombienet/tests/assign-core.js @@ -0,0 +1,46 @@ +// Assign a parachain to a core. +// +// First argument should be the parachain id. +// Second argument should be the core. +async function run(nodeName, networkInfo, args) { + const { wsUri, userDefinedTypes } = networkInfo.nodesByName[nodeName]; + const api = await zombie.connect(wsUri, userDefinedTypes); + + let para = Number(args[0]); + let core = Number(args[1]); + console.log(`Assigning para ${para} to core ${core}`); + + await zombie.util.cryptoWaitReady(); + + // Submit transaction with Alice accoung + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + + // Wait for this transaction to be finalized in a block. + await new Promise(async (resolve, reject) => { + const unsub = await api.tx.sudo + .sudo(api.tx.coretime.assignCore(core, 0, [[{ task: para }, 57600]], null)) + .signAndSend(alice, ({ status, isError }) => { + if (status.isInBlock) { + console.log( + `Transaction included at blockhash ${status.asInBlock}`, + ); + } else if (status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${status.asFinalized}`, + ); + unsub(); + return resolve(); + } else if (isError) { + console.log(`Transaction error`); + reject(`Transaction error`); + } + }); + }); + + + + return 0; +} + +module.exports = { run }; diff --git a/docker/dockerfiles/binary_injected.Dockerfile b/docker/dockerfiles/binary_injected.Dockerfile index c8930bd83f0274990aff281e84d75b7add9d1289..26c0ef7ae6414a472c04b17294d964572c14213a 100644 --- a/docker/dockerfiles/binary_injected.Dockerfile +++ b/docker/dockerfiles/binary_injected.Dockerfile @@ -32,7 +32,7 @@ LABEL io.parity.image.authors=${AUTHORS} \ USER root WORKDIR /app -# add polkadot binary to docker image +# add binary to docker image # sample for polkadot: COPY ./polkadot ./polkadot-*-worker /usr/local/bin/ COPY entrypoint.sh . COPY "bin/*" "/usr/local/bin/" diff --git a/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile b/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile index 196ba861f503c0fc82b6eb0e428df600ce6bfd49..55b9156e6a0ae811c8ef1d2bf8761452ae8c561a 100644 --- a/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile +++ b/docker/dockerfiles/bridges_zombienet_tests_injected.Dockerfile @@ -1,7 +1,7 @@ # this image is built on top of existing Zombienet image ARG ZOMBIENET_IMAGE # this image uses substrate-relay image built elsewhere -ARG SUBSTRATE_RELAY_IMAGE=docker.io/paritytech/substrate-relay:v1.5.0 +ARG SUBSTRATE_RELAY_IMAGE=docker.io/paritytech/substrate-relay:v1.6.8 # metadata ARG VCS_REF diff --git a/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile b/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile index 7e460bb22e892a30d360a69815e43b8c197d0fda..b68bf93fce994620567e9d61879057a2b4632312 100644 --- a/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile +++ b/docker/dockerfiles/polkadot/polkadot_builder.Dockerfile @@ -1,5 +1,5 @@ # This is the build stage for Polkadot. Here we create the binary in a temporary image. -FROM docker.io/paritytech/ci-linux:production as builder +FROM docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v20240408 as builder WORKDIR /polkadot COPY . /polkadot @@ -19,7 +19,8 @@ LABEL description="Multistage Docker image for Polkadot: a platform for web3" \ COPY --from=builder /polkadot/target/release/polkadot /usr/local/bin -RUN useradd -m -u 1000 -U -s /bin/sh -d /polkadot polkadot && \ +USER root +RUN useradd -m -u 1001 -U -s /bin/sh -d /polkadot polkadot && \ mkdir -p /data /polkadot/.local/share && \ chown -R polkadot:polkadot /data && \ ln -s /data /polkadot/.local/share/polkadot && \ diff --git a/docker/scripts/chain-spec-builder/build-injected.sh b/docker/scripts/chain-spec-builder/build-injected.sh new file mode 100755 index 0000000000000000000000000000000000000000..ede6cee3851382829d9f1793749a1358cf780edd --- /dev/null +++ b/docker/scripts/chain-spec-builder/build-injected.sh @@ -0,0 +1,14 @@ +#!/usr/bin/env bash + +# Sample call: +# $0 /path/to/folder_with_binary +# This script replace the former dedicated Dockerfile +# and shows how to use the generic binary_injected.dockerfile + +PROJECT_ROOT=`git rev-parse --show-toplevel` + +export BINARY=chain-spec-builder +export ARTIFACTS_FOLDER=$1 +# export TAGS=... + +$PROJECT_ROOT/docker/scripts/build-injected.sh diff --git a/docker/scripts/chain-spec-builder/test-build.sh b/docker/scripts/chain-spec-builder/test-build.sh new file mode 100755 index 0000000000000000000000000000000000000000..a42cab97703481c03698c417b9e995618db8c0c1 --- /dev/null +++ b/docker/scripts/chain-spec-builder/test-build.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash + +TMP=$(mktemp -d) +ENGINE=${ENGINE:-podman} + +export TAGS=latest,beta,7777,1.0.2-rc23 + +# Fetch some binaries +$ENGINE run --user root --rm -i \ + --pull always \ + -v "$TMP:/export" \ + --entrypoint /bin/bash \ + parity/chain-spec-builder -c \ + 'cp "$(which chain-spec-builder)" /export' + +echo "Checking binaries we got:" +ls -al $TMP + +./build-injected.sh $TMP diff --git a/docs/BACKPORT.md b/docs/BACKPORT.md new file mode 100644 index 0000000000000000000000000000000000000000..0b4a97e6f667594ffb38f8b12e3a35f3d0720d16 --- /dev/null +++ b/docs/BACKPORT.md @@ -0,0 +1,21 @@ +# Backporting + +This document explains how to backport a merged PR from `master` to one of the `stable*` branches. +Backports should only be used to fix bugs or security issues - never to introduce new features. + +## Steps + +1. Fix a bug through a PR that targets `master`. +2. Add label `A4-needs-backport` to the PR. +3. Merge the PR into `master`. +4. Wait for the bot to open the backport PR. +5. Ensure the change is audited or does not need audit. +6. Merge the backport PR. + +The label can also be added after the PR is merged. + +## Example + +For example here where the dev triggered the process by adding the label after merging: + +![backport](./images/backport-ex2.png) diff --git a/docs/RELEASE.md b/docs/RELEASE.md index e73be2779a99426203e209da846f938c0f73cceb..bea36741135969fb216fbe559709d8b43a1c4b35 100644 --- a/docs/RELEASE.md +++ b/docs/RELEASE.md @@ -45,7 +45,7 @@ variable. ## Westend & Rococo -For the these networks, in addition to incrementing the `Cargo.toml` version we also increment the `spec_version` and +For these networks, in addition to incrementing the `Cargo.toml` version we also increment the `spec_version` and sometimes the `transaction_version`. The spec version is also following the node version. Its schema is: `M_mmm_ppp` and for example `1_002_000` is the node release `1.2.0`. This versioning has no further meaning, and is only done to map from an on chain `spec_version` easily to the release in this repository. @@ -55,9 +55,10 @@ The Westend testnet will be updated to a new runtime every two weeks with the la **From `master` to `stable`** -Backports in this direction can be anything that is audited and either a `minor` or a `patch` bump. [Security -fixes](#bug-and-security-fix) should be prioritized over additions or improvements. Crates that are declared as internal -API can also have `major` version bumps through backports. +Backports in this direction can be anything that is audited and either a `minor` or a `patch` bump. +See [BACKPORT.md](./BACKPORT.md) for more explanation. [Security fixes](#bug-and-security-fix) +should be prioritized over additions or improvements. Crates that are declared as internal API can +also have `major` version bumps through backports. **From `stable` to `master`** @@ -164,5 +165,6 @@ Describes how developers should merge bug and security fixes. 2. The Pull Request is marked as priority fix. 3. Audit happens with priority. 4. It is merged into `master`. -5. It is automatically back-ported to `stable`. -6. The fix will be released in the next *Stable* release. In urgent cases, a release can happen earlier. +5. Dev adds the `A4-needs-backport` label. +6. It is automatically back-ported to `stable`. +7. The fix will be released in the next *Stable* release. In urgent cases, a release can happen earlier. diff --git a/docs/contributor/CONTRIBUTING.md b/docs/contributor/CONTRIBUTING.md index 96dc86e9780561e33e24fbc6f0346572d26598b7..53f42b9ae4fb41e995c16ef03f0abcc61a030684 100644 --- a/docs/contributor/CONTRIBUTING.md +++ b/docs/contributor/CONTRIBUTING.md @@ -4,18 +4,16 @@ The `Polkadot SDK` project is an **OPENISH Open Source Project** ## What? -Individuals making significant and valuable contributions are given commit-access to the project. -Contributions are done via pull-requests and need to be approved by the maintainers. +Individuals making significant and valuable contributions are given commit-access to the project. Contributions are done +via pull-requests and need to be approved by the maintainers. ## Rules There are a few basic ground-rules for contributors (including the maintainer(s) of the project): -1. **No `--force` pushes** or modifying the master branch history in any way. - If you need to rebase, ensure you do it in your own repo. No rewriting of the history - after the code has been shared (e.g. through a Pull-Request). -2. **Non-master branches**, prefixed with a short name moniker (e.g. `gav-my-feature`) must be - used for ongoing work. +1. **No `--force` pushes** or modifying the master branch history in any way. If you need to rebase, ensure you do it in + your own repo. No rewriting of the history after the code has been shared (e.g. through a Pull-Request). +2. **Non-master branches**, prefixed with a short name moniker (e.g. `gav-my-feature`) must be used for ongoing work. 3. **All modifications** must be made in a **pull-request** to solicit feedback from other contributors. 4. A pull-request **must not be merged until CI** has finished successfully. 5. Contributors should adhere to the [house coding style](./STYLE_GUIDE.md). @@ -25,12 +23,10 @@ There are a few basic ground-rules for contributors (including the maintainer(s) ### In General -A Pull Request (PR) needs to be reviewed and approved by project maintainers. -If a change does not alter any logic (e.g. comments, dependencies, docs), then it may be tagged -`A1-insubstantial` and merged faster. -If it is an urgent fix with no large change to logic, then it may be merged after a non-author -contributor has reviewed it well and approved the review once CI is complete. -No PR should be merged until all reviews' comments are addressed. +* A Pull Request (PR) needs to be reviewed and approved by project maintainers. +* If a change does not alter any logic (e.g. comments, dependencies, docs), then it may be tagged `A1-insubstantial` and +merged faster. +* No PR should be merged until all reviews' comments are addressed. ### Labels @@ -38,39 +34,26 @@ The set of labels and their description can be found [here](https://paritytech.g ### Process -1. Please use our [Pull Request Template](./PULL_REQUEST_TEMPLATE.md) and make sure all relevant - information is reflected in your PR. -2. Please tag each PR with minimum one `T*` label. The respective `T*` labels should signal the - component that was changed, they are also used by downstream users to track changes and to - include these changes properly into their own releases. -3. If you’re still working on your PR, please submit as “Draft”. Once a PR is ready for review change - the status to “Open”, so that the maintainers get to review your PR. Generally PRs should sit for - 48 hours in order to garner feedback. It may be merged before if all relevant parties had a look at it. -4. If you’re introducing a major change, that might impact the documentation please add the label - `T13-documentation`. The docs team will get in touch. -5. If your PR changes files in these paths: - - `polkadot` : `^runtime/polkadot` - `polkadot` : `^runtime/kusama` - `polkadot` : `^primitives/src/` - `polkadot` : `^runtime/common` - `substrate` : `^frame/` - `substrate` : `^primitives/` - - It should be added to the [security audit board](https://github.com/orgs/paritytech/projects/103) - and will need to undergo an audit before merge. -6. PRs will be able to be merged once all reviewers' comments are addressed and CI is successful. - -**Noting breaking changes:** -When breaking APIs, the PR description should mention what was changed alongside some examples on how -to change the code to make it work/compile. -It should also mention potential storage migrations and if they require some special setup aside adding -it to the list of migrations in the runtime. +1. Please use our [Pull Request Template](./PULL_REQUEST_TEMPLATE.md) and make sure all relevant information is + reflected in your PR. +2. Please tag each PR with minimum one `T*` label. The respective `T*` labels should signal the component that was + changed, they are also used by downstream users to track changes and to include these changes properly into their own + releases. +3. If you’re still working on your PR, please submit as “Draft”. Once a PR is ready for review change the status to + “Open”, so that the maintainers get to review your PR. Generally PRs should sit for 48 hours in order to garner + feedback. It may be merged before if all relevant parties had a look at it. +4. With respect to auditing, please see [AUDIT.md](../AUDIT.md). In general, merging to master can happen independently of + audit. +5. PRs will be able to be merged once all reviewers' comments are addressed and CI is successful. + +**Noting breaking changes:** When breaking APIs, the PR description should mention what was changed alongside some +examples on how to change the code to make it work/compile. It should also mention potential storage migrations and if +they require some special setup aside from adding it to the list of migrations in the runtime. ## Reviewing pull requests -When reviewing a pull request, the end-goal is to suggest useful changes to the author. -Reviews should finish with approval unless there are issues that would result in: +When reviewing a pull request, the end-goal is to suggest useful changes to the author. Reviews should finish with +approval unless there are issues that would result in: 1. Buggy behavior. 2. Undue maintenance burden. 3. Breaking with house coding style. @@ -80,18 +63,17 @@ Reviews should finish with approval unless there are issues that would result in The reviewers are also responsible to check: -1. if a changelog is necessary and attached -1. the quality of information in the changelog file -1. the PR has an impact on docs -1. that the docs team was included in the review process of a docs update +* if the PR description is well written to facilitate integration, in case it contains breaking changes. +* the PR has an impact on docs. **Reviews may not be used as an effective veto for a PR because**: 1. There exists a somewhat cleaner/better/faster way of accomplishing the same feature/fix. 2. It does not fit well with some other contributors' longer-term vision for the project. -## Documentation +## `PRDoc` -All Pull Requests must contain proper title & description. +All Pull Requests must contain proper title & description, as described in [Pull Request +Template](./PULL_REQUEST_TEMPLATE.md). Moreover, all pull requests must have a proper `prdoc` file attached. Some Pull Requests can be exempt of `prdoc` documentation, those must be labelled with [`R0-silent`](https://github.com/paritytech/labels/blob/main/ruled_labels/specs_polkadot-sdk.yaml#L89-L91). @@ -100,47 +82,89 @@ Non "silent" PRs must come with documentation in the form of a `.prdoc` file. See more about `prdoc` [here](./prdoc.md) +## Crate Configuration `Cargo.toml` + +The Polkadot SDK uses many conventions when configuring a crate. Watch out for these things when you +are creating a new crate. + +### Is the Crate chain-specific? + +Chain-specific crates, for example +[`bp-bridge-hub-rococo`](https://github.com/paritytech/polkadot-sdk/blob/4014b9bf2bf8f74862f63e7114e5c78009529be5/bridges/chains/chain-bridge-hub-rococo/Cargo.toml#L10-L11) +, should not be released as part of the Polkadot-SDK umbrella crate. We have a custom metadata +attribute that is picked up by the [generate-umbrella.py](../../scripts/generate-umbrella.py) +script, that should be applied to all chain-specific crates like such: + +```toml +[package] +# Other stuff... + +[package.metadata.polkadot-sdk] +exclude-from-umbrella = true + +# Other stuff... +``` + +### Is the Crate a Test, Example or Fuzzer? + +Test or example crates, like +[`pallet-example-task`](https://github.com/paritytech/polkadot-sdk/blob/9b4acf27b869d7cbb07b03f0857763b8c8cc7566/substrate/frame/examples/tasks/Cargo.toml#L9) +, should not be released to crates.io. To ensure this, you must add `publish = false` to your +crate's `package` section: + +```toml +[package] +# Other stuff... + +publish = false + +# Other stuff... +``` + ## Helping out -We use [labels](https://github.com/paritytech/polkadot-sdk/labels) to manage PRs and issues and communicate -state of a PR. Please familiarise yourself with them. Best way to get started is to a pick a ticket tagged -[easy](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AD0-easy) -or [medium](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AD1-medium) -and get going. Alternatively, look out for issues tagged [mentor](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AC1-mentor) -and get in contact with the mentor offering their support on that larger task. +We use [labels](https://github.com/paritytech/polkadot-sdk/labels) to manage PRs and issues and communicate state of a +PR. Please familiarise yourself with them. Best way to get started is to a pick a ticket tagged +[easy](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AD0-easy) or +[medium](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AD1-medium) and get going. +Alternatively, look out for issues tagged +[mentor](https://github.com/paritytech/polkadot-sdk/issues?q=is%3Aopen+is%3Aissue+label%3AC1-mentor) and get in contact +with the mentor offering their support on that larger task. **** ### Issues If what you are looking for is an answer rather than proposing a new feature or fix, search -[https://substrate.stackexchange.com](https://substrate.stackexchange.com/) to see if an post already -exists, and ask if not. Please do not file support issues here. -Before opening a new issue search to see if a similar one already exists and leave a comment that you -also experienced this issue or add your specifics that are related to an existing issue. -Please label issues with the following labels: +[https://substrate.stackexchange.com](https://substrate.stackexchange.com/) to see if an post already exists, and ask if +not. Please do not file support issues here. + +Before opening a new issue search to see if a similar one already exists and leave a comment that you also experienced +this issue or add your specifics that are related to an existing issue. + +Please label issues with the following labels (only relevant for maintainer): 1. `I*` issue severity and type. EXACTLY ONE REQUIRED. 2. `D*` issue difficulty, suggesting the level of complexity this issue has. AT MOST ONE ALLOWED. 3. `T*` Issue topic. MULTIPLE ALLOWED. ## Releases -Declaring formal releases remains the prerogative of the project maintainer(s). +Declaring formal releases remains the prerogative of the project maintainer(s). See [RELEASE.md](../RELEASE.md). ## UI tests -UI tests are used for macros to ensure that the output of a macro doesn’t change and is in the expected format. -These UI tests are sensible to any changes in the macro generated code or to switching the rust stable version. -The tests are only run when the `RUN_UI_TESTS` environment variable is set. So, when the CI is for example complaining -about failing UI tests and it is expected that they fail these tests need to be executed locally. -To simplify the updating of the UI test output there is a script -- `./scripts/update-ui-tests.sh` to update the tests for a current rust version locally -- `./scripts/update-ui-tests.sh 1.70` # to update the tests for a specific rust version locally - -Or if you have opened PR and you're member of `paritytech` - you can use command-bot to run the tests for you in CI: -- `bot update-ui` - will run the tests for the current rust version -- `bot update-ui latest --rust_version=1.70.0` - will run the tests for the specified rust version -- `bot update-ui latest -v CMD_IMAGE=paritytech/ci-unified:bullseye-1.70.0-2023-05-23 --rust_version=1.70.0` - +UI tests are used for macros to ensure that the output of a macro doesn’t change and is in the expected format. These UI +tests are sensible to any changes in the macro generated code or to switching the rust stable version. The tests are +only run when the `RUN_UI_TESTS` environment variable is set. So, when the CI is for example complaining about failing +UI tests and it is expected that they fail these tests need to be executed locally. To simplify the updating of the UI +test output there is a script +* `./scripts/update-ui-tests.sh` to update the tests for a current rust version locally +* `./scripts/update-ui-tests.sh 1.70` # to update the tests for a specific rust version locally + +Or if you have opened PR and you're member of `paritytech` - you can use [/cmd](./commands-readme.md) +to run the tests for you in CI: +* `/cmd update-ui` - will run the tests for the current rust version +* `/cmd update-ui --image docker.io/paritytech/ci-unified:bullseye-1.70.0-2023-05-23` - will run the tests for the specified rust version and specified image ## Feature Propagation @@ -151,10 +175,11 @@ We use [zepter](https://github.com/ggwpez/zepter) to enforce features are propag If you're member of **paritytech** org - you can use command-bot to run various of common commands in CI: -Start with comment in PR: `bot help` to see the list of available commands. +Start with comment in PR: `/cmd --help` to see the list of available commands. ## Deprecating code When deprecating and removing code you need to be mindful of how this could impact downstream developers. In order to -mitigate this impact, it is recommended to adhere to the steps outlined in the [Deprecation Checklist](./DEPRECATION_CHECKLIST.md). +mitigate this impact, it is recommended to adhere to the steps outlined in the [Deprecation +Checklist](./DEPRECATION_CHECKLIST.md). diff --git a/docs/contributor/DOCUMENTATION_GUIDELINES.md b/docs/contributor/DOCUMENTATION_GUIDELINES.md index 96811a2772d775f92ce4524416c295a689df1790..5ac99fff1cdbfa2b2425947f5af242c8dd03966f 100644 --- a/docs/contributor/DOCUMENTATION_GUIDELINES.md +++ b/docs/contributor/DOCUMENTATION_GUIDELINES.md @@ -1,7 +1,7 @@ # Substrate Documentation Guidelines This document is focused on documenting parts of Substrate that relate to its external API. The list of such crates can -be found in [CODEOWNERS](./CODEOWNERS). Search for the crates auto-assigned to the `docs-audit` team. +be found in [CODEOWNERS](/.github/CODEOWNERS). Search for the crates auto-assigned to the `docs-audit` team. These crates are used by external developers and need thorough documentation. They are the most concerned with FRAME development. @@ -33,7 +33,7 @@ First, consider the case for all such crates, except for those that are pallets. The first question is, what should you document? Use this filter: -1. In the crates assigned to `docs-audit` in [CODEOWNERS](./CODEOWNERS), +1. In the crates assigned to `docs-audit` in [CODEOWNERS](/.github/CODEOWNERS), 2. All `pub` items need to be documented. If not `pub`, it doesn't appear in the rust-docs, and is not public facing. - Within `pub` items, sometimes they are only `pub` to be used by another internal crate, and you can foresee that @@ -88,20 +88,19 @@ sections](https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/ru we will most likely not need to think about panic and safety in any runtime related code. Our code is never `unsafe`, and will (almost) never panic. -Use `# Examples as much as possible. These are great ways to further demonstrate what your APIs are doing, and add free -test coverage. As an additional benefit, any code in rust-docs is treated as an "integration tests", not unit tests, +Use `# Examples` as much as possible. These are great ways to further demonstrate what your APIs are doing, and add free +test coverage. As an additional benefit, any code in rust-docs is treated as an "integration test", which tests your crate in a different way than unit tests. So, it is both a win for "more documentation" and a win for "more test coverage". You can also consider having an `# Error` section optionally. Of course, this only applies if there is a `Result` being returned, and if the `Error` variants are overly complicated. -Strive to include correct links to other items in your written docs as much as possible. In other words, avoid -\`some_func\` and instead use \[\`some_fund\`\]. Read more about how to correctly use links in your rust-docs +Strive to include correct links to other items in your written docs as much as possible. +Read more about how to correctly use links in your rust-docs [here](https://doc.rust-lang.org/rustdoc/write-documentation/linking-to-items-by-name.html#valid-links) and -[here](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html#additions-to-the-documentation-syntax). Strive to -include correct links to other items in your written docs as much as possible. In other words, avoid `` `some_func` `` -and instead use ``[`some_func`]``. +[here](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html#additions-to-the-documentation-syntax). +In other words, avoid `` `some_func` `` and instead use ``[`some_func`]``. > While you are linking, you might become conscious of the fact that you are in need of linking to (too many) foreign items in order to explain your API. This is leaning more towards API-Design rather than documentation, but it is a @@ -137,7 +136,7 @@ the `macro@my_macro_name` syntax in your link. Read more about how to correctly The above five guidelines must always be reasonably respected in the documentation. -The following are a set of notes that may not necessarily hold in all circumstances: +The following is a set of notes that may not necessarily hold in all circumstances: --- @@ -145,7 +144,7 @@ The following are a set of notes that may not necessarily hold in all circumstan You should make sure that your code is properly-named and well-organized so that your code functions as a form of documentation. However, within the complexity of our projects in Polkadot/Substrate that is not enough. Particularly, -things like examples, errors and panics cannot be documented only through properly- named and well-organized code. +things like examples, errors and panics cannot be documented only through properly-named and well-organized code. > Our north star is self-documenting code that also happens to be well-documented and littered with examples. @@ -206,7 +205,7 @@ properly do this. ## Pallet Crates -The guidelines so far have been general in nature, and are applicable to crates that are pallets and crates that're not +The guidelines so far have been general in nature, and are applicable to crates that are pallets and crates that are not pallets. The following is relevant to how to document parts of a crate that is a pallet. See @@ -272,7 +271,7 @@ For the top-level pallet docs, consider the following template: //! up> ``` -This template's details (heading 3s and beyond) are left flexible, and at the discretion of the developer to make the +This template's details (Heading 3s and beyond) are left flexible, and at the discretion of the developer to make the best final choice about. For example, you might want to include `### Terminology` or not. Moreover, you might find it more useful to include it in `## Overview`. diff --git a/docs/contributor/PULL_REQUEST_TEMPLATE.md b/docs/contributor/PULL_REQUEST_TEMPLATE.md index 79a036a235ad92a2cfceeba9b8fb66a44d163dfd..99455c985076df0792bf2fff9fd7f488804595a1 100644 --- a/docs/contributor/PULL_REQUEST_TEMPLATE.md +++ b/docs/contributor/PULL_REQUEST_TEMPLATE.md @@ -2,35 +2,43 @@ ✄ ----------------------------------------------------------------------------- -Thank you for your Pull Request! 🙏 Please make sure it follows the contribution guidelines outlined in -[this document](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md) and fill -out the sections below. Once you're ready to submit your PR for review, please -delete this section and leave only the text under the "Description" heading. +Thank you for your Pull Request! 🙏 Please make sure it follows the contribution guidelines outlined in [this +document](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md) and fill out the +sections below. Once you're ready to submit your PR for review, please delete this section and leave only the text under +the "Description" heading. # Description -*Please include a summary of the changes and the related issue. Please also include relevant motivation and context, -including:* +*A concise description of what your PR is doing, and what potential issue it is solving. Use [Github semantic +linking](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) +to link the PR to an issue that must be closed once this is merged.* -- What does this PR do? -- Why are these changes needed? -- How were these changes implemented and what do they affect? +## Integration -*Use [Github semantic -linking](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) -to address any open issues this PR relates to or closes.* +*In depth notes about how this PR should be integrated by downstream projects. This part is mandatory, and should be +reviewed by reviewers, if the PR does NOT have the `R0-Silent` label. In case of a `R0-Silent`, it can be ignored.* + +## Review Notes + +*In depth notes about the **implementation** details of your PR. This should be the main guide for reviewers to +understand your approach and effectively review it. If too long, use +[`

`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/details)*. -Fixes # (issue number, *if applicable*) +*Imagine that someone who is depending on the old code wants to integrate your new code and the only information that +they get is this section. It helps to include example usage and default value here, with a `diff` code-block to show +possibly integration.* -Closes # (issue number, *if applicable*) +*Include your leftover TODOs, if any, here.* # Checklist -- [ ] My PR includes a detailed description as outlined in the "Description" section above -- [ ] My PR follows the [labeling requirements](CONTRIBUTING.md#Process) of this project (at minimum one label for `T` - required) -- [ ] I have made corresponding changes to the documentation (if applicable) -- [ ] I have added tests that prove my fix is effective or that my feature works (if applicable) +* [ ] My PR includes a detailed description as outlined in the "Description" and its two subsections above. +* [ ] My PR follows the [labeling requirements]( +https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/CONTRIBUTING.md#Process +) of this project (at minimum one label for `T` required) + * External contributors: ask maintainers to put the right label on your PR. +* [ ] I have made corresponding changes to the documentation (if applicable) +* [ ] I have added tests that prove my fix is effective or that my feature works (if applicable) You can remove the "Checklist" section once all have been checked. Thank you for your contribution! diff --git a/docs/contributor/commands-readme.md b/docs/contributor/commands-readme.md new file mode 100644 index 0000000000000000000000000000000000000000..2bb9bd7e7d582448b8c8efbba937ca227075f1f5 --- /dev/null +++ b/docs/contributor/commands-readme.md @@ -0,0 +1,44 @@ +# Running Commands in PRs + +You can run commands in PRs by triggering it via comment. It will use the context of your PR and post the results back. +Note: it works only for members of the `paritytech` organization. + +## Usage + +`/cmd --help` to see all available commands and usage format + +`/cmd --help` to see the usage of a specific command + + +### Commands + +- `/cmd fmt` to format the code in the PR. It commits back with the formatted code (fmt) and configs (taplo). + +- `/cmd bench` to generate weights for a runtime. Read more about [Weight Generation](weight-generation.md) + +### Flags + +1.`--quiet` to suppress the output of the command in the comments. +By default, the Start and End/Failure of the command will be commented with the link to a pipeline. +If you want to avoid, use this flag. Go to +[Action Tab](https://github.com/paritytech/polkadot-sdk/actions/workflows/cmd.yml) to see the pipeline status. + +2.`--continue-on-fail` to continue running the command even if something inside a command +(like specific pallet weight generation) are failed. +Basically avoids interruption in the middle with `exit 1` +The pipeline logs will include what is failed (like which runtimes/pallets), then you can re-run them separately or not. + +3.`--clean` to clean up all yours and bot's comments in PR relevant to `/cmd` commands. If you run too many commands, +or they keep failing, and you're rerunning them again, it's handy to add this flag to keep a PR clean. + +### Adding new Commands +Feel free to add new commands to the workflow, however **_note_** that triggered workflows will use the actions +from `main` (default) branch, meaning they will take effect only after the PR with new changes/command is merged. +If you want to test the new command, it's better to test in your fork and local-to-fork PRs, where you control +the default branch. + +### Examples +The regex in cmd.yml is: `^(\/cmd )([-\/\s\w.=:]+)$` accepts only alphanumeric, space, "-", "/", "=", ":", "." chars. + +`/cmd bench --runtime bridge-hub-westend --pallet=pallet_name` +`/cmd update-ui --image=docker.io/paritytech/ci-unified:bullseye-1.77.0-2024-04-10-v202407161507 --clean` diff --git a/docs/contributor/weight-generation.md b/docs/contributor/weight-generation.md new file mode 100644 index 0000000000000000000000000000000000000000..ebfdca59cae5d6f00b681d0b8ff94080e17202a4 --- /dev/null +++ b/docs/contributor/weight-generation.md @@ -0,0 +1,69 @@ +# Weight Generation + +To generate weights for a runtime. +Weights generation is using self-hosted runner which is provided by Parity CI, the rest commands are using standard +GitHub runners on `ubuntu-latest` or `ubuntu-20.04`. +Self-hosted runner for benchmarks (arc-runners-Polkadot-sdk-benchmark) is configured to meet requirements of reference +hardware for running validators +https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware + +In a PR run the actions through comment: + +```sh +/cmd bench --help # outputs the actual usage documentation with examples and supported runtimes + +# or + +/cmd --help # to see all available commands +``` + +To regenerate all weights (however it will take long, +so don't do it unless you really need it), run the following command: +```sh +/cmd bench +``` + +To generate weights for all pallets in a particular runtime(s), run the following command: +```sh +/cmd bench --runtime kusama polkadot +``` + +For Substrate pallets (supports sub-modules too): +```sh +/cmd bench --runtime dev --pallet pallet_asset_conversion_ops +``` + +> **📝 Note**: The action is not being run right-away, it will be queued and run in the next available runner. +So might be quick, but might also take up to 10 mins (That's in control of Github). +Once the action is run, you'll see reaction 👀 on original comment, and if you didn't pass `--quiet` - +it will also send a link to a pipeline when started, and link to whole workflow when finished. + +--- + +> **💡Hint #1** : if you run all runtimes or all pallets, it might be that some pallet in the middle is failed +to generate weights, thus it stops (fails) the whole pipeline. +> If you want, you can make it to continue running, even if some pallets are failed, add `--continue-on-fail` +flag to the command. The report will include which runtimes/pallets have failed, then you can re-run +them separately after all is done. + +This way it runs all possible runtimes for the specified pallets, if it finds them in the runtime +```sh +/cmd bench --pallet pallet_balances pallet_xcm_benchmarks::generic pallet_xcm_benchmarks::fungible +``` + +If you want to run all specific pallet(s) for specific runtime(s), you can do it like this: +```sh +/cmd bench --runtime bridge-hub-polkadot --pallet pallet_xcm_benchmarks::generic pallet_xcm_benchmarks::fungible +``` + + +> **💡Hint #2** : Sometimes when you run too many commands, or they keep failing and you're rerunning them again, +it's handy to add `--clean` flag to the command. This will clean up all yours and bot's comments in PR relevant to +/cmd commands. + +```sh +/cmd bench --runtime kusama polkadot --pallet=pallet_balances --clean --continue-on-fail +``` + +> **💡Hint #3** : If you have questions or need help, feel free to tag @paritytech/opstooling (in github comments) +or ping in [matrix](https://matrix.to/#/#command-bot:parity.io) channel. diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png b/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png new file mode 100644 index 0000000000000000000000000000000000000000..8909dc96a62a93f2bd8b9204e3f1a6885dffae52 Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_Black.png differ diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_BlackOnWhite.png b/docs/images/Polkadot_Logo_Horizontal_Pink_BlackOnWhite.png new file mode 100644 index 0000000000000000000000000000000000000000..ef2b997100ea26310f6588b5b932e3c9cc7d2604 Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_BlackOnWhite.png differ diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_White.png b/docs/images/Polkadot_Logo_Horizontal_Pink_White.png new file mode 100644 index 0000000000000000000000000000000000000000..ea814ea28d5c813613c087f0a2fe0e3e1f8f4b52 Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_White.png differ diff --git a/docs/images/Polkadot_Logo_Horizontal_Pink_WhiteOnBlack.png b/docs/images/Polkadot_Logo_Horizontal_Pink_WhiteOnBlack.png new file mode 100644 index 0000000000000000000000000000000000000000..421a38e1bdfad4c81be564dcebccf24d55a545a9 Binary files /dev/null and b/docs/images/Polkadot_Logo_Horizontal_Pink_WhiteOnBlack.png differ diff --git a/docs/images/backport-ex2.png b/docs/images/backport-ex2.png new file mode 100644 index 0000000000000000000000000000000000000000..97ccf6b00fb91c1691f1dd4eaf69c626ed6be741 Binary files /dev/null and b/docs/images/backport-ex2.png differ diff --git a/docs/mermaid/IA.mmd b/docs/mermaid/IA.mmd index 4eb50bcf96a8932de3fa90748fcfeb3ca7f02a5f..37417497e1f84f3a54fb3e55da631c9ce363e700 100644 --- a/docs/mermaid/IA.mmd +++ b/docs/mermaid/IA.mmd @@ -1,5 +1,6 @@ flowchart parity[paritytech.github.io] --> devhub[polkadot_sdk_docs] + polkadot_network[polkadot.network] --> devhub[polkadot_sdk_docs] devhub --> polkadot_sdk devhub --> reference_docs @@ -8,7 +9,5 @@ flowchart polkadot_sdk --> substrate polkadot_sdk --> frame polkadot_sdk --> cumulus - polkadot_sdk --> polkadot + polkadot_sdk --> polkadot[polkadot node] polkadot_sdk --> xcm - - diff --git a/docs/sdk/Cargo.toml b/docs/sdk/Cargo.toml index fe53845d8490ba0386c21100703c594987b67898..adc1c1a8efbca343e6693ca0027654cba3ea532b 100644 --- a/docs/sdk/Cargo.toml +++ b/docs/sdk/Cargo.toml @@ -15,89 +15,110 @@ workspace = true [dependencies] # Needed for all FRAME-based code -parity-scale-codec = { version = "3.0.0", default-features = false } -scale-info = { version = "2.6.0", default-features = false } -frame = { package = "polkadot-sdk-frame", path = "../../substrate/frame", features = [ +codec = { workspace = true } +scale-info = { workspace = true } +frame = { features = [ "experimental", "runtime", -] } -pallet-examples = { path = "../../substrate/frame/examples" } -pallet-default-config-example = { path = "../../substrate/frame/examples/default-config" } -pallet-example-offchain-worker = { path = "../../substrate/frame/examples/offchain-worker" } +], workspace = true, default-features = true } +pallet-examples = { workspace = true } +pallet-contracts = { workspace = true } +pallet-default-config-example = { workspace = true, default-features = true } +pallet-example-offchain-worker = { workspace = true, default-features = true } # How we build docs in rust-docs simple-mermaid = "0.1.1" -docify = "0.2.8" +docify = { workspace = true } # Polkadot SDK deps, typically all should only be in scope such that we can link to their doc item. -node-cli = { package = "staging-node-cli", path = "../../substrate/bin/node/cli" } -kitchensink-runtime = { path = "../../substrate/bin/node/runtime" } -chain-spec-builder = { package = "staging-chain-spec-builder", path = "../../substrate/bin/utils/chain-spec-builder" } -subkey = { path = "../../substrate/bin/utils/subkey" } -frame-system = { path = "../../substrate/frame/system", default-features = false } -frame-support = { path = "../../substrate/frame/support", default-features = false } -frame-executive = { path = "../../substrate/frame/executive", default-features = false } -pallet-example-single-block-migrations = { path = "../../substrate/frame/examples/single-block-migrations" } +polkadot-sdk = { features = ["runtime-full"], workspace = true, default-features = true } +node-cli = { workspace = true } +kitchensink-runtime = { workspace = true } +chain-spec-builder = { workspace = true, default-features = true } +subkey = { workspace = true, default-features = true } +frame-system = { workspace = true } +frame-support = { workspace = true } +frame-executive = { workspace = true } +pallet-example-single-block-migrations = { workspace = true, default-features = true } +frame-metadata-hash-extension = { workspace = true, default-features = true } +log = { workspace = true, default-features = true } # Substrate Client -sc-network = { path = "../../substrate/client/network" } -sc-rpc-api = { path = "../../substrate/client/rpc-api" } -sc-rpc = { path = "../../substrate/client/rpc" } -sc-client-db = { path = "../../substrate/client/db" } -sc-cli = { path = "../../substrate/client/cli" } -sc-consensus-aura = { path = "../../substrate/client/consensus/aura" } -sc-consensus-babe = { path = "../../substrate/client/consensus/babe" } -sc-consensus-grandpa = { path = "../../substrate/client/consensus/grandpa" } -sc-consensus-beefy = { path = "../../substrate/client/consensus/beefy" } -sc-consensus-manual-seal = { path = "../../substrate/client/consensus/manual-seal" } -sc-consensus-pow = { path = "../../substrate/client/consensus/pow" } -sc-executor = { path = "../../substrate/client/executor" } -sc-service = { path = "../../substrate/client/service" } +sc-network = { workspace = true, default-features = true } +sc-rpc-api = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sc-client-db = { workspace = true, default-features = true } +sc-cli = { workspace = true, default-features = true } +sc-consensus-aura = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sc-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-manual-seal = { workspace = true, default-features = true } +sc-consensus-pow = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } -substrate-wasm-builder = { path = "../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } # Cumulus -cumulus-pallet-aura-ext = { path = "../../cumulus/pallets/aura-ext" } -cumulus-pallet-parachain-system = { path = "../../cumulus/pallets/parachain-system", features = [ - "parameterized-consensus-hook", -] } -parachain-info = { package = "staging-parachain-info", path = "../../cumulus/parachains/pallets/parachain-info" } -cumulus-primitives-proof-size-hostfunction = { path = "../../cumulus/primitives/proof-size-hostfunction" } -cumulus-client-service = { path = "../../cumulus/client/service" } -cumulus-primitives-storage-weight-reclaim = { path = "../../cumulus/primitives/storage-weight-reclaim" } +cumulus-pallet-aura-ext = { workspace = true, default-features = true } +cumulus-pallet-parachain-system = { workspace = true, default-features = true } +parachain-info = { workspace = true, default-features = true } +cumulus-primitives-proof-size-hostfunction = { workspace = true, default-features = true } +cumulus-client-service = { workspace = true, default-features = true } +cumulus-primitives-storage-weight-reclaim = { workspace = true, default-features = true } # Pallets and FRAME internals -pallet-aura = { path = "../../substrate/frame/aura" } -pallet-timestamp = { path = "../../substrate/frame/timestamp" } -pallet-balances = { path = "../../substrate/frame/balances" } -pallet-assets = { path = "../../substrate/frame/assets" } -pallet-preimage = { path = "../../substrate/frame/preimage" } -pallet-transaction-payment = { path = "../../substrate/frame/transaction-payment" } -pallet-utility = { path = "../../substrate/frame/utility" } -pallet-multisig = { path = "../../substrate/frame/multisig" } -pallet-proxy = { path = "../../substrate/frame/proxy" } -pallet-authorship = { path = "../../substrate/frame/authorship" } -pallet-collective = { path = "../../substrate/frame/collective" } -pallet-democracy = { path = "../../substrate/frame/democracy" } -pallet-uniques = { path = "../../substrate/frame/uniques" } -pallet-nfts = { path = "../../substrate/frame/nfts" } -pallet-scheduler = { path = "../../substrate/frame/scheduler" } +pallet-aura = { workspace = true, default-features = true } +pallet-timestamp = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-assets = { workspace = true, default-features = true } +pallet-preimage = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +pallet-asset-tx-payment = { workspace = true, default-features = true } +pallet-skip-feeless-payment = { workspace = true, default-features = true } +pallet-asset-conversion-tx-payment = { workspace = true, default-features = true } +pallet-utility = { workspace = true, default-features = true } +pallet-multisig = { workspace = true, default-features = true } +pallet-proxy = { workspace = true, default-features = true } +pallet-authorship = { workspace = true, default-features = true } +pallet-collective = { workspace = true, default-features = true } +pallet-democracy = { workspace = true, default-features = true } +pallet-uniques = { workspace = true, default-features = true } +pallet-nfts = { workspace = true, default-features = true } +pallet-scheduler = { workspace = true, default-features = true } +pallet-referenda = { workspace = true, default-features = true } +pallet-broker = { workspace = true, default-features = true } +pallet-babe = { workspace = true, default-features = true } # Primitives -sp-io = { path = "../../substrate/primitives/io" } -sp-api = { path = "../../substrate/primitives/api" } -sp-core = { path = "../../substrate/primitives/core" } -sp-keyring = { path = "../../substrate/primitives/keyring" } -sp-runtime = { path = "../../substrate/primitives/runtime" } -sp-arithmetic = { path = "../../substrate/primitives/arithmetic" } +sp-io = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-runtime-interface = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-genesis-builder = { workspace = true, default-features = true } +sp-offchain = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } -# Misc pallet dependencies -pallet-referenda = { path = "../../substrate/frame/referenda" } -pallet-broker = { path = "../../substrate/frame/broker" } -pallet-babe = { path = "../../substrate/frame/babe" } - -sp-offchain = { path = "../../substrate/primitives/offchain" } -sp-version = { path = "../../substrate/primitives/version" } # XCM -xcm = { package = "staging-xcm", path = "../../polkadot/xcm" } +xcm = { workspace = true, default-features = true } +xcm-builder = { workspace = true } +xcm-docs = { workspace = true } +xcm-executor = { workspace = true } +xcm-simulator = { workspace = true } +pallet-xcm = { workspace = true } + +# runtime guides +chain-spec-guide-runtime = { workspace = true } + +# Templates +minimal-template-runtime = { workspace = true } +solochain-template-runtime = { workspace = true } +parachain-template-runtime = { workspace = true } diff --git a/docs/sdk/assets/header.html b/docs/sdk/assets/header.html index f55c31b53216cddc5da94099efc3566c27bdfe63..c24c10940759771dbcb672024e290b3422e57f96 100644 --- a/docs/sdk/assets/header.html +++ b/docs/sdk/assets/header.html @@ -14,12 +14,13 @@ headers.forEach(header => { let link = document.createElement("a"); link.href = "#" + header.id; - link.textContent = header.textContent; + const headerTextContent = header.textContent.replace("§", "") + link.textContent = headerTextContent; link.className = header.tagName.toLowerCase(); toc.appendChild(link); - if (header.id == "modules" && header.textContent == "Modules") { + if (header.id == "modules" && headerTextContent == "Modules") { modules.forEach(module => { let link = document.createElement("a"); link.href = module.href; diff --git a/docs/sdk/src/guides/async_backing_guide.rs b/docs/sdk/src/guides/async_backing_guide.rs new file mode 100644 index 0000000000000000000000000000000000000000..25ef3a12cbf033d37ebaca2bb6464dd67c92735e --- /dev/null +++ b/docs/sdk/src/guides/async_backing_guide.rs @@ -0,0 +1,254 @@ +//! # Upgrade Parachain for Asynchronous Backing Compatibility +//! +//! This guide is relevant for cumulus based parachain projects started in 2023 or before, whose +//! backing process is synchronous where parablocks can only be built on the latest Relay Chain +//! block. Async Backing allows collators to build parablocks on older Relay Chain blocks and create +//! pipelines of multiple pending parablocks. This parallel block generation increases efficiency +//! and throughput. For more information on Async backing and its terminology, refer to the document +//! on [the Polkadot Wiki.](https://wiki.polkadot.network/docs/maintain-guides-async-backing) +//! +//! > If starting a new parachain project, please use an async backing compatible template such as +//! > the +//! > [parachain template](https://github.com/paritytech/polkadot-sdk/tree/master/templates/parachain). +//! The rollout process for Async Backing has three phases. Phases 1 and 2 below put new +//! infrastructure in place. Then we can simply turn on async backing in phase 3. +//! +//! ## Prerequisite +//! +//! The relay chain needs to have async backing enabled so double-check that the relay-chain +//! configuration contains the following three parameters (especially when testing locally e.g. with +//! zombienet): +//! +//! ```json +//! "async_backing_params": { +//! "max_candidate_depth": 3, +//! "allowed_ancestry_len": 2 +//! }, +//! "scheduling_lookahead": 2 +//! ``` +//! +//!
scheduling_lookahead must be set to 2, otherwise parachain +//! block times will degrade to worse than with sync backing!
+//! +//! ## Phase 1 - Update Parachain Runtime +//! +//! This phase involves configuring your parachain’s runtime `/runtime/src/lib.rs` to make use of +//! async backing system. +//! +//! 1. Establish and ensure constants for `capacity` and `velocity` are both set to 1 in the +//! runtime. +//! 2. Establish and ensure the constant relay chain slot duration measured in milliseconds equal to +//! `6000` in the runtime. +//! ```rust +//! // Maximum number of blocks simultaneously accepted by the Runtime, not yet included into the +//! // relay chain. +//! pub const UNINCLUDED_SEGMENT_CAPACITY: u32 = 1; +//! // How many parachain blocks are processed by the relay chain per parent. Limits the number of +//! // blocks authored per slot. +//! pub const BLOCK_PROCESSING_VELOCITY: u32 = 1; +//! // Relay chain slot duration, in milliseconds. +//! pub const RELAY_CHAIN_SLOT_DURATION_MILLIS: u32 = 6000; +//! ``` +//! +//! 3. Establish constants `MILLISECS_PER_BLOCK` and `SLOT_DURATION` if not already present in the +//! runtime. +//! ```ignore +//! // `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked +//! // up by `pallet_aura` to implement `fn slot_duration()`. +//! // +//! // Change this to adjust the block time. +//! pub const MILLISECS_PER_BLOCK: u64 = 12000; +//! pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; +//! ``` +//! +//! 4. Configure `cumulus_pallet_parachain_system` in the runtime. +//! +//! - Define a `FixedVelocityConsensusHook` using our capacity, velocity, and relay slot duration +//! constants. Use this to set the parachain system `ConsensusHook` property. +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", ConsensusHook)] +//! ```ignore +//! impl cumulus_pallet_parachain_system::Config for Runtime { +//! .. +//! type ConsensusHook = ConsensusHook; +//! .. +//! } +//! ``` +//! - Set the parachain system property `CheckAssociatedRelayNumber` to +//! `RelayNumberMonotonicallyIncreases` +//! ```ignore +//! impl cumulus_pallet_parachain_system::Config for Runtime { +//! .. +//! type CheckAssociatedRelayNumber = RelayNumberMonotonicallyIncreases; +//! .. +//! } +//! ``` +//! +//! 5. Configure `pallet_aura` in the runtime. +//! +//! - Set `AllowMultipleBlocksPerSlot` to `false` (don't worry, we will set it to `true` when we +//! activate async backing in phase 3). +//! +//! - Define `pallet_aura::SlotDuration` using our constant `SLOT_DURATION` +//! ```ignore +//! impl pallet_aura::Config for Runtime { +//! .. +//! type AllowMultipleBlocksPerSlot = ConstBool; +//! #[cfg(feature = "experimental")] +//! type SlotDuration = ConstU64; +//! .. +//! } +//! ``` +//! +//! 6. Update `sp_consensus_aura::AuraApi::slot_duration` in `sp_api::impl_runtime_apis` to match +//! the constant `SLOT_DURATION` +#![doc = docify::embed!("../../templates/parachain/runtime/src/apis.rs", impl_slot_duration)] +//! +//! 7. Implement the `AuraUnincludedSegmentApi`, which allows the collator client to query its +//! runtime to determine whether it should author a block. +//! +//! - Add the dependency `cumulus-primitives-aura` to the `runtime/Cargo.toml` file for your +//! runtime +//! ```ignore +//! .. +//! cumulus-primitives-aura = { path = "../../../../primitives/aura", default-features = false } +//! .. +//! ``` +//! +//! - In the same file, add `"cumulus-primitives-aura/std",` to the `std` feature. +//! +//! - Inside the `impl_runtime_apis!` block for your runtime, implement the +//! `cumulus_primitives_aura::AuraUnincludedSegmentApi` as shown below. +#![doc = docify::embed!("../../templates/parachain/runtime/src/apis.rs", impl_can_build_upon)] +//! +//! **Note:** With a capacity of 1 we have an effective velocity of ½ even when velocity is +//! configured to some larger value. This is because capacity will be filled after a single block is +//! produced and will only be freed up after that block is included on the relay chain, which takes +//! 2 relay blocks to accomplish. Thus with capacity 1 and velocity 1 we get the customary 12 second +//! parachain block time. +//! +//! 8. If your `runtime/src/lib.rs` provides a `CheckInherents` type to `register_validate_block`, +//! remove it. `FixedVelocityConsensusHook` makes it unnecessary. The following example shows how +//! `register_validate_block` should look after removing `CheckInherents`. +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", register_validate_block)] +//! +//! +//! ## Phase 2 - Update Parachain Nodes +//! +//! This phase consists of plugging in the new lookahead collator node. +//! +//! 1. Import `cumulus_primitives_core::ValidationCode` to `node/src/service.rs`. +#![doc = docify::embed!("../../templates/parachain/node/src/service.rs", cumulus_primitives)] +//! +//! 2. In `node/src/service.rs`, modify `sc_service::spawn_tasks` to use a clone of `Backend` rather +//! than the original +//! ```ignore +//! sc_service::spawn_tasks(sc_service::SpawnTasksParams { +//! .. +//! backend: backend.clone(), +//! .. +//! })?; +//! ``` +//! +//! 3. Add `backend` as a parameter to `start_consensus()` in `node/src/service.rs` +//! ```text +//! fn start_consensus( +//! .. +//! backend: Arc, +//! .. +//! ``` +//! ```ignore +//! if validator { +//! start_consensus( +//! .. +//! backend.clone(), +//! .. +//! )?; +//! } +//! ``` +//! +//! 4. In `node/src/service.rs` import the lookahead collator rather than the basic collator +#![doc = docify::embed!("../../templates/parachain/node/src/service.rs", lookahead_collator)] +//! +//! 5. In `start_consensus()` replace the `BasicAuraParams` struct with `AuraParams` +//! - Change the struct type from `BasicAuraParams` to `AuraParams` +//! - In the `para_client` field, pass in a cloned para client rather than the original +//! - Add a `para_backend` parameter after `para_client`, passing in our para backend +//! - Provide a `code_hash_provider` closure like that shown below +//! - Increase `authoring_duration` from 500 milliseconds to 2000 +//! ```ignore +//! let params = AuraParams { +//! .. +//! para_client: client.clone(), +//! para_backend: backend.clone(), +//! .. +//! code_hash_provider: move |block_hash| { +//! client.code_at(block_hash).ok().map(|c| ValidationCode::from(c).hash()) +//! }, +//! .. +//! authoring_duration: Duration::from_millis(2000), +//! .. +//! }; +//! ``` +//! +//! **Note:** Set `authoring_duration` to whatever you want, taking your own hardware into account. +//! But if the backer who should be slower than you due to reading from disk, times out at two +//! seconds your candidates will be rejected. +//! +//! 6. In `start_consensus()` replace `basic_aura::run` with `aura::run` +//! ```ignore +//! let fut = +//! aura::run::( +//! params, +//! ); +//! task_manager.spawn_essential_handle().spawn("aura", None, fut); +//! ``` +//! +//! ## Phase 3 - Activate Async Backing +//! +//! This phase consists of changes to your parachain’s runtime that activate async backing feature. +//! +//! 1. Configure `pallet_aura`, setting `AllowMultipleBlocksPerSlot` to true in +//! `runtime/src/lib.rs`. +#![doc = docify::embed!("../../templates/parachain/runtime/src/configs/mod.rs", aura_config)] +//! +//! 2. Increase the maximum `UNINCLUDED_SEGMENT_CAPACITY` in `runtime/src/lib.rs`. +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", async_backing_params)] +//! +//! 3. Decrease `MILLISECS_PER_BLOCK` to 6000. +//! +//! - Note: For a parachain which measures time in terms of its own block number rather than by +//! relay block number it may be preferable to increase velocity. Changing block time may cause +//! complications, requiring additional changes. See the section “Timing by Block Number”. +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", block_times)] +//! +//! 4. Update `MAXIMUM_BLOCK_WEIGHT` to reflect the increased time available for block production. +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", max_block_weight)] +//! +//! 5. Add a feature flagged alternative for `MinimumPeriod` in `pallet_timestamp`. The type should +//! be `ConstU64<0>` with the feature flag experimental, and `ConstU64<{SLOT_DURATION / 2}>` +//! without. +//! ```ignore +//! impl pallet_timestamp::Config for Runtime { +//! .. +//! #[cfg(feature = "experimental")] +//! type MinimumPeriod = ConstU64<0>; +//! #[cfg(not(feature = "experimental"))] +//! type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>; +//! .. +//! } +//! ``` +//! +//! ## Timing by Block Number +//! +//! With asynchronous backing it will be possible for parachains to opt for a block time of 6 +//! seconds rather than 12 seconds. But modifying block duration isn’t so simple for a parachain +//! which was measuring time in terms of its own block number. It could result in expected and +//! actual time not matching up, stalling the parachain. +//! +//! One strategy to deal with this issue is to instead rely on relay chain block numbers for timing. +//! Relay block number is kept track of by each parachain in `pallet-parachain-system` with the +//! storage value `LastRelayChainBlockNumber`. This value can be obtained and used wherever timing +//! based on block number is needed. + +#![deny(rustdoc::broken_intra_doc_links)] +#![deny(rustdoc::private_intra_doc_links)] diff --git a/docs/sdk/src/guides/enable_elastic_scaling_mvp.rs b/docs/sdk/src/guides/enable_elastic_scaling_mvp.rs new file mode 100644 index 0000000000000000000000000000000000000000..38ef18b88e0d0af6ee6b25cadf577367a55c5e22 --- /dev/null +++ b/docs/sdk/src/guides/enable_elastic_scaling_mvp.rs @@ -0,0 +1,143 @@ +//! # Enable elastic scaling MVP for a parachain +//! +//!
This guide assumes full familiarity with Asynchronous Backing and its +//! terminology, as defined in the Polkadot Wiki. +//! Furthermore, the parachain should have already been upgraded according to the guide.
+//! +//! ## Quick introduction to elastic scaling +//! +//! [Elastic scaling](https://polkadot.network/blog/elastic-scaling-streamling-growth-on-polkadot) +//! is a feature that will enable parachains to seamlessly scale up/down the number of used cores. +//! This can be desirable in order to increase the compute or storage throughput of a parachain or +//! to lower the latency between a transaction being submitted and it getting built in a parachain +//! block. +//! +//! At present, with Asynchronous Backing enabled, a parachain can only include a block on the relay +//! chain every 6 seconds, irregardless of how many cores the parachain acquires. Elastic scaling +//! builds further on the 10x throughput increase of Async Backing, enabling collators to submit up +//! to 3 parachain blocks per relay chain block, resulting in a further 3x throughput increase. +//! +//! ## Current limitations of the MVP +//! +//! The full implementation of elastic scaling spans across the entire relay/parachain stack and is +//! still [work in progress](https://github.com/paritytech/polkadot-sdk/issues/1829). +//! The MVP is still considered experimental software, so stability is not guaranteed. +//! If you encounter any problems, +//! [please open an issue](https://github.com/paritytech/polkadot-sdk/issues). +//! Below are described the current limitations of the MVP: +//! +//! 1. **Limited core count**. Parachain block authoring is sequential, so the second block will +//! start being built only after the previous block is imported. The current block production is +//! capped at 2 seconds of execution. Therefore, assuming the full 2 seconds are used, a +//! parachain can only utilise at most 3 cores in a relay chain slot of 6 seconds. If the full +//! execution time is not being used, higher core counts can be achieved. +//! 2. **Single collator requirement for consistently scaling beyond a core at full authorship +//! duration of 2 seconds per block.** Using the current implementation with multiple collators +//! adds additional latency to the block production pipeline. Assuming block execution takes +//! about the same as authorship, the additional overhead is equal the duration of the authorship +//! plus the block announcement. Each collator must first import the previous block before +//! authoring a new one, so it is clear that the highest throughput can be achieved using a +//! single collator. Experiments show that the peak performance using more than one collator +//! (measured up to 10 collators) is utilising 2 cores with authorship time of 1.3 seconds per +//! block, which leaves 400ms for networking overhead. This would allow for 2.6 seconds of +//! execution, compared to the 2 seconds async backing enabled. +//! [More experiments](https://github.com/paritytech/polkadot-sdk/issues/4696) are being +//! conducted in this space. +//! 3. **Trusted collator set.** The collator set needs to be trusted until there’s a mitigation +//! that would prevent or deter multiple collators from submitting the same collation to multiple +//! backing groups. A solution is being discussed +//! [here](https://github.com/polkadot-fellows/RFCs/issues/92). +//! 4. **Fixed scaling.** For true elasticity, the parachain must be able to seamlessly acquire or +//! sell coretime as the user demand grows and shrinks over time, in an automated manner. This is +//! currently lacking - a parachain can only scale up or down by “manually” acquiring coretime. +//! This is not in the scope of the relay chain functionality. Parachains can already start +//! implementing such autoscaling, but we aim to provide a framework/examples for developing +//! autoscaling strategies. +//! +//! Another hard limitation that is not envisioned to ever be lifted is that parachains which create +//! forks will generally not be able to utilise the full number of cores they acquire. +//! +//! ## Using elastic scaling MVP +//! +//! ### Prerequisites +//! +//! - Ensure Asynchronous Backing is enabled on the network and you have enabled it on the parachain +//! using [`crate::guides::async_backing_guide`]. +//! - Ensure the `AsyncBackingParams.max_candidate_depth` value is configured to a value that is at +//! least double the maximum targeted parachain velocity. For example, if the parachain will build +//! at most 3 candidates per relay chain block, the `max_candidate_depth` should be at least 6. +//! - Use a trusted single collator for maximum throughput. +//! - Ensure enough coretime is assigned to the parachain. For maximum throughput the upper bound is +//! 3 cores. +//! +//!
Phase 1 is not needed if using the polkadot-parachain binary +//! built from the latest polkadot-sdk release! Simply pass the +//! --experimental-use-slot-based parameter to the command line and jump to Phase +//! 2.
+//! +//! The following steps assume using the cumulus parachain template. +//! +//! ### Phase 1 - (For custom parachain node) Update Parachain Node +//! +//! This assumes you are using +//! [the latest parachain template](https://github.com/paritytech/polkadot-sdk/tree/master/templates/parachain). +//! +//! This phase consists of plugging in the new slot-based collator. +//! +//! 1. In `node/src/service.rs` import the slot based collator instead of the lookahead collator. +#![doc = docify::embed!("../../cumulus/polkadot-parachain/polkadot-parachain-lib/src/service.rs", slot_based_colator_import)] +//! +//! 2. In `start_consensus()` +//! - Remove the `overseer_handle` param (also remove the +//! `OverseerHandle` type import if it’s not used elsewhere). +//! - Rename `AuraParams` to `SlotBasedParams`, remove the `overseer_handle` field and add a +//! `slot_drift` field with a value of `Duration::from_secs(1)`. +//! - Replace the single future returned by `aura::run` with the two futures returned by it and +//! spawn them as separate tasks: +#![doc = docify::embed!("../../cumulus/polkadot-parachain/polkadot-parachain-lib/src/service.rs", launch_slot_based_collator)] +//! +//! 3. In `start_parachain_node()` remove the `overseer_handle` param passed to `start_consensus`. +//! +//! ### Phase 2 - Activate fixed factor scaling in the runtime +//! +//! This phase consists of a couple of changes needed to be made to the parachain’s runtime in order +//! to utilise fixed factor scaling. +//! +//! First of all, you need to decide the upper limit to how many parachain blocks you need to +//! produce per relay chain block (in direct correlation with the number of acquired cores). This +//! should be either 1 (no scaling), 2 or 3. This is called the parachain velocity. +//! +//! If you configure a velocity which is different from the number of assigned cores, the measured +//! velocity in practice will be the minimum of these two. +//! +//! The chosen velocity will also be used to compute: +//! - The slot duration, by dividing the 6000 ms duration of the relay chain slot duration by the +//! velocity. +//! - The unincluded segment capacity, by multiplying the velocity with 2 and adding 1 to +//! it. +//! +//! Let’s assume a desired maximum velocity of 3 parachain blocks per relay chain block. The needed +//! changes would all be done in `runtime/src/lib.rs`: +//! +//! 1. Rename `BLOCK_PROCESSING_VELOCITY` to `MAX_BLOCK_PROCESSING_VELOCITY` and increase it to the +//! desired value. In this example, 3. +//! +//! ```ignore +//! const MAX_BLOCK_PROCESSING_VELOCITY: u32 = 3; +//! ``` +//! +//! 2. Set the `MILLISECS_PER_BLOCK` to the desired value. +//! +//! ```ignore +//! const MILLISECS_PER_BLOCK: u32 = +//! RELAY_CHAIN_SLOT_DURATION_MILLIS / MAX_BLOCK_PROCESSING_VELOCITY; +//! ``` +//! Note: for a parachain which measures time in terms of its own block number, changing block +//! time may cause complications, requiring additional changes. See here more information: +//! [`crate::guides::async_backing_guide#timing-by-block-number`]. +//! +//! 3. Increase the `UNINCLUDED_SEGMENT_CAPACITY` to the desired value. +//! +//! ```ignore +//! const UNINCLUDED_SEGMENT_CAPACITY: u32 = 2 * MAX_BLOCK_PROCESSING_VELOCITY + 1; +//! ``` diff --git a/docs/sdk/src/guides/enable_metadata_hash.rs b/docs/sdk/src/guides/enable_metadata_hash.rs new file mode 100644 index 0000000000000000000000000000000000000000..930afd4d8ff71c6c565700cf76759c1ce06b35f0 --- /dev/null +++ b/docs/sdk/src/guides/enable_metadata_hash.rs @@ -0,0 +1,88 @@ +//! # Enable metadata hash verification +//! +//! This guide will teach you how to enable the metadata hash verification in your runtime. +//! +//! ## What is metadata hash verification? +//! +//! Each FRAME based runtime exposes metadata about itself. This metadata is used by consumers of +//! the runtime to interpret the state, to construct transactions etc. Part of this metadata are the +//! type information. These type information can be used to e.g. decode storage entries or to decode +//! a transaction. So, the metadata is quite useful for wallets to interact with a FRAME based +//! chain. Online wallets can fetch the metadata directly from any node of the chain they are +//! connected to, but offline wallets can not do this. So, for the offline wallet to have access to +//! the metadata it needs to be transferred and stored on the device. The problem is that the +//! metadata has a size of several hundreds of kilobytes, which takes quite a while to transfer to +//! these offline wallets and the internal storage of these devices is also not big enough to store +//! the metadata for one or more networks. The next problem is that the offline wallet/user can not +//! trust the metadata to be correct. It is very important for the metadata to be correct or +//! otherwise an attacker could change them in a way that the offline wallet decodes a transaction +//! in a different way than what it will be decoded to on chain. So, the user may sign an incorrect +//! transaction leading to unexpected behavior. +//! +//! The metadata hash verification circumvents the issues of the huge metadata and the need to trust +//! some metadata blob to be correct. To generate a hash for the metadata, the metadata is chunked, +//! these chunks are put into a merkle tree and then the root of this merkle tree is the "metadata +//! hash". For a more technical explanation on how it works, see +//! [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html). At compile +//! time the metadata hash is generated and "baked" into the runtime. This makes it extremely cheap +//! for the runtime to verify on chain that the metadata hash is correct. By having the runtime +//! verify the hash on chain, the user also doesn't need to trust the offchain metadata. If the +//! metadata hash doesn't match the on chain metadata hash the transaction will be rejected. The +//! metadata hash itself is added to the data of the transaction that is signed, this means the +//! actual hash does not appear in the transaction. On chain the same procedure is repeated with the +//! metadata hash that is known by the runtime and if the metadata hash doesn't match the signature +//! verification will fail. As the metadata hash is actually the root of a merkle tree, the offline +//! wallet can get proofs of individual types to decode a transaction. This means that the offline +//! wallet does not require the entire metadata to be present on the device. +//! +//! ## Integrating metadata hash verification into your runtime +//! +//! The integration of the metadata hash verification is split into two parts, first the actual +//! integration into the runtime and secondly the enabling of the metadata hash generation at +//! compile time. +//! +//! ### Runtime integration +//! +//! From the runtime side only the +//! [`CheckMetadataHash`](frame_metadata_hash_extension::CheckMetadataHash) needs to be added to the +//! list of signed extension: +#![doc = docify::embed!("../../templates/parachain/runtime/src/lib.rs", template_signed_extra)] +//! +//! > **Note:** +//! > +//! > Adding the signed extension changes the encoding of the transaction and adds one extra byte +//! > per transaction! +//! +//! This signed extension will make sure to decode the requested `mode` and will add the metadata +//! hash to the signed data depending on the requested `mode`. The `mode` gives the user/wallet +//! control over deciding if the metadata hash should be verified or not. The metadata hash itself +//! is drawn from the `RUNTIME_METADATA_HASH` environment variable. If the environment variable is +//! not set, any transaction that requires the metadata hash is rejected with the error +//! `CannotLookup`. This is a security measurement to prevent including invalid transactions. +//! +//!
+//! +//! The extension does not work with the native runtime, because the +//! `RUNTIME_METADATA_HASH` environment variable is not set when building the +//! `frame-metadata-hash-extension` crate. +//! +//!
+//! +//! ### Enable metadata hash generation +//! +//! The metadata hash generation needs to be enabled when building the wasm binary. The +//! `substrate-wasm-builder` supports this out of the box: +#![doc = docify::embed!("../../templates/parachain/runtime/build.rs", template_enable_metadata_hash)] +//! +//! > **Note:** +//! > +//! > The `metadata-hash` feature needs to be enabled for the `substrate-wasm-builder` to enable the +//! > code for being able to generate the metadata hash. It is also recommended to put the metadata +//! > hash generation behind a feature in the runtime as shown above. The reason behind is that it +//! > adds a lot of code which increases the compile time and the generation itself also increases +//! > the compile time. Thus, it is recommended to enable the feature only when the metadata hash is +//! > required (e.g. for an on-chain build). +//! +//! The two parameters to `enable_metadata_hash` are the token symbol and the number of decimals of +//! the primary token of the chain. These information are included for the wallets to show token +//! related operations in a more user friendly way. diff --git a/docs/sdk/src/guides/enable_pov_reclaim.rs b/docs/sdk/src/guides/enable_pov_reclaim.rs index 3c0c5fba2158691b51abdcceed5db5130e58c9b4..13b27d18956b49fdb66b79fa44208321ad43c6f0 100644 --- a/docs/sdk/src/guides/enable_pov_reclaim.rs +++ b/docs/sdk/src/guides/enable_pov_reclaim.rs @@ -1,3 +1,5 @@ +//! # Enable storage weight reclaiming +//! //! This guide will teach you how to enable storage weight reclaiming for a parachain. The //! explanations in this guide assume a project structure similar to the one detailed in //! the [substrate documentation](crate::polkadot_sdk::substrate#anatomy-of-a-binary-crate). Full diff --git a/docs/sdk/src/guides/mod.rs b/docs/sdk/src/guides/mod.rs index 2dc807af8eaed45d78109bd1b22528d94e24bf06..a7fd146ccdf3a7be21e0a17382ee3abdaa4d961a 100644 --- a/docs/sdk/src/guides/mod.rs +++ b/docs/sdk/src/guides/mod.rs @@ -1,28 +1,46 @@ //! # Polkadot SDK Docs Guides //! -//! This crate contains a collection of guides that are foundational to the developers of -//! Polkadot SDK. They are common user-journeys that are traversed in the Polkadot ecosystem. +//! This crate contains a collection of guides that are foundational to the developers of Polkadot +//! SDK. They are common user-journeys that are traversed in the Polkadot ecosystem. +//! +//! 1. [`crate::guides::your_first_pallet`] is your starting point with Polkadot SDK. It contains +//! the basics of +//! building a simple crypto currency with FRAME. +//! 2. [`crate::guides::your_first_runtime`] is the next step in your journey. It contains the +//! basics of building a runtime that contains this pallet, plus a few common pallets from FRAME. +//! +//! +//! Other guides are related to other miscellaneous topics and are listed as modules below. /// Write your first simple pallet, learning the most most basic features of FRAME along the way. pub mod your_first_pallet; -/// Writing your first real [runtime](`crate::reference_docs::wasm_meta_protocol`), and successfully +/// Write your first real [runtime](`crate::reference_docs::wasm_meta_protocol`), /// compiling it to [WASM](crate::polkadot_sdk::substrate#wasm-build). pub mod your_first_runtime; -/// Running the given runtime with a node. No specific consensus mechanism is used at this stage. -pub mod your_first_node; - -/// How to change the consensus engine of both the node and the runtime. -pub mod changing_consensus; +// /// Running the given runtime with a node. No specific consensus mechanism is used at this stage. +// TODO +// pub mod your_first_node; -/// How to enhance a given runtime and node to be cumulus-enabled, run it as a parachain and connect -/// it to a relay-chain. -pub mod cumulus_enabled_parachain; +// /// How to enhance a given runtime and node to be cumulus-enabled, run it as a parachain +// /// and connect it to a relay-chain. +// TODO +// pub mod cumulus_enabled_parachain; -/// How to make a given runtime XCM-enabled, capable of sending messages (`Transact`) between itself -/// and the relay chain to which it is connected. -pub mod xcm_enabled_parachain; +// /// How to make a given runtime XCM-enabled, capable of sending messages (`Transact`) between +// /// itself and the relay chain to which it is connected. +// TODO +// pub mod xcm_enabled_parachain; /// How to enable storage weight reclaiming in a parachain node and runtime. pub mod enable_pov_reclaim; + +/// How to enable Async Backing on parachain projects that started in 2023 or before. +pub mod async_backing_guide; + +/// How to enable metadata hash verification in the runtime. +pub mod enable_metadata_hash; + +/// How to enable elastic scaling MVP on a parachain. +pub mod enable_elastic_scaling_mvp; diff --git a/docs/sdk/src/guides/your_first_pallet/mod.rs b/docs/sdk/src/guides/your_first_pallet/mod.rs index c6e0dd0edf8925105661591d0831d65ff8ed02be..006d0be7ded35eaf1cf933ee7574536ebc0ac909 100644 --- a/docs/sdk/src/guides/your_first_pallet/mod.rs +++ b/docs/sdk/src/guides/your_first_pallet/mod.rs @@ -1,6 +1,6 @@ //! # Currency Pallet //! -//! By the end of this guide, you will write a small FRAME pallet (see +//! By the end of this guide, you will have written a small FRAME pallet (see //! [`crate::polkadot_sdk::frame_runtime`]) that is capable of handling a simple crypto-currency. //! This pallet will: //! @@ -14,18 +14,14 @@ //! > FRAME-based runtimes use various techniques to re-use a currency pallet instead of writing //! > one. Further advanced FRAME related topics are discussed in [`crate::reference_docs`]. //! -//! ## Topics Covered +//! ## Writing Your First Pallet //! -//! The following FRAME topics are covered in this guide: +//! To get started, use one of the templates mentioned in [`crate::polkadot_sdk::templates`]. We +//! recommend using the `polkadot-sdk-minimal-template`. You might need to change small parts of +//! this guide, namely the crate/package names, based on which template you use. //! -//! - [Storage](frame::pallet_macros::storage) -//! - [Call](frame::pallet_macros::call) -//! - [Event](frame::pallet_macros::event) -//! - [Error](frame::pallet_macros::error) -//! - Basics of testing a pallet -//! - [Constructing a runtime](frame::runtime::prelude::construct_runtime) -//! -//! ## Writing Your First Pallet +//! > Be aware that you can read the entire source code backing this tutorial by clicking on the +//! > `source` button at the top right of the page. //! //! You should have studied the following modules as a prelude to this guide: //! @@ -33,16 +29,28 @@ //! - [`crate::reference_docs::trait_based_programming`] //! - [`crate::polkadot_sdk::frame_runtime`] //! +//! ## Topics Covered +//! +//! The following FRAME topics are covered in this guide: +//! +//! - [`pallet::storage`] +//! - [`pallet::call`] +//! - [`pallet::event`] +//! - [`pallet::error`] +//! - Basics of testing a pallet +//! - [Constructing a runtime](frame::runtime::prelude::construct_runtime) +//! //! ### Shell Pallet //! //! Consider the following as a "shell pallet". We continue building the rest of this pallet based //! on this template. //! -//! [`pallet::config`](frame::pallet_macros::config) and -//! [`pallet::pallet`](frame::pallet_macros::pallet) are both mandatory parts of any pallet. Refer -//! to the documentation of each to get an overview of what they do. +//! [`pallet::config`] and [`pallet::pallet`] are both mandatory parts of any +//! pallet. Refer to the documentation of each to get an overview of what they do. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", shell_pallet)] //! +//! All of the code that follows in this guide should live inside of the `mod pallet`. +//! //! ### Storage //! //! First, we will need to create two onchain storage declarations. @@ -55,18 +63,17 @@ //! > generic bounded type in the `Config` trait, and then specify it in the implementation. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Balance)] //! -//! The definition of these two storage items, based on [`frame::pallet_macros::storage`] details, -//! is as follows: +//! The definition of these two storage items, based on [`pallet::storage`] details, is as follows: #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", TotalIssuance)] #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Balances)] //! //! ### Dispatchables //! -//! Next, we will define the dispatchable functions. As per [`frame::pallet_macros::call`], these -//! will be defined as normal `fn`s attached to `struct Pallet`. +//! Next, we will define the dispatchable functions. As per [`pallet::call`], these will be defined +//! as normal `fn`s attached to `struct Pallet`. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", impl_pallet)] //! -//! The logic of the functions is self-explanatory. Instead, we will focus on the FRAME-related +//! The logic of these functions is self-explanatory. Instead, we will focus on the FRAME-related //! details: //! //! - Where do `T::AccountId` and `T::RuntimeOrigin` come from? These are both defined in @@ -76,10 +83,9 @@ //! document ([`crate::reference_docs::frame_origin`]). For now, you should only know the //! signature of the function: it takes a generic `T::RuntimeOrigin` and returns a //! `Result`. So by the end of this function call, we know that this dispatchable -//! was signed by `who`. +//! was signed by `sender`. #![doc = docify::embed!("../../substrate/frame/system/src/lib.rs", ensure_signed)] //! -//! //! - Where does `mutate`, `get` and `insert` and other storage APIs come from? All of them are //! explained in the corresponding `type`, for example, for `Balances::::insert`, you can look //! into [`frame::prelude::StorageMap::insert`]. @@ -90,13 +96,12 @@ //! Which is more or less a normal Rust `Result`, with a custom [`frame::prelude::DispatchError`] as //! the `Err` variant. We won't cover this error in detail here, but importantly you should know //! that there is an `impl From<&'static string> for DispatchError` provided (see -//! [here](`frame::prelude::DispatchError#impl-From<%26'static+str>-for-DispatchError`)). Therefore, +//! [here](`frame::prelude::DispatchError#impl-From<%26str>-for-DispatchError`)). Therefore, //! we can use basic string literals as our error type and `.into()` them into `DispatchError`. //! //! - Why are all `get` and `mutate` functions returning an `Option`? This is the default behavior //! of FRAME storage APIs. You can learn more about how to override this by looking into -//! [`frame::pallet_macros::storage`], and -//! [`frame::prelude::ValueQuery`]/[`frame::prelude::OptionQuery`] +//! [`pallet::storage`], and [`frame::prelude::ValueQuery`]/[`frame::prelude::OptionQuery`] //! //! ### Improving Errors //! @@ -112,10 +117,29 @@ //! ergonomic. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", transfer_better_checked)] //! -//! This is more or less all the logic that there is this basic currency pallet! +//! This is more or less all the logic that there is in this basic currency pallet! //! //! ### Your First (Test) Runtime //! +//! The typical testing code of a pallet lives in a module that imports some preludes useful for +//! testing, similar to: +//! +//! ``` +//! pub mod pallet { +//! // snip -- actually pallet code. +//! } +//! +//! #[cfg(test)] +//! mod tests { +//! // bring in the testing prelude of frame +//! use frame::testing_prelude::*; +//! // bring in all pallet items +//! use super::pallet::*; +//! +//! // snip -- rest of the testing code. +//! } +//! ``` +//! //! Next, we create a "test runtime" in order to test our pallet. Recall from //! [`crate::polkadot_sdk::frame_runtime`] that a runtime is a collection of pallets, expressed //! through [`frame::runtime::prelude::construct_runtime`]. All runtimes also have to include @@ -166,7 +190,6 @@ //! As noted above, the `T::AccountId` is now `u64`. Moreover, `Runtime` is replacing ``. //! This is why for example you see `Balances::::get(..)`. Finally, notice that the //! dispatchables are simply functions that can be called on top of the `Pallet` struct. -// TODO: hard to explain exactly `RuntimeOrigin::signed(ALICE)` at this point. //! //! Congratulations! You have written your first pallet and tested it! Next, we learn a few optional //! steps to improve our pallet. @@ -236,8 +259,7 @@ //! by one character. FRAME errors are exactly a solution to maintain readability, whilst fixing //! the drawbacks mentioned. In short, we use an enum to represent different variants of our //! error. These variants are then mapped in an efficient way (using only `u8` indices) to -//! [`sp_runtime::DispatchError::Module`]. Read more about this in -//! [`frame::pallet_macros::error`]. +//! [`sp_runtime::DispatchError::Module`]. Read more about this in [`pallet::error`]. //! //! - **Event**: Events are akin to the return type of dispatchables. They are mostly data blobs //! emitted by the runtime to let outside world know what is happening inside the pallet. Since @@ -246,20 +268,16 @@ //! use passive tense for event names (eg. `SomethingHappened`). This allows other sub-systems or //! external parties (eg. a light-node, a DApp) to listen to particular events happening, without //! needing to re-execute the whole state transition function. -// TODO: both need to be improved a lot at the pallet-macro rust-doc level. Also my explanation -// of event is probably not the best. //! //! With the explanation out of the way, let's see how these components can be added. Both follow a -//! fairly familiar syntax: normal Rust enums, with extra -//! [`#[frame::event]`](frame::pallet_macros::event) and -//! [`#[frame::error]`](frame::pallet_macros::error) attributes attached. +//! fairly familiar syntax: normal Rust enums, with extra [`pallet::event`] and [`pallet::error`] +//! attributes attached. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Event)] #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", Error)] //! -//! One slightly custom part of this is the [`#[pallet::generate_deposit(pub(super) fn -//! deposit_event)]`](frame::pallet_macros::generate_deposit) part. Without going into too -//! much detail, in order for a pallet to emit events to the rest of the system, it needs to do two -//! things: +//! One slightly custom part of this is the [`pallet::generate_deposit`] part. Without going into +//! too much detail, in order for a pallet to emit events to the rest of the system, it needs to do +//! two things: //! //! 1. Declare a type in its `Config` that refers to the overarching event type of the runtime. In //! short, by doing this, the pallet is expressing an important bound: `type RuntimeEvent: @@ -268,8 +286,8 @@ //! store it where needed. //! //! 2. But, doing this conversion and storing is too much to expect each pallet to define. FRAME -//! provides a default way of storing events, and this is what -//! [`pallet::generate_deposit`](frame::pallet_macros::generate_deposit) is doing. +//! provides a default way of storing events, and this is what [`pallet::generate_deposit`] is +//! doing. #![doc = docify::embed!("./src/guides/your_first_pallet/mod.rs", config_v2)] //! //! > These `Runtime*` types are better explained in @@ -297,10 +315,17 @@ //! - [`crate::reference_docs::defensive_programming`]. //! - [`crate::reference_docs::frame_origin`]. //! - [`crate::reference_docs::frame_runtime_types`]. -//! - The pallet we wrote in this guide was using `dev_mode`, learn more in -//! [`frame::pallet_macros::config`]. +//! - The pallet we wrote in this guide was using `dev_mode`, learn more in [`pallet::config`]. //! - Learn more about the individual pallet items/macros, such as event and errors and call, in //! [`frame::pallet_macros`]. +//! +//! [`pallet::storage`]: frame_support::pallet_macros::storage +//! [`pallet::call`]: frame_support::pallet_macros::call +//! [`pallet::event`]: frame_support::pallet_macros::event +//! [`pallet::error`]: frame_support::pallet_macros::error +//! [`pallet::pallet`]: frame_support::pallet +//! [`pallet::config`]: frame_support::pallet_macros::config +//! [`pallet::generate_deposit`]: frame_support::pallet_macros::generate_deposit #[docify::export] #[frame::pallet(dev_mode)] @@ -418,16 +443,22 @@ pub mod pallet { #[cfg(any(test, doc))] pub(crate) mod tests { use crate::guides::your_first_pallet::pallet::*; + + #[docify::export(testing_prelude)] use frame::testing_prelude::*; - const ALICE: u64 = 1; - const BOB: u64 = 2; - const CHARLIE: u64 = 3; + + pub(crate) const ALICE: u64 = 1; + pub(crate) const BOB: u64 = 2; + pub(crate) const CHARLIE: u64 = 3; #[docify::export] + // This runtime is only used for testing, so it should be somewhere like `#[cfg(test)] mod + // tests { .. }` mod runtime { use super::*; // we need to reference our `mod pallet` as an identifier to pass to // `construct_runtime`. + // YOU HAVE TO CHANGE THIS LINE BASED ON YOUR TEMPLATE use crate::guides::your_first_pallet::pallet as pallet_currency; construct_runtime!( @@ -595,7 +626,7 @@ pub mod pallet { #[test] fn transfer_works() { StateBuilder::default().build_and_execute(|| { - // given the the initial state, when: + // given the initial state, when: assert_ok!(Pallet::::transfer(RuntimeOrigin::signed(ALICE), BOB, 50)); // then: @@ -617,7 +648,7 @@ pub mod pallet { #[test] fn transfer_from_non_existent_fails() { StateBuilder::default().build_and_execute(|| { - // given the the initial state, when: + // given the initial state, when: assert_err!( Pallet::::transfer(RuntimeOrigin::signed(CHARLIE), ALICE, 10), "NonExistentAccount" @@ -738,7 +769,7 @@ pub mod pallet_v2 { // the final assertion. System::set_block_number(ALICE); - // given the the initial state, when: + // given the initial state, when: assert_ok!(Pallet::::transfer(RuntimeOrigin::signed(ALICE), BOB, 50)); // then: diff --git a/docs/sdk/src/guides/your_first_runtime.rs b/docs/sdk/src/guides/your_first_runtime.rs index 3e02ef1b1b28eedb7cea0ce38fb8b372a0caaf60..c58abc1120c13f5d9d724f7dd78464380f8840bf 100644 --- a/docs/sdk/src/guides/your_first_runtime.rs +++ b/docs/sdk/src/guides/your_first_runtime.rs @@ -1 +1,3 @@ //! # Your first Runtime +//! +//! 🚧 diff --git a/docs/sdk/src/lib.rs b/docs/sdk/src/lib.rs index e211476d2514419a3d0889ef426817342155c178..6dc87858530cf61d1a61426423ed6ae55c7fe786 100644 --- a/docs/sdk/src/lib.rs +++ b/docs/sdk/src/lib.rs @@ -13,8 +13,8 @@ //! We suggest the following reading sequence: //! //! - Start by learning about the the [`polkadot_sdk`], its structure and context. -//! - Then, head over the [`guides`]. This modules contains in-depth guides about the most important -//! user-journeys of the Polkadot SDK. +//! - Then, head over to the [`guides`]. This modules contains in-depth guides about the most +//! important user-journeys of the Polkadot SDK. //! - Whilst reading the guides, you might find back-links to [`reference_docs`]. //! - Finally, is the parent website of this crate that contains the //! list of further tools related to the Polkadot SDK. @@ -25,7 +25,7 @@ #![doc = simple_mermaid::mermaid!("../../mermaid/IA.mmd")] #![warn(rustdoc::broken_intra_doc_links)] #![warn(rustdoc::private_intra_doc_links)] -#![doc(html_favicon_url = "https://polkadot.network/favicon-32x32.png")] +#![doc(html_favicon_url = "https://polkadot.com/favicon.ico")] #![doc( html_logo_url = "https://europe1.discourse-cdn.com/standard21/uploads/polkadot2/original/1X/eb57081e2bb7c39e5fcb1a98b443e423fa4448ae.svg" )] @@ -36,7 +36,7 @@ pub mod meta_contributing; /// In-depth guides about the most common components of the Polkadot SDK. They are slightly more -/// high level and broad than reference docs. +/// high level and broad than [`reference_docs`]. pub mod guides; /// An introduction to the Polkadot SDK. Read this module to learn about the structure of the SDK, /// the tools that are provided as a part of it, and to gain a high level understanding of each. diff --git a/docs/sdk/src/meta_contributing.rs b/docs/sdk/src/meta_contributing.rs index a029595254c84dfa58639279b4fcd486f25c3f0e..e1297151b2312f9828bdddecb4fbbb76995132cb 100644 --- a/docs/sdk/src/meta_contributing.rs +++ b/docs/sdk/src/meta_contributing.rs @@ -14,7 +14,7 @@ //! documentation up-to-date, as the overhead is reduced by making sure everything is in one //! repository, and everything being in `.rs` files. //! -//! > This is not say that a more visually appealing version of this crate (for example as an +//! > This is not to say that a more visually appealing version of this crate (for example as an //! > `md-book`) cannot exist, but it would be outside the scope of this crate. //! //! Moreover, we acknowledge that a major pain point has been not only outdated *concepts*, but also diff --git a/docs/sdk/src/polkadot_sdk/frame_runtime.rs b/docs/sdk/src/polkadot_sdk/frame_runtime.rs index f9b8a381365c4b3675485f3f32cb0cf751138275..8acf19f7641379c3fdfda62ce34c5799179d0b4a 100644 --- a/docs/sdk/src/polkadot_sdk/frame_runtime.rs +++ b/docs/sdk/src/polkadot_sdk/frame_runtime.rs @@ -54,7 +54,7 @@ //! //! ### Example //! -//! The following examples showcases a minimal pallet. +//! The following example showcases a minimal pallet. #![doc = docify::embed!("src/polkadot_sdk/frame_runtime.rs", pallet)] //! //! @@ -85,9 +85,7 @@ //! [`crate::reference_docs::wasm_meta_protocol`]). Notable examples are: //! //! * writing a runtime in pure Rust, as done in [this template](https://github.com/JoshOrndorff/frameless-node-template). -//! * writing a runtime in AssemblyScript,as explored in [this project](https://github.com/LimeChain/subsembly). - -use frame::prelude::*; +//! * writing a runtime in AssemblyScript, as explored in [this project](https://github.com/LimeChain/subsembly). /// A FRAME based pallet. This `mod` is the entry point for everything else. All /// `#[pallet::xxx]` macros must be defined in this `mod`. Although, frame also provides an @@ -96,7 +94,7 @@ use frame::prelude::*; #[docify::export] #[frame::pallet(dev_mode)] pub mod pallet { - use super::*; + use frame::prelude::*; /// The configuration trait of a pallet. Mandatory. Allows a pallet to receive types at a /// later point from the runtime that wishes to contain it. It allows the pallet to be @@ -121,11 +119,11 @@ pub mod pallet { #[pallet::pallet] pub struct Pallet(PhantomData); - /// The events tha this pallet can emit. + /// The events that this pallet can emit. #[pallet::event] pub enum Event {} - /// A storage item that this pallet contains. This will be part of the state root trie/root + /// A storage item that this pallet contains. This will be part of the state root trie /// of the blockchain. #[pallet::storage] pub type Value = StorageValue; diff --git a/docs/sdk/src/polkadot_sdk/mod.rs b/docs/sdk/src/polkadot_sdk/mod.rs index 124d391421b9049dd5865fae0ac9e739e3f46cce..32cad72fba7e2e3b3bc9b74994309076eae43114 100644 --- a/docs/sdk/src/polkadot_sdk/mod.rs +++ b/docs/sdk/src/polkadot_sdk/mod.rs @@ -12,7 +12,7 @@ //! //! [![RFCs](https://img.shields.io/badge/fellowship-RFCs-e6007a?logo=polkadot)](https://github.com/polkadot-fellows/rfcs) //! [![Runtime](https://img.shields.io/badge/fellowship-runtimes-e6007a?logo=polkadot)](https://github.com/polkadot-fellows/runtimes) -//! [![Manifesto](https://img.shields.io/badge/fellowship-manifesto-e6007a?logo=polkadot)](https://github.com/polkadot-fellows/manifesto) +//! [![Manifesto](https://img.shields.io/badge/fellowship-manifesto-e6007a?logo=polkadot)](https://github.com/polkadot-fellows/manifesto/blob/main/manifesto.pdf) //! //! ## Getting Started //! @@ -34,7 +34,7 @@ //! Repo](https://img.shields.io/badge/github-substrate-2324CC85)](https://github.com/paritytech/polkadot-sdk/blob/master/substrate) //! //! [`substrate`] is the base blockchain framework used to power the Polkadot SDK. It is a full -//! toolkit to create sovereign blockchains, including but not limited to those who connect to +//! toolkit to create sovereign blockchains, including but not limited to those which connect to //! Polkadot as parachains. //! //! #### FRAME @@ -82,7 +82,7 @@ //! //! A Substrate-based chain is a blockchain composed of a runtime and a node. As noted above, the //! runtime is the application logic of the blockchain, and the node is everything else. -//! See [`crate::reference_docs::wasm_meta_protocol`] for an in-depth explanation of this. The +//! See [`reference_docs::wasm_meta_protocol`] for an in-depth explanation of this. The //! former is built with [`frame`], and the latter is built with rest of Substrate. //! //! > You can think of a Substrate-based chain as a white-labeled blockchain. @@ -103,8 +103,8 @@ //! //! ## Trophy Section: Notable Downstream Projects //! -//! A list of projects and tools in the blockchain ecosystem that one way or another parts of the -//! Polkadot SDK: +//! A list of projects and tools in the blockchain ecosystem that one way or another use parts of +//! the Polkadot SDK: //! //! * [Polygon's spin-off, Avail](https://github.com/availproject/avail) //! * [Cardano Partner Chains](https://iohk.io/en/blog/posts/2023/11/03/partner-chains-are-coming-to-cardano/) @@ -116,7 +116,7 @@ //! [`polkadot`]: crate::polkadot_sdk::polkadot //! [`xcm`]: crate::polkadot_sdk::xcm -/// Lean about Cumulus, the framework that transforms [`substrate`]-based chains into +/// Learn about Cumulus, the framework that transforms [`substrate`]-based chains into /// [`polkadot`]-enabled parachains. pub mod cumulus; /// Learn about FRAME, the framework used to build Substrate runtimes. diff --git a/docs/sdk/src/polkadot_sdk/polkadot.rs b/docs/sdk/src/polkadot_sdk/polkadot.rs index 61a6877696cb9298ed831562923d96d4a701bcc4..69532f323b9db73ceb4bf1254d34f6f22844a1d0 100644 --- a/docs/sdk/src/polkadot_sdk/polkadot.rs +++ b/docs/sdk/src/polkadot_sdk/polkadot.rs @@ -6,18 +6,20 @@ //! //! - [Polkadot Forum](https://forum.polkadot.network/) //! - [Polkadot Parachains](https://parachains.info/) -//! - [Polkadot (multi-chain) Explorer](https://subscan.io/) +//! - [Polkadot (multi-chain) Explorer: Subscan](https://subscan.io/) //! - Polkadot Fellowship -//! - [Manifesto](https://github.com/polkadot-fellows/manifesto) +//! - [Manifesto](https://github.com/polkadot-fellows/manifesto/blob/main/manifesto.pdf) //! - [Runtimes](https://github.com/polkadot-fellows/runtimes) //! - [RFCs](https://github.com/polkadot-fellows/rfcs) -//! - [Polkadot Specs](spec.polkadot.network) +//! - [Dashboard](https://polkadot-fellows.github.io/dashboard/) +//! - [Polkadot Specs](http://spec.polkadot.network) //! - [The Polkadot Parachain Host Implementers' Guide](https://paritytech.github.io/polkadot-sdk/book/) //! - [Whitepaper](https://www.polkadot.network/whitepaper/) +//! - [JAM Graypaper](https://graypaper.com) //! //! ## Alternative Node Implementations 🌈 //! -//! - [Smoldot](https://crates.io/crates/smoldot-light). Polkadot light node/client. +//! - [Smoldot](https://docs.rs/crate/smoldot-light/latest). Polkadot light node/client. //! - [KAGOME](https://github.com/qdrvm/kagome). C++ implementation of the Polkadot host. //! - [Gossamer](https://github.com/ChainSafe/gossamer). Golang implementation of the Polkadot host. //! @@ -43,7 +45,7 @@ //! > their execution and governance sovereignty. These chains are called "Parachains". //! //! * Shared Security: The idea of shared economic security sits at the core of Polkadot. Polkadot -//! enables different parachains* to pool their economic security from Polkadot (i.e. "*Relay +//! enables different parachains to pool their economic security from Polkadot (i.e. "*Relay //! Chain*"). //! * (heterogenous) Sharded Execution: Yet, each parachain is free to have its own execution logic //! (runtime), which also encompasses governance and sovereignty. Moreover, Polkadot ensures the @@ -78,7 +80,7 @@ //! Within the scope of Polkadot 1.x, two main scheduling ways have been considered: //! //! * Long term Parachains, obtained through locking a sum of DOT in an auction system. -//! * on-demand Parachains, purchased through paying DOT to the relay-chain whenever needed. +//! * On-demand Parachains, purchased through paying DOT to the relay-chain whenever needed. //! //! ### The Future //! diff --git a/docs/sdk/src/polkadot_sdk/substrate.rs b/docs/sdk/src/polkadot_sdk/substrate.rs index 69d74d86db1b585692d9df8ae9db08ae454ca9f9..56b89f8c9c2a3f106ad293c8fc605bd7304739ea 100644 --- a/docs/sdk/src/polkadot_sdk/substrate.rs +++ b/docs/sdk/src/polkadot_sdk/substrate.rs @@ -11,9 +11,9 @@ //! 1. Society and technology evolves. //! 2. Humans are fallible. //! -//! This, makes the task of designing a correct, safe and long-lasting blockchain system hard. +//! This makes the task of designing a correct, safe and long-lasting blockchain system hard. //! -//! Nonetheless, in strive towards achieve this goal, Substrate embraces the following: +//! Nonetheless, in strive towards achieving this goal, Substrate embraces the following: //! //! 1. Use of **Rust** as a modern and safe programming language, which limits human error through //! various means, most notably memory and type safety. @@ -27,7 +27,7 @@ //! blob. //! //! In essence, the meta-protocol of all Substrate based chains is the "Runtime as WASM blob" -//! accord. This enables the Runtime to become inherently upgradeable, crucially without forks. The +//! accord. This enables the Runtime to become inherently upgradeable, crucially without [forks](https://en.wikipedia.org/wiki/Fork_(blockchain)). The //! upgrade is merely a matter of the WASM blob being changed in the state, which is, in principle, //! same as updating an account's balance. Learn more about this in detail in //! [`crate::reference_docs::wasm_meta_protocol`]. @@ -63,9 +63,9 @@ //! categories: //! //! * `sc-*` (short for *Substrate-client*) crates, located under `./client` folder. These are all -//! the crates that lead to the node software. Notable examples [`sc_network`], various consensus -//! crates, RPC ([`sc_rpc_api`]) and database ([`sc_client_db`]), all of which are expected to -//! reside in the node side. +//! the crates that lead to the node software. Notable examples are [`sc_network`], various +//! consensus crates, RPC ([`sc_rpc_api`]) and database ([`sc_client_db`]), all of which are +//! expected to reside in the node side. //! * `sp-*` (short for *substrate-primitives*) crates, located under `./primitives` folder. These //! are crates that facilitate both the node and the runtime, but are not opinionated about what //! framework is using for building the runtime. Notable examples are [`sp_api`] and [`sp_io`], @@ -86,7 +86,9 @@ //! //! Substrate-based runtimes use [`substrate_wasm_builder`] in their `build.rs` to automatically //! build their WASM files as a part of normal build command (e.g. `cargo build`). Once built, the -//! wasm file is placed in `./target/{debug|release}/wbuild/{runtime_name}.wasm`. +//! wasm file is placed in `./target/{debug|release}/wbuild/{runtime_name}/{runtime_name}.wasm`. +//! +//! In order to ensure that the WASM build is **deterministic**, the [Substrate Runtime Toolbox (srtool)](https://github.com/paritytech/srtool) can be used. //! //! ### Binaries //! diff --git a/docs/sdk/src/polkadot_sdk/templates.rs b/docs/sdk/src/polkadot_sdk/templates.rs index 4bf0e839c798fc55dd1fa0696c6bfe8411c32bc8..03a7aa98198fa47ce7d19909b99a5a6fc4b49ca2 100644 --- a/docs/sdk/src/polkadot_sdk/templates.rs +++ b/docs/sdk/src/polkadot_sdk/templates.rs @@ -1,19 +1,33 @@ //! # Templates //! -//! ### Internal +//! This document enumerates a non-exhaustive list of templates that one can use to get started with +//! polkadot-sdk. //! -//! The following templates are maintained as a part of the `polkadot-sdk` repository: +//! > Know more tools/templates that are not listed here? please contribute them by opening a PR. //! -//! - classic [`substrate-node-template`]: is a white-labeled substrate-based blockchain with a -//! moderate amount of features. It can act as a great starting point for those who want to learn -//! Substrate/FRAME and want to have a template that is already doing something. -//! - [`substrate-minimal-template`]: Same as the above, but it contains the least amount of code in -//! both the node and runtime. It is a great starting point for those who want to deeply learn -//! Substrate and FRAME. -//! - classic [`cumulus-parachain-template`], which is the de-facto parachain template shipped with -//! Cumulus. It is the parachain-enabled version of [`substrate-node-template`]. +//! ## Internal //! -//! ### External Templates +//! The following [templates](https://github.com/paritytech/polkadot-sdk/blob/master/templates) are +//! maintained as a part of the `polkadot-sdk` repository: +//! +//! - `minimal_template_node`/[`minimal_template_runtime`]: A minimal template that contains the +//! least amount of features to be a functioning blockchain. Suitable for learning, development +//! and testing. This template is not meant to be used in production. +//! - `solochain_template_node`/[`solochain_template_runtime`]: Formerly known as +//! "substrate-node-template", is a white-labeled substrate-based blockchain (aka. solochain) that +//! contains moderate features, such as a basic consensus engine and some FRAME pallets. This +//! template can act as a good starting point for those who want to launch a solochain. +//! - `parachain_template_node`/[`parachain_template_runtime`]: A parachain template ready to be +//! connected to a test relay-chain. +//! +//! These templates are always kept up to date, and are mirrored to external repositories for easy +//! forking: +//! +//! - +//! - +//! - +//! +//! ## External Templates //! //! Noteworthy templates outside of this repository. //! @@ -22,23 +36,22 @@ //! - [`frontier-parachain-template`](https://github.com/paritytech/frontier-parachain-template): A //! parachain template for launching EVM-compatible parachains. //! -//! [`minimal-template`]: https://github.com/paritytech/polkadot-sdk/blob/master/templates/minimal/ -//! [`parachain-template`]: https://github.com/paritytech/polkadot-sdk/blob/master/templates/parachain/ - -// TODO: in general, we need to make a deliberate choice here of moving a few key templates to this -// repo (nothing stays in `substrate-developer-hub`) and the everything else should be community -// maintained. https://github.com/paritytech/polkadot-sdk-docs/issues/67 - -// TODO: we should rename `substrate-node-template` to `substrate-basic-template`, -// `substrate-blockchain-template`. `node` is confusing in the name. -// `substrate-blockchain-template` and `cumulus-parachain-template` go well together 🤝. https://github.com/paritytech/polkadot-sdk-docs/issues/67 - -// NOTE: a super important detail that I am looking forward to here is -// and -// . Meaning that I would not spend time on -// teaching someone too much detail about the ugly thing we call "node" nowadays. In the future, I -// am sure we will either have a better "node-builder" code that can actually be tested, or an -// "omni-node" that can run (almost) any wasm file. We should already build tutorials in this -// direction IMO. This also affects all the templates. If we have a good neat runtime file, which we -// are moving toward, and a good node-builder, we don't need all of these damn templates. These -// templates are only there because the boilerplate is super horrible atm. +//! ## OpenZeppelin +//! +//! In June 2023, OpenZeppelin was awarded a grant from the [Polkadot +//! treasury](https://polkadot.polkassembly.io/treasury/406) for building a number of Polkadot-sdk +//! based templates. These templates are a great starting point for developers and newcomers. +//! So far OpenZeppelin has released two templates, which have been fully [audited](https://github.com/OpenZeppelin/polkadot-runtime-templates/tree/main/audits): +//! - [`generic-runtime-template`](https://github.com/OpenZeppelin/polkadot-runtime-templates?tab=readme-ov-file#generic-runtime-template): +//! A minimal template that has all the common pallets that parachains use with secure defaults. +//! - [`evm-runtime-template`](https://github.com/OpenZeppelin/polkadot-runtime-templates/tree/main?tab=readme-ov-file#evm-template): +//! This template has EVM compatibility out of the box and allows migrating your solidity contracts +//! or EVM compatible dapps easily. It also uses 20 byte addresses like Ethereum and has some +//! Account Abstraction support. +//! +//! ## POP-CLI +//! +//! Is a CLI tool capable of scaffolding a new polkadot-sdk-based project, possibly removing the +//! need for templates. +//! +//! - diff --git a/docs/sdk/src/polkadot_sdk/xcm.rs b/docs/sdk/src/polkadot_sdk/xcm.rs index 5dcdc9e1de076c4507cb64517360df73e6733dc7..20841b0b55b93986e509a8751ff2e16e32df56eb 100644 --- a/docs/sdk/src/polkadot_sdk/xcm.rs +++ b/docs/sdk/src/polkadot_sdk/xcm.rs @@ -5,7 +5,7 @@ //! //! ## Overview //! -//! XCM is a standard, whose specification lives in the [xcm format repo](https://github.com/paritytech/xcm-format). +//! XCM is a standard, specification of which lives in the [xcm format repo](https://github.com/paritytech/xcm-format). //! It's agnostic both in programming language and blockchain platform, which means it could be used //! in Rust in Polkadot, or in Go or C++ in any other platform like Cosmos or Ethereum. //! @@ -34,13 +34,12 @@ //! but will be moved to its own repo in the future. //! //! Its main components are: -//! - `src`: the definition of the basic types and instructions -//! - [`xcm-executor`](https://paritytech.github.io/polkadot-sdk/master/staging_xcm_executor/struct.XcmExecutor.html): -//! an implementation of the virtual machine to execute instructions -//! - `pallet-xcm`: A FRAME pallet for interacting with the executor -//! - `xcm-builder`: a collection of types to configure the executor -//! - `xcm-simulator`: a playground for trying out different XCM programs and executor -//! configurations +//! - [`xcm`](::xcm): The definition of the basic types and instructions. +//! - [`xcm_executor`]: An implementation of the virtual machine to execute instructions. +//! - [`pallet_xcm`]: A FRAME pallet for interacting with the executor. +//! - [`xcm_builder`]: A collection of types to configure the executor. +//! - [`xcm_simulator`]: A playground for trying out different XCM programs and executor +//! configurations. //! //! ## Example //! @@ -50,7 +49,7 @@ //! //! ## Get started //! -//! To learn how it works and to get started, go to the [XCM docs](https://paritytech.github.io/xcm-docs/). +//! To learn how it works and to get started, go to the [XCM docs](xcm_docs). #[cfg(test)] mod tests { diff --git a/docs/sdk/src/reference_docs/blockchain_scalibility.rs b/docs/sdk/src/reference_docs/blockchain_scalibility.rs deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/docs/sdk/src/reference_docs/blockchain_state_machines.rs b/docs/sdk/src/reference_docs/blockchain_state_machines.rs index 0d1aefcc52770b70baf284335816f013cbfbe5ed..36ab0ce5ed54f448dd56ca28346b40e07b33c491 100644 --- a/docs/sdk/src/reference_docs/blockchain_state_machines.rs +++ b/docs/sdk/src/reference_docs/blockchain_state_machines.rs @@ -21,7 +21,7 @@ #![doc = simple_mermaid::mermaid!("../../../mermaid/stf.mmd")] //! //! In essence, the state of the blockchain at block N is the outcome of applying the state -//! transition function to the the previous state, and the current block as input. This can be +//! transition function to the previous state, and the current block as input. This can be //! mathematically represented as: //! //! ```math diff --git a/docs/sdk/src/reference_docs/chain_spec_genesis.rs b/docs/sdk/src/reference_docs/chain_spec_genesis.rs index 2ac51a91f2de78cf10262e5b38c2ebf482c15183..39e5993d020fa6cc262f8d7eebd4d7167ba5082e 100644 --- a/docs/sdk/src/reference_docs/chain_spec_genesis.rs +++ b/docs/sdk/src/reference_docs/chain_spec_genesis.rs @@ -1,4 +1,185 @@ -//! Chain spec and genesis build. +//! # What is chain-spec. //! -//! What is chain-spec. -//! What is genesis state and how to build it. +//! A chain specification file defines the set of properties that are required to run the node as +//! part of the chain. The chain specification consists of two main parts: +//! - initial state of the runtime, +//! - network / logical properties of the chain, the most important property being the list of +//! bootnodes. +//! +//! This document describes how the initial state is handled in pallets and runtime, and how to +//! interact with the runtime in order to build the genesis state. +//! +//! For more information on chain specification and its properties, refer to +//! [`sc_chain_spec#from-initial-state-to-raw-genesis`]. +//! +//! The initial genesis state can be provided in the following formats: +//! - full +//! - patch +//! - raw +//! +//! Each of the formats is explained in [_chain-spec-format_][`sc_chain_spec#chain-spec-formats`]. +//! +//! +//! # `GenesisConfig` for `pallet` +//! +//! Every frame pallet may have its initial state which is defined by the `GenesisConfig` internal +//! struct. It is a regular Rust struct, annotated with the [`pallet::genesis_config`] attribute. +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar_GenesisConfig)] +//! +//! The struct shall be defined within the pallet `mod`, as in the following code: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar)] +//! +//! The initial state conveyed in the `GenesisConfig` struct is transformed into state storage +//! items by means of the [`BuildGenesisConfig`] trait, which shall be implemented for the pallet's +//! `GenesisConfig` struct. The [`pallet::genesis_build`] attribute shall be attached to the `impl` +//! block: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_bar_build)] +//! +//! `GenesisConfig` may also contain more complicated types, including nested structs or enums, as +//! in the example for `pallet_foo`: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_foo_GenesisConfig)] +//! +//! Note that [`serde`] attributes can be used to control how the data +//! structures are stored into JSON. In the following example, the [`sp_core::bytes`] function is +//! used to serialize the `values` field. +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", SomeFooData2)] +//! +//! Please note that fields of `GenesisConfig` may not be directly mapped to storage items. In the +//! following example, the initial struct fields are used to compute (sum) the value that will be +//! stored in the state as `ProcessedEnumValue`: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/pallets.rs", pallet_foo_build)] +//! +//! # `GenesisConfig` for `runtimes` +//! +//! The runtime genesis config struct consists of configs for every pallet. For the [_demonstration +//! runtime_][`chain_spec_guide_runtime`] used in this guide, it consists of `SystemConfig`, +//! `BarConfig`, and `FooConfig`. This structure was automatically generated by a macro and it can +//! be sneak-peeked here: [`RuntimeGenesisConfig`]. For further reading on generated runtime +//! types, refer to [`frame_runtime_types`]. +//! +//! The macro automatically adds an attribute that renames all the fields to [`camelCase`]. It is a +//! good practice to add it to nested structures too, to have the naming of the JSON keys consistent +//! across the chain-spec file. +//! +//! ## `Default` for `GenesisConfig` +//! +//! `GenesisConfig` of all pallets must implement the `Default` trait. These are aggregated into +//! the runtime's `RuntimeGenesisConfig`'s `Default`. +//! +//! The default value of `RuntimeGenesisConfig` can be queried by the [`GenesisBuilder::get_preset`] +//! function provided by the runtime with `id:None`. +//! +//! A default value for `RuntimeGenesisConfig` usually is not operational. This is because for some +//! pallets it is not possible to define good defaults (e.g. an initial set of authorities). +//! +//! A default value is a base upon which a patch for `GenesisConfig` is applied. A good description +//! of how it exactly works is provided in [`get_storage_for_patch`] (and also in +//! [`GenesisBuilder::get_preset`]). A patch can be provided as an external file (manually created) +//! or as a built-in runtime preset. More info on presets is in the material to follow. +//! +//! ## Implementing `GenesisBuilder` for runtime +//! +//! The runtime exposes a dedicated runtime API for interacting with its genesis config: +//! [`sp_genesis_builder::GenesisBuilder`]. The implementation shall be provided within +//! the [`sp_api::impl_runtime_apis`] macro, typically making use of some helpers provided: +//! [`build_state`], [`get_preset`]. +//! A typical implementation of [`sp_genesis_builder::GenesisBuilder`] looks as follows: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/runtime.rs", runtime_impl)] +//! +//! Please note that two functions are customized: `preset_names` and `get_preset`. The first one +//! just provides a `Vec` of the names of supported presets, while the latter delegates the call +//! to a function that maps the name to an actual preset: +//! [`chain_spec_guide_runtime::presets::get_builtin_preset`] +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", get_builtin_preset)] +//! +//! ## Genesis state presets for runtime +//! +//! The runtime may provide many flavors of initial genesis state. This may be useful for predefined +//! testing networks, local development, or CI integration tests. Predefined genesis state may +//! contain a list of pre-funded accounts, predefined authorities for consensus, sudo key, and many +//! others useful for testing. +//! +//! Internally, presets can be provided in a number of ways: +//! - JSON in string form: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_1)] +//! - JSON using runtime types to serialize values: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_2)] +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_3)] +//! It is worth noting that a preset does not have to be the full `RuntimeGenesisConfig`, in that +//! sense that it does not have to contain all the keys of the struct. The preset is actually a JSON +//! patch that will be merged with the default value of `RuntimeGenesisConfig`. This approach should +//! simplify maintenance of built-in presets. The following example illustrates a runtime genesis +//! config patch: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_4)] +//! +//! ## Note on the importance of testing presets +//! +//! It is recommended to always test presets by adding tests that convert the preset into the +//! raw storage. Converting to raw storage involves the deserialization of the provided JSON blob, +//! which enforces the verification of the preset. The following code shows one of the approaches +//! that can be taken for testing: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", check_presets)] +//! +//! ## Note on the importance of using the `deny_unknown_fields` attribute +//! +//! It is worth noting that it is easy to make a hard-to-spot mistake, as in the following example +//! ([`FooStruct`] does not contain `fieldC`): +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", preset_invalid)] +//! Even though `preset_invalid` contains a key that does not exist, the deserialization of the JSON +//! blob does not fail. The misspelling is silently ignored due to the lack of the +//! [`deny_unknown_fields`] attribute on the [`FooStruct`] struct, which is internally used in +//! `GenesisConfig`. +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/src/presets.rs", invalid_preset_works)] +//! +//! ## Runtime `GenesisConfig` raw format +//! +//! A raw format of genesis config contains just the state's keys and values as they are stored in +//! the storage. This format is used to directly initialize the genesis storage. This format is +//! useful for long-term running chains, where the `GenesisConfig` structure for pallets may be +//! evolving over time. The JSON representation created at some point in time may no longer be +//! deserializable in the future, making a chain specification useless. The raw format is +//! recommended for production chains. +//! +//! For a detailed description of how the raw format is built, please refer to +//! [_chain-spec-raw-genesis_][`sc_chain_spec#from-initial-state-to-raw-genesis`]. Plain and +//! corresponding raw examples of chain-spec are given in +//! [_chain-spec-examples_][`sc_chain_spec#json-chain-specification-example`]. +//! The [`chain_spec_builder`] util supports building the raw storage. +//! +//! # Interacting with the tool +//! +//! The [`chain_spec_builder`] util allows interaction with the runtime in order to list or display +//! presets and build the chain specification file. It is possible to use the tool with the +//! [_demonstration runtime_][`chain_spec_guide_runtime`]. To build the required packages, just run +//! the following command: +//! ```ignore +//! cargo build -p staging-chain-spec-builder -p chain-spec-guide-runtime --release +//! ``` +//! The `chain-spec-builder` util can also be installed with `cargo install`: +//! ```ignore +//! cargo install staging-chain-spec-builder +//! cargo build -p chain-spec-guide-runtime --release +//! ``` +//! Here are some examples in the form of rust tests: +//! ## Listing available preset names: +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", list_presets)] +//! ## Displaying preset with given name +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", get_preset)] +//! ## Building chain-spec using given preset +#![doc = docify::embed!("./src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs", generate_chain_spec)] +//! +//! [`RuntimeGenesisConfig`]: +//! chain_spec_guide_runtime::runtime::RuntimeGenesisConfig +//! [`FooStruct`]: +//! chain_spec_guide_runtime::pallets::FooStruct +//! [`impl_runtime_apis`]: frame::runtime::prelude::impl_runtime_apis +//! [`build_state`]: frame_support::genesis_builder_helper::build_state +//! [`get_preset`]: frame_support::genesis_builder_helper::get_preset +//! [`pallet::genesis_build`]: frame_support::pallet_macros::genesis_build +//! [`pallet::genesis_config`]: frame_support::pallet_macros::genesis_config +//! [`BuildGenesisConfig`]: frame_support::traits::BuildGenesisConfig +//! [`serde`]: https://serde.rs/field-attrs.html +//! [`get_storage_for_patch`]: sc_chain_spec::GenesisConfigBuilderRuntimeCaller::get_storage_for_patch +//! [`GenesisBuilder::get_preset`]: sp_genesis_builder::GenesisBuilder::get_preset +//! [`deny_unknown_fields`]: https://serde.rs/container-attrs.html#deny_unknown_fields +//! [`camelCase`]: https://serde.rs/container-attrs.html#rename_all diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..02849571203285d5a9bbc19d4d3aecad8495c214 --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/Cargo.toml @@ -0,0 +1,69 @@ +[package] +name = "chain-spec-guide-runtime" +description = "A minimal runtime for chain spec guide" +version = "0.0.0" +license = "MIT-0" +authors.workspace = true +homepage.workspace = true +repository.workspace = true +edition.workspace = true +publish = false + +[dependencies] +docify = { workspace = true } +codec = { workspace = true } +scale-info = { workspace = true } +serde = { workspace = true } +serde_json = { workspace = true } + +# this is a frame-based runtime, thus importing `frame` with runtime feature enabled. +frame = { features = [ + "experimental", + "runtime", +], workspace = true } + +# pallets that we want to use +pallet-balances = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } + +# genesis builder that allows us to interact with runtime genesis config +sp-genesis-builder = { workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-core = { workspace = true } +sp-keyring = { workspace = true } +sp-application-crypto = { features = ["serde"], workspace = true } + +[build-dependencies] +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } + +[dev-dependencies] +chain-spec-builder = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } + +[features] +default = ["std"] +std = [ + "codec/std", + "scale-info/std", + + "frame/std", + + "pallet-balances/std", + "pallet-sudo/std", + "pallet-timestamp/std", + "pallet-transaction-payment-rpc-runtime-api/std", + "pallet-transaction-payment/std", + + "sp-application-crypto/std", + "sp-core/std", + "sp-genesis-builder/std", + "sp-keyring/std", + "sp-runtime/std", + + "serde/std", + "serde_json/std", + "substrate-wasm-builder", +] diff --git a/substrate/utils/frame/frame-utilities-cli/src/lib.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/build.rs similarity index 86% rename from substrate/utils/frame/frame-utilities-cli/src/lib.rs rename to docs/sdk/src/reference_docs/chain_spec_runtime/build.rs index 97129e36f7e9c04664a793d75d00e8bf8a86a413..e6f92757e225475ff744a4a0cf931787463d1544 100644 --- a/substrate/utils/frame/frame-utilities-cli/src/lib.rs +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/build.rs @@ -15,8 +15,9 @@ // See the License for the specific language governing permissions and // limitations under the License. -//! frame-system CLI utilities - -mod pallet_id; - -pub use pallet_id::PalletIdCmd; +fn main() { + #[cfg(feature = "std")] + { + substrate_wasm_builder::WasmBuilder::build_using_defaults(); + } +} diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7effce1bd6697196c3af45bde27e811250d0e5f --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/lib.rs @@ -0,0 +1,29 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#![cfg_attr(not(feature = "std"), no_std)] + +//! A minimal runtime that shows runtime genesis state. + +extern crate alloc; + +pub mod pallets; +pub mod presets; +pub mod runtime; + +#[cfg(feature = "std")] +pub use runtime::{WASM_BINARY, WASM_BINARY_BLOATY}; diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs new file mode 100644 index 0000000000000000000000000000000000000000..2ff2d9539e2dbdd13997f925474ecbaf5a2836c7 --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/pallets.rs @@ -0,0 +1,138 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Pallets for the chain-spec demo runtime. + +use alloc::vec::Vec; +use frame::prelude::*; + +#[docify::export] +#[frame::pallet(dev_mode)] +pub mod pallet_bar { + use super::*; + + #[pallet::config] + pub trait Config: frame_system::Config {} + + #[pallet::pallet] + pub struct Pallet(_); + + #[pallet::storage] + pub(super) type InitialAccount = StorageValue; + + /// Simple `GenesisConfig`. + #[pallet::genesis_config] + #[derive(DefaultNoBound)] + #[docify::export(pallet_bar_GenesisConfig)] + pub struct GenesisConfig { + pub initial_account: Option, + } + + #[pallet::genesis_build] + #[docify::export(pallet_bar_build)] + impl BuildGenesisConfig for GenesisConfig { + /// The storage building function that presents a direct mapping of the initial config + /// values to the storage items. + fn build(&self) { + InitialAccount::::set(self.initial_account.clone()); + } + } +} + +/// The sample structure used in `GenesisConfig`. +/// +/// This structure does not deny unknown fields. This may lead to some problems. +#[derive(Default, serde::Serialize, serde::Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FooStruct { + pub field_a: u8, + pub field_b: u8, +} + +/// The sample structure used in `GenesisConfig`. +/// +/// This structure does not deny unknown fields. This may lead to some problems. +#[derive(Default, serde::Serialize, serde::Deserialize)] +#[serde(deny_unknown_fields, rename_all = "camelCase")] +pub struct SomeFooData1 { + pub a: u8, + pub b: u8, +} + +/// Another sample structure used in `GenesisConfig`. +/// +/// The user defined serialization is used. +#[derive(Default, serde::Serialize, serde::Deserialize)] +#[docify::export] +#[serde(deny_unknown_fields, rename_all = "camelCase")] +pub struct SomeFooData2 { + #[serde(default, with = "sp_core::bytes")] + pub values: Vec, +} + +/// Sample enum used in `GenesisConfig`. +#[derive(Default, serde::Serialize, serde::Deserialize)] +pub enum FooEnum { + #[default] + Data0, + Data1(SomeFooData1), + Data2(SomeFooData2), +} + +#[docify::export] +#[frame::pallet(dev_mode)] +pub mod pallet_foo { + use super::*; + + #[pallet::config] + pub trait Config: frame_system::Config {} + + #[pallet::pallet] + pub struct Pallet(_); + + #[pallet::storage] + pub type ProcessedEnumValue = StorageValue; + #[pallet::storage] + pub type SomeInteger = StorageValue; + + /// The more sophisticated structure for conveying initial state. + #[docify::export(pallet_foo_GenesisConfig)] + #[pallet::genesis_config] + #[derive(DefaultNoBound)] + pub struct GenesisConfig { + pub some_integer: u32, + pub some_enum: FooEnum, + pub some_struct: FooStruct, + #[serde(skip)] + _phantom: PhantomData, + } + + #[pallet::genesis_build] + #[docify::export(pallet_foo_build)] + impl BuildGenesisConfig for GenesisConfig { + /// The build method that indirectly maps an initial config values into the storage items. + fn build(&self) { + let processed_value: u64 = match &self.some_enum { + FooEnum::Data0 => 0, + FooEnum::Data1(v) => (v.a + v.b).into(), + FooEnum::Data2(v) => v.values.iter().map(|v| *v as u64).sum(), + }; + ProcessedEnumValue::::set(Some(processed_value)); + SomeInteger::::set(Some(self.some_integer)); + } + } +} diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs new file mode 100644 index 0000000000000000000000000000000000000000..02c2d90f7c827f51dfe913fd0743109b9f96618a --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/presets.rs @@ -0,0 +1,166 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Presets for the chain-spec demo runtime. + +use crate::pallets::{FooEnum, SomeFooData1, SomeFooData2}; +use alloc::vec; +use serde_json::{json, to_string, Value}; +use sp_application_crypto::Ss58Codec; +use sp_keyring::AccountKeyring; + +/// A demo preset with strings only. +pub const PRESET_1: &str = "preset_1"; +/// A demo preset with real types. +pub const PRESET_2: &str = "preset_2"; +/// Another demo preset with real types. +pub const PRESET_3: &str = "preset_3"; +/// A single value patch preset. +pub const PRESET_4: &str = "preset_4"; +/// A single value patch preset. +pub const PRESET_INVALID: &str = "preset_invalid"; + +#[docify::export] +/// Function provides a preset demonstrating how use string representation of preset's internal +/// values. +fn preset_1() -> Value { + json!({ + "bar": { + "initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL", + }, + "foo": { + "someEnum": { + "Data2": { + "values": "0x0c0f" + } + }, + "someStruct" : { + "fieldA": 10, + "fieldB": 20 + }, + "someInteger": 100 + }, + }) +} + +#[docify::export] +/// Function provides a preset demonstrating how use the actual types to create a preset. +fn preset_2() -> Value { + json!({ + "bar": { + "initialAccount": AccountKeyring::Ferdie.public().to_ss58check(), + }, + "foo": { + "someEnum": FooEnum::Data2(SomeFooData2 { values: vec![12,16] }), + "someInteger": 200 + }, + }) +} + +#[docify::export] +/// Function provides a preset demonstrating how use the actual types to create a preset. +fn preset_3() -> Value { + json!({ + "bar": { + "initialAccount": AccountKeyring::Alice.public().to_ss58check(), + }, + "foo": { + "someEnum": FooEnum::Data1( + SomeFooData1 { + a: 12, + b: 16 + } + ), + "someInteger": 300 + }, + }) +} + +#[docify::export] +/// Function provides a minimal preset demonstrating how to patch single key in +/// `RuntimeGenesisConfig`. +fn preset_4() -> Value { + json!({ + "foo": { + "someEnum": { + "Data2": { + "values": "0x0c0f" + } + }, + }, + }) +} + +#[docify::export] +/// Function provides an invalid preset demonstrating how important is use of +/// [`deny_unknown_fields`] in data structures used in `GenesisConfig`. +fn preset_invalid() -> Value { + json!({ + "foo": { + "someStruct": { + "fieldC": 5 + }, + }, + }) +} + +/// Provides a JSON representation of preset identified by given `id`. +/// +/// If no preset with given `id` exits `None` is returned. +#[docify::export] +pub fn get_builtin_preset(id: &sp_genesis_builder::PresetId) -> Option> { + let preset = match id.try_into() { + Ok(PRESET_1) => preset_1(), + Ok(PRESET_2) => preset_2(), + Ok(PRESET_3) => preset_3(), + Ok(PRESET_4) => preset_4(), + Ok(PRESET_INVALID) => preset_invalid(), + _ => return None, + }; + + Some( + to_string(&preset) + .expect("serialization to json is expected to work. qed.") + .into_bytes(), + ) +} + +#[test] +#[docify::export] +fn check_presets() { + let builder = sc_chain_spec::GenesisConfigBuilderRuntimeCaller::<()>::new( + crate::WASM_BINARY.expect("wasm binary shall exists"), + ); + assert!(builder.get_storage_for_named_preset(Some(&PRESET_1.to_string())).is_ok()); + assert!(builder.get_storage_for_named_preset(Some(&PRESET_2.to_string())).is_ok()); + assert!(builder.get_storage_for_named_preset(Some(&PRESET_3.to_string())).is_ok()); + assert!(builder.get_storage_for_named_preset(Some(&PRESET_4.to_string())).is_ok()); +} + +#[test] +#[docify::export] +fn invalid_preset_works() { + let builder = sc_chain_spec::GenesisConfigBuilderRuntimeCaller::<()>::new( + crate::WASM_BINARY.expect("wasm binary shall exists"), + ); + // Even though a preset contains invalid_key, conversion to raw storage does not fail. This is + // because the [`FooStruct`] structure is not annotated with `deny_unknown_fields` [`serde`] + // attribute. + // This may lead to hard to debug problems, that's why using ['deny_unknown_fields'] is + // recommended. + assert!(builder.get_storage_for_named_preset(Some(&PRESET_INVALID.to_string())).is_ok()); +} diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs new file mode 100644 index 0000000000000000000000000000000000000000..195d1b124474dc0c076937c652095cd65884ca7d --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/src/runtime.rs @@ -0,0 +1,120 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! A minimal runtime that shows runtime genesis state. + +// Make the WASM binary available. +#[cfg(feature = "std")] +include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); + +use crate::{ + pallets::{pallet_bar, pallet_foo}, + presets::*, +}; +use alloc::{vec, vec::Vec}; +use frame::{ + deps::frame_support::{ + genesis_builder_helper::{build_state, get_preset}, + runtime, + }, + prelude::*, + runtime::{apis, prelude::*}, +}; +use sp_genesis_builder::PresetId; + +/// The runtime version. +#[runtime_version] +pub const VERSION: RuntimeVersion = RuntimeVersion { + spec_name: create_runtime_str!("minimal-template-runtime"), + impl_name: create_runtime_str!("minimal-template-runtime"), + authoring_version: 1, + spec_version: 0, + impl_version: 1, + apis: RUNTIME_API_VERSIONS, + transaction_version: 1, + state_version: 1, +}; + +/// The signed extensions that are added to the runtime. +type SignedExtra = (); + +// Composes the runtime by adding all the used pallets and deriving necessary types. +#[runtime] +mod runtime { + /// The main runtime type. + #[runtime::runtime] + #[runtime::derive(RuntimeCall, RuntimeEvent, RuntimeError, RuntimeOrigin, RuntimeTask)] + pub struct Runtime; + + /// Mandatory system pallet that should always be included in a FRAME runtime. + #[runtime::pallet_index(0)] + pub type System = frame_system; + + /// Sample pallet 1 + #[runtime::pallet_index(1)] + pub type Bar = pallet_bar; + + /// Sample pallet 2 + #[runtime::pallet_index(2)] + pub type Foo = pallet_foo; +} + +parameter_types! { + pub const Version: RuntimeVersion = VERSION; +} + +/// Implements the types required for the system pallet. +#[derive_impl(frame_system::config_preludes::SolochainDefaultConfig)] +impl frame_system::Config for Runtime { + type Block = Block; + type Version = Version; +} + +impl pallet_bar::Config for Runtime {} +impl pallet_foo::Config for Runtime {} + +type Block = frame::runtime::types_common::BlockOf; +type Header = HeaderFor; + +#[docify::export(runtime_impl)] +impl_runtime_apis! { + impl sp_genesis_builder::GenesisBuilder for Runtime { + fn build_state(config: Vec) -> sp_genesis_builder::Result { + build_state::(config) + } + + fn get_preset(id: &Option) -> Option> { + get_preset::(id, get_builtin_preset) + } + + fn preset_names() -> Vec { + vec![ + PresetId::from(PRESET_1), + PresetId::from(PRESET_2), + PresetId::from(PRESET_3), + PresetId::from(PRESET_4), + PresetId::from(PRESET_INVALID) + ] + } + } + + impl apis::Core for Runtime { + fn version() -> RuntimeVersion { VERSION } + fn execute_block(_: Block) { } + fn initialize_block(_: &Header) -> ExtrinsicInclusionMode { ExtrinsicInclusionMode::default() } + } +} diff --git a/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs new file mode 100644 index 0000000000000000000000000000000000000000..d08f547bba616ad7be11cf7f2ca0e151e5e6583c --- /dev/null +++ b/docs/sdk/src/reference_docs/chain_spec_runtime/tests/chain_spec_builder_tests.rs @@ -0,0 +1,129 @@ +use serde_json::{json, Value}; +use std::{process::Command, str}; + +const WASM_FILE_PATH: &str = + "../../../../../target/release/wbuild/chain-spec-guide-runtime/chain_spec_guide_runtime.wasm"; + +const CHAIN_SPEC_BUILDER_PATH: &str = "../../../../../target/release/chain-spec-builder"; + +fn get_chain_spec_builder_path() -> &'static str { + // dev-dependencies do not build binary. So let's do the naive work-around here: + let _ = std::process::Command::new("cargo") + .arg("build") + .arg("--release") + .arg("-p") + .arg("staging-chain-spec-builder") + .arg("--bin") + .arg("chain-spec-builder") + .status() + .expect("Failed to execute command"); + CHAIN_SPEC_BUILDER_PATH +} + +#[test] +#[docify::export] +fn list_presets() { + let output = Command::new(get_chain_spec_builder_path()) + .arg("list-presets") + .arg("-r") + .arg(WASM_FILE_PATH) + .output() + .expect("Failed to execute command"); + + let output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); + + let expected_output = json!({ + "presets":[ + "preset_1", + "preset_2", + "preset_3", + "preset_4", + "preset_invalid" + ] + }); + assert_eq!(output, expected_output, "Output did not match expected"); +} + +#[test] +#[docify::export] +fn get_preset() { + let output = Command::new(get_chain_spec_builder_path()) + .arg("display-preset") + .arg("-r") + .arg(WASM_FILE_PATH) + .arg("-p") + .arg("preset_2") + .output() + .expect("Failed to execute command"); + + let output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); + + //note: copy of chain_spec_guide_runtime::preset_1 + let expected_output = json!({ + "bar": { + "initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL", + }, + "foo": { + "someEnum": { + "Data2": { + "values": "0x0c10" + } + }, + "someInteger": 200 + }, + }); + assert_eq!(output, expected_output, "Output did not match expected"); +} + +#[test] +#[docify::export] +fn generate_chain_spec() { + let output = Command::new(get_chain_spec_builder_path()) + .arg("-c") + .arg("/dev/stdout") + .arg("create") + .arg("-r") + .arg(WASM_FILE_PATH) + .arg("named-preset") + .arg("preset_2") + .output() + .expect("Failed to execute command"); + + let mut output: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap(); + + //remove code field for better readability + if let Some(code) = output["genesis"]["runtimeGenesis"].as_object_mut().unwrap().get_mut("code") + { + *code = Value::String("0x123".to_string()); + } + + let expected_output = json!({ + "name": "Custom", + "id": "custom", + "chainType": "Live", + "bootNodes": [], + "telemetryEndpoints": null, + "protocolId": null, + "properties": null, + "codeSubstitutes": {}, + "genesis": { + "runtimeGenesis": { + "code": "0x123", + "patch": { + "bar": { + "initialAccount": "5CiPPseXPECbkjWCa6MnjNokrgYjMqmKndv2rSnekmSK2DjL" + }, + "foo": { + "someEnum": { + "Data2": { + "values": "0x0c10" + } + }, + "someInteger": 200 + } + } + } + } + }); + assert_eq!(output, expected_output, "Output did not match expected"); +} diff --git a/docs/sdk/src/reference_docs/cli.rs b/docs/sdk/src/reference_docs/cli.rs index 5779e0f8d04954e9fe1d245e0af4761fb0246805..b9cdbd60e9592418241426c4f82aa9a3223559a4 100644 --- a/docs/sdk/src/reference_docs/cli.rs +++ b/docs/sdk/src/reference_docs/cli.rs @@ -45,7 +45,7 @@ //! - `--chain=customSpec.json`: Uses the custom chain specification as input. //! - `--disable-default-bootnode`: Disables the default bootnodes in the node template. //! - `--raw`: Converts the chain specification into a raw format with encoded storage keys. -//! - `> customSpecRaw.json`: Outputs to customSpecRaw.json. +//! - `> customSpecRaw.json`: Outputs to `customSpecRaw.json`. //! //! #### Starting the First Node in a Private Network //! ```bash diff --git a/docs/sdk/src/reference_docs/consensus_swapping.rs b/docs/sdk/src/reference_docs/consensus_swapping.rs deleted file mode 100644 index e639761ee97b42fa68e1ba77250d490e28277e24..0000000000000000000000000000000000000000 --- a/docs/sdk/src/reference_docs/consensus_swapping.rs +++ /dev/null @@ -1,6 +0,0 @@ -//! Consensus Swapping -//! -//! Notes: -//! -//! - The typical workshop done by Joshy in some places where he swaps out the consensus to be PoW. -//! - This could also be a tutorial rather than a ref doc, depending on the size. diff --git a/docs/sdk/src/reference_docs/custom_host_functions.rs b/docs/sdk/src/reference_docs/custom_host_functions.rs new file mode 100644 index 0000000000000000000000000000000000000000..719b208a2bff7ed6fb1929cbdccae7dddda2ab00 --- /dev/null +++ b/docs/sdk/src/reference_docs/custom_host_functions.rs @@ -0,0 +1,27 @@ +//! # Custom Host Functions +//! +//! Host functions are functions that the wasm instance can use to communicate with the node. Learn +//! more about this in [`crate::reference_docs::wasm_meta_protocol`]. +//! +//! ## Finding Host Functions +//! +//! To declare a set of functions as host functions, you need to use the `#[runtime_interface]` +//! ([`sp_runtime_interface`]) attribute macro. The most notable set of host functions are those +//! that allow the runtime to access the chain state, namely [`sp_io::storage`]. Some other notable +//! host functions are also defined in [`sp_io`]. +//! +//! ## Adding New Host Functions +//! +//! > Adding a new host function is a big commitment and should be done with care. Namely, the nodes +//! > in the network need to support all host functions forever in order to be able to sync +//! > historical blocks. +//! +//! Adding host functions is only possible when you are using a node-template, so that you have +//! access to the boilerplate of building your node. +//! +//! A group of host functions can always be grouped to gether as a tuple: +#![doc = docify::embed!("../../substrate/primitives/io/src/lib.rs", SubstrateHostFunctions)] +//! +//! The host functions are attached to the node side's [`sc_executor::WasmExecutor`]. For example in +//! the minimal template, the setup looks as follows: +#![doc = docify::embed!("../../templates/minimal/node/src/service.rs", FullClient)] diff --git a/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs b/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs new file mode 100644 index 0000000000000000000000000000000000000000..083ed9f77e10214535dffa290acd256d8f75e633 --- /dev/null +++ b/docs/sdk/src/reference_docs/custom_runtime_api_rpc.rs @@ -0,0 +1,77 @@ +//! # Custom RPC do's and don'ts +//! +//! **TLDR:** Don't create new custom RPCs. Instead, rely on custom Runtime APIs, combined with +//! `state_call`. +//! +//! ## Background +//! +//! Polkadot-SDK offers the ability to query and subscribe storages directly. However what it does +//! not have is [view functions](https://github.com/paritytech/polkadot-sdk/issues/216). This is an +//! essential feature to avoid duplicated logic between runtime and the client SDK. Custom RPC was +//! used as a solution. It allow the RPC node to expose new RPCs that clients can be used to query +//! computed properties. +//! +//! ## Problems with Custom RPC +//! +//! Unfortunately, custom RPC comes with many problems. To list a few: +//! +//! - It is offchain logic executed by the RPC node and therefore the client has to trust the RPC +//! node. +//! - To upgrade or add a new RPC logic, the RPC node has to be upgraded. This can cause significant +//! trouble when the RPC infrastructure is decentralized as we will need to coordinate multiple +//! parties to upgrade the RPC nodes. +//! - A lot of boilerplate code is required to add custom RPC. +//! - It prevents dApps from using a light client or an alternative client. +//! - It makes ecosystem tooling integration much more complicated. For example, dApps will not +//! be able to use [Chopsticks](https://github.com/AcalaNetwork/chopsticks) for testing as +//! Chopsticks will not have the custom RPC implementation. +//! - Poorly implemented custom RPC can be a DoS vector. +//! +//! Hence, we should avoid custom RPC. +//! +//! ## Alternatives +//! +//! Generally, [`sc_rpc::state::StateBackend::call`] aka. `state_call` should be used instead of +//! custom RPC. +//! +//! Usually, each custom RPC comes with a corresponding runtime API which implements the business +//! logic. So instead of invoke the custom RPC, we can use `state_call` to invoke the runtime API +//! directly. This is a trivial change on the dApp and no change on the runtime side. We may remove +//! the custom RPC from the node side if wanted. +//! +//! There are some other cases that a simple runtime API is not enough. For example, implementation +//! of Ethereum RPC requires an additional offchain database to index transactions. In this +//! particular case, we can have the RPC implemented on another client. +//! +//! For example, the Acala EVM+ RPC are implemented by +//! [eth-rpc-adapter](https://github.com/AcalaNetwork/bodhi.js/tree/master/packages/eth-rpc-adapter). +//! Alternatively, the [Frontier](https://github.com/polkadot-evm/frontier) project also provided +//! Ethereum RPC compatibility directly in the node-side software. +//! +//! ## Create a new Runtime API +//! +//! For example, let's take a look at the process through which the account nonce can be queried +//! through an RPC. First, a new runtime-api needs to be declared: +#![doc = docify::embed!("../../substrate/frame/system/rpc/runtime-api/src/lib.rs", AccountNonceApi)] +//! +//! This API is implemented at the runtime level, always inside [`sp_api::impl_runtime_apis!`]. +//! +//! As noted, this is already enough to make this API usable via `state_call`. +//! +//! ## Create a new custom RPC (Legacy) +//! +//! Should you wish to implement the legacy approach of exposing this runtime-api as a custom +//! RPC-api, then a custom RPC server has to be defined. +#![doc = docify::embed!("../../substrate/utils/frame/rpc/system/src/lib.rs", SystemApi)] +//! +//! ## Add a new RPC to the node (Legacy) +//! +//! Finally, this custom RPC needs to be integrated into the node side. This is usually done in a +//! `rpc.rs` in a typical template, as follows: +#![doc = docify::embed!("../../templates/minimal/node/src/rpc.rs", create_full)] +//! +//! ## Future +//! +//! - [XCQ](https://forum.polkadot.network/t/cross-consensus-query-language-xcq/7583) will be a good +//! solution for most of the query needs. +//! - [New JSON-RPC Specification](https://github.com/paritytech/json-rpc-interface-spec) diff --git a/docs/sdk/src/reference_docs/defensive_programming.rs b/docs/sdk/src/reference_docs/defensive_programming.rs index 9828e1b50918f3e832523c686797091db034a985..82d624b01d97fccbd45f690e43ab3b0bdd1d4a89 100644 --- a/docs/sdk/src/reference_docs/defensive_programming.rs +++ b/docs/sdk/src/reference_docs/defensive_programming.rs @@ -16,7 +16,7 @@ //! [Defensive programming](https://en.wikipedia.org/wiki/Defensive_programming) is a design paradigm that enables a program to continue //! running despite unexpected behavior, input, or events that may arise in runtime. //! Usually, unforeseen circumstances may cause the program to stop or, in the Rust context, -//! panic!. Defensive practices allow for these circumstances to be accounted for ahead of time +//! `panic!`. Defensive practices allow for these circumstances to be accounted for ahead of time //! and for them to be handled gracefully, which is in line with the intended fault-tolerant and //! deterministic nature of blockchains. //! @@ -71,7 +71,7 @@ //! ### Defensive Traits //! //! The [`Defensive`](frame::traits::Defensive) trait provides a number of functions, all of which -//! provide an alternative to 'vanilla' Rust functions, e.g.,: +//! provide an alternative to 'vanilla' Rust functions, e.g.: //! //! - [`defensive_unwrap_or()`](frame::traits::Defensive::defensive_unwrap_or) instead of //! `unwrap_or()` @@ -127,7 +127,7 @@ //! - [Fixed point types](sp_arithmetic::fixed_point) and their associated usage can be found here. //! - [PerThing](sp_arithmetic::per_things) and its associated types can be found here. //! -//! Using floating point number types (i.e., f32. f64) in the runtime should be avoided, as a single non-deterministic result could cause chaos for blockchain consensus along with the issues above. For more on the specifics of the peculiarities of floating point calculations, [watch this video by the Computerphile](https://www.youtube.com/watch?v=PZRI1IfStY0). +//! Using floating point number types (i.e. f32, f64) in the runtime should be avoided, as a single non-deterministic result could cause chaos for blockchain consensus along with the issues above. For more on the specifics of the peculiarities of floating point calculations, [watch this video by the Computerphile](https://www.youtube.com/watch?v=PZRI1IfStY0). //! //! The following methods demonstrate different ways to handle numbers natively in Rust safely, //! without fear of panic or unexpected behavior from wrapping. diff --git a/docs/sdk/src/reference_docs/development_environment_advice.rs b/docs/sdk/src/reference_docs/development_environment_advice.rs index 9ba95dfa032945ac684f13b1c3961d4f8d0f649e..a5f38bb280deff9cc3b1ffb0d2a5d08dced39d55 100644 --- a/docs/sdk/src/reference_docs/development_environment_advice.rs +++ b/docs/sdk/src/reference_docs/development_environment_advice.rs @@ -15,8 +15,9 @@ //! ```json //! { //! // Use a separate target dir for Rust Analyzer. Helpful if you want to use Rust -//! // Analyzer and cargo on the command line at the same time. -//! "rust-analyzer.rust.analyzerTargetDir": "target/vscode-rust-analyzer", +//! // Analyzer and cargo on the command line at the same time, +//! // at the expense of duplicating build artifacts. +//! "rust-analyzer.cargo.targetDir": "target/vscode-rust-analyzer", //! // Improve stability //! "rust-analyzer.server.extraEnv": { //! "CHALK_OVERFLOW_DEPTH": "100000000", @@ -145,7 +146,7 @@ //! } //! ``` //! -//! //! and the same in Lua for `neovim/nvim-lspconfig`: +//! and the same in Lua for `neovim/nvim-lspconfig`: //! //! ```lua //! ["rust-analyzer"] = { diff --git a/docs/sdk/src/reference_docs/extrinsic_encoding.rs b/docs/sdk/src/reference_docs/extrinsic_encoding.rs index 8c8568a228fad140115e68feb3eec717ef30170c..31ce92c67e98a5911370472f2387bac3382a5230 100644 --- a/docs/sdk/src/reference_docs/extrinsic_encoding.rs +++ b/docs/sdk/src/reference_docs/extrinsic_encoding.rs @@ -191,7 +191,7 @@ #[docify::export] pub mod call_data { - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; // The outer enum composes calls within // different pallets together. We have two @@ -224,7 +224,7 @@ pub mod call_data { pub mod encoding_example { use super::call_data::{Call, PalletACall}; use crate::reference_docs::signed_extensions::signed_extensions_example; - use parity_scale_codec::Encode; + use codec::Encode; use sp_core::crypto::AccountId32; use sp_keyring::sr25519::Keyring; use sp_runtime::{ diff --git a/docs/sdk/src/reference_docs/fee_less_runtime.rs b/docs/sdk/src/reference_docs/fee_less_runtime.rs index 1213c26282537fdee2d04ebd452289f0e6bc759f..9146b30ec5774355ce91dd02a5bb010dcf6fbada 100644 --- a/docs/sdk/src/reference_docs/fee_less_runtime.rs +++ b/docs/sdk/src/reference_docs/fee_less_runtime.rs @@ -1,5 +1,6 @@ //! # Fee-Less Runtime //! +//! 🚧 Work In Progress 🚧 //! //! Notes: //! diff --git a/docs/sdk/src/reference_docs/frame_benchmarking_weight.rs b/docs/sdk/src/reference_docs/frame_benchmarking_weight.rs index db77547a4bf0fe0a6d24f8ffc80cdda206d576b4..cf9e58791492330d827630e76ebbb51df37ecafd 100644 --- a/docs/sdk/src/reference_docs/frame_benchmarking_weight.rs +++ b/docs/sdk/src/reference_docs/frame_benchmarking_weight.rs @@ -14,10 +14,10 @@ //! - improve documentation of `#[weight = ..]` and `#[pallet::weight(..)]`. All syntax variation //! should be covered. //! -//! on FRAME benchmarking machinery: +//! On FRAME benchmarking machinery: //! -//! - component analysis, why everything must be linear. -//! - how to write benchmarks, how you must think of worst case. -//! - how to run benchmarks. +//! - Component analysis, why everything must be linear. +//! - How to write benchmarks, how you must think of worst case. +//! - How to run benchmarks. //! //! - diff --git a/docs/sdk/src/reference_docs/frame_logging.rs b/docs/sdk/src/reference_docs/frame_logging.rs new file mode 100644 index 0000000000000000000000000000000000000000..1b03c6a2e35b53cb6775ad0648b6591eea525190 --- /dev/null +++ b/docs/sdk/src/reference_docs/frame_logging.rs @@ -0,0 +1,116 @@ +//! # FRAME Logging +//! +//! This reference docs briefly explores how to do logging and printing runtimes, mainly +//! FRAME-based. +//! +//! ## Using `println!` +//! +//! To recap, as with standard Rust, you can use `println!` _in your tests_, but it will only print +//! out if executed with `--nocapture`, or if the test panics. +//! +//! ``` +//! fn it_print() { +//! println!("Hello, world!"); +//! } +//! ``` +//! +//! within the pallet, if you want to use the standard `println!`, it needs to be wrapped in +//! [`sp_std::if_std`]. Of course, this means that this print code is only available to you in the +//! `std` compiler flag, and never present in a wasm build. +//! +//! ``` +//! // somewhere in your pallet. This is not a real pallet code. +//! mod pallet { +//! struct Pallet; +//! impl Pallet { +//! fn print() { +//! sp_std::if_std! { +//! println!("Hello, world!"); +//! } +//! } +//! } +//! } +//! ``` +//! +//! ## Using `log` +//! +//! First, ensure you are familiar with the [`log`] crate. In short, each log statement has: +//! +//! 1. `log-level`, signifying how important it is. +//! 2. `log-target`, signifying to which component it belongs. +//! +//! Add log statements to your pallet as such: +//! +//! You can add the log crate to the `Cargo.toml` of the pallet. +//! +//! ```text +//! #[dependencies] +//! log = { version = "x.y.z", default-features = false } +//! +//! #[features] +//! std = [ +//! // snip -- other pallets +//! "log/std" +//! ] +//! ``` +//! +//! More conveniently, the `frame` umbrella crate re-exports the log crate as [`frame::log`]. +//! +//! Then, the pallet can use this crate to emit log statements. In this statement, we use the info +//! level, and the target is `pallet-example`. +//! +//! ``` +//! mod pallet { +//! struct Pallet; +//! +//! impl Pallet { +//! fn logs() { +//! frame::log::info!(target: "pallet-example", "Hello, world!"); +//! } +//! } +//! } +//! ``` +//! +//! This will in itself just emit the log messages, **but unless if captured by a logger, they will +//! not go anywhere**. [`sp_api`] provides a handy function to enable the runtime logging: +//! +//! ``` +//! // in your test +//! fn it_also_prints() { +//! sp_api::init_runtime_logger(); +//! // call into your pallet, and now it will print `log` statements. +//! } +//! ``` +//! +//! Alternatively, you can use [`sp_tracing::try_init_simple`]. +//! +//! `info`, `error` and `warn` logs are printed by default, but if you want lower level logs to also +//! be printed, you must to add the following compiler flag: +//! +//! ```text +//! RUST_LOG=pallet-example=trace cargo test +//! ``` +//! +//! ## Enabling Logs in Production +//! +//! All logs from the runtime are emitted by default, but there is a feature flag in [`sp_api`], +//! called `disable-logging`, that can be used to disable all logs in the runtime. This is useful +//! for production chains to reduce the size and overhead of the wasm runtime. +#![doc = docify::embed!("../../substrate/primitives/api/src/lib.rs", init_runtime_logger)] +//! +//! Similar to the above, the proper `RUST_LOG` must also be passed to your compiler flag when +//! compiling the runtime. +//! +//! ## Log Target Prefixing +//! +//! Many [`crate::polkadot_sdk::frame_runtime`] pallets emit logs with log target `runtime::`, for example `runtime::system`. This then allows one to run a node with a wasm blob +//! compiled with `LOG_TARGET=runtime=debug`, which enables the log target of all pallets who's log +//! target starts with `runtime`. +//! +//! ## Low Level Primitives +//! +//! Under the hood, logging is another instance of host functions under the hood (as defined in +//! [`crate::reference_docs::wasm_meta_protocol`]). The runtime uses a set of host functions under +//! [`sp_io::logging`] and [`sp_io::misc`] to emit all logs and prints. You typically do not need to +//! use these APIs directly. diff --git a/docs/sdk/src/reference_docs/frame_offchain_workers.rs b/docs/sdk/src/reference_docs/frame_offchain_workers.rs index 7999707e5ee018c4bb7634e7a506ff8fee8fa8ac..b0aaf1789d4cc3855a0718f459beff7778951e97 100644 --- a/docs/sdk/src/reference_docs/frame_offchain_workers.rs +++ b/docs/sdk/src/reference_docs/frame_offchain_workers.rs @@ -58,7 +58,6 @@ //! [`frame::pallet_macros::hooks`]. //! //! ``` -//! //! #[frame::pallet] //! pub mod pallet { //! use frame::prelude::*; @@ -89,7 +88,7 @@ //! //! They can both read from the state, and have no means of updating the state, other than the route //! of submitting an extrinsic to the chain. Therefore, it is worth thinking twice before embedding -//! a logic as a part of Substrate's offchain worker API. Does it have to be there? can it not be a +//! a logic as a part of Substrate's offchain worker API. Does it have to be there? Can it not be a //! simple, actual offchain application that lives outside of the chain's WASM blob? //! //! Some of the reasons why you might want to do the opposite, and actually embed an offchain worker diff --git a/docs/sdk/src/reference_docs/frame_pallet_coupling.rs b/docs/sdk/src/reference_docs/frame_pallet_coupling.rs index be464bbbf8359c77fa549ab80bcb0008244488f9..a22137f979dc1455d488dce71e75662e0071cc08 100644 --- a/docs/sdk/src/reference_docs/frame_pallet_coupling.rs +++ b/docs/sdk/src/reference_docs/frame_pallet_coupling.rs @@ -30,8 +30,8 @@ //! //! There are generally two ways to achieve this: //! -//! 1. Tight coupling pallets -//! 2. Loose coupling pallets +//! 1. Tight coupling pallets. +//! 2. Loose coupling pallets. //! //! To explain the difference between the two, consider two pallets, `A` and `B`. In both cases, `A` //! wants to use some functionality exposed by `B`. @@ -74,8 +74,8 @@ //! pallet makes its own `trait Config` be bounded by another pallet's `trait Config`, it is //! expressing two things: //! -//! 1. that it can only exist in a runtime if the other pallet is also present. -//! 2. that it can use the other pallet's functionality. +//! 1. That it can only exist in a runtime if the other pallet is also present. +//! 2. That it can use the other pallet's functionality. //! //! `pallet-foo`'s `Config` would then look like: #![doc = docify::embed!("./src/reference_docs/frame_pallet_coupling.rs", tight_config)] @@ -110,7 +110,7 @@ //! Crucially, when using loose coupling, we gain the flexibility of providing different //! implementations of `AuthorProvider`, such that different users of a `pallet-foo` can use //! different ones, without any code change being needed. For example, in the code snippets of this -//! module, you can fund [`OtherAuthorProvider`] which is an alternative implementation of +//! module, you can find [`OtherAuthorProvider`], which is an alternative implementation of //! [`AuthorProvider`]. #![doc = docify::embed!("./src/reference_docs/frame_pallet_coupling.rs", other_author_provider)] //! @@ -135,8 +135,8 @@ //! general, it is easier to argue about multiple pallet if they only communicate together via a //! known trait, rather than having access to all of each others public items, such as storage and //! dispatchables. -//! * If a group of pallets are meant to work together, and but are not foreseen to be generalized, -//! or used by others, consider tightly coupling pallets, *if it simplifies the development*. +//! * If a group of pallets is meant to work together, but is not foreseen to be generalized, or +//! used by others, consider tightly coupling pallets, *if it simplifies the development*. //! * If a pallet needs a functionality provided by another pallet, but multiple implementations can //! be foreseen, consider loosely coupling pallets. //! diff --git a/docs/sdk/src/reference_docs/frame_runtime_types.rs b/docs/sdk/src/reference_docs/frame_runtime_types.rs index 32cda5bc5345d7eee43efa9e2b99ac831c8fb3a8..e99106ade878137ed308aa05c3bb43236727a3a4 100644 --- a/docs/sdk/src/reference_docs/frame_runtime_types.rs +++ b/docs/sdk/src/reference_docs/frame_runtime_types.rs @@ -36,7 +36,7 @@ #![doc = docify::embed!("./src/reference_docs/frame_runtime_types.rs", pallet_bar)] //! //! Let's explore how each of these affect the [`RuntimeCall`], [`RuntimeOrigin`] and -//! [`RuntimeGenesisConfig`] generated in [`runtime`] by respectively. +//! [`RuntimeGenesisConfig`] generated in [`runtime`] respectively. //! //! As observed, [`RuntimeCall`] has 3 variants, one for each pallet and one for `frame_system`. If //! you explore further, you will soon realize that each variant is merely a pointer to the `Call` @@ -102,6 +102,10 @@ //! bounds, such as being [`frame::traits::IsSubType`]: #![doc = docify::embed!("./src/reference_docs/frame_runtime_types.rs", custom_runtime_call_usages)] //! +//! > Once Rust's "_Associated Type Bounds RFC_" is usable, this syntax can be used to +//! > simplify the above scenario. See [this](https://github.com/paritytech/polkadot-sdk/issues/3743) +//! > issue for more information. +//! //! ### Asserting Equality of Multiple Runtime Composite Enums //! //! Recall that in the above example, `::RuntimeCall` and `). +//! See the +//! [multi-block-migrations example](https://github.com/paritytech/polkadot-sdk/tree/0d7d2177807ec6b3094f4491a45b0bc0d74d3c8b/substrate/frame/examples/multi-block-migrations) +//! for reference. //! //! [`OnRuntimeUpgrade`]: frame_support::traits::OnRuntimeUpgrade //! [`StorageVersion`]: frame_support::traits::StorageVersion diff --git a/docs/sdk/src/reference_docs/frame_storage_derives.rs b/docs/sdk/src/reference_docs/frame_storage_derives.rs new file mode 100644 index 0000000000000000000000000000000000000000..4fbfb4a5cc839b8e4c0af4efd9db5e20613abc17 --- /dev/null +++ b/docs/sdk/src/reference_docs/frame_storage_derives.rs @@ -0,0 +1,202 @@ +//! # Frame storage derives +//! +//! > **Note:** +//! > +//! > In all examples, a few lines of boilerplate have been hidden from each snippet for +//! > conciseness. +//! +//! Let's begin by starting to store a `NewType` in a storage item: +//! +//! ```compile_fail +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! pub struct NewType(u32); +// +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType>; +//! } +//! ``` +//! +//! This raises a number of compiler errors, like: +//! ```text +//! the trait `MaxEncodedLen` is not implemented for `NewType`, which is required by +//! `frame::prelude::StorageValue<_GeneratedPrefixForStorageSomething, NewType>: +//! StorageInfoTrait` +//! ``` +//! +//! This implies the following set of traits that need to be derived for a type to be stored in +//! `frame` storage: +//! ```rust +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! #[derive(codec::Encode, codec::Decode, codec::MaxEncodedLen, scale_info::TypeInfo)] +//! pub struct NewType(u32); +//! +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType>; +//! } +//! ``` +//! +//! Next, let's look at how this will differ if we are to store a type that is derived from `T` in +//! storage, such as [`frame::prelude::BlockNumberFor`]: +//! ```compile_fail +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! #[derive(codec::Encode, codec::Decode, codec::MaxEncodedLen, scale_info::TypeInfo)] +//! pub struct NewType(BlockNumberFor); +//! +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType>; +//! } +//! ``` +//! +//! Surprisingly, this will also raise a number of errors, like: +//! ```text +//! the trait `TypeInfo` is not implemented for `T`, which is required +//! by`frame_support::pallet_prelude::StorageValue, +//! pallet_2::NewType>:StorageEntryMetadataBuilder +//! ``` +//! +//! Why is that? The underlying reason is that the `TypeInfo` `derive` macro will only work for +//! `NewType` if all of `NewType`'s generics also implement `TypeInfo`. This is not the case for `T` +//! in the example above. +//! +//! If you expand an instance of the derive, you will find something along the lines of: +//! `impl TypeInfo for NewType where T: TypeInfo { ... }`. This is the reason why the +//! `TypeInfo` trait is required for `T`. +//! +//! To fix this, we need to add a `#[scale_info(skip_type_params(T))]` +//! attribute to `NewType`. This additional macro will instruct the `derive` to skip the bound on +//! `T`. +//! ```rust +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! #[derive(codec::Encode, codec::Decode, codec::MaxEncodedLen, scale_info::TypeInfo)] +//! #[scale_info(skip_type_params(T))] +//! pub struct NewType(BlockNumberFor); +//! +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType>; +//! } +//! ``` +//! +//! Next, let's say we wish to store `NewType` as [`frame::prelude::ValueQuery`], which means it +//! must also implement `Default`. This should be as simple as adding `derive(Default)` to it, +//! right? +//! ```compile_fail +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! #[derive(codec::Encode, codec::Decode, codec::MaxEncodedLen, scale_info::TypeInfo, Default)] +//! #[scale_info(skip_type_params(T))] +//! pub struct NewType(BlockNumberFor); +//! +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType, ValueQuery>; +//! } +//! ``` +//! +//! Under the hood, the expansion of the `derive(Default)` will suffer from the same restriction as +//! before: it will only work if `T: Default`, and `T` is not `Default`. Note that this is an +//! expected issue: `T` is merely a wrapper of many other types, such as `BlockNumberFor`. +//! `BlockNumberFor` should indeed implement `Default`, but `T` implementing `Default` is rather +//! meaningless. +//! +//! To fix this, frame provides a set of macros that are analogous to normal rust derive macros, but +//! work nicely on top of structs that are generic over `T: Config`. These macros are: +//! +//! - [`frame::prelude::DefaultNoBound`] +//! - [`frame::prelude::DebugNoBound`] +//! - [`frame::prelude::PartialEqNoBound`] +//! - [`frame::prelude::EqNoBound`] +//! - [`frame::prelude::CloneNoBound`] +//! - [`frame::prelude::PartialOrdNoBound`] +//! - [`frame::prelude::OrdNoBound`] +//! +//! The above traits are almost certainly needed for your tests - to print your type, assert equality +//! or clone it. +//! +//! We can fix the following example by using [`frame::prelude::DefaultNoBound`]. +//! ```rust +//! #[frame::pallet] +//! pub mod pallet { +//! # use frame::prelude::*; +//! # #[pallet::config] +//! # pub trait Config: frame_system::Config {} +//! # #[pallet::pallet] +//! # pub struct Pallet(_); +//! #[derive( +//! codec::Encode, +//! codec::Decode, +//! codec::MaxEncodedLen, +//! scale_info::TypeInfo, +//! DefaultNoBound +//! )] +//! #[scale_info(skip_type_params(T))] +//! pub struct NewType(BlockNumberFor); +//! +//! #[pallet::storage] +//! pub type Something = StorageValue<_, NewType, ValueQuery>; +//! } +//! ``` +//! +//! Finally, if a custom type that is provided through `Config` is to be stored in the storage, it +//! is subject to the same trait requirements. The following does not work: +//! ```compile_fail +//! #[frame::pallet] +//! pub mod pallet { +//! use frame::prelude::*; +//! #[pallet::config] +//! pub trait Config: frame_system::Config { +//! type CustomType; +//! } +//! #[pallet::pallet] +//! pub struct Pallet(_); +//! #[pallet::storage] +//! pub type Something = StorageValue<_, T::CustomType>; +//! } +//! ``` +//! +//! But adding the right trait bounds will fix it. +//! ```rust +//! #[frame::pallet] +//! pub mod pallet { +//! use frame::prelude::*; +//! #[pallet::config] +//! pub trait Config: frame_system::Config { +//! type CustomType: codec::FullCodec +//! + codec::MaxEncodedLen +//! + scale_info::TypeInfo +//! + Debug +//! + Default; +//! } +//! #[pallet::pallet] +//! pub struct Pallet(_); +//! #[pallet::storage] +//! pub type Something = StorageValue<_, T::CustomType>; +//! } +//! ``` diff --git a/docs/sdk/src/reference_docs/frame_system_accounts.rs b/docs/sdk/src/reference_docs/frame_system_accounts.rs index ae9d2c9e0cb3ca7a694d9e5330363c05f6f78cb0..c93e1196ea7e8cf9de1fdc589a71345fc0d6e072 100644 --- a/docs/sdk/src/reference_docs/frame_system_accounts.rs +++ b/docs/sdk/src/reference_docs/frame_system_accounts.rs @@ -1,5 +1,7 @@ //! # FRAME Accounts //! +//! 🚧 Work In Progress 🚧 +//! //! How `frame_system` handles accountIds. Nonce. Consumers and Providers, reference counting. // - poorly understood topics, needs one great article to rul them all. diff --git a/docs/sdk/src/reference_docs/frame_tokens.rs b/docs/sdk/src/reference_docs/frame_tokens.rs index 57b493fafa59c053f2496d5e4809f7deaa0da316..a76e524ceb85490999d4cac6eeee3589f7b7ac2b 100644 --- a/docs/sdk/src/reference_docs/frame_tokens.rs +++ b/docs/sdk/src/reference_docs/frame_tokens.rs @@ -22,11 +22,11 @@ //! //! On completion of reading this doc, you should have a good understanding of: //! - The distinction between token traits and trait implementations in FRAME, and why this -//! distinction is helpful -//! - Token-related traits available in FRAME -//! - Token-related trait implementations in FRAME -//! - How to choose the right trait or trait implementation for your use case -//! - Where to go next +//! distinction is helpful. +//! - Token-related traits available in FRAME. +//! - Token-related trait implementations in FRAME. +//! - How to choose the right trait or trait implementation for your use case. +//! - Where to go next. //! //! ## Getting Started //! @@ -56,9 +56,16 @@ //! //! **Trait implementations** are concrete implementations of these traits. For example, one of the //! many traits [`pallet_balances`] implements is -//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`)*. It provides the concrete way -//! of inspecting the total issuance, balance of accounts, etc. There can be many implementations of -//! the same traits. +//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`)[^1]. It provides the concrete +//! way of inspecting the total issuance, balance of accounts, etc. There can be many +//! implementations of the same traits. +//! +//! [^1]: Rust Advanced Tip: The knowledge that [`pallet_balances`] implements +//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`) is not some arcane knowledge +//! that you have to know by heart or memorize. One can simply look at the list of the implementors +//! of any trait in the Rust Doc to find all implementors (e.g. +//! [Mutate trait implementors](https://paritytech.github.io/polkadot-sdk/master/frame_support/traits/tokens/fungible/trait.Mutate.html#implementors)), +//! or use the `rust-analyzer`'s `Implementations` action. //! //! The distinction between traits and trait implementations is helpful because it allows pallets //! and other logic to be generic over their dependencies, avoiding tight coupling. @@ -68,10 +75,10 @@ //! pallet may use [`pallet_balances`] in a tightly coupled manner, directly calling methods //! on the pallet to reserve and unreserve deposits. This approach works well, //! until someone has a use case requiring that an asset from a different pallet such as -//! [`pallet_assets`] is used for the deposit. Rather than tightly couple [`pallet_preimage`] to -//! [`pallet_balances`], [`pallet_assets`], and every other token-handling pallet a user -//! could possibly specify, [`pallet_preimage`] does not specify a concrete pallet as a dependency -//! but instead accepts any dependency which implements the +//! [`pallet_assets`] is used for the deposit. Rather than tightly coupling [`pallet_preimage`] to +//! [`pallet_balances`], [`pallet_assets`], and every other token-handling pallet, a user +//! could possibly specify that [`pallet_preimage`] does not specify a concrete pallet as a +//! dependency, but instead accepts any dependency which implements the //! [`currency::ReservableCurrency`](`frame_support::traits::tokens::currency::ReservableCurrency`) //! trait, namely via its [`Config::Currency`](`pallet_preimage::pallet::Config::Currency`) //! associated type. This allows [`pallet_preimage`] to support any arbitrary pallet implementing @@ -81,15 +88,6 @@ //! Read more about coupling, and the benefits of loose coupling //! [here](crate::reference_docs::frame_pallet_coupling). //! -//! ##### *Rust Advanced Tip -//! -//! The knowledge that [`pallet_balances`] implements -//! [`fungible::Inspect`](`frame_support::traits::fungible::Inspect`) is not some arcane knowledge -//! that you have to know by heart or memorize. One can simply look at the list of the implementors -//! of any trait in the Rust Doc to find all implementors (e.g. -//! ), -//! or use the `rust-analyzer` `Implementations` action. -//! //! ## Fungible Token Traits in FRAME //! //! The [`fungible`](`frame_support::traits::fungible`) crate contains the latest set of FRAME diff --git a/docs/sdk/src/reference_docs/light_nodes.rs b/docs/sdk/src/reference_docs/light_nodes.rs deleted file mode 100644 index d6670bf03ab1a8e36ef1d8b80717d1b3833daff5..0000000000000000000000000000000000000000 --- a/docs/sdk/src/reference_docs/light_nodes.rs +++ /dev/null @@ -1,7 +0,0 @@ -//! # Light Clients -//! -//! -//! Notes: should contain only high level information about light clients, then link to how to set -//! it up in PAPI and SubXT -//! -//! diff --git a/docs/sdk/src/reference_docs/metadata.rs b/docs/sdk/src/reference_docs/metadata.rs index 702c1c30fd9cf2d09082b39fecf880065ebd5375..485614088140e693f2dffce3a9a711582c888032 100644 --- a/docs/sdk/src/reference_docs/metadata.rs +++ b/docs/sdk/src/reference_docs/metadata.rs @@ -1 +1,25 @@ //! # Metadata +//! +//! The existence of metadata in polkadot-sdk goes back to the (forkless) upgrade-ability of all +//! Substrate-based blockchains, which is achieved through +//! [`crate::reference_docs::wasm_meta_protocol`]. You can learn more about the details of how to +//! deal with these upgrades in [`crate::reference_docs::frame_runtime_upgrades_and_migrations`]. +//! +//! Another consequence of upgrade-ability is that as a UI, wallet, or generally an offchain entity, +//! it is hard to know the types internal to the runtime, specifically in light of the fact that +//! they can change at any point in time. +//! +//! This is why all Substrate-based runtimes must expose a [`sp_api::Metadata`] api, which mandates +//! the runtime to return a description of itself. The return type of this api is `Vec`, meaning +//! that it is up to the runtime developer to decide on the format of this. +//! +//! All [`crate::polkadot_sdk::frame_runtime`] based runtimes expose a specific metadata language, +//! maintained in which is adopted in the Polkadot +//! ecosystem. +//! +//! ## Metadata Explorers: +//! +//! A few noteworthy tools that inspect the (FRAME-based) metadata of a chain: +//! +//! - +//! - diff --git a/docs/sdk/src/reference_docs/mod.rs b/docs/sdk/src/reference_docs/mod.rs index 145df8844f26e5b58d737a4290035e3886bf63fe..7f2edb08d46e98e2cdc56944b4a1e54a097b8719 100644 --- a/docs/sdk/src/reference_docs/mod.rs +++ b/docs/sdk/src/reference_docs/mod.rs @@ -7,14 +7,15 @@ //! //! ## What is a "reference document"? //! -//! First, see [why we use rust-docs for everything](crate#why-rust-docs) and our documentation -//! [principles](crate#principles). We acknowledge that as much of the crucial information should be -//! embedded in the low level rust-docs. Then, high level scenarios should be covered in -//! [`crate::guides`]. Finally, we acknowledge that there is a category of information that is: +//! First, see [why we use rust-docs for everything](crate::meta_contributing#why-rust-docs) and our +//! documentation [principles](crate::meta_contributing#principles). We acknowledge that as much of +//! the crucial information should be embedded in the low level rust-docs. Then, high level +//! scenarios should be covered in [`crate::guides`]. Finally, we acknowledge that there is a +//! category of information that is: //! -//! 1. crucial to know. -//! 2. is too high level to be in the rust-doc of any one `type`, `trait` or `fn`. -//! 3. is too low level to be encompassed in a [`crate::guides`]. +//! 1. Crucial to know. +//! 2. Is too high level to be in the rust-doc of any one `type`, `trait` or `fn`. +//! 3. Is too low level to be encompassed in a [`crate::guides`]. //! //! We call this class of documents "reference documents". Our goal should be to minimize the number //! of "reference" docs, as they incur maintenance burden. @@ -40,17 +41,20 @@ pub mod runtime_vs_smart_contract; pub mod extrinsic_encoding; /// Learn about the signed extensions that form a part of extrinsics. -// TODO: @jsdw https://github.com/paritytech/polkadot-sdk-docs/issues/42 pub mod signed_extensions; /// Learn about *Origins*, a topic in FRAME that enables complex account abstractions to be built. pub mod frame_origin; +/// Learn about the details of what derives are needed for a type to be store-able in `frame` +/// storage. +pub mod frame_storage_derives; + /// Learn about how to write safe and defensive code in your FRAME runtime. pub mod defensive_programming; -/// Learn about composite enums and other runtime level types, such as "RuntimeEvent" and -/// "RuntimeCall". +/// Learn about composite enums and other runtime level types, such as `RuntimeEvent` and +/// `RuntimeCall`. pub mod frame_runtime_types; /// Learn about how to make a pallet/runtime that is fee-less and instead uses another mechanism to @@ -59,9 +63,11 @@ pub mod fee_less_runtime; /// Learn about metadata, the main means through which an upgradeable runtime communicates its /// properties to the outside world. -// TODO: @jsdw https://github.com/paritytech/polkadot-sdk-docs/issues/47 pub mod metadata; +/// Learn about how to add custom host functions to the node. +pub mod custom_host_functions; + /// Learn about how frame-system handles `account-ids`, nonces, consumers and providers. pub mod frame_system_accounts; @@ -76,29 +82,14 @@ pub mod frame_benchmarking_weight; pub mod frame_tokens; /// Learn about chain specification file and the genesis state of the blockchain. -// TODO: @michalkucharczyk https://github.com/paritytech/polkadot-sdk-docs/issues/51 pub mod chain_spec_genesis; -/// Learn about all the memory limitations of the WASM runtime when it comes to memory usage. -// TODO: @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/52 -pub mod wasm_memory; - /// Learn about Substrate's CLI, and how it can be extended. -// TODO: @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/53 pub mod cli; -/// Learn about Substrate's consensus algorithms, and how you can switch between two. -// TODO: @JoshOrndorff @kianenigma https://github.com/paritytech/polkadot-sdk-docs/issues/54 -pub mod consensus_swapping; - /// Learn about Runtime Upgrades and best practices for writing Migrations. pub mod frame_runtime_upgrades_and_migrations; -/// Learn about light nodes, how they function, and how Substrate-based chains come -/// light-node-first out of the box. -// TODO: @jsdw @josepot https://github.com/paritytech/polkadot-sdk-docs/issues/68 -pub mod light_nodes; - /// Learn about the offchain workers, how they function, and how to use them, as provided by the /// [`frame`] APIs. pub mod frame_offchain_workers; @@ -106,3 +97,12 @@ pub mod frame_offchain_workers; /// Learn about the different ways through which multiple [`frame`] pallets can be combined to work /// together. pub mod frame_pallet_coupling; + +/// Learn about how to do logging in FRAME-based runtimes. +pub mod frame_logging; + +/// Learn about the Polkadot Umbrella crate that re-exports all other crates. +pub mod umbrella_crate; + +/// Learn about how to create custom RPC endpoints and runtime APIs. +pub mod custom_runtime_api_rpc; diff --git a/docs/sdk/src/reference_docs/runtime_vs_smart_contract.rs b/docs/sdk/src/reference_docs/runtime_vs_smart_contract.rs index 379b0c11b2ad077eb320f72225e513d1b9ed6d67..c91b66b944c603eaa75625d9d1e84b698f1c3027 100644 --- a/docs/sdk/src/reference_docs/runtime_vs_smart_contract.rs +++ b/docs/sdk/src/reference_docs/runtime_vs_smart_contract.rs @@ -20,8 +20,8 @@ //! #### Smart Contracts in Substrate //! Smart Contracts are autonomous, programmable constructs deployed on the blockchain. //! In [FRAME](frame), Smart Contracts infrastructure is implemented by the -//! [`pallet_contracts`](../../../pallet_contracts/index.html) for WASM-based contracts or the -//! [`pallet_evm`](../../../pallet_evm/index.html) for EVM-compatible contracts. These pallets +//! [`pallet_contracts`] for WASM-based contracts or the +//! [`pallet_evm`](https://github.com/polkadot-evm/frontier/tree/master/frame/evm) for EVM-compatible contracts. These pallets //! enable Smart Contract developers to build applications and systems on top of a Substrate-based //! blockchain. //! @@ -32,21 +32,14 @@ //! //! ## Comparative Table //! -//! | Aspect | Runtime -//! | Smart Contracts | +//! | Aspect | Runtime | Smart Contracts | //! |-----------------------|-------------------------------------------------------------------------|----------------------------------------------------------------------| -//! | **Design Philosophy** | Core logic of a blockchain, allowing broad and deep customization. -//! | Designed for DApps deployed on the blockchain runtime.| | **Development Complexity** | Requires in-depth knowledge of Rust and Substrate. Suitable for complex blockchain architectures. | Easier to develop with knowledge of Smart Contract languages like Solidity or [ink!](https://use.ink/). | -//! | **Upgradeability and Flexibility** | Offers comprehensive upgradeability with migration logic -//! and on-chain governance, allowing modifications to the entire blockchain logic without hard -//! forks. | Less flexible in upgrade migrations but offers more straightforward deployment and -//! iteration. | | **Performance and Efficiency** | More efficient, optimized for specific needs of -//! the blockchain. | Can be less efficient due to its generic nature (e.g. the overhead of a -//! virtual machine). | | **Security Considerations** | Security flaws can affect the entire -//! blockchain. | Security risks usually localized to the individual -//! contract. | | **Weighing and Metering** | Operations can be weighed, allowing for precise -//! benchmarking. | Execution is metered, allowing for measurement of resource -//! consumption. | +//! | **Design Philosophy** | Core logic of a blockchain, allowing broad and deep customization. | Designed for DApps deployed on the blockchain runtime. | +//! | **Development Complexity** | Requires in-depth knowledge of Rust and Substrate. Suitable for complex blockchain architectures. | Easier to develop with knowledge of Smart Contract languages like Solidity or [ink!](https://use.ink/). | +//! | **Upgradeability and Flexibility** | Offers comprehensive upgradeability with migration logic and on-chain governance, allowing modifications to the entire blockchain logic without hard forks. | Less flexible in upgrade migrations but offers more straightforward deployment and iteration. | +//! | **Performance and Efficiency** | More efficient, optimized for specific needs of the blockchain. | Can be less efficient due to its generic nature (e.g. the overhead of a virtual machine). | +//! | **Security Considerations** | Security flaws can affect the entire blockchain. | Security risks usually localized to the individual contract. | +//! | **Weighing and Metering** | Operations can be weighed, allowing for precise benchmarking. | Execution is metered, allowing for measurement of resource consumption. | //! //! We will now explore these differences in more detail. //! @@ -115,7 +108,7 @@ //! - **Deployment and Iteration**: Smart Contracts, by nature, are designed for more //! straightforward deployment and iteration. Developers can quickly deploy contracts. //! - **Contract Code Updates**: Once deployed, although typically immutable, Smart Contracts can be -//! upgraded, but lack of migration logic. The [pallet_contracts](../../../pallet_contracts/index.html) +//! upgraded, but lack of migration logic. The [`pallet_contracts`] //! allows for contracts to be upgraded by exposing the `set_code` dispatchable. More details on this //! can be found in [Ink! documentation on upgradeable contracts](https://use.ink/basics/upgradeable-contracts). //! - **Isolated Impact**: Upgrades or changes to a smart contract generally impact only that diff --git a/docs/sdk/src/reference_docs/signed_extensions.rs b/docs/sdk/src/reference_docs/signed_extensions.rs index 28b1426536bcdf371865db74a104a27d51869c86..c644aeaa41650817cd02b0dcc7a97e80c2b19bd0 100644 --- a/docs/sdk/src/reference_docs/signed_extensions.rs +++ b/docs/sdk/src/reference_docs/signed_extensions.rs @@ -1,14 +1,66 @@ //! Signed extensions are, briefly, a means for different chains to extend the "basic" extrinsic //! format with custom data that can be checked by the runtime. //! -//! # Example +//! # FRAME provided signed extensions +//! +//! FRAME by default already provides the following signed extensions: +//! +//! - [`CheckGenesis`](frame_system::CheckGenesis): Ensures that a transaction was sent for the same +//! network. Determined based on genesis. +//! +//! - [`CheckMortality`](frame_system::CheckMortality): Extends a transaction with a configurable +//! mortality. +//! +//! - [`CheckNonZeroSender`](frame_system::CheckNonZeroSender): Ensures that the sender of a +//! transaction is not the *all zero account* (all bytes of the accountid are zero). +//! +//! - [`CheckNonce`](frame_system::CheckNonce): Extends a transaction with a nonce to prevent replay +//! of transactions and to provide ordering of transactions. +//! +//! - [`CheckSpecVersion`](frame_system::CheckSpecVersion): Ensures that a transaction was built for +//! the currently active runtime. +//! +//! - [`CheckTxVersion`](frame_system::CheckTxVersion): Ensures that the transaction signer used the +//! correct encoding of the call. +//! +//! - [`CheckWeight`](frame_system::CheckWeight): Ensures that the transaction fits into the block +//! before dispatching it. +//! +//! - [`ChargeTransactionPayment`](pallet_transaction_payment::ChargeTransactionPayment): Charges +//! transaction fees from the signer based on the weight of the call using the native token. +//! +//! - [`ChargeAssetTxPayment`](pallet_asset_tx_payment::ChargeAssetTxPayment): Charges transaction +//! fees from the signer based on the weight of the call using any supported asset (including the +//! native token). +//! +//! - [`ChargeAssetTxPayment`(using +//! conversion)](pallet_asset_conversion_tx_payment::ChargeAssetTxPayment): Charges transaction +//! fees from the signer based on the weight of the call using any supported asset (including the +//! native token). The asset is converted to the native token using a pool. +//! +//! - [`SkipCheckIfFeeless`](pallet_skip_feeless_payment::SkipCheckIfFeeless): Allows transactions +//! to be processed without paying any fee. This requires that the `call` that should be +//! dispatched is augmented with the [`feeless_if`](frame_support::pallet_macros::feeless_if) +//! attribute. +//! +//! - [`CheckMetadataHash`](frame_metadata_hash_extension::CheckMetadataHash): Extends transactions +//! to include the so-called metadata hash. This is required by chains to support the generic +//! Ledger application and other similar offline wallets. +//! +//! - [`StorageWeightReclaim`](cumulus_primitives_storage_weight_reclaim::StorageWeightReclaim): A +//! signed extension for parachains that reclaims unused storage weight after executing a +//! transaction. +//! +//! For more information about these extensions, follow the link to the type documentation. +//! +//! # Building a custom signed extension //! //! Defining a couple of very simple signed extensions looks like the following: #![doc = docify::embed!("./src/reference_docs/signed_extensions.rs", signed_extensions_example)] #[docify::export] pub mod signed_extensions_example { - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; use scale_info::TypeInfo; use sp_runtime::traits::SignedExtension; diff --git a/docs/sdk/src/reference_docs/trait_based_programming.rs b/docs/sdk/src/reference_docs/trait_based_programming.rs index ace3138807071a35dfaf4ea75e3321960f05137e..90b38f63a5809028c3172fe23199a635128ebc11 100644 --- a/docs/sdk/src/reference_docs/trait_based_programming.rs +++ b/docs/sdk/src/reference_docs/trait_based_programming.rs @@ -196,7 +196,7 @@ mod with_system { mod fully_qualified { use super::with_system::*; - // Simple of using fully qualified syntax. + // Example of using fully qualified syntax. type AccountIdOf = ::AccountId; } diff --git a/docs/sdk/src/reference_docs/umbrella_crate.rs b/docs/sdk/src/reference_docs/umbrella_crate.rs new file mode 100644 index 0000000000000000000000000000000000000000..1074cde37693d3aed03474ab3b89743ec538c188 --- /dev/null +++ b/docs/sdk/src/reference_docs/umbrella_crate.rs @@ -0,0 +1,90 @@ +//! # Umbrella Crate +//! +//! The Polkadot-SDK "umbrella" is a crate that re-exports all other published crates. This makes it +//! possible to have a very small `Cargo.toml` file that only has one dependency, the umbrella +//! crate. This helps with selecting the right combination of crate versions, since otherwise 3rd +//! party tools are needed to select a compatible set of versions. +//! +//! ## Features +//! +//! The umbrella crate supports no-std builds and can therefore be used in the runtime and node. +//! There are two main features: `runtime` and `node`. The `runtime` feature enables all `no-std` +//! crates, while the `node` feature enables all `std` crates. It should be used like any other +//! crate in the repo, with `default-features = false`. +//! +//! For more fine-grained control, additionally, each crate can be enabled selectively. The umbrella +//! exposes one feature per dependency. For example, if you only want to use the `frame-support` +//! crate, you can enable the `frame-support` feature. +//! +//! The umbrella exposes a few more general features: +//! - `tuples-96`: Needs to be enabled for runtimes that have more than 64 pallets. +//! - `serde`: Specifically enable `serde` en/decoding support. +//! - `experimental`: Experimental enable experimental features - should not yet used in production. +//! - `with-tracing`: Enable tracing support. +//! - `try-runtime`, `runtime-benchmarks` and `std`: These follow the standard conventions. +//! - `runtime`: As described above, enable all `no-std` crates. +//! - `node`: As described above, enable all `std` crates. +//! - There does *not* exist a dedicated docs feature. To generate docs, enable the `runtime` and +//! `node` feature. For `docs.rs` the manifest contains specific configuration to make it show up +//! all re-exports. +//! +//! There is a specific [`zepter`](https://github.com/ggwpez/zepter) check in place to ensure that +//! the features of the umbrella are correctly configured. This check is run in CI and locally when +//! running `zepter`. +//! +//! ## Generation +//! +//! The umbrella crate needs to be updated every time when a new crate is added or removed from the +//! workspace. It is checked in CI by calling its generation script. The generation script is +//! located in `./scripts/generate-umbrella.py` and needs dependency `cargo_workspace`. +//! +//! Example: `python3 scripts/generate-umbrella.py --sdk . --version 1.9.0` +//! +//! ## Usage +//! +//! > Note: You can see a live example in the `staging-node-cli` and `kitchensink-runtime` crates. +//! +//! The umbrella crate can be added to your runtime crate like this: +//! +//! `polkadot-sdk = { path = "../../../../umbrella", features = ["runtime"], default-features = +//! false }` +//! +//! or for a node: +//! +//! `polkadot-sdk = { path = "../../../../umbrella", features = ["node"], default-features = false +//! }` +//! +//! In the code, it is then possible to bring all dependencies into scope via: +//! +//! `use polkadot_sdk::*;` +//! +//! ### Known Issues +//! +//! The only known issue so far is the fact that the `use` statement brings the dependencies only +//! into the outer module scope - not the global crate scope. For example, the following code would +//! need to be adjusted: +//! +//! ```rust +//! use polkadot_sdk::*; +//! +//! mod foo { +//! // This does sadly not compile: +//! frame_support::parameter_types! { } +//! +//! // Instead, we need to do this (or add an equivalent `use` statement): +//! polkadot_sdk::frame_support::parameter_types! { } +//! } +//! ``` +//! +//! Apart from this, no issues are known. There could be some bugs with how macros locate their own +//! re-exports. Please [report issues](https://github.com/paritytech/polkadot-sdk/issues) that arise from using this crate. +//! +//! ## Dependencies +//! +//! The umbrella crate re-exports all published crates, with a few exceptions: +//! - Runtime crates like `rococo-runtime` etc are not exported. This otherwise leads to very weird +//! compile errors and should not be needed anyway. +//! - Example and fuzzing crates are not exported. This is currently detected by checking the name +//! of the crate for these magic words. In the future, it will utilize custom metadata, as it is +//! done in the `rococo-runtime` crate. +//! - The umbrella crate itself. Should be obvious :) diff --git a/docs/sdk/src/reference_docs/wasm_memory.rs b/docs/sdk/src/reference_docs/wasm_memory.rs deleted file mode 100644 index 4f4cda31094e40e8f308dbb06de4ab0ecd828777..0000000000000000000000000000000000000000 --- a/docs/sdk/src/reference_docs/wasm_memory.rs +++ /dev/null @@ -1,7 +0,0 @@ -//! # WASM Memory Limitations. -//! -//! Notes: -//! -//! - Stack: Need to use `Box<_>` -//! - Heap: Substrate imposes a limit. PvF execution has its own limits -//! - Heap: There is also a maximum amount that a single allocation can have. diff --git a/docs/sdk/src/reference_docs/wasm_meta_protocol.rs b/docs/sdk/src/reference_docs/wasm_meta_protocol.rs index 37d1460f0e1a3737217ac0c80ec41de769db4c1a..55b5cb204dc2d32b707d0fce9dab5b2ade347715 100644 --- a/docs/sdk/src/reference_docs/wasm_meta_protocol.rs +++ b/docs/sdk/src/reference_docs/wasm_meta_protocol.rs @@ -1,11 +1,13 @@ //! # WASM Meta Protocol //! //! All Substrate based chains adhere to a unique architectural design novel to the Polkadot -//! ecosystem. We refer to this design as the "WASM Meta Protocol". +//! ecosystem. We refer to this design as the "**WASM Meta Protocol**". //! //! Consider the fact that a traditional blockchain software is usually a monolithic artifact. -//! Upgrading any part of the system implies upgrading the entire system. This has historically led -//! to cumbersome forkful upgrades to be the status quo in the blockchain ecosystem. +//! **Upgrading any part of the system implies upgrading the entire system**. This has historically +//! led to cumbersome forkful upgrades to be the status quo in blockchain ecosystems. In other +//! words, the entire node software is the specification of the blockchain's [`state transition +//! function`](crate::reference_docs::blockchain_state_machines). //! //! Moreover, the idea of "storing code in the state" is explored in the context of smart contracts //! platforms, but has not been expanded further. @@ -15,20 +17,19 @@ //! that a smart contract platform stores the code of individual contracts in its state. As noted in //! [`crate::reference_docs::blockchain_state_machines`], this state transition function is called //! the **Runtime**, and WASM is chosen as the bytecode. The Runtime is stored under a special key -//! in the state (see -//! [`sp_core::storage::well_known_keys`](../../../sp_core/index.html)) and can be -//! updated as a part of the state transition function's execution, just like a user's account -//! balance can be updated. +//! in the state (see [`sp_core::storage::well_known_keys`]) and can be updated as a part of the +//! state transition function's execution, just like a user's account balance can be updated. //! //! > Note that while we drew an analogy between smart contracts and runtimes in the above, there //! > are fundamental differences between the two, explained in //! > [`crate::reference_docs::runtime_vs_smart_contract`]. //! -//! The rest of the system that is NOT the state transition function is called the **node**, and -//! is a normal binary that is compiled from Rust to different hardware targets. +//! The rest of the system that is NOT the state transition function is called the +//! [**Node**](crate::reference_docs::glossary#node), and is a normal binary that is compiled from +//! Rust to different hardware targets. //! //! This design enables all Substrate-based chains to be fork-less-ly upgradeable, because the -//! Runtime can be updates on the fly, within the execution of a block, and the node is (for the +//! Runtime can be updated on the fly, within the execution of a block, and the node is (for the //! most part) oblivious to the change that is happening. //! //! Therefore, the high-level architecture of a any Substrate-based chain can be demonstrated as @@ -47,15 +48,18 @@ #![doc = simple_mermaid::mermaid!("../../../mermaid/substrate_client_runtime.mmd")] //! //! A runtime must have a set of runtime APIs in order to have any meaningful blockchain -//! functionality, but it can also expose more APIs. See TODO as an example of how to add custom -//! runtime APIs to your FRAME-based runtime. +//! functionality, but it can also expose more APIs. See +//! [`crate::reference_docs::custom_runtime_api_rpc`] as an example of how to add custom runtime +//! APIs to your FRAME-based runtime. //! //! Similarly, for a runtime to be "compatible" with a node, the node must implement the full set of //! host functions that the runtime at any point in time requires. Given the fact that a runtime can //! evolve in time, and a blockchain node (typically) wishes to be capable of re-executing all the //! previous blocks, this means that a node must always maintain support for the old host functions. -//! This also implies that adding a new host function is a big commitment and should be done with -//! care. This is why, for example, adding a new host function to Polkadot always requires an RFC. +//! **This implies that adding a new host function is a big commitment and should be done with +//! care**. This is why, for example, adding a new host function to Polkadot always requires an RFC. +//! Learn how to add a new host function to your runtime in +//! [`crate::reference_docs::custom_host_functions`]. //! //! ## Node vs. Runtime //! @@ -78,7 +82,7 @@ //! //! ## State //! -//! From the previous sections, we know that the a database component is part of the node, not the +//! From the previous sections, we know that the database component is part of the node, not the //! runtime. We also hinted that a set of host functions ([`sp_io::storage`]) are how the runtime //! issues commands to the node to read/write to the state. Let's dive deeper into this. //! @@ -90,11 +94,11 @@ //! //! In fact, [`sp_core::storage::well_known_keys`] are the only state keys that the node side is //! aware of. The rest of the state, including what logic the runtime has, what balance each user -//! has and such are all only comprehensible to the runtime. +//! has and such, are all only comprehensible to the runtime. #![doc = simple_mermaid::mermaid!("../../../mermaid/state.mmd")] //! //! In the above diagram, all of the state keys and values are opaque bytes to the node. The node -//! does not know what they mean, and it does not now what is the type of the corresponding value +//! does not know what they mean, and it does not know what is the type of the corresponding value //! (e.g. if it is a number of a vector). Contrary, the runtime knows both the meaning of their //! keys, and the type of the values. //! @@ -105,9 +109,50 @@ //! //! ## Native Runtime //! -//! TODO +//! Historically, the node software also kept a native copy of the runtime at the time of +//! compilation within it. This used to be called the "Native Runtime". The main purpose of the +//! native runtime used to be leveraging the faster execution time and better debugging +//! infrastructure of native code. However, neither of the two arguments strongly hold and the +//! native runtime is being fully removed from the node-sdk. //! +//! See: +//! +//! > Also, note that the flags [`sc_cli::ExecutionStrategy::Native`] is already a noop and all +//! > chains built with Substrate only use WASM execution. +//! +//! ### Runtime Versions +//! +//! An important detail of the native execution worth learning about is that the node software, +//! obviously, only uses the native runtime if it is the same code as with the wasm blob stored +//! onchain. Else, nodes who run the native runtime will come to a different state transition. How +//! do nodes determine if two runtimes are the same? Through the very important +//! [`sp_version::RuntimeVersion`]. All runtimes expose their version via a runtime api +//! ([`sp_api::Core::version`]) that returns this struct. The node software, or other applications, +//! inspect this struct to examine the identity of a runtime, and to determine if two runtimes are +//! the same. Namely, [`sp_version::RuntimeVersion::spec_version`] is the main key that implies two +//! runtimes are the same. +//! +//! Therefore, it is utmost important to make sure before any runtime upgrade, the spec version is +//! updated. //! //! ## Example: Block Execution. //! -//! TODO +//! As a final example to recap, let's look at how Substrate-based nodes execute blocks. Blocks are +//! received in the node side software as opaque blobs and in the networking layer. +//! +//! At some point, based on the consensus algorithm's rules, the node decides to import (aka. +//! *validate*) a block. +//! +//! * First, the node will fetch the state of the parent hash of the block that wishes to be +//! imported. +//! * The runtime is fetched from this state, and placed into a WASM execution environment. +//! * The [`sp_api::Core::execute_block`] runtime API is called and the block is passed in as an +//! argument. +//! * The runtime will then execute the block, and update the state accordingly. Any state update is +//! issued via the [`sp_io::storage`] host functions. +//! * Both the runtime and node will check the state-root of the state after the block execution to +//! match the one claimed in the block header. +//! +//! > Example taken from [this +//! > lecture](https://polkadot-blockchain-academy.github.io/pba-book/substrate/wasm/page.html#example-2-block-import-9) +//! > of the Polkadot Blockchain Academy. diff --git a/polkadot/Cargo.toml b/polkadot/Cargo.toml index 7b5679e1084efbfa6a0f419debcaa217f8c65be2..3a939464868fed72d4bf89f3501dae84769d97b0 100644 --- a/polkadot/Cargo.toml +++ b/polkadot/Cargo.toml @@ -25,32 +25,32 @@ default-run = "polkadot" workspace = true [dependencies] -color-eyre = { version = "0.6.1", default-features = false } -tikv-jemallocator = { version = "0.5.0", optional = true, features = ["unprefixed_malloc_on_supported_platforms"] } +color-eyre = { workspace = true } +tikv-jemallocator = { optional = true, features = ["unprefixed_malloc_on_supported_platforms"], workspace = true } # Crates in our workspace, defined as dependencies so we can pass them feature flags. -polkadot-cli = { path = "cli", features = ["rococo-native", "westend-native"] } -polkadot-node-core-pvf = { path = "node/core/pvf" } -polkadot-node-core-pvf-prepare-worker = { path = "node/core/pvf/prepare-worker" } -polkadot-overseer = { path = "node/overseer" } +polkadot-cli = { features = ["rococo-native", "westend-native"], workspace = true, default-features = true } +polkadot-node-core-pvf = { workspace = true, default-features = true } +polkadot-node-core-pvf-prepare-worker = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } # Needed for worker binaries. -polkadot-node-core-pvf-common = { path = "node/core/pvf/common" } -polkadot-node-core-pvf-execute-worker = { path = "node/core/pvf/execute-worker" } +polkadot-node-core-pvf-common = { workspace = true, default-features = true } +polkadot-node-core-pvf-execute-worker = { workspace = true, default-features = true } [target.'cfg(target_os = "linux")'.dependencies] tikv-jemallocator = { version = "0.5.0", features = ["unprefixed_malloc_on_supported_platforms"] } [dev-dependencies] -assert_cmd = "2.0.4" -nix = { version = "0.27.1", features = ["signal"] } -tempfile = "3.2.0" -tokio = "1.37" -substrate-rpc-client = { path = "../substrate/utils/frame/rpc/client" } -polkadot-core-primitives = { path = "core-primitives" } +assert_cmd = { workspace = true } +nix = { features = ["signal"], workspace = true } +tempfile = { workspace = true } +tokio = { workspace = true, default-features = true } +substrate-rpc-client = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } [build-dependencies] -substrate-build-script-utils = { path = "../substrate/utils/build-script-utils" } +substrate-build-script-utils = { workspace = true, default-features = true } [badges] maintenance = { status = "actively-developed" } @@ -68,6 +68,11 @@ jemalloc-allocator = [ "polkadot-overseer/jemalloc-allocator", ] +# Generate the metadata hash needed for CheckMetadataHash +# in the builtin test runtimes (westend and rococo). +metadata-hash = [ + "polkadot-cli/metadata-hash", +] # Enables timeout-based tests supposed to be run only in CI environment as they may be flaky # when run locally depending on system load diff --git a/polkadot/README.md b/polkadot/README.md index d7435f27b946f096dc6902a15e556c2b3d58799e..fa14995e9af376b6bd3a2040af512a7d1ba52127 100644 --- a/polkadot/README.md +++ b/polkadot/README.md @@ -11,7 +11,7 @@ guides, like how to run a validator node, see the [Polkadot Wiki](https://wiki.p If you just wish to run a Polkadot node without compiling it yourself, you may either: -- run the latest binary from our [releases](https://github.com/paritytech/polkadot-sdk/releases) page (make sure to also +- run the [latest released binary](https://github.com/paritytech/polkadot-sdk/releases/latest) (make sure to also download all the `worker` binaries and put them in the same directory as `polkadot`), or - install Polkadot from one of our package repositories. @@ -103,9 +103,8 @@ Connect to the global Polkadot Mainnet network by running: ../target/release/polkadot --chain=polkadot ``` -You can see your node on [telemetry] (set a custom name with `--name "my custom name"`). - -[telemetry](https://telemetry.polkadot.io/#list/Polkadot): https://telemetry.polkadot.io/#list/Polkadot +You can see your node on [Polkadot telemetry](https://telemetry.polkadot.io/#list/0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3) +(set a custom name with `--name "my custom name"`). ### Connect to the "Kusama" Canary Network @@ -115,9 +114,8 @@ Connect to the global Kusama canary network by running: ../target/release/polkadot --chain=kusama ``` -You can see your node on [telemetry] (set a custom name with `--name "my custom name"`). - -[telemetry](https://telemetry.polkadot.io/#list/Kusama): https://telemetry.polkadot.io/#list/Kusama +You can see your node on [Kusama telemetry](https://telemetry.polkadot.io/#list/0xb0a8d493285c2df73290dfb7e61f870f17b41801197a149ca93654499ea3dafe) +(set a custom name with `--name "my custom name"`). ### Connect to the Westend Testnet @@ -127,9 +125,8 @@ Connect to the global Westend testnet by running: ../target/release/polkadot --chain=westend ``` -You can see your node on [telemetry] (set a custom name with `--name "my custom name"`). - -[telemetry](https://telemetry.polkadot.io/#list/Westend): https://telemetry.polkadot.io/#list/Westend +You can see your node on [Westend telemetry](https://telemetry.polkadot.io/#list/0xe143f23803ac50e8f6f8e62695d1ce9e4e1d68aa36c1cd2cfd15340213f3423e) +(set a custom name with `--name "my custom name"`). ### Obtaining DOTs @@ -147,7 +144,7 @@ Then, grab the Polkadot source code: ```bash git clone https://github.com/paritytech/polkadot-sdk.git -cd polkadot +cd polkadot-sdk ``` Then build the code. You will need to build in release mode (`--release`) to start a network. Only @@ -185,7 +182,7 @@ You can run a simple single-node development "network" on your machine by runnin cargo run --bin polkadot --release -- --dev ``` -You can muck around by heading to and choose "Local Node" from the +You can muck around by heading to and choosing "Local Node" from the Settings menu. ### Local Two-node Testnet @@ -214,11 +211,11 @@ that we currently maintain. ### Using Docker -[Using Docker](../docs/contributor/docker.md) +[Using Docker](https://github.com/paritytech/polkadot-sdk/blob/master/docs/contributor/docker.md) ### Shell Completion -[Shell Completion](doc/shell-completion.md) +[Shell Completion](https://github.com/paritytech/polkadot-sdk/blob/master/polkadot/doc/shell-completion.md) ## Contributing @@ -232,4 +229,4 @@ that we currently maintain. ## License -Polkadot is [GPL 3.0 licensed](LICENSE). +Polkadot is [GPL 3.0 licensed](https://github.com/paritytech/polkadot-sdk/blob/master/polkadot/LICENSE). diff --git a/polkadot/cli/Cargo.toml b/polkadot/cli/Cargo.toml index 719d00490a9d031c48fd8d047eec319d60b8e7b0..da37f6062c5725e9162718c7d49ee50d94617140 100644 --- a/polkadot/cli/Cargo.toml +++ b/polkadot/cli/Cargo.toml @@ -18,37 +18,39 @@ wasm-opt = false crate-type = ["cdylib", "rlib"] [dependencies] -cfg-if = "1.0" -clap = { version = "4.5.3", features = ["derive"], optional = true } +cfg-if = { workspace = true } +clap = { features = ["derive"], optional = true, workspace = true } log = { workspace = true, default-features = true } thiserror = { workspace = true } -futures = "0.3.30" -pyro = { package = "pyroscope", version = "0.5.3", optional = true } -pyroscope_pprofrs = { version = "0.2", optional = true } +futures = { workspace = true } +pyroscope = { optional = true, workspace = true } +pyroscope_pprofrs = { optional = true, workspace = true } -service = { package = "polkadot-service", path = "../node/service", default-features = false, optional = true } +polkadot-service = { optional = true, workspace = true } -sp-core = { path = "../../substrate/primitives/core" } -sp-io = { path = "../../substrate/primitives/io" } -sp-keyring = { path = "../../substrate/primitives/keyring" } -sp-maybe-compressed-blob = { path = "../../substrate/primitives/maybe-compressed-blob" } -frame-benchmarking-cli = { path = "../../substrate/utils/frame/benchmarking-cli", optional = true } -sc-cli = { path = "../../substrate/client/cli", optional = true } -sc-service = { path = "../../substrate/client/service", optional = true } -polkadot-node-metrics = { path = "../node/metrics" } -polkadot-node-primitives = { path = "../node/primitives" } -sc-tracing = { path = "../../substrate/client/tracing", optional = true } -sc-sysinfo = { path = "../../substrate/client/sysinfo" } -sc-executor = { path = "../../substrate/client/executor" } -sc-storage-monitor = { path = "../../substrate/client/storage-monitor" } -sp-runtime = { path = "../../substrate/primitives/runtime" } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +frame-benchmarking-cli = { optional = true, workspace = true, default-features = true } +sc-cli = { optional = true, workspace = true, default-features = true } +sc-service = { optional = true, workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +sc-tracing = { optional = true, workspace = true, default-features = true } +sc-sysinfo = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-storage-monitor = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [build-dependencies] -substrate-build-script-utils = { path = "../../substrate/utils/build-script-utils" } +substrate-build-script-utils = { workspace = true, default-features = true } [features] default = ["cli", "db", "full-node"] -db = ["service/db"] +db = ["polkadot-service/db"] +metadata-hash = ["polkadot-service/metadata-hash"] +service = ["dep:polkadot-service"] cli = [ "clap", "frame-benchmarking-cli", @@ -60,24 +62,24 @@ cli = [ runtime-benchmarks = [ "frame-benchmarking-cli?/runtime-benchmarks", "polkadot-node-metrics/runtime-benchmarks", + "polkadot-service?/runtime-benchmarks", "sc-service?/runtime-benchmarks", - "service/runtime-benchmarks", "sp-runtime/runtime-benchmarks", ] -full-node = ["service/full-node"] +full-node = ["polkadot-service/full-node"] try-runtime = [ - "service/try-runtime", + "polkadot-service?/try-runtime", "sp-runtime/try-runtime", ] -fast-runtime = ["service/fast-runtime"] -pyroscope = ["pyro", "pyroscope_pprofrs"] +fast-runtime = ["polkadot-service/fast-runtime"] +pyroscope = ["dep:pyroscope", "pyroscope_pprofrs"] # Configure the native runtimes to use. -westend-native = ["service/westend-native"] -rococo-native = ["service/rococo-native"] +westend-native = ["polkadot-service/westend-native"] +rococo-native = ["polkadot-service/rococo-native"] -malus = ["full-node", "service/malus"] +malus = ["full-node", "polkadot-service/malus"] runtime-metrics = [ "polkadot-node-metrics/runtime-metrics", - "service/runtime-metrics", + "polkadot-service/runtime-metrics", ] diff --git a/polkadot/cli/src/command.rs b/polkadot/cli/src/command.rs index f5ee538e8cec5f418c0f2bb06336f78a81425cae..62d99122c3012701aa46039b13c3c05d3331d8c3 100644 --- a/polkadot/cli/src/command.rs +++ b/polkadot/cli/src/command.rs @@ -18,17 +18,17 @@ use crate::cli::{Cli, Subcommand, NODE_VERSION}; use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE}; use futures::future::TryFutureExt; use log::info; -use sc_cli::SubstrateCli; -use service::{ +use polkadot_service::{ self, benchmarking::{benchmark_inherent_data, RemarkBuilder, TransferKeepAliveBuilder}, HeaderBackend, IdentifyVariant, }; +use sc_cli::SubstrateCli; use sp_core::crypto::Ss58AddressFormatRegistry; use sp_keyring::Sr25519Keyring; use std::net::ToSocketAddrs; -pub use crate::{error::Error, service::BlockId}; +pub use crate::error::Error; #[cfg(feature = "hostperfcheck")] pub use polkadot_performance_test::PerfCheckError; #[cfg(feature = "pyroscope")] @@ -85,55 +85,55 @@ impl SubstrateCli for Cli { id }; Ok(match id { - "kusama" => Box::new(service::chain_spec::kusama_config()?), + "kusama" => Box::new(polkadot_service::chain_spec::kusama_config()?), name if name.starts_with("kusama-") && !name.ends_with(".json") => Err(format!("`{name}` is not supported anymore as the kusama native runtime no longer part of the node."))?, - "polkadot" => Box::new(service::chain_spec::polkadot_config()?), + "polkadot" => Box::new(polkadot_service::chain_spec::polkadot_config()?), name if name.starts_with("polkadot-") && !name.ends_with(".json") => Err(format!("`{name}` is not supported anymore as the polkadot native runtime no longer part of the node."))?, - "paseo" => Box::new(service::chain_spec::paseo_config()?), - "rococo" => Box::new(service::chain_spec::rococo_config()?), + "paseo" => Box::new(polkadot_service::chain_spec::paseo_config()?), + "rococo" => Box::new(polkadot_service::chain_spec::rococo_config()?), #[cfg(feature = "rococo-native")] - "dev" | "rococo-dev" => Box::new(service::chain_spec::rococo_development_config()?), + "dev" | "rococo-dev" => Box::new(polkadot_service::chain_spec::rococo_development_config()?), #[cfg(feature = "rococo-native")] - "rococo-local" => Box::new(service::chain_spec::rococo_local_testnet_config()?), + "rococo-local" => Box::new(polkadot_service::chain_spec::rococo_local_testnet_config()?), #[cfg(feature = "rococo-native")] - "rococo-staging" => Box::new(service::chain_spec::rococo_staging_testnet_config()?), + "rococo-staging" => Box::new(polkadot_service::chain_spec::rococo_staging_testnet_config()?), #[cfg(not(feature = "rococo-native"))] name if name.starts_with("rococo-") && !name.ends_with(".json") || name == "dev" => Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?, - "westend" => Box::new(service::chain_spec::westend_config()?), + "westend" => Box::new(polkadot_service::chain_spec::westend_config()?), #[cfg(feature = "westend-native")] - "westend-dev" => Box::new(service::chain_spec::westend_development_config()?), + "westend-dev" => Box::new(polkadot_service::chain_spec::westend_development_config()?), #[cfg(feature = "westend-native")] - "westend-local" => Box::new(service::chain_spec::westend_local_testnet_config()?), + "westend-local" => Box::new(polkadot_service::chain_spec::westend_local_testnet_config()?), #[cfg(feature = "westend-native")] - "westend-staging" => Box::new(service::chain_spec::westend_staging_testnet_config()?), + "westend-staging" => Box::new(polkadot_service::chain_spec::westend_staging_testnet_config()?), #[cfg(not(feature = "westend-native"))] name if name.starts_with("westend-") && !name.ends_with(".json") => Err(format!("`{}` only supported with `westend-native` feature enabled.", name))?, - "wococo" => Box::new(service::chain_spec::wococo_config()?), + "wococo" => Box::new(polkadot_service::chain_spec::wococo_config()?), #[cfg(feature = "rococo-native")] - "wococo-dev" => Box::new(service::chain_spec::wococo_development_config()?), + "wococo-dev" => Box::new(polkadot_service::chain_spec::wococo_development_config()?), #[cfg(feature = "rococo-native")] - "wococo-local" => Box::new(service::chain_spec::wococo_local_testnet_config()?), + "wococo-local" => Box::new(polkadot_service::chain_spec::wococo_local_testnet_config()?), #[cfg(not(feature = "rococo-native"))] name if name.starts_with("wococo-") => Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?, #[cfg(feature = "rococo-native")] - "versi-dev" => Box::new(service::chain_spec::versi_development_config()?), + "versi-dev" => Box::new(polkadot_service::chain_spec::versi_development_config()?), #[cfg(feature = "rococo-native")] - "versi-local" => Box::new(service::chain_spec::versi_local_testnet_config()?), + "versi-local" => Box::new(polkadot_service::chain_spec::versi_local_testnet_config()?), #[cfg(feature = "rococo-native")] - "versi-staging" => Box::new(service::chain_spec::versi_staging_testnet_config()?), + "versi-staging" => Box::new(polkadot_service::chain_spec::versi_staging_testnet_config()?), #[cfg(not(feature = "rococo-native"))] name if name.starts_with("versi-") => Err(format!("`{}` only supported with `rococo-native` feature enabled.", name))?, path => { let path = std::path::PathBuf::from(path); - let chain_spec = Box::new(service::GenericChainSpec::from_json_file(path.clone())?) - as Box; + let chain_spec = Box::new(polkadot_service::GenericChainSpec::from_json_file(path.clone())?) + as Box; // When `force_*` is given or the file name starts with the name of one of the known // chains, we use the chain spec for the specific chain. @@ -142,11 +142,11 @@ impl SubstrateCli for Cli { chain_spec.is_wococo() || chain_spec.is_versi() { - Box::new(service::RococoChainSpec::from_json_file(path)?) + Box::new(polkadot_service::RococoChainSpec::from_json_file(path)?) } else if self.run.force_kusama || chain_spec.is_kusama() { - Box::new(service::GenericChainSpec::from_json_file(path)?) + Box::new(polkadot_service::GenericChainSpec::from_json_file(path)?) } else if self.run.force_westend || chain_spec.is_westend() { - Box::new(service::WestendChainSpec::from_json_file(path)?) + Box::new(polkadot_service::WestendChainSpec::from_json_file(path)?) } else { chain_spec } @@ -155,7 +155,7 @@ impl SubstrateCli for Cli { } } -fn set_default_ss58_version(spec: &Box) { +fn set_default_ss58_version(spec: &Box) { let ss58_version = if spec.is_kusama() { Ss58AddressFormatRegistry::KusamaAccount } else if spec.is_westend() { @@ -176,7 +176,7 @@ fn set_default_ss58_version(spec: &Box) { #[cfg(feature = "malus")] pub fn run_node( run: Cli, - overseer_gen: impl service::OverseerGen, + overseer_gen: impl polkadot_service::OverseerGen, malus_finality_delay: Option, ) -> Result<()> { run_node_inner(run, overseer_gen, malus_finality_delay, |_logger_builder, _config| {}) @@ -184,7 +184,7 @@ pub fn run_node( fn run_node_inner( cli: Cli, - overseer_gen: impl service::OverseerGen, + overseer_gen: impl polkadot_service::OverseerGen, maybe_malus_finality_delay: Option, logger_hook: F, ) -> Result<()> @@ -192,7 +192,7 @@ where F: FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Configuration), { let runner = cli - .create_runner_with_logger_hook::(&cli.run.base, logger_hook) + .create_runner_with_logger_hook::<_, _, F>(&cli.run.base, logger_hook) .map_err(Error::from)?; let chain_spec = &runner.config().chain_spec; @@ -235,10 +235,10 @@ where .flatten(); let database_source = config.database.clone(); - let task_manager = service::build_full( + let task_manager = polkadot_service::build_full( config, - service::NewFullParams { - is_parachain_node: service::IsParachainNode::No, + polkadot_service::NewFullParams { + is_parachain_node: polkadot_service::IsParachainNode::No, enable_beefy, force_authoring_backoff: cli.run.force_authoring_backoff, jaeger_agent, @@ -284,7 +284,7 @@ pub fn run() -> Result<()> { .next() .ok_or_else(|| Error::AddressResolutionMissing)?; // The pyroscope agent requires a `http://` prefix, so we just do that. - let agent = pyro::PyroscopeAgent::builder( + let agent = pyroscope::PyroscopeAgent::builder( "http://".to_owned() + address.to_string().as_str(), "polkadot".to_owned(), ) @@ -303,7 +303,7 @@ pub fn run() -> Result<()> { match &cli.subcommand { None => run_node_inner( cli, - service::ValidatorOverseerGen, + polkadot_service::ValidatorOverseerGen, None, polkadot_node_metrics::logger_hook(), ), @@ -319,7 +319,7 @@ pub fn run() -> Result<()> { runner.async_run(|mut config| { let (client, _, import_queue, task_manager) = - service::new_chain_ops(&mut config, None)?; + polkadot_service::new_chain_ops(&mut config, None)?; Ok((cmd.run(client, import_queue).map_err(Error::SubstrateCli), task_manager)) }) }, @@ -331,7 +331,8 @@ pub fn run() -> Result<()> { Ok(runner.async_run(|mut config| { let (client, _, _, task_manager) = - service::new_chain_ops(&mut config, None).map_err(Error::PolkadotService)?; + polkadot_service::new_chain_ops(&mut config, None) + .map_err(Error::PolkadotService)?; Ok((cmd.run(client, config.database).map_err(Error::SubstrateCli), task_manager)) })?) }, @@ -342,7 +343,8 @@ pub fn run() -> Result<()> { set_default_ss58_version(chain_spec); Ok(runner.async_run(|mut config| { - let (client, _, _, task_manager) = service::new_chain_ops(&mut config, None)?; + let (client, _, _, task_manager) = + polkadot_service::new_chain_ops(&mut config, None)?; Ok((cmd.run(client, config.chain_spec).map_err(Error::SubstrateCli), task_manager)) })?) }, @@ -354,7 +356,7 @@ pub fn run() -> Result<()> { Ok(runner.async_run(|mut config| { let (client, _, import_queue, task_manager) = - service::new_chain_ops(&mut config, None)?; + polkadot_service::new_chain_ops(&mut config, None)?; Ok((cmd.run(client, import_queue).map_err(Error::SubstrateCli), task_manager)) })?) }, @@ -369,15 +371,18 @@ pub fn run() -> Result<()> { set_default_ss58_version(chain_spec); Ok(runner.async_run(|mut config| { - let (client, backend, _, task_manager) = service::new_chain_ops(&mut config, None)?; + let (client, backend, _, task_manager) = + polkadot_service::new_chain_ops(&mut config, None)?; let aux_revert = Box::new(|client, backend, blocks| { - service::revert_backend(client, backend, blocks, config).map_err(|err| { - match err { - service::Error::Blockchain(err) => err.into(), - // Generic application-specific error. - err => sc_cli::Error::Application(err.into()), - } - }) + polkadot_service::revert_backend(client, backend, blocks, config).map_err( + |err| { + match err { + polkadot_service::Error::Blockchain(err) => err.into(), + // Generic application-specific error. + err => sc_cli::Error::Application(err.into()), + } + }, + ) }); Ok(( cmd.run(client, backend, Some(aux_revert)).map_err(Error::SubstrateCli), @@ -400,21 +405,22 @@ pub fn run() -> Result<()> { .into()), #[cfg(feature = "runtime-benchmarks")] BenchmarkCmd::Storage(cmd) => runner.sync_run(|mut config| { - let (client, backend, _, _) = service::new_chain_ops(&mut config, None)?; + let (client, backend, _, _) = + polkadot_service::new_chain_ops(&mut config, None)?; let db = backend.expose_db(); let storage = backend.expose_storage(); cmd.run(config, client.clone(), db, storage).map_err(Error::SubstrateCli) }), BenchmarkCmd::Block(cmd) => runner.sync_run(|mut config| { - let (client, _, _, _) = service::new_chain_ops(&mut config, None)?; + let (client, _, _, _) = polkadot_service::new_chain_ops(&mut config, None)?; cmd.run(client.clone()).map_err(Error::SubstrateCli) }), // These commands are very similar and can be handled in nearly the same way. BenchmarkCmd::Extrinsic(_) | BenchmarkCmd::Overhead(_) => runner.sync_run(|mut config| { - let (client, _, _, _) = service::new_chain_ops(&mut config, None)?; + let (client, _, _, _) = polkadot_service::new_chain_ops(&mut config, None)?; let header = client.header(client.info().genesis_hash).unwrap().unwrap(); let inherent_data = benchmark_inherent_data(header) .map_err(|e| format!("generating inherent data: {:?}", e))?; @@ -454,7 +460,7 @@ pub fn run() -> Result<()> { if cfg!(feature = "runtime-benchmarks") { runner.sync_run(|config| { - cmd.run_with_spec::, ()>( + cmd.run_with_spec::, ()>( Some(config.chain_spec), ) .map_err(|e| Error::SubstrateCli(e)) @@ -481,7 +487,7 @@ pub fn run() -> Result<()> { Some(Subcommand::Key(cmd)) => Ok(cmd.run(&cli)?), Some(Subcommand::ChainInfo(cmd)) => { let runner = cli.create_runner(cmd)?; - Ok(runner.sync_run(|config| cmd.run::(&config))?) + Ok(runner.sync_run(|config| cmd.run::(&config))?) }, }?; diff --git a/polkadot/cli/src/error.rs b/polkadot/cli/src/error.rs index 219289796522e495db1b7170a8efcec9b95a3530..1fcd2ca04bb05fa76d057343a2a31b65c88d09ea 100644 --- a/polkadot/cli/src/error.rs +++ b/polkadot/cli/src/error.rs @@ -17,7 +17,7 @@ #[derive(thiserror::Error, Debug)] pub enum Error { #[error(transparent)] - PolkadotService(#[from] service::Error), + PolkadotService(#[from] polkadot_service::Error), #[error(transparent)] SubstrateCli(#[from] sc_cli::Error), @@ -34,7 +34,7 @@ pub enum Error { #[cfg(feature = "pyroscope")] #[error("Failed to connect to pyroscope agent")] - PyroscopeError(#[from] pyro::error::PyroscopeError), + PyroscopeError(#[from] pyroscope::error::PyroscopeError), #[error("Failed to resolve provided URL")] AddressResolutionFailure(#[from] std::io::Error), diff --git a/polkadot/cli/src/lib.rs b/polkadot/cli/src/lib.rs index 4bb0dfb7583543937380d21da249bc612b842aba..944f8438f20fd6b126d47105ef26df07493c40ec 100644 --- a/polkadot/cli/src/lib.rs +++ b/polkadot/cli/src/lib.rs @@ -26,10 +26,12 @@ mod command; mod error; #[cfg(feature = "service")] -pub use service::{self, Block, CoreApi, IdentifyVariant, ProvideRuntimeApi, TFullClient}; +pub use polkadot_service::{ + self as service, Block, CoreApi, IdentifyVariant, ProvideRuntimeApi, TFullClient, +}; #[cfg(feature = "malus")] -pub use service::overseer::validator_overseer_builder; +pub use polkadot_service::overseer::validator_overseer_builder; #[cfg(feature = "cli")] pub use cli::*; diff --git a/polkadot/core-primitives/Cargo.toml b/polkadot/core-primitives/Cargo.toml index 8dfa0b87328b1af0bc4cbc1bcd677919acaaf892..42ca27953738e5c06dc5cb904323ee6a5bbc91f2 100644 --- a/polkadot/core-primitives/Cargo.toml +++ b/polkadot/core-primitives/Cargo.toml @@ -10,18 +10,16 @@ license.workspace = true workspace = true [dependencies] -sp-core = { path = "../../substrate/primitives/core", default-features = false } -sp-std = { path = "../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +scale-info = { features = ["derive"], workspace = true } +codec = { features = ["derive"], workspace = true } [features] default = ["std"] std = [ - "parity-scale-codec/std", + "codec/std", "scale-info/std", "sp-core/std", "sp-runtime/std", - "sp-std/std", ] diff --git a/polkadot/core-primitives/src/lib.rs b/polkadot/core-primitives/src/lib.rs index a74cdef3ad763a552fcb33586eb3e1956006ee47..666636def46048ad2d97c48d5b82591df3108fcc 100644 --- a/polkadot/core-primitives/src/lib.rs +++ b/polkadot/core-primitives/src/lib.rs @@ -20,7 +20,9 @@ //! //! These core Polkadot types are used by the relay chain and the Parachains. -use parity_scale_codec::{Decode, Encode}; +extern crate alloc; + +use codec::{Decode, Encode}; use scale_info::TypeInfo; use sp_runtime::{ generic, @@ -81,8 +83,8 @@ impl std::fmt::Display for CandidateHash { } } -impl sp_std::fmt::Debug for CandidateHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for CandidateHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{:?}", self.0) } } @@ -119,7 +121,7 @@ pub type Remark = [u8; 32]; /// A message sent from the relay-chain down to a parachain. /// /// The size of the message is limited by the `config.max_downward_message_size` parameter. -pub type DownwardMessage = sp_std::vec::Vec; +pub type DownwardMessage = alloc::vec::Vec; /// A wrapped version of `DownwardMessage`. The difference is that it has attached the block number /// when the message was sent. @@ -139,7 +141,7 @@ pub struct InboundHrmpMessage { /// enacted. pub sent_at: BlockNumber, /// The message payload. - pub data: sp_std::vec::Vec, + pub data: alloc::vec::Vec, } /// An HRMP message seen from the perspective of a sender. @@ -148,7 +150,7 @@ pub struct OutboundHrmpMessage { /// The para that will get this message in its downward message queue. pub recipient: Id, /// The message payload. - pub data: sp_std::vec::Vec, + pub data: alloc::vec::Vec, } /// `V2` primitives. diff --git a/polkadot/erasure-coding/Cargo.toml b/polkadot/erasure-coding/Cargo.toml index db5967e20f5e4fdbcd54c42a92f0bcf1d1ef3bab..969742c5bb0aa792ea81b287f588b1315a48971d 100644 --- a/polkadot/erasure-coding/Cargo.toml +++ b/polkadot/erasure-coding/Cargo.toml @@ -10,16 +10,17 @@ license.workspace = true workspace = true [dependencies] -polkadot-primitives = { path = "../primitives" } -polkadot-node-primitives = { package = "polkadot-node-primitives", path = "../node/primitives" } -novelpoly = { package = "reed-solomon-novelpoly", version = "2.0.0" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive", "std"] } -sp-core = { path = "../../substrate/primitives/core" } -sp-trie = { path = "../../substrate/primitives/trie" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +novelpoly = { workspace = true } +codec = { features = ["derive", "std"], workspace = true } +sp-core = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } thiserror = { workspace = true } [dev-dependencies] -criterion = { version = "0.5.1", default-features = false, features = ["cargo_bench_support"] } +quickcheck = { workspace = true } +criterion = { features = ["cargo_bench_support"], workspace = true } [[bench]] name = "scaling_with_validators" diff --git a/polkadot/erasure-coding/benches/README.md b/polkadot/erasure-coding/benches/README.md index 94fca5400c610636831c08b5282d6d47f4199878..20f79827d280b23782368c4f56f2a85f5d4eed41 100644 --- a/polkadot/erasure-coding/benches/README.md +++ b/polkadot/erasure-coding/benches/README.md @@ -7,7 +7,8 @@ cargo bench ## `scaling_with_validators` This benchmark evaluates the performance of constructing the chunks and the erasure root from PoV and -reconstructing the PoV from chunks. You can see the results of running this bench on 5950x below. +reconstructing the PoV from chunks (either from systematic chunks or regular chunks). +You can see the results of running this bench on 5950x below (only including recovery from regular chunks). Interestingly, with `10_000` chunks (validators) its slower than with `50_000` for both construction and reconstruction. ``` @@ -37,3 +38,6 @@ reconstruct/10000 time: [496.35 ms 505.17 ms 515.42 ms] reconstruct/50000 time: [276.56 ms 277.53 ms 278.58 ms] thrpt: [17.948 MiB/s 18.016 MiB/s 18.079 MiB/s] ``` + +Results from running on an Apple M2 Pro, systematic recovery is generally 40 times faster than +regular recovery, achieving 1 Gib/s. diff --git a/polkadot/erasure-coding/benches/scaling_with_validators.rs b/polkadot/erasure-coding/benches/scaling_with_validators.rs index 759385bbdef4ed85e5db087d2d93c7cb51250db8..3d743faa4169b48f651e99e2e005237d727841d7 100644 --- a/polkadot/erasure-coding/benches/scaling_with_validators.rs +++ b/polkadot/erasure-coding/benches/scaling_with_validators.rs @@ -53,12 +53,16 @@ fn construct_and_reconstruct_5mb_pov(c: &mut Criterion) { } group.finish(); - let mut group = c.benchmark_group("reconstruct"); + let mut group = c.benchmark_group("reconstruct_regular"); for n_validators in N_VALIDATORS { let all_chunks = chunks(n_validators, &pov); - let mut c: Vec<_> = all_chunks.iter().enumerate().map(|(i, c)| (&c[..], i)).collect(); - let last_chunks = c.split_off((c.len() - 1) * 2 / 3); + let chunks: Vec<_> = all_chunks + .iter() + .enumerate() + .take(polkadot_erasure_coding::recovery_threshold(n_validators).unwrap()) + .map(|(i, c)| (&c[..], i)) + .collect(); group.throughput(Throughput::Bytes(pov.len() as u64)); group.bench_with_input( @@ -67,7 +71,31 @@ fn construct_and_reconstruct_5mb_pov(c: &mut Criterion) { |b, &n| { b.iter(|| { let _pov: Vec = - polkadot_erasure_coding::reconstruct(n, last_chunks.clone()).unwrap(); + polkadot_erasure_coding::reconstruct(n, chunks.clone()).unwrap(); + }); + }, + ); + } + group.finish(); + + let mut group = c.benchmark_group("reconstruct_systematic"); + for n_validators in N_VALIDATORS { + let all_chunks = chunks(n_validators, &pov); + + let chunks = all_chunks + .into_iter() + .take(polkadot_erasure_coding::systematic_recovery_threshold(n_validators).unwrap()) + .collect::>(); + + group.throughput(Throughput::Bytes(pov.len() as u64)); + group.bench_with_input( + BenchmarkId::from_parameter(n_validators), + &n_validators, + |b, &n| { + b.iter(|| { + let _pov: Vec = + polkadot_erasure_coding::reconstruct_from_systematic(n, chunks.clone()) + .unwrap(); }); }, ); diff --git a/polkadot/erasure-coding/fuzzer/Cargo.toml b/polkadot/erasure-coding/fuzzer/Cargo.toml index 4e5ef9d229d82db298f57cd4f853042079b5a1f8..6f451f0319b23dee9ebbf08726dd4550f518e95d 100644 --- a/polkadot/erasure-coding/fuzzer/Cargo.toml +++ b/polkadot/erasure-coding/fuzzer/Cargo.toml @@ -10,10 +10,10 @@ publish = false workspace = true [dependencies] -polkadot-erasure-coding = { path = ".." } -honggfuzz = "0.5" -polkadot-primitives = { path = "../../primitives" } -primitives = { package = "polkadot-node-primitives", path = "../../node/primitives" } +polkadot-erasure-coding = { workspace = true, default-features = true } +honggfuzz = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } [[bin]] name = "reconstruct" diff --git a/polkadot/erasure-coding/fuzzer/src/reconstruct.rs b/polkadot/erasure-coding/fuzzer/src/reconstruct.rs index b2f9690a6fd3791f04eca052a902ab660c777e07..6cb5742bc7d1267af24450900a700f42dc18cc24 100644 --- a/polkadot/erasure-coding/fuzzer/src/reconstruct.rs +++ b/polkadot/erasure-coding/fuzzer/src/reconstruct.rs @@ -16,7 +16,7 @@ use honggfuzz::fuzz; use polkadot_erasure_coding::*; -use primitives::AvailableData; +use polkadot_node_primitives::AvailableData; fn main() { loop { diff --git a/polkadot/erasure-coding/fuzzer/src/round_trip.rs b/polkadot/erasure-coding/fuzzer/src/round_trip.rs index 2e38becf651d447d71e2b26463f0c26df277994b..627c9724d494832ede0d5ced55a2524fd179052b 100644 --- a/polkadot/erasure-coding/fuzzer/src/round_trip.rs +++ b/polkadot/erasure-coding/fuzzer/src/round_trip.rs @@ -16,8 +16,8 @@ use honggfuzz::fuzz; use polkadot_erasure_coding::*; +use polkadot_node_primitives::{AvailableData, BlockData, PoV}; use polkadot_primitives::PersistedValidationData; -use primitives::{AvailableData, BlockData, PoV}; use std::sync::Arc; fn main() { diff --git a/polkadot/erasure-coding/src/lib.rs b/polkadot/erasure-coding/src/lib.rs index e5155df4beba95aa9e7944e3e9a67d4e55a1db9c..9ebf5d11d7a78e9c7044db6743fcd33ff1dc5110 100644 --- a/polkadot/erasure-coding/src/lib.rs +++ b/polkadot/erasure-coding/src/lib.rs @@ -24,7 +24,7 @@ //! f is the maximum number of faulty validators in the system. //! The data is coded so any f+1 chunks can be used to reconstruct the full data. -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_primitives::{AvailableData, Proof}; use polkadot_primitives::{BlakeTwo256, Hash as H256, HashT}; use sp_core::Blake2Hasher; @@ -69,6 +69,9 @@ pub enum Error { /// Bad payload in reconstructed bytes. #[error("Reconstructed payload invalid")] BadPayload, + /// Unable to decode reconstructed bytes. + #[error("Unable to decode reconstructed payload: {0}")] + Decode(#[source] codec::Error), /// Invalid branch proof. #[error("Invalid branch proof")] InvalidBranchProof, @@ -110,6 +113,14 @@ pub const fn recovery_threshold(n_validators: usize) -> Result { Ok(needed + 1) } +/// Obtain the threshold of systematic chunks that should be enough to recover the data. +/// +/// If the regular `recovery_threshold` is a power of two, then it returns the same value. +/// Otherwise, it returns the next lower power of two. +pub fn systematic_recovery_threshold(n_validators: usize) -> Result { + code_params(n_validators).map(|params| params.k()) +} + fn code_params(n_validators: usize) -> Result { // we need to be able to reconstruct from 1/3 - eps @@ -127,6 +138,41 @@ fn code_params(n_validators: usize) -> Result { }) } +/// Reconstruct the v1 available data from the set of systematic chunks. +/// +/// Provide a vector containing chunk data. If too few chunks are provided, recovery is not +/// possible. +pub fn reconstruct_from_systematic_v1( + n_validators: usize, + chunks: Vec>, +) -> Result { + reconstruct_from_systematic(n_validators, chunks) +} + +/// Reconstruct the available data from the set of systematic chunks. +/// +/// Provide a vector containing the first k chunks in order. If too few chunks are provided, +/// recovery is not possible. +pub fn reconstruct_from_systematic( + n_validators: usize, + chunks: Vec>, +) -> Result { + let code_params = code_params(n_validators)?; + let k = code_params.k(); + + for chunk_data in chunks.iter().take(k) { + if chunk_data.len() % 2 != 0 { + return Err(Error::UnevenLength) + } + } + + let bytes = code_params.make_encoder().reconstruct_from_systematic( + chunks.into_iter().take(k).map(|data| WrappedShard::new(data)).collect(), + )?; + + Decode::decode(&mut &bytes[..]).map_err(|err| Error::Decode(err)) +} + /// Obtain erasure-coded chunks for v1 `AvailableData`, one for each validator. /// /// Works only up to 65536 validators, and `n_validators` must be non-zero. @@ -285,13 +331,41 @@ pub fn branch_hash(root: &H256, branch_nodes: &Proof, index: usize) -> Result

Self { + // Limit the POV len to 1 mib, otherwise the test will take forever + let pov_len = (u32::arbitrary(g) % (1024 * 1024)).max(2); + + let pov = (0..pov_len).map(|_| u8::arbitrary(g)).collect(); + + let pvd = PersistedValidationData { + parent_head: HeadData((0..u16::arbitrary(g)).map(|_| u8::arbitrary(g)).collect()), + relay_parent_number: u32::arbitrary(g), + relay_parent_storage_root: [u8::arbitrary(g); 32].into(), + max_pov_size: u32::arbitrary(g), + }; + + ArbitraryAvailableData(AvailableData { + pov: Arc::new(PoV { block_data: BlockData(pov) }), + validation_data: pvd, + }) + } + } + #[test] fn field_order_is_right_size() { assert_eq!(MAX_VALIDATORS, 65536); @@ -318,6 +392,25 @@ mod tests { assert_eq!(reconstructed, available_data); } + #[test] + fn round_trip_systematic_works() { + fn property(available_data: ArbitraryAvailableData, n_validators: u16) { + let n_validators = n_validators.max(2); + let kpow2 = systematic_recovery_threshold(n_validators as usize).unwrap(); + let chunks = obtain_chunks(n_validators as usize, &available_data.0).unwrap(); + assert_eq!( + reconstruct_from_systematic_v1( + n_validators as usize, + chunks.into_iter().take(kpow2).collect() + ) + .unwrap(), + available_data.0 + ); + } + + QuickCheck::new().quickcheck(property as fn(ArbitraryAvailableData, u16)) + } + #[test] fn reconstruct_does_not_panic_on_low_validator_count() { let reconstructed = reconstruct_v1(1, [].iter().cloned()); diff --git a/polkadot/node/collation-generation/Cargo.toml b/polkadot/node/collation-generation/Cargo.toml index ebc53a9e01bbe5abc6ba18e500ad3bafcf35ead3..4b0a5f7248ab383884365105b164f27f2a090bf1 100644 --- a/polkadot/node/collation-generation/Cargo.toml +++ b/polkadot/node/collation-generation/Cargo.toml @@ -10,21 +10,21 @@ description = "Collator-side subsystem that handles incoming candidate submissio workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../gum" } -polkadot-erasure-coding = { path = "../../erasure-coding" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-node-subsystem-util = { path = "../subsystem-util" } -polkadot-primitives = { path = "../../primitives" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" } +futures = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } thiserror = { workspace = true } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } +codec = { features = ["bit-vec", "derive"], workspace = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" } -assert_matches = "1.4.0" -rstest = "0.18.2" -sp-keyring = { path = "../../../substrate/primitives/keyring" } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +assert_matches = { workspace = true } +rstest = { workspace = true } +sp-keyring = { workspace = true, default-features = true } diff --git a/polkadot/node/collation-generation/src/lib.rs b/polkadot/node/collation-generation/src/lib.rs index 374f090a2671a1c3a0f9c5f945cd16954a53bcce..50adbddea4136e08e64893c419fb6bb28e5134f3 100644 --- a/polkadot/node/collation-generation/src/lib.rs +++ b/polkadot/node/collation-generation/src/lib.rs @@ -31,8 +31,8 @@ #![deny(missing_docs)] +use codec::Encode; use futures::{channel::oneshot, future::FutureExt, join, select}; -use parity_scale_codec::Encode; use polkadot_node_primitives::{ AvailableData, Collation, CollationGenerationConfig, CollationSecondedSignal, PoV, SubmitCollationParams, @@ -45,7 +45,7 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_util::{ request_async_backing_params, request_availability_cores, request_para_backing_state, request_persisted_validation_data, request_validation_code, request_validation_code_hash, - request_validators, vstaging::fetch_claim_queue, + request_validators, runtime::fetch_claim_queue, }; use polkadot_primitives::{ collator_signature_payload, CandidateCommitments, CandidateDescriptor, CandidateReceipt, @@ -147,11 +147,7 @@ impl CollationGenerationSubsystem { Ok(FromOrchestra::Communication { msg: CollationGenerationMessage::Reinitialize(config), }) => { - if self.config.is_none() { - gum::error!(target: LOG_TARGET, "no initial initialization"); - } else { - self.config = Some(Arc::new(config)); - } + self.config = Some(Arc::new(config)); false }, Ok(FromOrchestra::Communication { diff --git a/polkadot/node/collation-generation/src/tests.rs b/polkadot/node/collation-generation/src/tests.rs index 10c391cba25d1cba13df33891e65f0abb10944c4..0feee79e763c94cbb6c1e1c16d6913ccd4a52bc2 100644 --- a/polkadot/node/collation-generation/src/tests.rs +++ b/polkadot/node/collation-generation/src/tests.rs @@ -34,15 +34,15 @@ use polkadot_primitives::{ AsyncBackingParams, BlockNumber, CollatorPair, HeadData, PersistedValidationData, ScheduledCore, ValidationCode, }; +use polkadot_primitives_test_helpers::{ + dummy_candidate_descriptor, dummy_hash, dummy_head_data, dummy_validator, make_candidate, +}; use rstest::rstest; use sp_keyring::sr25519::Keyring as Sr25519Keyring; use std::{ collections::{BTreeMap, VecDeque}, pin::Pin, }; -use test_helpers::{ - dummy_candidate_descriptor, dummy_hash, dummy_head_data, dummy_validator, make_candidate, -}; type VirtualOverseer = TestSubsystemContextHandle; diff --git a/polkadot/node/core/approval-voting/Cargo.toml b/polkadot/node/core/approval-voting/Cargo.toml index 5139d6c6a3f5caa789a5eaed714408d06a3b2b31..bc0187bf49228a2bf5e691c4fddce89ede9dc225 100644 --- a/polkadot/node/core/approval-voting/Cargo.toml +++ b/polkadot/node/core/approval-voting/Cargo.toml @@ -10,51 +10,51 @@ description = "Approval Voting Subsystem of the Polkadot node" workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -gum = { package = "tracing-gum", path = "../../gum" } -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -schnellru = "0.2.1" -merlin = "3.0" -schnorrkel = "0.11.4" -kvdb = "0.13.0" -derive_more = "0.99.17" +futures = { workspace = true } +futures-timer = { workspace = true } +codec = { features = ["bit-vec", "derive"], workspace = true } +gum = { workspace = true, default-features = true } +bitvec = { features = ["alloc"], workspace = true } +schnellru = { workspace = true } +merlin = { workspace = true, default-features = true } +schnorrkel = { workspace = true, default-features = true } +kvdb = { workspace = true } +derive_more = { workspace = true, default-features = true } thiserror = { workspace = true } -itertools = "0.11" +itertools = { workspace = true } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-overseer = { path = "../../overseer" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-jaeger = { path = "../../jaeger" } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } -sc-keystore = { path = "../../../../substrate/client/keystore", default-features = false } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common", default-features = false } -sp-consensus-slots = { path = "../../../../substrate/primitives/consensus/slots", default-features = false } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto", default-features = false, features = ["full_crypto"] } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +sc-keystore = { workspace = true } +sp-consensus = { workspace = true } +sp-consensus-slots = { workspace = true } +sp-application-crypto = { features = ["full_crypto"], workspace = true } +sp-runtime = { workspace = true } # rand_core should match schnorrkel -rand_core = "0.6.2" -rand_chacha = { version = "0.3.1" } -rand = "0.8.5" +rand_core = { workspace = true } +rand_chacha = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } [dev-dependencies] -async-trait = "0.1.79" -parking_lot = "0.12.1" -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -assert_matches = "1.4.0" -kvdb-memorydb = "0.13.0" -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +async-trait = { workspace = true } +parking_lot = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +assert_matches = { workspace = true } +kvdb-memorydb = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } log = { workspace = true, default-features = true } -env_logger = "0.11" +sp-tracing = { workspace = true } -polkadot-subsystem-bench = { path = "../../subsystem-bench" } +polkadot-subsystem-bench = { workspace = true } [[bench]] name = "approval-voting-regression-bench" diff --git a/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs b/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs index 9a5f0d29dbd3180676a01eba0b382dbb26ef11ea..41418bcc511f87a4f321d02c0d701dfe5775ba25 100644 --- a/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs +++ b/polkadot/node/core/approval-voting/benches/approval-voting-regression-bench.rs @@ -61,7 +61,7 @@ fn main() -> Result<(), String> { print!("\r[{}{}]", "#".repeat(n), "_".repeat(BENCH_COUNT - n)); std::io::stdout().flush().unwrap(); let (mut env, state) = prepare_test(config.clone(), options.clone(), false); - env.runtime().block_on(bench_approvals("approvals_throughput", &mut env, state)) + env.runtime().block_on(bench_approvals(&mut env, state)) }) .collect(); println!("\rDone!{}", " ".repeat(BENCH_COUNT)); @@ -74,15 +74,16 @@ fn main() -> Result<(), String> { .map_err(|e| e.to_string())?; println!("{}", average_usage); - // We expect no variance for received and sent - // but use 0.001 because we operate with floats + // We expect some small variance for received and sent because the + // test messages are generated at every benchmark run and they contain + // random data so use 0.01 as the accepted variance. messages.extend(average_usage.check_network_usage(&[ - ("Received from peers", 52942.4600, 0.001), - ("Sent to peers", 63547.0330, 0.001), + ("Received from peers", 52941.6071, 0.01), + ("Sent to peers", 63995.2200, 0.01), ])); messages.extend(average_usage.check_cpu_usage(&[ - ("approval-distribution", 7.0317, 0.1), - ("approval-voting", 9.5751, 0.1), + ("approval-distribution", 6.3912, 0.1), + ("approval-voting", 10.0578, 0.1), ])); if messages.is_empty() { diff --git a/polkadot/node/core/approval-voting/src/approval_checking.rs b/polkadot/node/core/approval-voting/src/approval_checking.rs index 693a28800114c5196076fcabc2a194bf36f7a218..96eb25626de8c167255027e1320b079eb8f60e2a 100644 --- a/polkadot/node/core/approval-voting/src/approval_checking.rs +++ b/polkadot/node/core/approval-voting/src/approval_checking.rs @@ -23,6 +23,7 @@ use polkadot_primitives::ValidatorIndex; use crate::{ persisted_entries::{ApprovalEntry, CandidateEntry, TrancheEntry}, time::Tick, + MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE, }; /// Result of counting the necessary tranches needed for approving a block. @@ -32,6 +33,7 @@ pub struct TranchesToApproveResult { pub required_tranches: RequiredTranches, /// The total number of no_shows at the moment we are doing the counting. pub total_observed_no_shows: usize, + pub no_show_validators: Vec, } /// The required tranches of assignments needed to determine whether a candidate is approved. @@ -188,6 +190,8 @@ struct State { /// The last tick at which a considered assignment was received. last_assignment_tick: Option, total_observed_no_shows: usize, + // The validator's index that are no-shows. + no_show_validators: Vec, } impl State { @@ -203,6 +207,7 @@ impl State { return TranchesToApproveResult { required_tranches: RequiredTranches::All, total_observed_no_shows: self.total_observed_no_shows, + no_show_validators: self.no_show_validators.clone(), } } @@ -217,6 +222,7 @@ impl State { last_assignment_tick: self.last_assignment_tick, }, total_observed_no_shows: self.total_observed_no_shows, + no_show_validators: self.no_show_validators.clone(), } } @@ -234,6 +240,7 @@ impl State { clock_drift, }, total_observed_no_shows: self.total_observed_no_shows, + no_show_validators: self.no_show_validators.clone(), } } else { TranchesToApproveResult { @@ -244,6 +251,7 @@ impl State { clock_drift, }, total_observed_no_shows: self.total_observed_no_shows, + no_show_validators: self.no_show_validators.clone(), } } } @@ -253,11 +261,12 @@ impl State { } fn advance( - &self, + mut self, new_assignments: usize, new_no_shows: usize, next_no_show: Option, last_assignment_tick: Option, + no_show_validators: Vec, ) -> State { let new_covered = if self.depth == 0 { new_assignments @@ -290,6 +299,17 @@ impl State { (self.depth, covering, uncovered) }; + // Make sure we don't store too many no-show validators, since this metric + // is valuable if there are just a few of them to identify the problematic + // validators. + // If there are a lot then we've got bigger problems and no need to make this + // array unnecessarily large. + if self.no_show_validators.len() + no_show_validators.len() < + MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE + { + self.no_show_validators.extend(no_show_validators); + } + State { assignments, depth, @@ -299,6 +319,7 @@ impl State { next_no_show, last_assignment_tick, total_observed_no_shows: self.total_observed_no_shows + new_no_shows, + no_show_validators: self.no_show_validators, } } } @@ -354,8 +375,9 @@ fn count_no_shows( block_tick: Tick, no_show_duration: Tick, drifted_tick_now: Tick, -) -> (usize, Option) { +) -> (usize, Option, Vec) { let mut next_no_show = None; + let mut no_show_validators = Vec::new(); let no_shows = assignments .iter() .map(|(v_index, tick)| { @@ -379,12 +401,14 @@ fn count_no_shows( // the clock drift will be removed again to do the comparison above. next_no_show = super::min_prefer_some(next_no_show, Some(no_show_at + clock_drift)); } - + if is_no_show { + no_show_validators.push(*v_index); + } is_no_show }) .count(); - (no_shows, next_no_show) + (no_shows, next_no_show, no_show_validators) } /// Determine the amount of tranches of assignments needed to determine approval of a candidate. @@ -408,6 +432,7 @@ pub fn tranches_to_approve( next_no_show: None, last_assignment_tick: None, total_observed_no_shows: 0, + no_show_validators: Vec::new(), }; // The `ApprovalEntry` doesn't have any data for empty tranches. We still want to iterate over @@ -446,7 +471,7 @@ pub fn tranches_to_approve( // // While we count the no-shows, we also determine the next possible no-show we might // see within this tranche. - let (no_shows, next_no_show) = count_no_shows( + let (no_shows, next_no_show, no_show_validators) = count_no_shows( assignments, approvals, clock_drift, @@ -455,7 +480,7 @@ pub fn tranches_to_approve( drifted_tick_now, ); - let s = s.advance(n_assignments, no_shows, next_no_show, last_assignment_tick); + let s = s.advance(n_assignments, no_shows, next_no_show, last_assignment_tick, no_show_validators); let output = s.output(tranche, needed_approvals, n_validators, no_show_duration); *state = match output.required_tranches { @@ -482,9 +507,9 @@ pub fn tranches_to_approve( mod tests { use super::*; use crate::{approval_db, BTreeMap}; - use ::test_helpers::{dummy_candidate_receipt, dummy_hash}; use bitvec::{bitvec, order::Lsb0 as BitOrderLsb0, vec::BitVec}; use polkadot_primitives::GroupIndex; + use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; #[test] fn pending_is_not_approved() { @@ -1186,7 +1211,7 @@ mod tests { approvals.set(v_index, true); } - let (no_shows, next_no_show) = count_no_shows( + let (no_shows, next_no_show, _) = count_no_shows( &test.assignments, &approvals, test.clock_drift, @@ -1390,6 +1415,7 @@ mod tests { next_no_show: None, last_assignment_tick: None, total_observed_no_shows: 0, + no_show_validators: Default::default(), }; assert_eq!( @@ -1414,6 +1440,7 @@ mod tests { next_no_show: None, last_assignment_tick: None, total_observed_no_shows: 0, + no_show_validators: Default::default(), }; assert_eq!( diff --git a/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs index 249dcf912df50530e87f732edf2848664df1136e..11266f0b99d83ac4dcdb5e24251bbd1a5c5ee081 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/common/mod.rs @@ -17,7 +17,7 @@ //! Common helper functions for all versions of approval-voting database. use std::sync::Arc; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_subsystem::{SubsystemError, SubsystemResult}; use polkadot_node_subsystem_util::database::{DBTransaction, Database}; use polkadot_primitives::{BlockNumber, CandidateHash, CandidateIndex, Hash}; @@ -64,7 +64,7 @@ impl DbBackend { #[derive(Debug, derive_more::From, derive_more::Display)] pub enum Error { Io(std::io::Error), - InvalidDecoding(parity_scale_codec::Error), + InvalidDecoding(codec::Error), InternalError(SubsystemError), } diff --git a/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs index 011d0a559c022d2294acf0cdcc22364bc301a8dd..53e9db64f63641ba7a816a75609b771fc594afb6 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v1/mod.rs @@ -22,7 +22,7 @@ //! its data in the database. Any breaking changes here will still //! require a db migration (check `node/service/src/parachains_db/upgrade.rs`). -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_primitives::approval::v1::{AssignmentCert, DelayTranche}; use polkadot_primitives::{ BlockNumber, CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, Hash, SessionIndex, diff --git a/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs index b0966ad01f7bff8242e3255968b3e85b4d0239ca..4c08d22f3ca2d4f91a27e2b319d8859100f0ec55 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v1/tests.rs @@ -25,7 +25,9 @@ use polkadot_node_subsystem_util::database::Database; use polkadot_primitives::Id as ParaId; use std::{collections::HashMap, sync::Arc}; -use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash}; +use polkadot_primitives_test_helpers::{ + dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash, +}; const DATA_COL: u32 = 0; diff --git a/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs index da42fc5be485caabdd8f8428bdf15c9bf6eb08e9..cd9256a5d47eda0da75b3ca0238fbdd2060d1294 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v2/mod.rs @@ -16,7 +16,7 @@ //! Version 2 of the DB schema. -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_primitives::approval::{v1::DelayTranche, v2::AssignmentCertV2}; use polkadot_node_subsystem::{SubsystemError, SubsystemResult}; use polkadot_node_subsystem_util::database::{DBTransaction, Database}; diff --git a/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs index 5fa915add4166fa1f042dadaae063aaa83941b92..06a3cc1e306b643b18dff67d11baca79ca378848 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v2/tests.rs @@ -34,7 +34,9 @@ use polkadot_primitives::Id as ParaId; use sp_consensus_slots::Slot; use std::{collections::HashMap, sync::Arc}; -use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash}; +use polkadot_primitives_test_helpers::{ + dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash, +}; const DATA_COL: u32 = 0; diff --git a/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs b/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs index 3e4f4302195256205905d3f931039cbf9631824c..7118fb6770fd79d80454524bd33abb2ba3d8f2ce 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v3/mod.rs @@ -19,7 +19,7 @@ //! Version 3 modifies the `our_approval` format of `ApprovalEntry` //! and adds a new field `pending_signatures` for `BlockEntry` -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_primitives::approval::v2::CandidateBitfield; use polkadot_node_subsystem::SubsystemResult; use polkadot_node_subsystem_util::database::{DBTransaction, Database}; diff --git a/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs b/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs index 7c0cf9d4f7daaccd1887a03a2a06e9bb4e6b587e..d2a1d7d400b1495688865c0a0d30b04e44d14e20 100644 --- a/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs +++ b/polkadot/node/core/approval-voting/src/approval_db/v3/tests.rs @@ -33,7 +33,9 @@ use polkadot_primitives::Id as ParaId; use sp_consensus_slots::Slot; use std::{collections::HashMap, sync::Arc}; -use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash}; +use polkadot_primitives_test_helpers::{ + dummy_candidate_receipt, dummy_candidate_receipt_bad_sig, dummy_hash, +}; const DATA_COL: u32 = 0; diff --git a/polkadot/node/core/approval-voting/src/criteria.rs b/polkadot/node/core/approval-voting/src/criteria.rs index 57c0ac272dc5a5cad8b9c69831faa5ecfc778033..fb9d281e43bc3d0ed866ed0c2114ee64345fbdc9 100644 --- a/polkadot/node/core/approval-voting/src/criteria.rs +++ b/polkadot/node/core/approval-voting/src/criteria.rs @@ -16,8 +16,8 @@ //! Assignment criteria VRF generation and checking. +use codec::{Decode, Encode}; use itertools::Itertools; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_primitives::approval::{ self as approval_types, v1::{AssignmentCert, AssignmentCertKind, DelayTranche, RelayVRFStory}, diff --git a/polkadot/node/core/approval-voting/src/import.rs b/polkadot/node/core/approval-voting/src/import.rs index f4be42a4845080ce90fb87ddc838e2c1ab792ed1..3ddef1e01c45b99ce797d64b78f2e2c88993471f 100644 --- a/polkadot/node/core/approval-voting/src/import.rs +++ b/polkadot/node/core/approval-voting/src/import.rs @@ -607,9 +607,8 @@ pub(crate) mod tests { use super::*; use crate::{ approval_db::common::{load_block_entry, DbBackend}, - RuntimeInfo, RuntimeInfoConfig, + RuntimeInfo, RuntimeInfoConfig, MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS, }; - use ::test_helpers::{dummy_candidate_receipt, dummy_hash}; use assert_matches::assert_matches; use polkadot_node_primitives::{ approval::v1::{VrfSignature, VrfTranscript}, @@ -622,6 +621,8 @@ pub(crate) mod tests { node_features::FeatureIndex, ExecutorParams, Id as ParaId, IndexedVec, NodeFeatures, SessionInfo, ValidatorId, ValidatorIndex, }; + use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; + use schnellru::{ByLength, LruMap}; pub(crate) use sp_consensus_babe::{ digests::{CompatibleDigestItem, PreDigest, SecondaryVRFPreDigest}, AllowedSlots, BabeEpochConfiguration, Epoch as BabeEpoch, @@ -658,6 +659,10 @@ pub(crate) mod tests { clock: Box::new(MockClock::default()), assignment_criteria: Box::new(MockAssignmentCriteria::default()), spans: HashMap::new(), + per_block_assignments_gathering_times: LruMap::new(ByLength::new( + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS, + )), + no_show_stats: Default::default(), } } diff --git a/polkadot/node/core/approval-voting/src/lib.rs b/polkadot/node/core/approval-voting/src/lib.rs index b5ed92fa39c873c0a1e5f40c52705a5803971b60..d4b6855a44d0e410bbec757cae25eb7bd4803acb 100644 --- a/polkadot/node/core/approval-voting/src/lib.rs +++ b/polkadot/node/core/approval-voting/src/lib.rs @@ -63,6 +63,12 @@ use sc_keystore::LocalKeystore; use sp_application_crypto::Pair; use sp_consensus::SyncOracle; use sp_consensus_slots::Slot; +use std::time::Instant; + +// The max number of blocks we keep track of assignments gathering times. Normally, +// this would never be reached because we prune the data on finalization, but we need +// to also ensure the data is not growing unecessarily large. +const MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS: u32 = 100; use futures::{ channel::oneshot, @@ -182,6 +188,14 @@ struct MetricsInner { time_recover_and_approve: prometheus::Histogram, candidate_signatures_requests_total: prometheus::Counter, unapproved_candidates_in_unfinalized_chain: prometheus::Gauge, + // The time it takes in each stage to gather enough assignments. + // We defined a `stage` as being the entire process of gathering enough assignments to + // be able to approve a candidate: + // E.g: + // - Stage 0: We wait for the needed_approvals assignments to be gathered. + // - Stage 1: We wait for enough tranches to cover all no-shows in stage 0. + // - Stage 2: We wait for enough tranches to cover all no-shows of stage 1. + assignments_gathering_time_by_stage: prometheus::HistogramVec, } /// Approval Voting metrics. @@ -302,6 +316,20 @@ impl Metrics { metrics.unapproved_candidates_in_unfinalized_chain.set(count as u64); } } + + pub fn observe_assignment_gathering_time(&self, stage: usize, elapsed_as_millis: usize) { + if let Some(metrics) = &self.0 { + let stage_string = stage.to_string(); + // We don't want to have too many metrics entries with this label to not put unncessary + // pressure on the metrics infrastructure, so we cap the stage at 10, which is + // equivalent to having already a finalization lag to 10 * no_show_slots, so it should + // be more than enough. + metrics + .assignments_gathering_time_by_stage + .with_label_values(&[if stage < 10 { stage_string.as_str() } else { "inf" }]) + .observe(elapsed_as_millis as f64); + } + } } impl metrics::Metrics for Metrics { @@ -431,6 +459,17 @@ impl metrics::Metrics for Metrics { )?, registry, )?, + assignments_gathering_time_by_stage: prometheus::register( + prometheus::HistogramVec::new( + prometheus::HistogramOpts::new( + "polkadot_parachain_assignments_gather_time_by_stage_ms", + "The time in ms it takes for each stage to gather enough assignments needed for approval", + ) + .buckets(vec![0.0, 250.0, 500.0, 1000.0, 2000.0, 4000.0, 8000.0, 16000.0, 32000.0]), + &["stage"], + )?, + registry, + )?, }; Ok(Metrics(Some(metrics))) @@ -652,6 +691,7 @@ struct ApprovalStatus { tranche_now: DelayTranche, block_tick: Tick, last_no_shows: usize, + no_show_validators: Vec, } #[derive(Copy, Clone)] @@ -788,6 +828,73 @@ struct State { clock: Box, assignment_criteria: Box, spans: HashMap, + // Per block, candidate records about how long we take until we gather enough + // assignments, this is relevant because it gives us a good idea about how many + // tranches we trigger and why. + per_block_assignments_gathering_times: + LruMap>, + no_show_stats: NoShowStats, +} + +// Regularly dump the no-show stats at this block number frequency. +const NO_SHOW_DUMP_FREQUENCY: BlockNumber = 50; +// The maximum number of validators we record no-shows for, per candidate. +pub(crate) const MAX_RECORDED_NO_SHOW_VALIDATORS_PER_CANDIDATE: usize = 20; + +// No show stats per validator and per parachain. +// This is valuable information when we have to debug live network issue, because +// it gives information if things are going wrong only for some validators or just +// for some parachains. +#[derive(Debug, Clone, PartialEq, Eq, Default)] +struct NoShowStats { + per_validator_no_show: HashMap>, + per_parachain_no_show: HashMap, + last_dumped_block_number: BlockNumber, +} + +impl NoShowStats { + // Print the no-show stats if NO_SHOW_DUMP_FREQUENCY blocks have passed since the last + // print. + fn maybe_print(&mut self, current_block_number: BlockNumber) { + if self.last_dumped_block_number > current_block_number || + current_block_number - self.last_dumped_block_number < NO_SHOW_DUMP_FREQUENCY + { + return + } + if self.per_parachain_no_show.is_empty() && self.per_validator_no_show.is_empty() { + return + } + + gum::debug!( + target: LOG_TARGET, + "Validators with no_show {:?} and parachains with no_shows {:?} since {:}", + self.per_validator_no_show, + self.per_parachain_no_show, + self.last_dumped_block_number + ); + + self.last_dumped_block_number = current_block_number; + + self.per_validator_no_show.clear(); + self.per_parachain_no_show.clear(); + } +} + +#[derive(Debug, Clone, PartialEq, Eq)] +struct AssignmentGatheringRecord { + // The stage we are in. + // Candidate assignment gathering goes in stages, first we wait for needed_approvals(stage 0) + // Then if we have no-shows, we move into stage 1 and wait for enough tranches to cover all + // no-shows. + stage: usize, + // The time we started the stage. + stage_start: Option, +} + +impl Default for AssignmentGatheringRecord { + fn default() -> Self { + AssignmentGatheringRecord { stage: 0, stage_start: Some(Instant::now()) } + } } #[overseer::contextbounds(ApprovalVoting, prefix = self::overseer)] @@ -826,21 +933,25 @@ impl State { ); if let Some(approval_entry) = candidate_entry.approval_entry(&block_hash) { - let TranchesToApproveResult { required_tranches, total_observed_no_shows } = - approval_checking::tranches_to_approve( - approval_entry, - candidate_entry.approvals(), - tranche_now, - block_tick, - no_show_duration, - session_info.needed_approvals as _, - ); + let TranchesToApproveResult { + required_tranches, + total_observed_no_shows, + no_show_validators, + } = approval_checking::tranches_to_approve( + approval_entry, + candidate_entry.approvals(), + tranche_now, + block_tick, + no_show_duration, + session_info.needed_approvals as _, + ); let status = ApprovalStatus { required_tranches, block_tick, tranche_now, last_no_shows: total_observed_no_shows, + no_show_validators, }; Some((approval_entry, status)) @@ -893,6 +1004,116 @@ impl State { }, } } + + fn mark_begining_of_gathering_assignments( + &mut self, + block_number: BlockNumber, + block_hash: Hash, + candidate: CandidateHash, + ) { + if let Some(record) = self + .per_block_assignments_gathering_times + .get_or_insert(block_number, HashMap::new) + .and_then(|records| Some(records.entry((block_hash, candidate)).or_default())) + { + if record.stage_start.is_none() { + record.stage += 1; + gum::debug!( + target: LOG_TARGET, + stage = ?record.stage, + ?block_hash, + ?candidate, + "Started a new assignment gathering stage", + ); + record.stage_start = Some(Instant::now()); + } + } + } + + fn mark_gathered_enough_assignments( + &mut self, + block_number: BlockNumber, + block_hash: Hash, + candidate: CandidateHash, + ) -> AssignmentGatheringRecord { + let record = self + .per_block_assignments_gathering_times + .get(&block_number) + .and_then(|entry| entry.get_mut(&(block_hash, candidate))); + let stage = record.as_ref().map(|record| record.stage).unwrap_or_default(); + AssignmentGatheringRecord { + stage, + stage_start: record.and_then(|record| record.stage_start.take()), + } + } + + fn cleanup_assignments_gathering_timestamp(&mut self, remove_lower_than: BlockNumber) { + while let Some((block_number, _)) = self.per_block_assignments_gathering_times.peek_oldest() + { + if *block_number < remove_lower_than { + self.per_block_assignments_gathering_times.pop_oldest(); + } else { + break + } + } + } + + fn observe_assignment_gathering_status( + &mut self, + metrics: &Metrics, + required_tranches: &RequiredTranches, + block_hash: Hash, + block_number: BlockNumber, + candidate_hash: CandidateHash, + ) { + match required_tranches { + RequiredTranches::All | RequiredTranches::Pending { .. } => { + self.mark_begining_of_gathering_assignments( + block_number, + block_hash, + candidate_hash, + ); + }, + RequiredTranches::Exact { .. } => { + let time_to_gather = + self.mark_gathered_enough_assignments(block_number, block_hash, candidate_hash); + if let Some(gathering_started) = time_to_gather.stage_start { + if gathering_started.elapsed().as_millis() > 6000 { + gum::trace!( + target: LOG_TARGET, + ?block_hash, + ?candidate_hash, + "Long assignment gathering time", + ); + } + metrics.observe_assignment_gathering_time( + time_to_gather.stage, + gathering_started.elapsed().as_millis() as usize, + ) + } + }, + } + } + + fn record_no_shows( + &mut self, + session_index: SessionIndex, + para_id: u32, + no_show_validators: &Vec, + ) { + if !no_show_validators.is_empty() { + *self.no_show_stats.per_parachain_no_show.entry(para_id.into()).or_default() += 1; + } + for validator_index in no_show_validators { + *self + .no_show_stats + .per_validator_no_show + .entry(session_index) + .or_default() + .entry(*validator_index) + .or_default() += 1; + } + } } #[derive(Debug, Clone)] @@ -914,6 +1135,7 @@ enum Action { candidate: CandidateReceipt, backing_group: GroupIndex, distribute_assignment: bool, + core_index: Option, }, NoteApprovedInChainSelection(Hash), IssueApproval(CandidateHash, ApprovalVoteRequest), @@ -941,6 +1163,10 @@ where clock: subsystem.clock, assignment_criteria, spans: HashMap::new(), + per_block_assignments_gathering_times: LruMap::new(ByLength::new( + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS, + )), + no_show_stats: NoShowStats::default(), }; // `None` on start-up. Gets initialized/updated on leaf update @@ -972,7 +1198,7 @@ where subsystem.metrics.on_wakeup(); process_wakeup( &mut ctx, - &state, + &mut state, &mut overlayed_db, &mut session_info_provider, woken_block, @@ -1174,6 +1400,7 @@ async fn handle_actions( candidate, backing_group, distribute_assignment, + core_index, } => { // Don't launch approval work if the node is syncing. if let Mode::Syncing(_) = *mode { @@ -1230,6 +1457,7 @@ async fn handle_actions( block_hash, backing_group, executor_params, + core_index, &launch_approval_span, ) .await @@ -1467,6 +1695,7 @@ async fn distribution_messages_for_activation( candidate: candidate_entry.candidate_receipt().clone(), backing_group: approval_entry.backing_group(), distribute_assignment: false, + core_index: Some(*core_index), }); } }, @@ -1582,6 +1811,8 @@ async fn handle_from_overseer( "Imported new block.", ); + state.no_show_stats.maybe_print(block_batch.block_number); + for (c_hash, c_entry) in block_batch.imported_candidates { metrics.on_candidate_imported(); @@ -1628,6 +1859,7 @@ async fn handle_from_overseer( // `prune_finalized_wakeups` prunes all finalized block hashes. We prune spans // accordingly. wakeups.prune_finalized_wakeups(block_number, &mut state.spans); + state.cleanup_assignments_gathering_timestamp(block_number); // // `prune_finalized_wakeups` prunes all finalized block hashes. We prune spans // accordingly. let hash_set = @@ -2474,7 +2706,7 @@ where async fn check_and_import_approval( sender: &mut Sender, - state: &State, + state: &mut State, db: &mut OverlayedBackend<'_, impl Backend>, session_info_provider: &mut RuntimeInfo, metrics: &Metrics, @@ -2706,7 +2938,7 @@ impl ApprovalStateTransition { // as necessary and schedules any further wakeups. async fn advance_approval_state( sender: &mut Sender, - state: &State, + state: &mut State, db: &mut OverlayedBackend<'_, impl Backend>, session_info_provider: &mut RuntimeInfo, metrics: &Metrics, @@ -2745,7 +2977,8 @@ where let mut actions = Vec::new(); let block_hash = block_entry.block_hash(); let block_number = block_entry.block_number(); - + let session_index = block_entry.session(); + let para_id = candidate_entry.candidate_receipt().descriptor().para_id; let tick_now = state.clock.tick_now(); let (is_approved, status) = if let Some((approval_entry, status)) = state @@ -2757,6 +2990,13 @@ where approval_entry, status.required_tranches.clone(), ); + state.observe_assignment_gathering_status( + &metrics, + &status.required_tranches, + block_hash, + block_entry.block_number(), + candidate_hash, + ); // Check whether this is approved, while allowing a maximum // assignment tick of `now - APPROVAL_DELAY` - that is, that @@ -2834,7 +3074,9 @@ where if is_approved { approval_entry.mark_approved(); } - + if newly_approved { + state.record_no_shows(session_index, para_id.into(), &status.no_show_validators); + } actions.extend(schedule_wakeup_action( &approval_entry, block_hash, @@ -2937,7 +3179,7 @@ fn should_trigger_assignment( #[overseer::contextbounds(ApprovalVoting, prefix = self::overseer)] async fn process_wakeup( ctx: &mut Context, - state: &State, + state: &mut State, db: &mut OverlayedBackend<'_, impl Backend>, session_info_provider: &mut RuntimeInfo, relay_block: Hash, @@ -3050,6 +3292,11 @@ async fn process_wakeup( "Launching approval work.", ); + let candidate_core_index = block_entry + .candidates() + .iter() + .find_map(|(core_index, h)| (h == &candidate_hash).then_some(*core_index)); + if let Some(claimed_core_indices) = get_assignment_core_indices(&indirect_cert.cert.kind, &candidate_hash, &block_entry) { @@ -3062,7 +3309,6 @@ async fn process_wakeup( true }; db.write_block_entry(block_entry.clone()); - actions.push(Action::LaunchApproval { claimed_candidate_indices, candidate_hash, @@ -3074,10 +3320,12 @@ async fn process_wakeup( candidate: candidate_receipt, backing_group, distribute_assignment, + core_index: candidate_core_index, }); }, Err(err) => { - // Never happens, it should only happen if no cores are claimed, which is a bug. + // Never happens, it should only happen if no cores are claimed, which is a + // bug. gum::warn!( target: LOG_TARGET, block_hash = ?relay_block, @@ -3133,6 +3381,7 @@ async fn launch_approval( block_hash: Hash, backing_group: GroupIndex, executor_params: ExecutorParams, + core_index: Option, span: &jaeger::Span, ) -> SubsystemResult> { let (a_tx, a_rx) = oneshot::channel(); @@ -3179,6 +3428,7 @@ async fn launch_approval( candidate.clone(), session_index, Some(backing_group), + core_index, a_tx, )) .await; diff --git a/polkadot/node/core/approval-voting/src/persisted_entries.rs b/polkadot/node/core/approval-voting/src/persisted_entries.rs index 6eeb99cb99ffa017492dba93e72556eab9104c8e..59a4618100515a179a3cdc8b72aee41024ff0bbb 100644 --- a/polkadot/node/core/approval-voting/src/persisted_entries.rs +++ b/polkadot/node/core/approval-voting/src/persisted_entries.rs @@ -559,7 +559,7 @@ impl BlockEntry { self.distributed_assignments.resize(new_len, false); self.distributed_assignments |= bitfield; - // If the an operation did not change our current bitfied, we return true. + // If the an operation did not change our current bitfield, we return true. let distributed = total_one_bits == self.distributed_assignments.count_ones(); distributed diff --git a/polkadot/node/core/approval-voting/src/tests.rs b/polkadot/node/core/approval-voting/src/tests.rs index 312d805bbefb7b2b2605093fa2cadde0a1f10511..b912449baa4dcf55a5b22ae5a0e3dd33e6a10847 100644 --- a/polkadot/node/core/approval-voting/src/tests.rs +++ b/polkadot/node/core/approval-voting/src/tests.rs @@ -17,6 +17,10 @@ use self::test_helpers::mock::new_leaf; use super::*; use crate::backend::V1ReadBackend; +use overseer::prometheus::{ + prometheus::{IntCounter, IntCounterVec}, + Histogram, HistogramOpts, HistogramVec, Opts, +}; use polkadot_node_primitives::{ approval::{ v1::{ @@ -40,7 +44,7 @@ use polkadot_primitives::{ ApprovalVote, CandidateCommitments, CandidateEvent, CoreIndex, GroupIndex, Header, Id as ParaId, IndexedVec, NodeFeatures, ValidationCode, ValidatorSignature, }; -use std::time::Duration; +use std::{cmp::max, time::Duration}; use assert_matches::assert_matches; use async_trait::async_trait; @@ -64,7 +68,7 @@ use super::{ }, }; -use ::test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig}; +use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_candidate_receipt_bad_sig}; const SLOT_DURATION_MILLIS: u64 = 5000; @@ -459,7 +463,8 @@ fn sign_approval_multiple_candidates( .into() } -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; #[derive(Default)] struct HarnessConfigBuilder { @@ -538,17 +543,14 @@ fn test_harness>( config: HarnessConfig, test: impl FnOnce(TestHarness) -> T, ) { - let _ = env_logger::builder() - .is_test(true) - .filter(Some("polkadot_node_core_approval_voting"), log::LevelFilter::Trace) - .filter(Some(LOG_TARGET), log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let HarnessConfig { sync_oracle, sync_oracle_handle, clock, backend, assignment_criteria } = config; let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool); let keystore = LocalKeystore::in_memory(); let _ = keystore.sr25519_generate_new( @@ -3330,7 +3332,7 @@ async fn recover_available_data(virtual_overseer: &mut VirtualOverseer) { assert_matches!( virtual_overseer.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Ok(available_data)).unwrap(); }, @@ -5049,3 +5051,235 @@ fn subsystem_sends_pending_approvals_on_approval_restart() { virtual_overseer }); } + +// Test we correctly update the timer when we mark the beginning of gathering assignments. +#[test] +fn test_gathering_assignments_statements() { + let mut state = State { + keystore: Arc::new(LocalKeystore::in_memory()), + slot_duration_millis: 6_000, + clock: Box::new(MockClock::default()), + assignment_criteria: Box::new(MockAssignmentCriteria::check_only(|_| Ok(0))), + spans: HashMap::new(), + per_block_assignments_gathering_times: LruMap::new(ByLength::new( + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS, + )), + no_show_stats: NoShowStats::default(), + }; + + for i in 0..200i32 { + state.mark_begining_of_gathering_assignments( + i as u32, + Hash::repeat_byte(i as u8), + CandidateHash(Hash::repeat_byte(i as u8)), + ); + assert!( + state.per_block_assignments_gathering_times.len() <= + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as usize + ); + + assert_eq!( + state + .per_block_assignments_gathering_times + .iter() + .map(|(block_number, _)| block_number) + .min(), + Some(max(0, i - MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as i32 + 1) as u32).as_ref() + ) + } + assert_eq!( + state.per_block_assignments_gathering_times.len(), + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS as usize + ); + + let nothing_changes = state + .per_block_assignments_gathering_times + .iter() + .map(|(block_number, _)| *block_number) + .sorted() + .collect::>(); + + for i in 150..200i32 { + state.mark_begining_of_gathering_assignments( + i as u32, + Hash::repeat_byte(i as u8), + CandidateHash(Hash::repeat_byte(i as u8)), + ); + assert_eq!( + nothing_changes, + state + .per_block_assignments_gathering_times + .iter() + .map(|(block_number, _)| *block_number) + .sorted() + .collect::>() + ); + } + + for i in 110..120 { + let block_hash = Hash::repeat_byte(i as u8); + let candidate_hash = CandidateHash(Hash::repeat_byte(i as u8)); + + state.mark_gathered_enough_assignments(i as u32, block_hash, candidate_hash); + + assert!(state + .per_block_assignments_gathering_times + .get(&i) + .unwrap() + .get(&(block_hash, candidate_hash)) + .unwrap() + .stage_start + .is_none()); + state.mark_begining_of_gathering_assignments(i as u32, block_hash, candidate_hash); + let record = state + .per_block_assignments_gathering_times + .get(&i) + .unwrap() + .get(&(block_hash, candidate_hash)) + .unwrap(); + + assert!(record.stage_start.is_some()); + assert_eq!(record.stage, 1); + } + + state.cleanup_assignments_gathering_timestamp(200); + assert_eq!(state.per_block_assignments_gathering_times.len(), 0); +} + +// Test we note the time we took to transition RequiredTranche from Pending to Exact and +// that we increase the stage when we transition from Exact to Pending. +#[test] +fn test_observe_assignment_gathering_status() { + let mut state = State { + keystore: Arc::new(LocalKeystore::in_memory()), + slot_duration_millis: 6_000, + clock: Box::new(MockClock::default()), + assignment_criteria: Box::new(MockAssignmentCriteria::check_only(|_| Ok(0))), + spans: HashMap::new(), + per_block_assignments_gathering_times: LruMap::new(ByLength::new( + MAX_BLOCKS_WITH_ASSIGNMENT_TIMESTAMPS, + )), + no_show_stats: NoShowStats::default(), + }; + + let metrics_inner = MetricsInner { + imported_candidates_total: IntCounter::new("dummy", "dummy").unwrap(), + assignments_produced: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")).unwrap(), + approvals_produced_total: IntCounterVec::new(Opts::new("dummy", "dummy"), &["dummy"]) + .unwrap(), + no_shows_total: IntCounter::new("dummy", "dummy").unwrap(), + observed_no_shows: IntCounter::new("dummy", "dummy").unwrap(), + approved_by_one_third: IntCounter::new("dummy", "dummy").unwrap(), + wakeups_triggered_total: IntCounter::new("dummy", "dummy").unwrap(), + coalesced_approvals_buckets: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")) + .unwrap(), + coalesced_approvals_delay: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")) + .unwrap(), + candidate_approval_time_ticks: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")) + .unwrap(), + block_approval_time_ticks: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")) + .unwrap(), + time_db_transaction: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")).unwrap(), + time_recover_and_approve: Histogram::with_opts(HistogramOpts::new("dummy", "dummy")) + .unwrap(), + candidate_signatures_requests_total: IntCounter::new("dummy", "dummy").unwrap(), + unapproved_candidates_in_unfinalized_chain: prometheus::Gauge::::new( + "dummy", "dummy", + ) + .unwrap(), + assignments_gathering_time_by_stage: HistogramVec::new( + HistogramOpts::new("test", "test"), + &["stage"], + ) + .unwrap(), + }; + + let metrics = Metrics(Some(metrics_inner)); + let block_hash = Hash::repeat_byte(1); + let candidate_hash = CandidateHash(Hash::repeat_byte(1)); + let block_number = 1; + + // Transition from Pending to Exact and check stage 0 time is recorded. + state.observe_assignment_gathering_status( + &metrics, + &RequiredTranches::Pending { + considered: 0, + next_no_show: None, + maximum_broadcast: 0, + clock_drift: 0, + }, + block_hash, + block_number, + candidate_hash, + ); + + state.observe_assignment_gathering_status( + &metrics, + &RequiredTranches::Exact { + needed: 2, + tolerated_missing: 2, + next_no_show: None, + last_assignment_tick: None, + }, + block_hash, + block_number, + candidate_hash, + ); + + let value = metrics + .0 + .as_ref() + .unwrap() + .assignments_gathering_time_by_stage + .get_metric_with_label_values(&["0"]) + .unwrap(); + + assert_eq!(value.get_sample_count(), 1); + + // Transition from Exact to Pending to Exact and check stage 1 time is recorded. + state.observe_assignment_gathering_status( + &metrics, + &RequiredTranches::Pending { + considered: 0, + next_no_show: None, + maximum_broadcast: 0, + clock_drift: 0, + }, + block_hash, + block_number, + candidate_hash, + ); + + state.observe_assignment_gathering_status( + &metrics, + &RequiredTranches::Exact { + needed: 2, + tolerated_missing: 2, + next_no_show: None, + last_assignment_tick: None, + }, + block_hash, + block_number, + candidate_hash, + ); + + let value = metrics + .0 + .as_ref() + .unwrap() + .assignments_gathering_time_by_stage + .get_metric_with_label_values(&["0"]) + .unwrap(); + + assert_eq!(value.get_sample_count(), 1); + + let value = metrics + .0 + .as_ref() + .unwrap() + .assignments_gathering_time_by_stage + .get_metric_with_label_values(&["1"]) + .unwrap(); + + assert_eq!(value.get_sample_count(), 1); +} diff --git a/polkadot/node/core/av-store/Cargo.toml b/polkadot/node/core/av-store/Cargo.toml index bc9b979228a1db8c4adfc01bd2d60470721bfcac..c867180e541bbf013cc874450e132c08f87981a5 100644 --- a/polkadot/node/core/av-store/Cargo.toml +++ b/polkadot/node/core/av-store/Cargo.toml @@ -10,32 +10,32 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -kvdb = "0.13.0" +futures = { workspace = true } +futures-timer = { workspace = true } +kvdb = { workspace = true } thiserror = { workspace = true } -gum = { package = "tracing-gum", path = "../../gum" } -bitvec = "1.0.0" +gum = { workspace = true, default-features = true } +bitvec = { workspace = true, default-features = true } -parity-scale-codec = { version = "3.6.1", features = ["derive"] } -erasure = { package = "polkadot-erasure-coding", path = "../../../erasure-coding" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-overseer = { path = "../../overseer" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common", default-features = false } -polkadot-node-jaeger = { path = "../../jaeger" } +codec = { features = ["derive"], workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +sp-consensus = { workspace = true } +polkadot-node-jaeger = { workspace = true, default-features = true } [dev-dependencies] log = { workspace = true, default-features = true } -env_logger = "0.11" -assert_matches = "1.4.0" -kvdb-memorydb = "0.13.0" +assert_matches = { workspace = true } +kvdb-memorydb = { workspace = true } +sp-tracing = { workspace = true } -sp-core = { path = "../../../../substrate/primitives/core" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -parking_lot = "0.12.1" -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +sp-core = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/core/av-store/src/lib.rs b/polkadot/node/core/av-store/src/lib.rs index 68db4686a9740bb052f7d05031d148cd5b05e0a2..7b245c9e3c52f88d39ebe7d8252f1db128edcaca 100644 --- a/polkadot/node/core/av-store/src/lib.rs +++ b/polkadot/node/core/av-store/src/lib.rs @@ -26,6 +26,7 @@ use std::{ time::{Duration, SystemTime, SystemTimeError, UNIX_EPOCH}, }; +use codec::{Decode, Encode, Error as CodecError, Input}; use futures::{ channel::{ mpsc::{channel, Receiver as MpscReceiver, Sender as MpscSender}, @@ -34,7 +35,6 @@ use futures::{ future, select, FutureExt, SinkExt, StreamExt, }; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode, Error as CodecError, Input}; use polkadot_node_subsystem_util::database::{DBTransaction, Database}; use sp_consensus::SyncOracle; @@ -48,8 +48,10 @@ use polkadot_node_subsystem::{ }; use polkadot_node_subsystem_util as util; use polkadot_primitives::{ - BlockNumber, CandidateEvent, CandidateHash, CandidateReceipt, Hash, Header, ValidatorIndex, + BlockNumber, CandidateEvent, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex, Hash, + Header, NodeFeatures, ValidatorIndex, }; +use util::availability_chunks::availability_chunk_indices; mod metrics; pub use self::metrics::*; @@ -208,9 +210,9 @@ fn load_chunk( db: &Arc, config: &Config, candidate_hash: &CandidateHash, - chunk_index: ValidatorIndex, + validator_index: ValidatorIndex, ) -> Result, Error> { - let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode(); + let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode(); query_inner(db, config.col_data, &key) } @@ -219,10 +221,10 @@ fn write_chunk( tx: &mut DBTransaction, config: &Config, candidate_hash: &CandidateHash, - chunk_index: ValidatorIndex, + validator_index: ValidatorIndex, erasure_chunk: &ErasureChunk, ) { - let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode(); + let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode(); tx.put_vec(config.col_data, &key, erasure_chunk.encode()); } @@ -231,9 +233,9 @@ fn delete_chunk( tx: &mut DBTransaction, config: &Config, candidate_hash: &CandidateHash, - chunk_index: ValidatorIndex, + validator_index: ValidatorIndex, ) { - let key = (CHUNK_PREFIX, candidate_hash, chunk_index).encode(); + let key = (CHUNK_PREFIX, candidate_hash, validator_index).encode(); tx.delete(config.col_data, &key[..]); } @@ -352,7 +354,7 @@ pub enum Error { ChainApi(#[from] ChainApiError), #[error(transparent)] - Erasure(#[from] erasure::Error), + Erasure(#[from] polkadot_erasure_coding::Error), #[error(transparent)] Io(#[from] io::Error), @@ -1139,20 +1141,23 @@ fn process_message( Some(meta) => { let mut chunks = Vec::new(); - for (index, _) in meta.chunks_stored.iter().enumerate().filter(|(_, b)| **b) { + for (validator_index, _) in + meta.chunks_stored.iter().enumerate().filter(|(_, b)| **b) + { + let validator_index = ValidatorIndex(validator_index as _); let _timer = subsystem.metrics.time_get_chunk(); match load_chunk( &subsystem.db, &subsystem.config, &candidate, - ValidatorIndex(index as _), + validator_index, )? { - Some(c) => chunks.push(c), + Some(c) => chunks.push((validator_index, c)), None => { gum::warn!( target: LOG_TARGET, ?candidate, - index, + ?validator_index, "No chunk found for set bit in meta" ); }, @@ -1169,11 +1174,17 @@ fn process_message( }); let _ = tx.send(a); }, - AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk, tx } => { + AvailabilityStoreMessage::StoreChunk { candidate_hash, validator_index, chunk, tx } => { subsystem.metrics.on_chunks_received(1); let _timer = subsystem.metrics.time_store_chunk(); - match store_chunk(&subsystem.db, &subsystem.config, candidate_hash, chunk) { + match store_chunk( + &subsystem.db, + &subsystem.config, + candidate_hash, + validator_index, + chunk, + ) { Ok(true) => { let _ = tx.send(Ok(())); }, @@ -1191,6 +1202,8 @@ fn process_message( n_validators, available_data, expected_erasure_root, + core_index, + node_features, tx, } => { subsystem.metrics.on_chunks_received(n_validators as _); @@ -1203,6 +1216,8 @@ fn process_message( n_validators as _, available_data, expected_erasure_root, + core_index, + node_features, ); match res { @@ -1233,6 +1248,7 @@ fn store_chunk( db: &Arc, config: &Config, candidate_hash: CandidateHash, + validator_index: ValidatorIndex, chunk: ErasureChunk, ) -> Result { let mut tx = DBTransaction::new(); @@ -1242,12 +1258,12 @@ fn store_chunk( None => return Ok(false), // we weren't informed of this candidate by import events. }; - match meta.chunks_stored.get(chunk.index.0 as usize).map(|b| *b) { + match meta.chunks_stored.get(validator_index.0 as usize).map(|b| *b) { Some(true) => return Ok(true), // already stored. Some(false) => { - meta.chunks_stored.set(chunk.index.0 as usize, true); + meta.chunks_stored.set(validator_index.0 as usize, true); - write_chunk(&mut tx, config, &candidate_hash, chunk.index, &chunk); + write_chunk(&mut tx, config, &candidate_hash, validator_index, &chunk); write_meta(&mut tx, config, &candidate_hash, &meta); }, None => return Ok(false), // out of bounds. @@ -1257,6 +1273,7 @@ fn store_chunk( target: LOG_TARGET, ?candidate_hash, chunk_index = %chunk.index.0, + validator_index = %validator_index.0, "Stored chunk index for candidate.", ); @@ -1264,13 +1281,14 @@ fn store_chunk( Ok(true) } -// Ok(true) on success, Ok(false) on failure, and Err on internal error. fn store_available_data( subsystem: &AvailabilityStoreSubsystem, candidate_hash: CandidateHash, n_validators: usize, available_data: AvailableData, expected_erasure_root: Hash, + core_index: CoreIndex, + node_features: NodeFeatures, ) -> Result<(), Error> { let mut tx = DBTransaction::new(); @@ -1303,8 +1321,8 @@ fn store_available_data( // Important note: This check below is critical for consensus and the `backing` subsystem relies // on it to ensure candidate validity. - let chunks = erasure::obtain_chunks_v1(n_validators, &available_data)?; - let branches = erasure::branches(chunks.as_ref()); + let chunks = polkadot_erasure_coding::obtain_chunks_v1(n_validators, &available_data)?; + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); if branches.root() != expected_erasure_root { return Err(Error::InvalidErasureRoot) @@ -1312,16 +1330,26 @@ fn store_available_data( drop(erasure_span); - let erasure_chunks = chunks.iter().zip(branches.map(|(proof, _)| proof)).enumerate().map( - |(index, (chunk, proof))| ErasureChunk { + let erasure_chunks: Vec<_> = chunks + .iter() + .zip(branches.map(|(proof, _)| proof)) + .enumerate() + .map(|(index, (chunk, proof))| ErasureChunk { chunk: chunk.clone(), proof, - index: ValidatorIndex(index as u32), - }, - ); + index: ChunkIndex(index as u32), + }) + .collect(); - for chunk in erasure_chunks { - write_chunk(&mut tx, &subsystem.config, &candidate_hash, chunk.index, &chunk); + let chunk_indices = availability_chunk_indices(Some(&node_features), n_validators, core_index)?; + for (validator_index, chunk_index) in chunk_indices.into_iter().enumerate() { + write_chunk( + &mut tx, + &subsystem.config, + &candidate_hash, + ValidatorIndex(validator_index as u32), + &erasure_chunks[chunk_index.0 as usize], + ); } meta.data_available = true; diff --git a/polkadot/node/core/av-store/src/tests.rs b/polkadot/node/core/av-store/src/tests.rs index 652bf2a3fda4822fdae0020bcd48993ed8e771ed..958917a3104fdb3101b6bb81a63e8370a73474f9 100644 --- a/polkadot/node/core/av-store/src/tests.rs +++ b/polkadot/node/core/av-store/src/tests.rs @@ -18,9 +18,9 @@ use super::*; use assert_matches::assert_matches; use futures::{channel::oneshot, executor, future, Future}; +use util::availability_chunks::availability_chunk_index; use self::test_helpers::mock::new_leaf; -use ::test_helpers::TestCandidateBuilder; use parking_lot::Mutex; use polkadot_node_primitives::{AvailableData, BlockData, PoV, Proof}; use polkadot_node_subsystem::{ @@ -31,9 +31,10 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_node_subsystem_util::{database::Database, TimeoutExt}; use polkadot_primitives::{ - CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, HeadData, Header, + node_features, CandidateHash, CandidateReceipt, CoreIndex, GroupIndex, HeadData, Header, PersistedValidationData, ValidatorId, }; +use polkadot_primitives_test_helpers::TestCandidateBuilder; use sp_keyring::Sr25519Keyring; mod columns { @@ -44,7 +45,8 @@ mod columns { const TEST_CONFIG: Config = Config { col_data: columns::DATA, col_meta: columns::META }; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; #[derive(Clone)] struct TestClock { @@ -120,14 +122,11 @@ fn test_harness>( store: Arc, test: impl FnOnce(VirtualOverseer) -> T, ) { - let _ = env_logger::builder() - .is_test(true) - .filter(Some("polkadot_node_core_av_store"), log::LevelFilter::Trace) - .filter(Some(LOG_TARGET), log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = AvailabilityStoreSubsystem::with_pruning_config_and_clock( store, @@ -272,8 +271,7 @@ fn runtime_api_error_does_not_stop_the_subsystem() { // but that's fine, we're still alive let (tx, rx) = oneshot::channel(); let candidate_hash = CandidateHash(Hash::repeat_byte(33)); - let validator_index = ValidatorIndex(5); - let query_chunk = AvailabilityStoreMessage::QueryChunk(candidate_hash, validator_index, tx); + let query_chunk = AvailabilityStoreMessage::QueryChunk(candidate_hash, 5.into(), tx); overseer_send(&mut virtual_overseer, query_chunk.into()).await; @@ -288,12 +286,13 @@ fn store_chunk_works() { test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move { let candidate_hash = CandidateHash(Hash::repeat_byte(33)); - let validator_index = ValidatorIndex(5); + let chunk_index = ChunkIndex(5); + let validator_index = ValidatorIndex(2); let n_validators = 10; let chunk = ErasureChunk { chunk: vec![1, 2, 3], - index: validator_index, + index: chunk_index, proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(), }; @@ -314,8 +313,12 @@ fn store_chunk_works() { let (tx, rx) = oneshot::channel(); - let chunk_msg = - AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx }; + let chunk_msg = AvailabilityStoreMessage::StoreChunk { + candidate_hash, + validator_index, + chunk: chunk.clone(), + tx, + }; overseer_send(&mut virtual_overseer, chunk_msg).await; assert_eq!(rx.await.unwrap(), Ok(())); @@ -336,18 +339,23 @@ fn store_chunk_does_nothing_if_no_entry_already() { test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move { let candidate_hash = CandidateHash(Hash::repeat_byte(33)); - let validator_index = ValidatorIndex(5); + let chunk_index = ChunkIndex(5); + let validator_index = ValidatorIndex(2); let chunk = ErasureChunk { chunk: vec![1, 2, 3], - index: validator_index, + index: chunk_index, proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(), }; let (tx, rx) = oneshot::channel(); - let chunk_msg = - AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx }; + let chunk_msg = AvailabilityStoreMessage::StoreChunk { + candidate_hash, + validator_index, + chunk: chunk.clone(), + tx, + }; overseer_send(&mut virtual_overseer, chunk_msg).await; assert_eq!(rx.await.unwrap(), Err(())); @@ -418,6 +426,8 @@ fn store_available_data_erasure_mismatch() { let candidate_hash = CandidateHash(Hash::repeat_byte(1)); let validator_index = ValidatorIndex(5); let n_validators = 10; + let core_index = CoreIndex(8); + let node_features = NodeFeatures::EMPTY; let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; @@ -431,6 +441,8 @@ fn store_available_data_erasure_mismatch() { candidate_hash, n_validators, available_data: available_data.clone(), + core_index, + node_features, tx, // A dummy erasure root should lead to failure. expected_erasure_root: Hash::default(), @@ -450,97 +462,187 @@ fn store_available_data_erasure_mismatch() { } #[test] -fn store_block_works() { - let store = test_store(); - let test_state = TestState::default(); - test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move { - let candidate_hash = CandidateHash(Hash::repeat_byte(1)); - let validator_index = ValidatorIndex(5); - let n_validators = 10; - - let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; - - let available_data = AvailableData { - pov: Arc::new(pov), - validation_data: test_state.persisted_validation_data.clone(), - }; - let (tx, rx) = oneshot::channel(); - - let chunks = erasure::obtain_chunks_v1(10, &available_data).unwrap(); - let mut branches = erasure::branches(chunks.as_ref()); - - let block_msg = AvailabilityStoreMessage::StoreAvailableData { - candidate_hash, - n_validators, - available_data: available_data.clone(), - tx, - expected_erasure_root: branches.root(), - }; - - virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await; - assert_eq!(rx.await.unwrap(), Ok(())); - - let pov = query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap(); - assert_eq!(pov, available_data); - - let chunk = query_chunk(&mut virtual_overseer, candidate_hash, validator_index) - .await - .unwrap(); - - let branch = branches.nth(5).unwrap(); - let expected_chunk = ErasureChunk { - chunk: branch.1.to_vec(), - index: ValidatorIndex(5), - proof: Proof::try_from(branch.0).unwrap(), - }; - - assert_eq!(chunk, expected_chunk); - virtual_overseer - }); -} - -#[test] -fn store_pov_and_query_chunk_works() { - let store = test_store(); - let test_state = TestState::default(); - - test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move { - let candidate_hash = CandidateHash(Hash::repeat_byte(1)); - let n_validators = 10; - - let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; - - let available_data = AvailableData { - pov: Arc::new(pov), - validation_data: test_state.persisted_validation_data.clone(), - }; - - let chunks_expected = - erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); - let branches = erasure::branches(chunks_expected.as_ref()); - - let (tx, rx) = oneshot::channel(); - let block_msg = AvailabilityStoreMessage::StoreAvailableData { - candidate_hash, - n_validators, - available_data, - tx, - expected_erasure_root: branches.root(), - }; - - virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await; +fn store_pov_and_queries_work() { + // If the AvailabilityChunkMapping feature is not enabled, + // ValidatorIndex->ChunkIndex mapping should be 1:1 for all core indices. + { + let n_cores = 4; + for core_index in 0..n_cores { + let store = test_store(); + let test_state = TestState::default(); + let core_index = CoreIndex(core_index); + + test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move { + let node_features = NodeFeatures::EMPTY; + let candidate_hash = CandidateHash(Hash::repeat_byte(1)); + let n_validators = 10; + + let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; + let available_data = AvailableData { + pov: Arc::new(pov), + validation_data: test_state.persisted_validation_data.clone(), + }; + + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data) + .unwrap(); + + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); + + let (tx, rx) = oneshot::channel(); + let block_msg = AvailabilityStoreMessage::StoreAvailableData { + candidate_hash, + n_validators, + available_data: available_data.clone(), + tx, + core_index, + expected_erasure_root: branches.root(), + node_features: node_features.clone(), + }; + + virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await; + assert_eq!(rx.await.unwrap(), Ok(())); + + let pov: AvailableData = + query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap(); + assert_eq!(pov, available_data); + + let query_all_chunks_res = query_all_chunks( + &mut virtual_overseer, + availability_chunk_indices( + Some(&node_features), + n_validators as usize, + core_index, + ) + .unwrap(), + candidate_hash, + ) + .await; + assert_eq!(query_all_chunks_res.len(), chunks.len()); + + let branches: Vec<_> = branches.collect(); + + for validator_index in 0..n_validators { + let chunk = query_chunk( + &mut virtual_overseer, + candidate_hash, + ValidatorIndex(validator_index as _), + ) + .await + .unwrap(); + let branch = &branches[validator_index as usize]; + let expected_chunk = ErasureChunk { + chunk: branch.1.to_vec(), + index: validator_index.into(), + proof: Proof::try_from(branch.0.clone()).unwrap(), + }; + assert_eq!(chunk, expected_chunk); + assert_eq!(chunk, query_all_chunks_res[validator_index as usize]); + } - assert_eq!(rx.await.unwrap(), Ok(())); + virtual_overseer + }); + } + } - for i in 0..n_validators { - let chunk = query_chunk(&mut virtual_overseer, candidate_hash, ValidatorIndex(i as _)) - .await - .unwrap(); + // If the AvailabilityChunkMapping feature is enabled, let's also test the + // ValidatorIndex -> ChunkIndex mapping. + { + let n_cores = 4; + for core_index in 0..n_cores { + let store = test_store(); + let test_state = TestState::default(); + + test_harness(test_state.clone(), store.clone(), |mut virtual_overseer| async move { + let mut node_features = NodeFeatures::EMPTY; + let feature_bit = node_features::FeatureIndex::AvailabilityChunkMapping; + node_features.resize((feature_bit as u8 + 1) as usize, false); + node_features.set(feature_bit as u8 as usize, true); + + let candidate_hash = CandidateHash(Hash::repeat_byte(1)); + let n_validators = 10; + + let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; + let available_data = AvailableData { + pov: Arc::new(pov), + validation_data: test_state.persisted_validation_data.clone(), + }; + + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data) + .unwrap(); + + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); + let core_index = CoreIndex(core_index); + + let (tx, rx) = oneshot::channel(); + let block_msg = AvailabilityStoreMessage::StoreAvailableData { + candidate_hash, + n_validators, + available_data: available_data.clone(), + tx, + core_index, + expected_erasure_root: branches.root(), + node_features: node_features.clone(), + }; + + virtual_overseer.send(FromOrchestra::Communication { msg: block_msg }).await; + assert_eq!(rx.await.unwrap(), Ok(())); + + let pov: AvailableData = + query_available_data(&mut virtual_overseer, candidate_hash).await.unwrap(); + assert_eq!(pov, available_data); + + let query_all_chunks_res = query_all_chunks( + &mut virtual_overseer, + availability_chunk_indices( + Some(&node_features), + n_validators as usize, + core_index, + ) + .unwrap(), + candidate_hash, + ) + .await; + assert_eq!(query_all_chunks_res.len(), chunks.len()); + + let branches: Vec<_> = branches.collect(); + + for validator_index in 0..n_validators { + let chunk = query_chunk( + &mut virtual_overseer, + candidate_hash, + ValidatorIndex(validator_index as _), + ) + .await + .unwrap(); + let expected_chunk_index = availability_chunk_index( + Some(&node_features), + n_validators as usize, + core_index, + ValidatorIndex(validator_index), + ) + .unwrap(); + let branch = &branches[expected_chunk_index.0 as usize]; + let expected_chunk = ErasureChunk { + chunk: branch.1.to_vec(), + index: expected_chunk_index, + proof: Proof::try_from(branch.0.clone()).unwrap(), + }; + assert_eq!(chunk, expected_chunk); + assert_eq!( + &chunk, + query_all_chunks_res + .iter() + .find(|c| c.index == expected_chunk_index) + .unwrap() + ); + } - assert_eq!(chunk.chunk, chunks_expected[i as usize]); + virtual_overseer + }); } - virtual_overseer - }); + } } #[test] @@ -567,14 +669,17 @@ fn query_all_chunks_works() { { let chunks_expected = - erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); - let branches = erasure::branches(chunks_expected.as_ref()); + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data) + .unwrap(); + let branches = polkadot_erasure_coding::branches(chunks_expected.as_ref()); let (tx, rx) = oneshot::channel(); let block_msg = AvailabilityStoreMessage::StoreAvailableData { candidate_hash: candidate_hash_1, n_validators, available_data, tx, + core_index: CoreIndex(1), + node_features: NodeFeatures::EMPTY, expected_erasure_root: branches.root(), }; @@ -598,7 +703,7 @@ fn query_all_chunks_works() { let chunk = ErasureChunk { chunk: vec![1, 2, 3], - index: ValidatorIndex(1), + index: ChunkIndex(1), proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(), }; @@ -606,6 +711,7 @@ fn query_all_chunks_works() { let store_chunk_msg = AvailabilityStoreMessage::StoreChunk { candidate_hash: candidate_hash_2, chunk, + validator_index: ValidatorIndex(1), tx, }; @@ -615,29 +721,29 @@ fn query_all_chunks_works() { assert_eq!(rx.await.unwrap(), Ok(())); } - { - let (tx, rx) = oneshot::channel(); - - let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_1, tx); - virtual_overseer.send(FromOrchestra::Communication { msg }).await; - assert_eq!(rx.await.unwrap().len(), n_validators as usize); - } - - { - let (tx, rx) = oneshot::channel(); + let chunk_indices = + availability_chunk_indices(None, n_validators as usize, CoreIndex(0)).unwrap(); - let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_2, tx); - virtual_overseer.send(FromOrchestra::Communication { msg }).await; - assert_eq!(rx.await.unwrap().len(), 1); - } + assert_eq!( + query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_1) + .await + .len(), + n_validators as usize + ); - { - let (tx, rx) = oneshot::channel(); + assert_eq!( + query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_2) + .await + .len(), + 1 + ); + assert_eq!( + query_all_chunks(&mut virtual_overseer, chunk_indices.clone(), candidate_hash_3) + .await + .len(), + 0 + ); - let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash_3, tx); - virtual_overseer.send(FromOrchestra::Communication { msg }).await; - assert_eq!(rx.await.unwrap().len(), 0); - } virtual_overseer }); } @@ -659,14 +765,17 @@ fn stored_but_not_included_data_is_pruned() { }; let (tx, rx) = oneshot::channel(); - let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); - let branches = erasure::branches(chunks.as_ref()); + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); let block_msg = AvailabilityStoreMessage::StoreAvailableData { candidate_hash, n_validators, available_data: available_data.clone(), tx, + node_features: NodeFeatures::EMPTY, + core_index: CoreIndex(1), expected_erasure_root: branches.root(), }; @@ -714,8 +823,9 @@ fn stored_data_kept_until_finalized() { let parent = Hash::repeat_byte(2); let block_number = 10; - let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); - let branches = erasure::branches(chunks.as_ref()); + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data).unwrap(); + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); let (tx, rx) = oneshot::channel(); let block_msg = AvailabilityStoreMessage::StoreAvailableData { @@ -723,6 +833,8 @@ fn stored_data_kept_until_finalized() { n_validators, available_data: available_data.clone(), tx, + node_features: NodeFeatures::EMPTY, + core_index: CoreIndex(1), expected_erasure_root: branches.root(), }; @@ -989,8 +1101,10 @@ fn forkfullness_works() { validation_data: test_state.persisted_validation_data.clone(), }; - let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data_1).unwrap(); - let branches = erasure::branches(chunks.as_ref()); + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data_1) + .unwrap(); + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); let (tx, rx) = oneshot::channel(); let msg = AvailabilityStoreMessage::StoreAvailableData { @@ -998,6 +1112,8 @@ fn forkfullness_works() { n_validators, available_data: available_data_1.clone(), tx, + node_features: NodeFeatures::EMPTY, + core_index: CoreIndex(1), expected_erasure_root: branches.root(), }; @@ -1005,8 +1121,10 @@ fn forkfullness_works() { rx.await.unwrap().unwrap(); - let chunks = erasure::obtain_chunks_v1(n_validators as _, &available_data_2).unwrap(); - let branches = erasure::branches(chunks.as_ref()); + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(n_validators as _, &available_data_2) + .unwrap(); + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); let (tx, rx) = oneshot::channel(); let msg = AvailabilityStoreMessage::StoreAvailableData { @@ -1014,6 +1132,8 @@ fn forkfullness_works() { n_validators, available_data: available_data_2.clone(), tx, + node_features: NodeFeatures::EMPTY, + core_index: CoreIndex(1), expected_erasure_root: branches.root(), }; @@ -1126,6 +1246,25 @@ async fn query_chunk( rx.await.unwrap() } +async fn query_all_chunks( + virtual_overseer: &mut VirtualOverseer, + chunk_mapping: Vec, + candidate_hash: CandidateHash, +) -> Vec { + let (tx, rx) = oneshot::channel(); + + let msg = AvailabilityStoreMessage::QueryAllChunks(candidate_hash, tx); + virtual_overseer.send(FromOrchestra::Communication { msg }).await; + + let resp = rx.await.unwrap(); + resp.into_iter() + .map(|(val_idx, chunk)| { + assert_eq!(chunk.index, chunk_mapping[val_idx.0 as usize]); + chunk + }) + .collect() +} + async fn has_all_chunks( virtual_overseer: &mut VirtualOverseer, candidate_hash: CandidateHash, @@ -1206,12 +1345,12 @@ fn query_chunk_size_works() { test_harness(TestState::default(), store.clone(), |mut virtual_overseer| async move { let candidate_hash = CandidateHash(Hash::repeat_byte(33)); - let validator_index = ValidatorIndex(5); + let chunk_index = ChunkIndex(5); let n_validators = 10; let chunk = ErasureChunk { chunk: vec![1, 2, 3], - index: validator_index, + index: chunk_index, proof: Proof::try_from(vec![vec![3, 4, 5]]).unwrap(), }; @@ -1232,8 +1371,12 @@ fn query_chunk_size_works() { let (tx, rx) = oneshot::channel(); - let chunk_msg = - AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk: chunk.clone(), tx }; + let chunk_msg = AvailabilityStoreMessage::StoreChunk { + candidate_hash, + chunk: chunk.clone(), + tx, + validator_index: chunk_index.into(), + }; overseer_send(&mut virtual_overseer, chunk_msg).await; assert_eq!(rx.await.unwrap(), Ok(())); diff --git a/polkadot/node/core/backing/Cargo.toml b/polkadot/node/core/backing/Cargo.toml index 26fa54470fbda6c1e5a22999a34022173b003fe6..1b52afc309bc9e301f879a720d253467a5359f13 100644 --- a/polkadot/node/core/backing/Cargo.toml +++ b/polkadot/node/core/backing/Cargo.toml @@ -10,28 +10,28 @@ description = "The Candidate Backing Subsystem. Tracks parachain candidates that workspace = true [dependencies] -futures = "0.3.30" -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -erasure-coding = { package = "polkadot-erasure-coding", path = "../../../erasure-coding" } -statement-table = { package = "polkadot-statement-table", path = "../../../statement-table" } -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -gum = { package = "tracing-gum", path = "../../gum" } +futures = { workspace = true } +sp-keystore = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-statement-table = { workspace = true, default-features = true } +bitvec = { features = ["alloc"], workspace = true } +gum = { workspace = true, default-features = true } thiserror = { workspace = true } -fatality = "0.0.6" -schnellru = "0.2.1" +fatality = { workspace = true } +schnellru = { workspace = true } [dev-dependencies] -sp-core = { path = "../../../../substrate/primitives/core" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -futures = { version = "0.3.30", features = ["thread-pool"] } -assert_matches = "1.4.0" -rstest = "0.18.2" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +sp-core = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +futures = { features = ["thread-pool"], workspace = true } +assert_matches = { workspace = true } +rstest = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/core/backing/src/error.rs b/polkadot/node/core/backing/src/error.rs index 52684f3fe3063e95dcab48947cf86ca62c321372..568f7140264457af301776f9fb3f5641ef312a07 100644 --- a/polkadot/node/core/backing/src/error.rs +++ b/polkadot/node/core/backing/src/error.rs @@ -88,7 +88,7 @@ pub enum Error { JoinMultiple(#[source] oneshot::Canceled), #[error("Obtaining erasure chunks failed")] - ObtainErasureChunks(#[from] erasure_coding::Error), + ObtainErasureChunks(#[from] polkadot_erasure_coding::Error), #[error(transparent)] ValidationFailed(#[from] ValidationFailed), diff --git a/polkadot/node/core/backing/src/lib.rs b/polkadot/node/core/backing/src/lib.rs index 23acb0450944e8eedea437da545830174ed84449..f276321c87ed08f2f0d9f5e67901b7ce8492d4c5 100644 --- a/polkadot/node/core/backing/src/lib.rs +++ b/polkadot/node/core/backing/src/lib.rs @@ -30,7 +30,7 @@ //! assigned group of validators may be backed on-chain and proceed to the availability //! stage. //! -//! Depth is a concept relating to asynchronous backing, by which validators +//! Depth is a concept relating to asynchronous backing, by which //! short sub-chains of candidates are backed and extended off-chain, and then placed //! asynchronously into blocks of the relay chain as those are authored and as the //! relay-chain state becomes ready for them. Asynchronous backing allows parachains to @@ -66,7 +66,7 @@ #![deny(unused_crate_dependencies)] use std::{ - collections::{BTreeMap, HashMap, HashSet}, + collections::{HashMap, HashSet}, sync::Arc, }; @@ -88,7 +88,7 @@ use polkadot_node_subsystem::{ messages::{ AvailabilityDistributionMessage, AvailabilityStoreMessage, CanSecondRequest, CandidateBackingMessage, CandidateValidationMessage, CollatorProtocolMessage, - HypotheticalCandidate, HypotheticalFrontierRequest, IntroduceCandidateRequest, + HypotheticalCandidate, HypotheticalMembershipRequest, IntroduceSecondedCandidateRequest, ProspectiveParachainsMessage, ProvisionableData, ProvisionerMessage, RuntimeApiMessage, RuntimeApiRequest, StatementDistributionMessage, StoreAvailableDataError, }, @@ -100,7 +100,8 @@ use polkadot_node_subsystem_util::{ executor_params_at_relay_parent, request_from_runtime, request_session_index_for_child, request_validator_groups, request_validators, runtime::{ - self, prospective_parachains_mode, request_min_backing_votes, ProspectiveParachainsMode, + self, fetch_claim_queue, prospective_parachains_mode, request_min_backing_votes, + ClaimQueueSnapshot, ProspectiveParachainsMode, }, Validator, }; @@ -111,8 +112,7 @@ use polkadot_primitives::{ PvfExecKind, SessionIndex, SigningContext, ValidationCode, ValidatorId, ValidatorIndex, ValidatorSignature, ValidityAttestation, }; -use sp_keystore::KeystorePtr; -use statement_table::{ +use polkadot_statement_table::{ generic::AttestedCandidate as TableAttestedCandidate, v2::{ SignedStatement as TableSignedStatement, Statement as TableStatement, @@ -120,7 +120,8 @@ use statement_table::{ }, Config as TableConfig, Context as TableContextTrait, Table, }; -use util::{runtime::request_node_features, vstaging::get_disabled_validators_with_fallback}; +use sp_keystore::KeystorePtr; +use util::runtime::{get_disabled_validators_with_fallback, request_node_features}; mod error; @@ -210,8 +211,8 @@ struct PerRelayParentState { prospective_parachains_mode: ProspectiveParachainsMode, /// The hash of the relay parent on top of which this job is doing it's work. parent: Hash, - /// The `ParaId` assigned to the local validator at this relay parent. - assigned_para: Option, + /// Session index. + session_index: SessionIndex, /// The `CoreIndex` assigned to the local validator at this relay parent. assigned_core: Option, /// The candidates that are backed by enough validators in their group, by hash. @@ -231,8 +232,11 @@ struct PerRelayParentState { /// If true, we're appending extra bits in the BackedCandidate validator indices bitfield, /// which represent the assigned core index. True if ElasticScalingMVP is enabled. inject_core_index: bool, - /// The core states for all cores. - cores: Vec, + /// The number of cores. + n_cores: u32, + /// Claim queue state. If the runtime API is not available, it'll be populated with info from + /// availability cores. + claim_queue: ClaimQueueSnapshot, /// The validator index -> group mapping at this relay parent. validator_to_group: Arc>>, /// The associated group rotation information. @@ -242,20 +246,44 @@ struct PerRelayParentState { struct PerCandidateState { persisted_validation_data: PersistedValidationData, seconded_locally: bool, - para_id: ParaId, relay_parent: Hash, } -struct ActiveLeafState { - prospective_parachains_mode: ProspectiveParachainsMode, - /// The candidates seconded at various depths under this active - /// leaf with respect to parachain id. A candidate can only be - /// seconded when its hypothetical frontier under every active leaf - /// has an empty entry in this map. - /// - /// When prospective parachains are disabled, the only depth - /// which is allowed is 0. - seconded_at_depth: HashMap>, +enum ActiveLeafState { + // If prospective-parachains is disabled, one validator may only back one candidate per + // paraid. + ProspectiveParachainsDisabled { seconded: HashSet }, + ProspectiveParachainsEnabled { max_candidate_depth: usize, allowed_ancestry_len: usize }, +} + +impl ActiveLeafState { + fn new(mode: ProspectiveParachainsMode) -> Self { + match mode { + ProspectiveParachainsMode::Disabled => + Self::ProspectiveParachainsDisabled { seconded: HashSet::new() }, + ProspectiveParachainsMode::Enabled { max_candidate_depth, allowed_ancestry_len } => + Self::ProspectiveParachainsEnabled { max_candidate_depth, allowed_ancestry_len }, + } + } + + fn add_seconded_candidate(&mut self, para_id: ParaId) { + if let Self::ProspectiveParachainsDisabled { seconded } = self { + seconded.insert(para_id); + } + } +} + +impl From<&ActiveLeafState> for ProspectiveParachainsMode { + fn from(state: &ActiveLeafState) -> Self { + match *state { + ActiveLeafState::ProspectiveParachainsDisabled { .. } => + ProspectiveParachainsMode::Disabled, + ActiveLeafState::ProspectiveParachainsEnabled { + max_candidate_depth, + allowed_ancestry_len, + } => ProspectiveParachainsMode::Enabled { max_candidate_depth, allowed_ancestry_len }, + } + } } /// The state of the subsystem. @@ -277,11 +305,11 @@ struct State { /// parachains. /// /// Relay-chain blocks which don't support prospective parachains are - /// never included in the fragment trees of active leaves which do. + /// never included in the fragment chains of active leaves which do. /// /// While it would be technically possible to support such leaves in - /// fragment trees, it only benefits the transition period when asynchronous - /// backing is being enabled and complicates code complexity. + /// fragment chains, it only benefits the transition period when asynchronous + /// backing is being enabled and complicates code. per_relay_parent: HashMap, /// State tracked for all candidates relevant to the implicit view. /// @@ -510,6 +538,8 @@ async fn store_available_data( candidate_hash: CandidateHash, available_data: AvailableData, expected_erasure_root: Hash, + core_index: CoreIndex, + node_features: NodeFeatures, ) -> Result<(), Error> { let (tx, rx) = oneshot::channel(); // Important: the `av-store` subsystem will check if the erasure root of the `available_data` @@ -522,6 +552,8 @@ async fn store_available_data( n_validators, available_data, expected_erasure_root, + core_index, + node_features, tx, }) .await; @@ -545,6 +577,8 @@ async fn make_pov_available( candidate_hash: CandidateHash, validation_data: PersistedValidationData, expected_erasure_root: Hash, + core_index: CoreIndex, + node_features: NodeFeatures, ) -> Result<(), Error> { store_available_data( sender, @@ -552,6 +586,8 @@ async fn make_pov_available( candidate_hash, AvailableData { pov, validation_data }, expected_erasure_root, + core_index, + node_features, ) .await } @@ -622,6 +658,7 @@ struct BackgroundValidationParams { tx_command: mpsc::Sender<(Hash, ValidatedCandidateCommand)>, candidate: CandidateReceipt, relay_parent: Hash, + session_index: SessionIndex, persisted_validation_data: PersistedValidationData, pov: PoVData, n_validators: usize, @@ -633,12 +670,14 @@ async fn validate_and_make_available( impl overseer::CandidateBackingSenderTrait, impl Fn(BackgroundValidationResult) -> ValidatedCandidateCommand + Sync, >, + core_index: CoreIndex, ) -> Result<(), Error> { let BackgroundValidationParams { mut sender, mut tx_command, candidate, relay_parent, + session_index, persisted_validation_data, pov, n_validators, @@ -668,6 +707,10 @@ async fn validate_and_make_available( Err(e) => return Err(Error::UtilError(e)), }; + let node_features = request_node_features(relay_parent, session_index, &mut sender) + .await? + .unwrap_or(NodeFeatures::EMPTY); + let pov = match pov { PoVData::Ready(pov) => pov, PoVData::FetchFromValidator { from_validator, candidate_hash, pov_hash } => @@ -723,6 +766,8 @@ async fn validate_and_make_available( candidate.hash(), validation_data.clone(), candidate.descriptor.erasure_root, + core_index, + node_features, ) .await; @@ -782,8 +827,8 @@ async fn handle_communication( CandidateBackingMessage::Statement(relay_parent, statement) => { handle_statement_message(ctx, state, relay_parent, statement, metrics).await?; }, - CandidateBackingMessage::GetBackedCandidates(requested_candidates, tx) => - handle_get_backed_candidates_message(state, requested_candidates, tx, metrics)?, + CandidateBackingMessage::GetBackableCandidates(requested_candidates, tx) => + handle_get_backable_candidates_message(state, requested_candidates, tx, metrics)?, CandidateBackingMessage::CanSecond(request, tx) => handle_can_second_request(ctx, state, request, tx).await, } @@ -864,17 +909,9 @@ async fn handle_active_leaves_update( return Ok(()) } - state.per_leaf.insert( - leaf.hash, - ActiveLeafState { - prospective_parachains_mode: ProspectiveParachainsMode::Disabled, - // This is empty because the only allowed relay-parent and depth - // when prospective parachains are disabled is the leaf hash and 0, - // respectively. We've just learned about the leaf hash, so we cannot - // have any candidates seconded with it as a relay-parent yet. - seconded_at_depth: HashMap::new(), - }, - ); + state + .per_leaf + .insert(leaf.hash, ActiveLeafState::new(ProspectiveParachainsMode::Disabled)); (vec![leaf.hash], ProspectiveParachainsMode::Disabled) }, @@ -882,63 +919,9 @@ async fn handle_active_leaves_update( let fresh_relay_parents = state.implicit_view.known_allowed_relay_parents_under(&leaf.hash, None); - // At this point, all candidates outside of the implicit view - // have been cleaned up. For all which remain, which we've seconded, - // we ask the prospective parachains subsystem where they land in the fragment - // tree for the given active leaf. This comprises our `seconded_at_depth`. - - let remaining_seconded = state - .per_candidate - .iter() - .filter(|(_, cd)| cd.seconded_locally) - .map(|(c_hash, cd)| (*c_hash, cd.para_id)); - - // one-to-one correspondence to remaining_seconded - let mut membership_answers = FuturesOrdered::new(); - - for (candidate_hash, para_id) in remaining_seconded { - let (tx, rx) = oneshot::channel(); - membership_answers - .push_back(rx.map_ok(move |membership| (para_id, candidate_hash, membership))); + let active_leaf_state = ActiveLeafState::new(prospective_parachains_mode); - ctx.send_message(ProspectiveParachainsMessage::GetTreeMembership( - para_id, - candidate_hash, - tx, - )) - .await; - } - - let mut seconded_at_depth = HashMap::new(); - while let Some(response) = membership_answers.next().await { - match response { - Err(oneshot::Canceled) => { - gum::warn!( - target: LOG_TARGET, - "Prospective parachains subsystem unreachable for membership request", - ); - }, - Ok((para_id, candidate_hash, membership)) => { - // This request gives membership in all fragment trees. We have some - // wasted data here, and it can be optimized if it proves - // relevant to performance. - if let Some((_, depths)) = - membership.into_iter().find(|(leaf_hash, _)| leaf_hash == &leaf.hash) - { - let para_entry: &mut BTreeMap = - seconded_at_depth.entry(para_id).or_default(); - for depth in depths { - para_entry.insert(depth, candidate_hash); - } - } - }, - } - } - - state.per_leaf.insert( - leaf.hash, - ActiveLeafState { prospective_parachains_mode, seconded_at_depth }, - ); + state.per_leaf.insert(leaf.hash, active_leaf_state); let fresh_relay_parent = match fresh_relay_parents { Some(f) => f.to_vec(), @@ -981,7 +964,7 @@ async fn handle_active_leaves_update( // block itself did. leaf_mode }, - Some(l) => l.prospective_parachains_mode, + Some(l) => l.into(), }; // construct a `PerRelayParent` from the runtime API @@ -1023,20 +1006,19 @@ macro_rules! try_runtime_api { fn core_index_from_statement( validator_to_group: &IndexedVec>, group_rotation_info: &GroupRotationInfo, - cores: &[CoreState], + n_cores: u32, + claim_queue: &ClaimQueueSnapshot, statement: &SignedFullStatementWithPVD, ) -> Option { let compact_statement = statement.as_unchecked(); let candidate_hash = CandidateHash(*compact_statement.unchecked_payload().candidate_hash()); - let n_cores = cores.len(); - gum::trace!( target:LOG_TARGET, ?group_rotation_info, ?statement, ?validator_to_group, - n_cores = ?cores.len(), + n_cores, ?candidate_hash, "Extracting core index from statement" ); @@ -1048,7 +1030,7 @@ fn core_index_from_statement( ?group_rotation_info, ?statement, ?validator_to_group, - n_cores = ?cores.len() , + n_cores, ?candidate_hash, "Invalid validator index: {:?}", statement_validator_index @@ -1057,37 +1039,25 @@ fn core_index_from_statement( }; // First check if the statement para id matches the core assignment. - let core_index = group_rotation_info.core_for_group(*group_index, n_cores); + let core_index = group_rotation_info.core_for_group(*group_index, n_cores as _); - if core_index.0 as usize > n_cores { + if core_index.0 > n_cores { gum::warn!(target: LOG_TARGET, ?candidate_hash, ?core_index, n_cores, "Invalid CoreIndex"); return None } if let StatementWithPVD::Seconded(candidate, _pvd) = statement.payload() { let candidate_para_id = candidate.descriptor.para_id; - let assigned_para_id = match &cores[core_index.0 as usize] { - CoreState::Free => { - gum::debug!(target: LOG_TARGET, ?candidate_hash, "Invalid CoreIndex, core is not assigned to any para_id"); - return None - }, - CoreState::Occupied(occupied) => - if let Some(next) = &occupied.next_up_on_available { - next.para_id - } else { - return None - }, - CoreState::Scheduled(scheduled) => scheduled.para_id, - }; + let mut assigned_paras = claim_queue.iter_claims_for_core(&core_index); - if assigned_para_id != candidate_para_id { + if !assigned_paras.any(|id| id == &candidate_para_id) { gum::debug!( target: LOG_TARGET, ?candidate_hash, ?core_index, - ?assigned_para_id, + assigned_paras = ?claim_queue.iter_claims_for_core(&core_index).collect::>(), ?candidate_para_id, - "Invalid CoreIndex, core is assigned to a different para_id" + "Invalid CoreIndex, core is not assigned to this para_id" ); return None } @@ -1148,6 +1118,8 @@ async fn construct_per_relay_parent_state( Error::UtilError(TryFrom::try_from(e).expect("the conversion is infallible; qed")) })?; + let maybe_claim_queue = try_runtime_api!(fetch_claim_queue(ctx.sender(), parent).await); + let signing_context = SigningContext { parent_hash: parent, session_index }; let validator = match Validator::construct( &validators, @@ -1172,31 +1144,35 @@ async fn construct_per_relay_parent_state( let mut groups = HashMap::>::new(); let mut assigned_core = None; - let mut assigned_para = None; + + let has_claim_queue = maybe_claim_queue.is_some(); + let mut claim_queue = maybe_claim_queue.unwrap_or_default().0; for (idx, core) in cores.iter().enumerate() { - let core_para_id = match core { - CoreState::Scheduled(scheduled) => scheduled.para_id, - CoreState::Occupied(occupied) => - if mode.is_enabled() { + let core_index = CoreIndex(idx as _); + + if !has_claim_queue { + match core { + CoreState::Scheduled(scheduled) => + claim_queue.insert(core_index, [scheduled.para_id].into_iter().collect()), + CoreState::Occupied(occupied) if mode.is_enabled() => { // Async backing makes it legal to build on top of // occupied core. if let Some(next) = &occupied.next_up_on_available { - next.para_id + claim_queue.insert(core_index, [next.para_id].into_iter().collect()) } else { continue } - } else { - continue }, - CoreState::Free => continue, - }; + _ => continue, + }; + } else if !claim_queue.contains_key(&core_index) { + continue + } - let core_index = CoreIndex(idx as _); let group_index = group_rotation_info.group_for_core(core_index, n_cores); if let Some(g) = validator_groups.get(group_index.0 as usize) { if validator.as_ref().map_or(false, |v| g.contains(&v.index())) { - assigned_para = Some(core_para_id); assigned_core = Some(core_index); } groups.insert(core_index, g.clone()); @@ -1229,8 +1205,8 @@ async fn construct_per_relay_parent_state( Ok(Some(PerRelayParentState { prospective_parachains_mode: mode, parent, + session_index, assigned_core, - assigned_para, backed: HashSet::new(), table: Table::new(table_config), table_context, @@ -1239,7 +1215,8 @@ async fn construct_per_relay_parent_state( fallbacks: HashMap::new(), minimum_backing_votes, inject_core_index, - cores, + n_cores: cores.len() as u32, + claim_queue: ClaimQueueSnapshot::from(claim_queue), validator_to_group: validator_to_group.clone(), group_rotation_info, })) @@ -1247,20 +1224,20 @@ async fn construct_per_relay_parent_state( enum SecondingAllowed { No, - Yes(Vec<(Hash, Vec)>), + // On which leaves is seconding allowed. + Yes(Vec), } -/// Checks whether a candidate can be seconded based on its hypothetical frontiers in the fragment -/// tree and what we've already seconded in all active leaves. +/// Checks whether a candidate can be seconded based on its hypothetical membership in the fragment +/// chain. #[overseer::contextbounds(CandidateBacking, prefix = self::overseer)] async fn seconding_sanity_check( ctx: &mut Context, active_leaves: &HashMap, implicit_view: &ImplicitView, hypothetical_candidate: HypotheticalCandidate, - backed_in_path_only: bool, ) -> SecondingAllowed { - let mut membership = Vec::new(); + let mut leaves_for_seconding = Vec::new(); let mut responses = FuturesOrdered::>>::new(); let candidate_para = hypothetical_candidate.candidate_para(); @@ -1268,7 +1245,7 @@ async fn seconding_sanity_check( let candidate_hash = hypothetical_candidate.candidate_hash(); for (head, leaf_state) in active_leaves { - if leaf_state.prospective_parachains_mode.is_enabled() { + if ProspectiveParachainsMode::from(leaf_state).is_enabled() { // Check that the candidate relay parent is allowed for para, skip the // leaf otherwise. let allowed_parents_for_para = @@ -1278,40 +1255,36 @@ async fn seconding_sanity_check( } let (tx, rx) = oneshot::channel(); - ctx.send_message(ProspectiveParachainsMessage::GetHypotheticalFrontier( - HypotheticalFrontierRequest { + ctx.send_message(ProspectiveParachainsMessage::GetHypotheticalMembership( + HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(*head), - backed_in_path_only, + fragment_chain_relay_parent: Some(*head), }, tx, )) .await; - let response = rx.map_ok(move |frontiers| { - let depths: Vec = frontiers + let response = rx.map_ok(move |candidate_memberships| { + let is_member_or_potential = candidate_memberships .into_iter() - .flat_map(|(candidate, memberships)| { - debug_assert_eq!(candidate.candidate_hash(), candidate_hash); - memberships.into_iter().flat_map(|(relay_parent, depths)| { - debug_assert_eq!(relay_parent, *head); - depths - }) + .find_map(|(candidate, leaves)| { + (candidate.candidate_hash() == candidate_hash).then_some(leaves) }) - .collect(); - (depths, head, leaf_state) + .and_then(|leaves| leaves.into_iter().find(|leaf| leaf == head)) + .is_some(); + + (is_member_or_potential, head) }); responses.push_back(response.boxed()); } else { if *head == candidate_relay_parent { - if leaf_state - .seconded_at_depth - .get(&candidate_para) - .map_or(false, |occupied| occupied.contains_key(&0)) - { - // The leaf is already occupied. - return SecondingAllowed::No + if let ActiveLeafState::ProspectiveParachainsDisabled { seconded } = leaf_state { + if seconded.contains(&candidate_para) { + // The leaf is already occupied. For non-prospective parachains, we only + // second one candidate. + return SecondingAllowed::No + } } - responses.push_back(futures::future::ok((vec![0], head, leaf_state)).boxed()); + responses.push_back(futures::future::ok((true, head)).boxed()); } } } @@ -1325,38 +1298,32 @@ async fn seconding_sanity_check( Err(oneshot::Canceled) => { gum::warn!( target: LOG_TARGET, - "Failed to reach prospective parachains subsystem for hypothetical frontiers", + "Failed to reach prospective parachains subsystem for hypothetical membership", ); return SecondingAllowed::No }, - Ok((depths, head, leaf_state)) => { - for depth in &depths { - if leaf_state - .seconded_at_depth - .get(&candidate_para) - .map_or(false, |occupied| occupied.contains_key(&depth)) - { - gum::debug!( - target: LOG_TARGET, - ?candidate_hash, - depth, - leaf_hash = ?head, - "Refusing to second candidate at depth - already occupied." - ); - - return SecondingAllowed::No - } - } - - membership.push((*head, depths)); + Ok((is_member_or_potential, head)) => match is_member_or_potential { + false => { + gum::debug!( + target: LOG_TARGET, + ?candidate_hash, + leaf_hash = ?head, + "Refusing to second candidate at leaf. Is not a potential member.", + ); + }, + true => { + leaves_for_seconding.push(*head); + }, }, } } - // At this point we've checked the depths of the candidate against all active - // leaves. - SecondingAllowed::Yes(membership) + if leaves_for_seconding.is_empty() { + SecondingAllowed::No + } else { + SecondingAllowed::Yes(leaves_for_seconding) + } } /// Performs seconding sanity check for an advertisement. @@ -1385,16 +1352,12 @@ async fn handle_can_second_request( &state.per_leaf, &state.implicit_view, hypothetical_candidate, - true, ) .await; match result { SecondingAllowed::No => false, - SecondingAllowed::Yes(membership) => { - // Candidate should be recognized by at least some fragment tree. - membership.iter().any(|(_, m)| !m.is_empty()) - }, + SecondingAllowed::Yes(leaves) => !leaves.is_empty(), } } else { // Relay parent is unknown or async backing is disabled. @@ -1435,20 +1398,6 @@ async fn handle_validated_candidate_command( commitments, }; - let parent_head_data_hash = persisted_validation_data.parent_head.hash(); - // Note that `GetHypotheticalFrontier` doesn't account for recursion, - // i.e. candidates can appear at multiple depths in the tree and in fact - // at all depths, and we don't know what depths a candidate will ultimately - // occupy because that's dependent on other candidates we haven't yet - // received. - // - // The only way to effectively rule this out is to have candidate receipts - // directly commit to the parachain block number or some other incrementing - // counter. That requires a major primitives format upgrade, so for now - // we just rule out trivial cycles. - if parent_head_data_hash == receipt.commitments.head_data.hash() { - return Ok(()) - } let hypothetical_candidate = HypotheticalCandidate::Complete { candidate_hash, receipt: Arc::new(receipt.clone()), @@ -1457,12 +1406,11 @@ async fn handle_validated_candidate_command( // sanity check that we're allowed to second the candidate // and that it doesn't conflict with other candidates we've // seconded. - let fragment_tree_membership = match seconding_sanity_check( + let hypothetical_membership = match seconding_sanity_check( ctx, &state.per_leaf, &state.implicit_view, hypothetical_candidate, - false, ) .await { @@ -1517,8 +1465,8 @@ async fn handle_validated_candidate_command( Some(p) => p.seconded_locally = true, } - // update seconded depths in active leaves. - for (leaf, depths) in fragment_tree_membership { + // record seconded candidates for non-prospective-parachains mode. + for leaf in hypothetical_membership { let leaf_data = match state.per_leaf.get_mut(&leaf) { None => { gum::warn!( @@ -1532,14 +1480,7 @@ async fn handle_validated_candidate_command( Some(d) => d, }; - let seconded_at_depth = leaf_data - .seconded_at_depth - .entry(candidate.descriptor().para_id) - .or_default(); - - for depth in depths { - seconded_at_depth.insert(depth, candidate_hash); - } + leaf_data.add_seconded_candidate(candidate.descriptor().para_id); } rp_state.issued_statements.insert(candidate_hash); @@ -1650,7 +1591,7 @@ fn sign_statement( /// and any of the following are true: /// 1. There is no `PersistedValidationData` attached. /// 2. Prospective parachains are enabled for the relay parent and the prospective parachains -/// subsystem returned an empty `FragmentTreeMembership` i.e. did not recognize the candidate as +/// subsystem returned an empty `HypotheticalMembership` i.e. did not recognize the candidate as /// being applicable to any of the active leaves. #[overseer::contextbounds(CandidateBacking, prefix = self::overseer)] async fn import_statement( @@ -1686,8 +1627,8 @@ async fn import_statement( if !per_candidate.contains_key(&candidate_hash) { if rp_state.prospective_parachains_mode.is_enabled() { let (tx, rx) = oneshot::channel(); - ctx.send_message(ProspectiveParachainsMessage::IntroduceCandidate( - IntroduceCandidateRequest { + ctx.send_message(ProspectiveParachainsMessage::IntroduceSecondedCandidate( + IntroduceSecondedCandidateRequest { candidate_para: candidate.descriptor().para_id, candidate_receipt: candidate.clone(), persisted_validation_data: pvd.clone(), @@ -1705,17 +1646,9 @@ async fn import_statement( return Err(Error::RejectedByProspectiveParachains) }, - Ok(membership) => - if membership.is_empty() { - return Err(Error::RejectedByProspectiveParachains) - }, + Ok(false) => return Err(Error::RejectedByProspectiveParachains), + Ok(true) => {}, } - - ctx.send_message(ProspectiveParachainsMessage::CandidateSeconded( - candidate.descriptor().para_id, - candidate_hash, - )) - .await; } // Only save the candidate if it was approved by prospective parachains. @@ -1725,7 +1658,6 @@ async fn import_statement( persisted_validation_data: pvd.clone(), // This is set after importing when seconding locally. seconded_locally: false, - para_id: candidate.descriptor().para_id, relay_parent: candidate.descriptor().relay_parent, }, ); @@ -1737,7 +1669,8 @@ async fn import_statement( let core = core_index_from_statement( &rp_state.validator_to_group, &rp_state.group_rotation_info, - &rp_state.cores, + rp_state.n_cores, + &rp_state.claim_queue, statement, ) .ok_or(Error::CoreIndexUnavailable)?; @@ -1786,13 +1719,6 @@ async fn post_import_statement_actions( candidate_hash, )) .await; - // Backed candidate potentially unblocks new advertisements, - // notify collator protocol. - ctx.send_message(CollatorProtocolMessage::Backed { - para_id, - para_head: backed.candidate().descriptor.para_head, - }) - .await; // Notify statement distribution of backed candidate. ctx.send_message(StatementDistributionMessage::Backed(candidate_hash)).await; } else { @@ -1878,10 +1804,11 @@ async fn background_validate_and_make_available( >, ) -> Result<(), Error> { let candidate_hash = params.candidate.hash(); + let Some(core_index) = rp_state.assigned_core else { return Ok(()) }; if rp_state.awaiting_validation.insert(candidate_hash) { // spawn background task. let bg = async move { - if let Err(error) = validate_and_make_available(params).await { + if let Err(error) = validate_and_make_available(params, core_index).await { if let Error::BackgroundValidationMpsc(error) = error { gum::debug!( target: LOG_TARGET, @@ -1956,6 +1883,7 @@ async fn kick_off_validation_work( tx_command: background_validation_tx.clone(), candidate: attesting.candidate, relay_parent: rp_state.parent, + session_index: rp_state.session_index, persisted_validation_data, pov, n_validators: rp_state.table_context.validators.len(), @@ -2016,7 +1944,7 @@ async fn maybe_validate_and_import( if let Some(summary) = summary { // import_statement already takes care of communicating with the // prospective parachains subsystem. At this point, the candidate - // has already been accepted into the fragment trees. + // has already been accepted by the subsystem. let candidate_hash = summary.candidate; @@ -2109,6 +2037,7 @@ async fn validate_and_second( tx_command: background_validation_tx.clone(), candidate: candidate.clone(), relay_parent: rp_state.parent, + session_index: rp_state.session_index, persisted_validation_data, pov: PoVData::Ready(pov), n_validators: rp_state.table_context.validators.len(), @@ -2165,23 +2094,24 @@ async fn handle_second_message( return Ok(()) } + let assigned_paras = rp_state.assigned_core.and_then(|core| rp_state.claim_queue.0.get(&core)); + // Sanity check that candidate is from our assignment. - if Some(candidate.descriptor().para_id) != rp_state.assigned_para { + if !matches!(assigned_paras, Some(paras) if paras.contains(&candidate.descriptor().para_id)) { gum::debug!( target: LOG_TARGET, our_assignment_core = ?rp_state.assigned_core, - our_assignment_para = ?rp_state.assigned_para, + our_assignment_paras = ?assigned_paras, collation = ?candidate.descriptor().para_id, "Subsystem asked to second for para outside of our assignment", ); - - return Ok(()) + return Ok(()); } gum::debug!( target: LOG_TARGET, our_assignment_core = ?rp_state.assigned_core, - our_assignment_para = ?rp_state.assigned_para, + our_assignment_paras = ?assigned_paras, collation = ?candidate.descriptor().para_id, "Current assignments vs collation", ); @@ -2228,7 +2158,7 @@ async fn handle_statement_message( } } -fn handle_get_backed_candidates_message( +fn handle_get_backable_candidates_message( state: &State, requested_candidates: HashMap>, tx: oneshot::Sender>>, diff --git a/polkadot/node/core/backing/src/tests/mod.rs b/polkadot/node/core/backing/src/tests/mod.rs index d1969e656db673b70b070c9b708bab867bec9fcb..10eb45b82d12544be09a188493d7114fc99c6d58 100644 --- a/polkadot/node/core/backing/src/tests/mod.rs +++ b/polkadot/node/core/backing/src/tests/mod.rs @@ -16,10 +16,6 @@ use self::test_helpers::mock::new_leaf; use super::*; -use ::test_helpers::{ - dummy_candidate_receipt_bad_sig, dummy_collator, dummy_collator_signature, - dummy_committed_candidate_receipt, dummy_hash, validator_pubkeys, -}; use assert_matches::assert_matches; use futures::{future, Future}; use polkadot_node_primitives::{BlockData, InvalidCandidate, SignedFullStatement, Statement}; @@ -36,13 +32,20 @@ use polkadot_primitives::{ node_features, CandidateDescriptor, GroupRotationInfo, HeadData, PersistedValidationData, PvfExecKind, ScheduledCore, SessionIndex, LEGACY_MIN_BACKING_VOTES, }; +use polkadot_primitives_test_helpers::{ + dummy_candidate_receipt_bad_sig, dummy_collator, dummy_collator_signature, + dummy_committed_candidate_receipt, dummy_hash, validator_pubkeys, +}; +use polkadot_statement_table::v2::Misbehavior; use rstest::rstest; use sp_application_crypto::AppCrypto; use sp_keyring::Sr25519Keyring; use sp_keystore::Keystore; use sp_tracing as _; -use statement_table::v2::Misbehavior; -use std::{collections::HashMap, time::Duration}; +use std::{ + collections::{BTreeMap, HashMap, VecDeque}, + time::Duration, +}; mod prospective_parachains; @@ -75,6 +78,7 @@ pub(crate) struct TestState { validator_groups: (Vec>, GroupRotationInfo), validator_to_group: IndexedVec>, availability_cores: Vec, + claim_queue: BTreeMap>, head_data: HashMap, signing_context: SigningContext, relay_parent: Hash, @@ -130,6 +134,10 @@ impl Default for TestState { CoreState::Scheduled(ScheduledCore { para_id: chain_b, collator: None }), ]; + let mut claim_queue = BTreeMap::new(); + claim_queue.insert(CoreIndex(0), [chain_a].into_iter().collect()); + claim_queue.insert(CoreIndex(1), [chain_b].into_iter().collect()); + let mut head_data = HashMap::new(); head_data.insert(chain_a, HeadData(vec![4, 5, 6])); head_data.insert(chain_b, HeadData(vec![5, 6, 7])); @@ -153,6 +161,7 @@ impl Default for TestState { validator_groups: (validator_groups, group_rotation_info), validator_to_group, availability_cores, + claim_queue, head_data, validation_data, signing_context, @@ -164,7 +173,8 @@ impl Default for TestState { } } -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; fn test_harness>( keystore: KeystorePtr, @@ -172,7 +182,8 @@ fn test_harness>( ) { let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = async move { if let Err(e) = super::run(context, keystore, Metrics(None)).await { @@ -196,8 +207,9 @@ fn test_harness>( fn make_erasure_root(test: &TestState, pov: PoV, validation_data: PersistedValidationData) -> Hash { let available_data = AvailableData { validation_data, pov: Arc::new(pov) }; - let chunks = erasure_coding::obtain_chunks_v1(test.validators.len(), &available_data).unwrap(); - erasure_coding::branches(&chunks).root() + let chunks = + polkadot_erasure_coding::obtain_chunks_v1(test.validators.len(), &available_data).unwrap(); + polkadot_erasure_coding::branches(&chunks).root() } #[derive(Default, Clone)] @@ -335,6 +347,26 @@ async fn test_startup(virtual_overseer: &mut VirtualOverseer, test_state: &TestS tx.send(Ok(test_state.disabled_validators.clone())).unwrap(); } ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx)) + ) if parent == test_state.relay_parent => { + tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap(); + } + ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx)) + ) if parent == test_state.relay_parent => { + tx.send(Ok( + test_state.claim_queue.clone() + )).unwrap(); + } + ); } async fn assert_validation_requests( @@ -367,6 +399,15 @@ async fn assert_validation_requests( tx.send(Ok(Some(ExecutorParams::default()))).unwrap(); } ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(_, RuntimeApiRequest::NodeFeatures(sess_idx, tx)) + ) if sess_idx == 1 => { + tx.send(Ok(NodeFeatures::EMPTY)).unwrap(); + } + ); } async fn assert_validate_from_exhaustive( @@ -662,7 +703,7 @@ fn backing_works(#[case] elastic_scaling_mvp: bool) { virtual_overseer.send(FromOrchestra::Communication { msg: statement }).await; let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( std::iter::once(( test_state.chain_ids[0], vec![(candidate_a_hash, test_state.relay_parent)], @@ -718,11 +759,16 @@ fn get_backed_candidate_preserves_order() { // Assign the second core to the same para as the first one. test_state.availability_cores[1] = CoreState::Scheduled(ScheduledCore { para_id: test_state.chain_ids[0], collator: None }); + *test_state.claim_queue.get_mut(&CoreIndex(1)).unwrap() = + [test_state.chain_ids[0]].into_iter().collect(); // Add another availability core for paraid 2. test_state.availability_cores.push(CoreState::Scheduled(ScheduledCore { para_id: test_state.chain_ids[1], collator: None, })); + test_state + .claim_queue + .insert(CoreIndex(2), [test_state.chain_ids[1]].into_iter().collect()); test_harness(test_state.keystore.clone(), |mut virtual_overseer| async move { test_startup(&mut virtual_overseer, &test_state).await; @@ -849,7 +895,7 @@ fn get_backed_candidate_preserves_order() { // Happy case, all candidates should be present. let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( [ ( test_state.chain_ids[0], @@ -900,7 +946,7 @@ fn get_backed_candidate_preserves_order() { ], ] { let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( [ (test_state.chain_ids[0], candidates), (test_state.chain_ids[1], vec![(candidate_c_hash, test_state.relay_parent)]), @@ -939,7 +985,7 @@ fn get_backed_candidate_preserves_order() { ], ] { let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( [ (test_state.chain_ids[0], candidates), (test_state.chain_ids[1], vec![(candidate_c_hash, test_state.relay_parent)]), @@ -984,7 +1030,7 @@ fn get_backed_candidate_preserves_order() { ], ] { let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( [ (test_state.chain_ids[0], candidates), (test_state.chain_ids[1], vec![(candidate_c_hash, test_state.relay_parent)]), @@ -1091,7 +1137,8 @@ fn extract_core_index_from_statement_works() { let core_index_1 = core_index_from_statement( &test_state.validator_to_group, &test_state.validator_groups.1, - &test_state.availability_cores, + test_state.availability_cores.len() as _, + &test_state.claim_queue.clone().into(), &signed_statement_1, ) .unwrap(); @@ -1101,7 +1148,8 @@ fn extract_core_index_from_statement_works() { let core_index_2 = core_index_from_statement( &test_state.validator_to_group, &test_state.validator_groups.1, - &test_state.availability_cores, + test_state.availability_cores.len() as _, + &test_state.claim_queue.clone().into(), &signed_statement_2, ); @@ -1111,7 +1159,8 @@ fn extract_core_index_from_statement_works() { let core_index_3 = core_index_from_statement( &test_state.validator_to_group, &test_state.validator_groups.1, - &test_state.availability_cores, + test_state.availability_cores.len() as _, + &test_state.claim_queue.clone().into(), &signed_statement_3, ) .unwrap(); @@ -1272,7 +1321,7 @@ fn backing_works_while_validation_ongoing() { virtual_overseer.send(FromOrchestra::Communication { msg: statement }).await; let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( std::iter::once(( test_state.chain_ids[0], vec![(candidate_a.hash(), test_state.relay_parent)], @@ -1893,7 +1942,7 @@ fn backing_works_after_failed_validation() { // Try to get a set of backable candidates to trigger _some_ action in the subsystem // and check that it is still alive. let (tx, rx) = oneshot::channel(); - let msg = CandidateBackingMessage::GetBackedCandidates( + let msg = CandidateBackingMessage::GetBackableCandidates( std::iter::once(( test_state.chain_ids[0], vec![(candidate.hash(), test_state.relay_parent)], @@ -1946,7 +1995,7 @@ fn candidate_backing_reorders_votes() { data[32..36].copy_from_slice(idx.encode().as_slice()); let sig = ValidatorSignature::try_from(data).unwrap(); - statement_table::generic::ValidityAttestation::Implicit(sig) + polkadot_statement_table::generic::ValidityAttestation::Implicit(sig) }; let attested = TableAttestedCandidate { @@ -2084,7 +2133,7 @@ fn retry_works() { virtual_overseer.send(FromOrchestra::Communication { msg: statement }).await; // Not deterministic which message comes first: - for _ in 0u32..5 { + for _ in 0u32..6 { match virtual_overseer.recv().await { AllMessages::Provisioner(ProvisionerMessage::ProvisionableData( _, @@ -2115,6 +2164,12 @@ fn retry_works() { )) => { tx.send(Ok(Some(ExecutorParams::default()))).unwrap(); }, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _, + RuntimeApiRequest::NodeFeatures(1, tx), + )) => { + tx.send(Ok(NodeFeatures::EMPTY)).unwrap(); + }, msg => { assert!(false, "Unexpected message: {:?}", msg); }, @@ -2662,32 +2717,7 @@ fn validator_ignores_statements_from_disabled_validators() { virtual_overseer.send(FromOrchestra::Communication { msg: statement_3 }).await; - assert_matches!( - virtual_overseer.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx)) - ) if hash == validation_code.hash() => { - tx.send(Ok(Some(validation_code.clone()))).unwrap(); - } - ); - - assert_matches!( - virtual_overseer.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx)) - ) => { - tx.send(Ok(1u32.into())).unwrap(); - } - ); - - assert_matches!( - virtual_overseer.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(sess_idx, tx)) - ) if sess_idx == 1 => { - tx.send(Ok(Some(ExecutorParams::default()))).unwrap(); - } - ); + assert_validation_requests(&mut virtual_overseer, validation_code.clone()).await; // Sending a `Statement::Seconded` for our assignment will start // validation process. The first thing requested is the PoV. diff --git a/polkadot/node/core/backing/src/tests/prospective_parachains.rs b/polkadot/node/core/backing/src/tests/prospective_parachains.rs index 94310d2aa164650db84b78ddf361a9f465ac207d..15bc0b4a113902ab118bb24f5075eb947b9d874c 100644 --- a/polkadot/node/core/backing/src/tests/prospective_parachains.rs +++ b/polkadot/node/core/backing/src/tests/prospective_parachains.rs @@ -17,7 +17,7 @@ //! Tests for the backing subsystem with enabled prospective parachains. use polkadot_node_subsystem::{ - messages::{ChainApiMessage, FragmentTreeMembership}, + messages::{ChainApiMessage, HypotheticalMembership}, ActivatedLeaf, TimeoutExt, }; use polkadot_primitives::{AsyncBackingParams, BlockNumber, Header, OccupiedCore}; @@ -40,7 +40,6 @@ async fn activate_leaf( virtual_overseer: &mut VirtualOverseer, leaf: TestLeaf, test_state: &TestState, - seconded_in_view: usize, ) { let TestLeaf { activated, min_relay_parents } = leaf; let leaf_hash = activated.hash; @@ -68,15 +67,6 @@ async fn activate_leaf( .min() .unwrap_or(&leaf_number); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx) - ) if parent == leaf_hash => { - tx.send(min_relay_parents).unwrap(); - } - ); - let ancestry_len = leaf_number + 1 - min_min; let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h))) @@ -118,23 +108,20 @@ async fn activate_leaf( tx.send(Ok(Some(header))).unwrap(); } ); - requested_len += 1; - } - } - for _ in 0..seconded_in_view { - let msg = match next_overseer_message.take() { - Some(msg) => msg, - None => virtual_overseer.recv().await, - }; - assert_matches!( - msg, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetTreeMembership(.., tx), - ) => { - tx.send(Vec::new()).unwrap(); + if requested_len == 0 { + assert_matches!( + virtual_overseer.recv().await, + AllMessages::ProspectiveParachains( + ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx) + ) if parent == leaf_hash => { + tx.send(min_relay_parents.clone()).unwrap(); + } + ); } - ); + + requested_len += 1; + } } for (hash, number) in ancestry_iter.take(requested_len) { @@ -225,6 +212,26 @@ async fn activate_leaf( tx.send(Ok(Vec::new())).unwrap(); } ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx)) + ) if parent == hash => { + tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap(); + } + ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx)) + ) if parent == hash => { + tx.send(Ok( + test_state.claim_queue.clone() + )).unwrap(); + } + ); } } @@ -297,11 +304,11 @@ async fn assert_validate_seconded_candidate( ); } -async fn assert_hypothetical_frontier_requests( +async fn assert_hypothetical_membership_requests( virtual_overseer: &mut VirtualOverseer, mut expected_requests: Vec<( - HypotheticalFrontierRequest, - Vec<(HypotheticalCandidate, FragmentTreeMembership)>, + HypotheticalMembershipRequest, + Vec<(HypotheticalCandidate, HypotheticalMembership)>, )>, ) { // Requests come with no particular order. @@ -311,13 +318,13 @@ async fn assert_hypothetical_frontier_requests( assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetHypotheticalFrontier(request, tx), + ProspectiveParachainsMessage::GetHypotheticalMembership(request, tx), ) => { let idx = match expected_requests.iter().position(|r| r.0 == request) { Some(idx) => idx, None => panic!( - "unexpected hypothetical frontier request, no match found for {:?}", + "unexpected hypothetical membership request, no match found for {:?}", request ), }; @@ -330,18 +337,17 @@ async fn assert_hypothetical_frontier_requests( } } -fn make_hypothetical_frontier_response( - depths: Vec, +fn make_hypothetical_membership_response( hypothetical_candidate: HypotheticalCandidate, relay_parent_hash: Hash, -) -> Vec<(HypotheticalCandidate, FragmentTreeMembership)> { - vec![(hypothetical_candidate, vec![(relay_parent_hash, depths)])] +) -> Vec<(HypotheticalCandidate, HypotheticalMembership)> { + vec![(hypothetical_candidate, vec![relay_parent_hash])] } // Test that `seconding_sanity_check` works when a candidate is allowed // for all leaves. #[test] -fn seconding_sanity_check_allowed() { +fn seconding_sanity_check_allowed_on_all() { let test_state = TestState::default(); test_harness(test_state.keystore.clone(), |mut virtual_overseer| async move { // Candidate is seconded in a parent of the activated `leaf_a`. @@ -364,8 +370,8 @@ fn seconding_sanity_check_allowed() { let min_relay_parents = vec![(para_id, LEAF_B_BLOCK_NUMBER - LEAF_B_ANCESTRY_LEN)]; let test_leaf_b = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; - activate_leaf(&mut virtual_overseer, test_leaf_b, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; + activate_leaf(&mut virtual_overseer, test_leaf_b, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -412,24 +418,19 @@ fn seconding_sanity_check_allowed() { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }; - let expected_request_a = HypotheticalFrontierRequest { + let expected_request_a = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_a_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_a_hash), }; - let expected_response_a = make_hypothetical_frontier_response( - vec![0, 1, 2, 3], - hypothetical_candidate.clone(), - leaf_a_hash, - ); - let expected_request_b = HypotheticalFrontierRequest { + let expected_response_a = + make_hypothetical_membership_response(hypothetical_candidate.clone(), leaf_a_hash); + let expected_request_b = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_b_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_b_hash), }; let expected_response_b = - make_hypothetical_frontier_response(vec![3], hypothetical_candidate, leaf_b_hash); - assert_hypothetical_frontier_requests( + make_hypothetical_membership_response(hypothetical_candidate, leaf_b_hash); + assert_hypothetical_membership_requests( &mut virtual_overseer, vec![ (expected_request_a, expected_response_a), @@ -441,7 +442,7 @@ fn seconding_sanity_check_allowed() { assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -449,19 +450,10 @@ fn seconding_sanity_check_allowed() { req.candidate_receipt == candidate && req.candidate_para == para_id && pvd == req.persisted_validation_data => { - // Any non-empty response will do. - tx.send(vec![(leaf_a_hash, vec![0, 1, 2, 3])]).unwrap(); + tx.send(true).unwrap(); } ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains(ProspectiveParachainsMessage::CandidateSeconded( - _, - _ - )) - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::StatementDistribution( @@ -484,8 +476,8 @@ fn seconding_sanity_check_allowed() { }); } -// Test that `seconding_sanity_check` works when a candidate is disallowed -// for at least one leaf. +// Test that `seconding_sanity_check` disallows seconding when a candidate is disallowed +// for all leaves. #[test] fn seconding_sanity_check_disallowed() { let test_state = TestState::default(); @@ -510,7 +502,7 @@ fn seconding_sanity_check_disallowed() { let min_relay_parents = vec![(para_id, LEAF_B_BLOCK_NUMBER - LEAF_B_ANCESTRY_LEN)]; let test_leaf_b = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -557,17 +549,13 @@ fn seconding_sanity_check_disallowed() { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }; - let expected_request_a = HypotheticalFrontierRequest { + let expected_request_a = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_a_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_a_hash), }; - let expected_response_a = make_hypothetical_frontier_response( - vec![0, 1, 2, 3], - hypothetical_candidate, - leaf_a_hash, - ); - assert_hypothetical_frontier_requests( + let expected_response_a = + make_hypothetical_membership_response(hypothetical_candidate, leaf_a_hash); + assert_hypothetical_membership_requests( &mut virtual_overseer, vec![(expected_request_a, expected_response_a)], ) @@ -576,7 +564,7 @@ fn seconding_sanity_check_disallowed() { assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -584,19 +572,10 @@ fn seconding_sanity_check_disallowed() { req.candidate_receipt == candidate && req.candidate_para == para_id && pvd == req.persisted_validation_data => { - // Any non-empty response will do. - tx.send(vec![(leaf_a_hash, vec![0, 2, 3])]).unwrap(); + tx.send(true).unwrap(); } ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains(ProspectiveParachainsMessage::CandidateSeconded( - _, - _ - )) - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::StatementDistribution( @@ -615,10 +594,7 @@ fn seconding_sanity_check_disallowed() { } ); - // A seconded candidate occupies a depth, try to second another one. - // It is allowed in a new leaf but not allowed in the old one. - // Expect it to be rejected. - activate_leaf(&mut virtual_overseer, test_leaf_b, &test_state, 1).await; + activate_leaf(&mut virtual_overseer, test_leaf_b, &test_state).await; let leaf_a_grandparent = get_parent_hash(leaf_a_parent); let candidate = TestCandidateBuilder { para_id, @@ -659,28 +635,20 @@ fn seconding_sanity_check_disallowed() { receipt: Arc::new(candidate), persisted_validation_data: pvd, }; - let expected_request_a = HypotheticalFrontierRequest { + let expected_request_a = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_a_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_a_hash), }; - let expected_response_a = make_hypothetical_frontier_response( - vec![3], - hypothetical_candidate.clone(), - leaf_a_hash, - ); - let expected_request_b = HypotheticalFrontierRequest { + let expected_empty_response = vec![(hypothetical_candidate.clone(), vec![])]; + let expected_request_b = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_b_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_b_hash), }; - let expected_response_b = - make_hypothetical_frontier_response(vec![1], hypothetical_candidate, leaf_b_hash); - assert_hypothetical_frontier_requests( + assert_hypothetical_membership_requests( &mut virtual_overseer, vec![ - (expected_request_a, expected_response_a), // All depths are occupied. - (expected_request_b, expected_response_b), + (expected_request_a, expected_empty_response.clone()), + (expected_request_b, expected_empty_response), ], ) .await; @@ -695,6 +663,137 @@ fn seconding_sanity_check_disallowed() { }); } +// Test that `seconding_sanity_check` allows seconding a candidate when it's allowed on at least one +// leaf. +#[test] +fn seconding_sanity_check_allowed_on_at_least_one_leaf() { + let test_state = TestState::default(); + test_harness(test_state.keystore.clone(), |mut virtual_overseer| async move { + // Candidate is seconded in a parent of the activated `leaf_a`. + const LEAF_A_BLOCK_NUMBER: BlockNumber = 100; + const LEAF_A_ANCESTRY_LEN: BlockNumber = 3; + let para_id = test_state.chain_ids[0]; + + // `a` is grandparent of `b`. + let leaf_a_hash = Hash::from_low_u64_be(130); + let leaf_a_parent = get_parent_hash(leaf_a_hash); + let activated = new_leaf(leaf_a_hash, LEAF_A_BLOCK_NUMBER); + let min_relay_parents = vec![(para_id, LEAF_A_BLOCK_NUMBER - LEAF_A_ANCESTRY_LEN)]; + let test_leaf_a = TestLeaf { activated, min_relay_parents }; + + const LEAF_B_BLOCK_NUMBER: BlockNumber = LEAF_A_BLOCK_NUMBER + 2; + const LEAF_B_ANCESTRY_LEN: BlockNumber = 4; + + let leaf_b_hash = Hash::from_low_u64_be(128); + let activated = new_leaf(leaf_b_hash, LEAF_B_BLOCK_NUMBER); + let min_relay_parents = vec![(para_id, LEAF_B_BLOCK_NUMBER - LEAF_B_ANCESTRY_LEN)]; + let test_leaf_b = TestLeaf { activated, min_relay_parents }; + + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; + activate_leaf(&mut virtual_overseer, test_leaf_b, &test_state).await; + + let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; + let pvd = dummy_pvd(); + let validation_code = ValidationCode(vec![1, 2, 3]); + + let expected_head_data = test_state.head_data.get(¶_id).unwrap(); + + let pov_hash = pov.hash(); + let candidate = TestCandidateBuilder { + para_id, + relay_parent: leaf_a_parent, + pov_hash, + head_data: expected_head_data.clone(), + erasure_root: make_erasure_root(&test_state, pov.clone(), pvd.clone()), + persisted_validation_data_hash: pvd.hash(), + validation_code: validation_code.0.clone(), + } + .build(); + + let second = CandidateBackingMessage::Second( + leaf_a_hash, + candidate.to_plain(), + pvd.clone(), + pov.clone(), + ); + + virtual_overseer.send(FromOrchestra::Communication { msg: second }).await; + + assert_validate_seconded_candidate( + &mut virtual_overseer, + leaf_a_parent, + &candidate, + &pov, + &pvd, + &validation_code, + expected_head_data, + false, + ) + .await; + + // `seconding_sanity_check` + let hypothetical_candidate = HypotheticalCandidate::Complete { + candidate_hash: candidate.hash(), + receipt: Arc::new(candidate.clone()), + persisted_validation_data: pvd.clone(), + }; + let expected_request_a = HypotheticalMembershipRequest { + candidates: vec![hypothetical_candidate.clone()], + fragment_chain_relay_parent: Some(leaf_a_hash), + }; + let expected_response_a = + make_hypothetical_membership_response(hypothetical_candidate.clone(), leaf_a_hash); + let expected_request_b = HypotheticalMembershipRequest { + candidates: vec![hypothetical_candidate.clone()], + fragment_chain_relay_parent: Some(leaf_b_hash), + }; + let expected_response_b = vec![(hypothetical_candidate.clone(), vec![])]; + assert_hypothetical_membership_requests( + &mut virtual_overseer, + vec![ + (expected_request_a, expected_response_a), + (expected_request_b, expected_response_b), + ], + ) + .await; + // Prospective parachains are notified. + assert_matches!( + virtual_overseer.recv().await, + AllMessages::ProspectiveParachains( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( + req, + tx, + ), + ) if + req.candidate_receipt == candidate + && req.candidate_para == para_id + && pvd == req.persisted_validation_data => { + tx.send(true).unwrap(); + } + ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::StatementDistribution( + StatementDistributionMessage::Share( + parent_hash, + _signed_statement, + ) + ) if parent_hash == leaf_a_parent => {} + ); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::CollatorProtocol(CollatorProtocolMessage::Seconded(hash, statement)) => { + assert_eq!(leaf_a_parent, hash); + assert_matches!(statement.payload(), Statement::Seconded(_)); + } + ); + + virtual_overseer + }); +} + // Test that a seconded candidate which is not approved by prospective parachains // subsystem doesn't change the view. #[test] @@ -712,7 +811,7 @@ fn prospective_parachains_reject_candidate() { let min_relay_parents = vec![(para_id, LEAF_A_BLOCK_NUMBER - LEAF_A_ANCESTRY_LEN)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -760,25 +859,20 @@ fn prospective_parachains_reject_candidate() { persisted_validation_data: pvd.clone(), }; let expected_request_a = vec![( - HypotheticalFrontierRequest { + HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_a_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_a_hash), }, - make_hypothetical_frontier_response( - vec![0, 1, 2, 3], - hypothetical_candidate, - leaf_a_hash, - ), + make_hypothetical_membership_response(hypothetical_candidate, leaf_a_hash), )]; - assert_hypothetical_frontier_requests(&mut virtual_overseer, expected_request_a.clone()) + assert_hypothetical_membership_requests(&mut virtual_overseer, expected_request_a.clone()) .await; // Prospective parachains are notified. assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -787,7 +881,7 @@ fn prospective_parachains_reject_candidate() { && req.candidate_para == para_id && pvd == req.persisted_validation_data => { // Reject it. - tx.send(Vec::new()).unwrap(); + tx.send(false).unwrap(); } ); @@ -825,12 +919,12 @@ fn prospective_parachains_reject_candidate() { .await; // `seconding_sanity_check` - assert_hypothetical_frontier_requests(&mut virtual_overseer, expected_request_a).await; + assert_hypothetical_membership_requests(&mut virtual_overseer, expected_request_a).await; // Prospective parachains are notified. assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -838,19 +932,10 @@ fn prospective_parachains_reject_candidate() { req.candidate_receipt == candidate && req.candidate_para == para_id && pvd == req.persisted_validation_data => { - // Any non-empty response will do. - tx.send(vec![(leaf_a_hash, vec![0, 2, 3])]).unwrap(); + tx.send(true).unwrap(); } ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains(ProspectiveParachainsMessage::CandidateSeconded( - _, - _ - )) - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::StatementDistribution( @@ -890,7 +975,7 @@ fn second_multiple_candidates_per_relay_parent() { let min_relay_parents = vec![(para_id, LEAF_BLOCK_NUMBER - LEAF_ANCESTRY_LEN)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -911,12 +996,10 @@ fn second_multiple_candidates_per_relay_parent() { let mut candidate_b = candidate_a.clone(); candidate_b.relay_parent = leaf_grandparent; - // With depths. - let candidate_a = (candidate_a.build(), 1); - let candidate_b = (candidate_b.build(), 2); + let candidate_a = candidate_a.build(); + let candidate_b = candidate_b.build(); for candidate in &[candidate_a, candidate_b] { - let (candidate, depth) = candidate; let second = CandidateBackingMessage::Second( leaf_hash, candidate.to_plain(), @@ -945,46 +1028,33 @@ fn second_multiple_candidates_per_relay_parent() { persisted_validation_data: pvd.clone(), }; let expected_request_a = vec![( - HypotheticalFrontierRequest { + HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_hash), }, - make_hypothetical_frontier_response( - vec![*depth], - hypothetical_candidate, - leaf_hash, - ), + make_hypothetical_membership_response(hypothetical_candidate, leaf_hash), )]; - assert_hypothetical_frontier_requests( + assert_hypothetical_membership_requests( &mut virtual_overseer, expected_request_a.clone(), ) .await; // Prospective parachains are notified. - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( - req, - tx, - ), - ) if - &req.candidate_receipt == candidate - && req.candidate_para == para_id - && pvd == req.persisted_validation_data - => { - // Any non-empty response will do. - tx.send(vec![(leaf_hash, vec![0, 2, 3])]).unwrap(); - } - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::CandidateSeconded(_, _) - ) + ProspectiveParachainsMessage::IntroduceSecondedCandidate( + req, + tx, + ), + ) if + &req.candidate_receipt == candidate + && req.candidate_para == para_id + && pvd == req.persisted_validation_data + => { + tx.send(true).unwrap(); + } ); assert_matches!( @@ -1026,7 +1096,7 @@ fn backing_works() { let min_relay_parents = vec![(para_id, LEAF_BLOCK_NUMBER - LEAF_ANCESTRY_LEN)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -1048,7 +1118,6 @@ fn backing_works() { .build(); let candidate_a_hash = candidate_a.hash(); - let candidate_a_para_head = candidate_a.descriptor().para_head; let public1 = Keystore::sr25519_generate_new( &*test_state.keystore, @@ -1096,7 +1165,7 @@ fn backing_works() { assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -1104,19 +1173,10 @@ fn backing_works() { req.candidate_receipt == candidate_a && req.candidate_para == para_id && pvd == req.persisted_validation_data => { - // Any non-empty response will do. - tx.send(vec![(leaf_hash, vec![0, 2, 3])]).unwrap(); + tx.send(true).unwrap(); } ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains(ProspectiveParachainsMessage::CandidateSeconded( - _, - _ - )) - ); - assert_validate_seconded_candidate( &mut virtual_overseer, candidate_a.descriptor().relay_parent, @@ -1147,13 +1207,6 @@ fn backing_works() { ), ) if candidate_a_hash == candidate_hash && candidate_para_id == para_id ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::CollatorProtocol(CollatorProtocolMessage::Backed { - para_id: _para_id, - para_head, - }) if para_id == _para_id && candidate_a_para_head == para_head - ); assert_matches!( virtual_overseer.recv().await, AllMessages::StatementDistribution(StatementDistributionMessage::Backed ( @@ -1187,7 +1240,7 @@ fn concurrent_dependent_candidates() { let min_relay_parents = vec![(para_id, LEAF_BLOCK_NUMBER - LEAF_ANCESTRY_LEN)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let head_data = &[ HeadData(vec![10, 20, 30]), // Before `a`. @@ -1299,13 +1352,10 @@ fn concurrent_dependent_candidates() { // Order is not guaranteed since we have 2 statements being handled concurrently. match msg { AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate(_, tx), + ProspectiveParachainsMessage::IntroduceSecondedCandidate(_, tx), ) => { - tx.send(vec![(leaf_hash, vec![0, 2, 3])]).unwrap(); + tx.send(true).unwrap(); }, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::CandidateSeconded(_, _), - ) => {}, AllMessages::RuntimeApi(RuntimeApiMessage::Request( _, RuntimeApiRequest::ValidationCodeByHash(_, tx), @@ -1362,7 +1412,6 @@ fn concurrent_dependent_candidates() { AllMessages::ProspectiveParachains( ProspectiveParachainsMessage::CandidateBacked(..), ) => {}, - AllMessages::CollatorProtocol(CollatorProtocolMessage::Backed { .. }) => {}, AllMessages::StatementDistribution(StatementDistributionMessage::Share( _, statement, @@ -1406,7 +1455,13 @@ fn concurrent_dependent_candidates() { )) => { tx.send(Ok(test_state.validator_groups.clone())).unwrap(); }, - + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _, + RuntimeApiRequest::NodeFeatures(sess_idx, tx), + )) => { + assert_eq!(sess_idx, 1); + tx.send(Ok(NodeFeatures::EMPTY)).unwrap(); + }, AllMessages::RuntimeApi(RuntimeApiMessage::Request( _parent, RuntimeApiRequest::AvailabilityCores(tx), @@ -1447,7 +1502,7 @@ fn seconding_sanity_check_occupy_same_depth() { let min_relay_parents = vec![(para_id_a, min_block_number), (para_id_b, min_block_number)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -1506,44 +1561,35 @@ fn seconding_sanity_check_occupy_same_depth() { persisted_validation_data: pvd.clone(), }; let expected_request_a = vec![( - HypotheticalFrontierRequest { + HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_hash), }, // Send the same membership for both candidates. - make_hypothetical_frontier_response(vec![0, 1], hypothetical_candidate, leaf_hash), + make_hypothetical_membership_response(hypothetical_candidate, leaf_hash), )]; - assert_hypothetical_frontier_requests( + assert_hypothetical_membership_requests( &mut virtual_overseer, expected_request_a.clone(), ) .await; // Prospective parachains are notified. - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( - req, - tx, - ), - ) if - &req.candidate_receipt == candidate - && &req.candidate_para == para_id - && pvd == req.persisted_validation_data - => { - // Any non-empty response will do. - tx.send(vec![(leaf_hash, vec![0, 2, 3])]).unwrap(); - } - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::CandidateSeconded(_, _) - ) + ProspectiveParachainsMessage::IntroduceSecondedCandidate( + req, + tx, + ), + ) if + &req.candidate_receipt == candidate + && &req.candidate_para == para_id + && pvd == req.persisted_validation_data + => { + tx.send(true).unwrap(); + } ); assert_matches!( @@ -1581,7 +1627,8 @@ fn occupied_core_assignment() { let previous_para_id = test_state.chain_ids[1]; // Set the core state to occupied. - let mut candidate_descriptor = ::test_helpers::dummy_candidate_descriptor(Hash::zero()); + let mut candidate_descriptor = + polkadot_primitives_test_helpers::dummy_candidate_descriptor(Hash::zero()); candidate_descriptor.para_id = previous_para_id; test_state.availability_cores[0] = CoreState::Occupied(OccupiedCore { group_responsible: Default::default(), @@ -1600,7 +1647,7 @@ fn occupied_core_assignment() { let min_relay_parents = vec![(para_id, LEAF_A_BLOCK_NUMBER - LEAF_A_ANCESTRY_LEN)]; let test_leaf_a = TestLeaf { activated, min_relay_parents }; - activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state, 0).await; + activate_leaf(&mut virtual_overseer, test_leaf_a, &test_state).await; let pov = PoV { block_data: BlockData(vec![42, 43, 44]) }; let pvd = dummy_pvd(); @@ -1648,23 +1695,18 @@ fn occupied_core_assignment() { persisted_validation_data: pvd.clone(), }; let expected_request = vec![( - HypotheticalFrontierRequest { + HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(leaf_a_hash), - backed_in_path_only: false, + fragment_chain_relay_parent: Some(leaf_a_hash), }, - make_hypothetical_frontier_response( - vec![0, 1, 2, 3], - hypothetical_candidate, - leaf_a_hash, - ), + make_hypothetical_membership_response(hypothetical_candidate, leaf_a_hash), )]; - assert_hypothetical_frontier_requests(&mut virtual_overseer, expected_request).await; + assert_hypothetical_membership_requests(&mut virtual_overseer, expected_request).await; // Prospective parachains are notified. assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::IntroduceCandidate( + ProspectiveParachainsMessage::IntroduceSecondedCandidate( req, tx, ), @@ -1673,19 +1715,10 @@ fn occupied_core_assignment() { && req.candidate_para == para_id && pvd == req.persisted_validation_data => { - // Any non-empty response will do. - tx.send(vec![(leaf_a_hash, vec![0, 1, 2, 3])]).unwrap(); + tx.send(true).unwrap(); } ); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains(ProspectiveParachainsMessage::CandidateSeconded( - _, - _ - )) - ); - assert_matches!( virtual_overseer.recv().await, AllMessages::StatementDistribution( diff --git a/polkadot/node/core/bitfield-signing/Cargo.toml b/polkadot/node/core/bitfield-signing/Cargo.toml index 0663e0f1b699bbf44e0ecd51dcf646bc27966a2c..126a18a141661c49411b576d9730e255ca627692 100644 --- a/polkadot/node/core/bitfield-signing/Cargo.toml +++ b/polkadot/node/core/bitfield-signing/Cargo.toml @@ -10,15 +10,15 @@ description = "Bitfield signing subsystem for the Polkadot node" workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -wasm-timer = "0.2.5" +futures = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +wasm-timer = { workspace = true } thiserror = { workspace = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/core/bitfield-signing/src/lib.rs b/polkadot/node/core/bitfield-signing/src/lib.rs index 89851c4a033b58428fa8eac366aafcd5f7144140..e3effb7949eaea0381c556c47eae0a1b6f09dc33 100644 --- a/polkadot/node/core/bitfield-signing/src/lib.rs +++ b/polkadot/node/core/bitfield-signing/src/lib.rs @@ -27,15 +27,14 @@ use futures::{ FutureExt, }; use polkadot_node_subsystem::{ - errors::RuntimeApiError, jaeger, - messages::{ - AvailabilityStoreMessage, BitfieldDistributionMessage, RuntimeApiMessage, RuntimeApiRequest, - }, + messages::{AvailabilityStoreMessage, BitfieldDistributionMessage}, overseer, ActivatedLeaf, FromOrchestra, OverseerSignal, PerLeafSpan, SpawnedSubsystem, - SubsystemError, SubsystemResult, SubsystemSender, + SubsystemError, SubsystemResult, +}; +use polkadot_node_subsystem_util::{ + self as util, request_availability_cores, runtime::recv_runtime, Validator, }; -use polkadot_node_subsystem_util::{self as util, Validator}; use polkadot_primitives::{AvailabilityBitfield, CoreState, Hash, ValidatorIndex}; use sp_keystore::{Error as KeystoreError, KeystorePtr}; use std::{collections::HashMap, time::Duration}; @@ -69,7 +68,7 @@ pub enum Error { MpscSend(#[from] mpsc::SendError), #[error(transparent)] - Runtime(#[from] RuntimeApiError), + Runtime(#[from] util::runtime::Error), #[error("Keystore failed: {0:?}")] Keystore(KeystoreError), @@ -79,8 +78,8 @@ pub enum Error { /// for whether we have the availability chunk for our validator index. async fn get_core_availability( core: &CoreState, - validator_idx: ValidatorIndex, - sender: &Mutex<&mut impl SubsystemSender>, + validator_index: ValidatorIndex, + sender: &Mutex<&mut impl overseer::BitfieldSigningSenderTrait>, span: &jaeger::Span, ) -> Result { if let CoreState::Occupied(core) = core { @@ -90,14 +89,11 @@ async fn get_core_availability( sender .lock() .await - .send_message( - AvailabilityStoreMessage::QueryChunkAvailability( - core.candidate_hash, - validator_idx, - tx, - ) - .into(), - ) + .send_message(AvailabilityStoreMessage::QueryChunkAvailability( + core.candidate_hash, + validator_index, + tx, + )) .await; let res = rx.await.map_err(Into::into); @@ -116,25 +112,6 @@ async fn get_core_availability( } } -/// delegates to the v1 runtime API -async fn get_availability_cores( - relay_parent: Hash, - sender: &mut impl SubsystemSender, -) -> Result, Error> { - let (tx, rx) = oneshot::channel(); - sender - .send_message( - RuntimeApiMessage::Request(relay_parent, RuntimeApiRequest::AvailabilityCores(tx)) - .into(), - ) - .await; - match rx.await { - Ok(Ok(out)) => Ok(out), - Ok(Err(runtime_err)) => Err(runtime_err.into()), - Err(err) => Err(err.into()), - } -} - /// - get the list of core states from the runtime /// - for each core, concurrently determine chunk availability (see `get_core_availability`) /// - return the bitfield if there were no errors at any point in this process (otherwise, it's @@ -143,12 +120,12 @@ async fn construct_availability_bitfield( relay_parent: Hash, span: &jaeger::Span, validator_idx: ValidatorIndex, - sender: &mut impl SubsystemSender, + sender: &mut impl overseer::BitfieldSigningSenderTrait, ) -> Result { // get the set of availability cores from the runtime let availability_cores = { let _span = span.child("get-availability-cores"); - get_availability_cores(relay_parent, sender).await? + recv_runtime(request_availability_cores(relay_parent, sender).await).await? }; // Wrap the sender in a Mutex to share it between the futures. diff --git a/polkadot/node/core/bitfield-signing/src/tests.rs b/polkadot/node/core/bitfield-signing/src/tests.rs index 106ecc06b1569862d7adeacada748e03b586b4ec..eeaa524d1c631101915ad0209c67307499bab73d 100644 --- a/polkadot/node/core/bitfield-signing/src/tests.rs +++ b/polkadot/node/core/bitfield-signing/src/tests.rs @@ -16,9 +16,9 @@ use super::*; use futures::{executor::block_on, pin_mut, StreamExt}; -use polkadot_node_subsystem::messages::AllMessages; +use polkadot_node_subsystem::messages::{AllMessages, RuntimeApiMessage, RuntimeApiRequest}; use polkadot_primitives::{CandidateHash, OccupiedCore}; -use test_helpers::dummy_candidate_descriptor; +use polkadot_primitives_test_helpers::dummy_candidate_descriptor; fn occupied_core(para_id: u32, candidate_hash: CandidateHash) -> CoreState { CoreState::Occupied(OccupiedCore { @@ -64,7 +64,7 @@ fn construct_availability_bitfield_works() { AllMessages::AvailabilityStore( AvailabilityStoreMessage::QueryChunkAvailability(c_hash, vidx, tx), ) => { - assert_eq!(validator_index, vidx); + assert_eq!(validator_index, vidx.into()); tx.send(c_hash == hash_a).unwrap(); }, diff --git a/polkadot/node/core/candidate-validation/Cargo.toml b/polkadot/node/core/candidate-validation/Cargo.toml index 0cf4707aad29b3931cab7d65005799cf58c8c38e..fcacc38cae65cb6b6bd8fe56a247c38a06fb05a1 100644 --- a/polkadot/node/core/candidate-validation/Cargo.toml +++ b/polkadot/node/core/candidate-validation/Cargo.toml @@ -10,29 +10,31 @@ license.workspace = true workspace = true [dependencies] -async-trait = "0.1.79" -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } +async-trait = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } -sp-maybe-compressed-blob = { package = "sp-maybe-compressed-blob", path = "../../../../substrate/primitives/maybe-compressed-blob" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } +sp-keystore = { workspace = true } +sp-application-crypto = { workspace = true } +codec = { features = ["bit-vec", "derive"], workspace = true } -polkadot-primitives = { path = "../../../primitives" } -polkadot-parachain-primitives = { path = "../../../parachain" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-metrics = { path = "../../metrics" } -polkadot-overseer = { path = "../../overseer" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } [target.'cfg(not(any(target_os = "android", target_os = "unknown")))'.dependencies] -polkadot-node-core-pvf = { path = "../pvf" } +polkadot-node-core-pvf = { workspace = true, default-features = true } [dev-dependencies] -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -futures = { version = "0.3.30", features = ["thread-pool"] } -assert_matches = "1.4.0" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-core = { path = "../../../../substrate/primitives/core" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +sp-keyring = { workspace = true, default-features = true } +futures = { features = ["thread-pool"], workspace = true } +assert_matches = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/core/candidate-validation/src/lib.rs b/polkadot/node/core/candidate-validation/src/lib.rs index 08881dad1961f4beb4249c632f3a82c8f86cc68c..103d29e8d269429be3dc94fa3f0e4d85d4c98a67 100644 --- a/polkadot/node/core/candidate-validation/src/lib.rs +++ b/polkadot/node/core/candidate-validation/src/lib.rs @@ -27,9 +27,7 @@ use polkadot_node_core_pvf::{ InternalValidationError, InvalidCandidate as WasmInvalidCandidate, PossiblyInvalidError, PrepareError, PrepareJobKind, PvfPrepData, ValidationError, ValidationHost, }; -use polkadot_node_primitives::{ - BlockData, InvalidCandidate, PoV, ValidationResult, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT, -}; +use polkadot_node_primitives::{InvalidCandidate, PoV, ValidationResult}; use polkadot_node_subsystem::{ errors::RuntimeApiError, messages::{ @@ -39,25 +37,27 @@ use polkadot_node_subsystem::{ overseer, FromOrchestra, OverseerSignal, SpawnedSubsystem, SubsystemError, SubsystemResult, SubsystemSender, }; -use polkadot_node_subsystem_util::executor_params_at_relay_parent; -use polkadot_parachain_primitives::primitives::{ - ValidationParams, ValidationResult as WasmValidationResult, -}; +use polkadot_node_subsystem_util as util; +use polkadot_overseer::ActiveLeavesUpdate; +use polkadot_parachain_primitives::primitives::ValidationResult as WasmValidationResult; use polkadot_primitives::{ executor_params::{ DEFAULT_APPROVAL_EXECUTION_TIMEOUT, DEFAULT_BACKING_EXECUTION_TIMEOUT, DEFAULT_LENIENT_PREPARATION_TIMEOUT, DEFAULT_PRECHECK_PREPARATION_TIMEOUT, }, - CandidateCommitments, CandidateDescriptor, CandidateReceipt, ExecutorParams, Hash, - OccupiedCoreAssumption, PersistedValidationData, PvfExecKind, PvfPrepKind, ValidationCode, - ValidationCodeHash, + AuthorityDiscoveryId, CandidateCommitments, CandidateDescriptor, CandidateEvent, + CandidateReceipt, ExecutorParams, Hash, OccupiedCoreAssumption, PersistedValidationData, + PvfExecKind, PvfPrepKind, SessionIndex, ValidationCode, ValidationCodeHash, }; +use sp_application_crypto::{AppCrypto, ByteArray}; +use sp_keystore::KeystorePtr; -use parity_scale_codec::Encode; +use codec::Encode; use futures::{channel::oneshot, prelude::*, stream::FuturesUnordered}; use std::{ + collections::HashSet, path::PathBuf, pin::Pin, sync::Arc, @@ -88,7 +88,7 @@ const PVF_APPROVAL_EXECUTION_RETRY_DELAY: Duration = Duration::from_millis(200); const TASK_LIMIT: usize = 30; /// Configuration for the candidate validation subsystem -#[derive(Clone)] +#[derive(Clone, Default)] pub struct Config { /// The path where candidate validation can store compiled artifacts for PVFs. pub artifacts_cache_path: PathBuf, @@ -111,6 +111,7 @@ pub struct Config { /// The candidate validation subsystem. pub struct CandidateValidationSubsystem { + keystore: KeystorePtr, #[allow(missing_docs)] pub metrics: Metrics, #[allow(missing_docs)] @@ -122,10 +123,11 @@ impl CandidateValidationSubsystem { /// Create a new `CandidateValidationSubsystem`. pub fn with_config( config: Option, + keystore: KeystorePtr, metrics: Metrics, pvf_metrics: polkadot_node_core_pvf::Metrics, ) -> Self { - CandidateValidationSubsystem { config, metrics, pvf_metrics } + CandidateValidationSubsystem { keystore, config, metrics, pvf_metrics } } } @@ -133,7 +135,7 @@ impl CandidateValidationSubsystem { impl CandidateValidationSubsystem { fn start(self, ctx: Context) -> SpawnedSubsystem { if let Some(config) = self.config { - let future = run(ctx, self.metrics, self.pvf_metrics, config) + let future = run(ctx, self.keystore, self.metrics, self.pvf_metrics, config) .map_err(|e| SubsystemError::with_origin("candidate-validation", e)) .boxed(); SpawnedSubsystem { name: "candidate-validation-subsystem", future } @@ -223,6 +225,7 @@ where #[overseer::contextbounds(CandidateValidation, prefix = self::overseer)] async fn run( mut ctx: Context, + keystore: KeystorePtr, metrics: Metrics, pvf_metrics: polkadot_node_core_pvf::Metrics, Config { @@ -253,13 +256,16 @@ async fn run( ctx.spawn_blocking("pvf-validation-host", task.boxed())?; let mut tasks = FuturesUnordered::new(); + let mut prepare_state = PrepareValidationState::default(); loop { loop { futures::select! { comm = ctx.recv().fuse() => { match comm { - Ok(FromOrchestra::Signal(OverseerSignal::ActiveLeaves(_))) => {}, + Ok(FromOrchestra::Signal(OverseerSignal::ActiveLeaves(update))) => { + maybe_prepare_validation(ctx.sender(), keystore.clone(), validation_host.clone(), update, &mut prepare_state).await; + }, Ok(FromOrchestra::Signal(OverseerSignal::BlockFinalized(..))) => {}, Ok(FromOrchestra::Signal(OverseerSignal::Conclude)) => return Ok(()), Ok(FromOrchestra::Communication { msg }) => { @@ -298,6 +304,237 @@ async fn run( } } +struct PrepareValidationState { + session_index: Option, + is_next_session_authority: bool, + // PVF host won't prepare the same code hash twice, so here we just avoid extra communication + already_prepared_code_hashes: HashSet, + // How many PVFs per block we take to prepare themselves for the next session validation + per_block_limit: usize, +} + +impl Default for PrepareValidationState { + fn default() -> Self { + Self { + session_index: None, + is_next_session_authority: false, + already_prepared_code_hashes: HashSet::new(), + per_block_limit: 1, + } + } +} + +async fn maybe_prepare_validation( + sender: &mut Sender, + keystore: KeystorePtr, + validation_backend: impl ValidationBackend, + update: ActiveLeavesUpdate, + state: &mut PrepareValidationState, +) where + Sender: SubsystemSender, +{ + let Some(leaf) = update.activated else { return }; + let new_session_index = new_session_index(sender, state.session_index, leaf.hash).await; + if new_session_index.is_some() { + state.session_index = new_session_index; + state.already_prepared_code_hashes.clear(); + state.is_next_session_authority = check_next_session_authority( + sender, + keystore, + leaf.hash, + state.session_index.expect("qed: just checked above"), + ) + .await; + } + + // On every active leaf check candidates and prepare PVFs our node doesn't have yet. + if state.is_next_session_authority { + let code_hashes = prepare_pvfs_for_backed_candidates( + sender, + validation_backend, + leaf.hash, + &state.already_prepared_code_hashes, + state.per_block_limit, + ) + .await; + state.already_prepared_code_hashes.extend(code_hashes.unwrap_or_default()); + } +} + +// Returns the new session index if it is greater than the current one. +async fn new_session_index( + sender: &mut Sender, + session_index: Option, + relay_parent: Hash, +) -> Option +where + Sender: SubsystemSender, +{ + let Ok(Ok(new_session_index)) = + util::request_session_index_for_child(relay_parent, sender).await.await + else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + "cannot fetch session index from runtime API", + ); + return None + }; + + session_index.map_or(Some(new_session_index), |index| { + if new_session_index > index { + Some(new_session_index) + } else { + None + } + }) +} + +// Returns true if the node is an authority in the next session. +async fn check_next_session_authority( + sender: &mut Sender, + keystore: KeystorePtr, + relay_parent: Hash, + session_index: SessionIndex, +) -> bool +where + Sender: SubsystemSender, +{ + // In spite of function name here we request past, present and future authorities. + // It's ok to stil prepare PVFs in other cases, but better to request only future ones. + let Ok(Ok(authorities)) = util::request_authorities(relay_parent, sender).await.await else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + "cannot fetch authorities from runtime API", + ); + return false + }; + + // We need to exclude at least current session authority from the previous request + let Ok(Ok(Some(session_info))) = + util::request_session_info(relay_parent, session_index, sender).await.await + else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + "cannot fetch session info from runtime API", + ); + return false + }; + + let is_past_present_or_future_authority = authorities + .iter() + .any(|v| keystore.has_keys(&[(v.to_raw_vec(), AuthorityDiscoveryId::ID)])); + + let is_present_authority = session_info + .discovery_keys + .iter() + .any(|v| keystore.has_keys(&[(v.to_raw_vec(), AuthorityDiscoveryId::ID)])); + + // There is still a chance to be a previous session authority, but this extra work does not + // affect the finalization. + is_past_present_or_future_authority && !is_present_authority +} + +// Sends PVF with unknown code hashes to the validation host returning the list of code hashes sent. +async fn prepare_pvfs_for_backed_candidates( + sender: &mut Sender, + mut validation_backend: impl ValidationBackend, + relay_parent: Hash, + already_prepared: &HashSet, + per_block_limit: usize, +) -> Option> +where + Sender: SubsystemSender, +{ + let Ok(Ok(events)) = util::request_candidate_events(relay_parent, sender).await.await else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + "cannot fetch candidate events from runtime API", + ); + return None + }; + let code_hashes = events + .into_iter() + .filter_map(|e| match e { + CandidateEvent::CandidateBacked(receipt, ..) => { + let h = receipt.descriptor.validation_code_hash; + if already_prepared.contains(&h) { + None + } else { + Some(h) + } + }, + _ => None, + }) + .take(per_block_limit) + .collect::>(); + + let Ok(executor_params) = util::executor_params_at_relay_parent(relay_parent, sender).await + else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + "cannot fetch executor params for the session", + ); + return None + }; + let timeout = pvf_prep_timeout(&executor_params, PvfPrepKind::Prepare); + + let mut active_pvfs = vec![]; + let mut processed_code_hashes = vec![]; + for code_hash in code_hashes { + let Ok(Ok(Some(validation_code))) = + util::request_validation_code_by_hash(relay_parent, code_hash, sender) + .await + .await + else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + ?code_hash, + "cannot fetch validation code hash from runtime API", + ); + continue; + }; + + let pvf = PvfPrepData::from_code( + validation_code.0, + executor_params.clone(), + timeout, + PrepareJobKind::Prechecking, + ); + + active_pvfs.push(pvf); + processed_code_hashes.push(code_hash); + } + + if active_pvfs.is_empty() { + return None + } + + if let Err(err) = validation_backend.heads_up(active_pvfs).await { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + ?err, + "cannot prepare PVF for the next session", + ); + return None + }; + + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + ?processed_code_hashes, + "Prepared PVF for the next session", + ); + + Some(processed_code_hashes) +} + struct RuntimeRequestFailed; async fn runtime_api_request( @@ -378,43 +615,35 @@ where }, }; - let executor_params = - if let Ok(executor_params) = executor_params_at_relay_parent(relay_parent, sender).await { - gum::debug!( - target: LOG_TARGET, - ?relay_parent, - ?validation_code_hash, - "precheck: acquired executor params for the session: {:?}", - executor_params, - ); - executor_params - } else { - gum::warn!( - target: LOG_TARGET, - ?relay_parent, - ?validation_code_hash, - "precheck: failed to acquire executor params for the session, thus voting against.", - ); - return PreCheckOutcome::Invalid - }; + let executor_params = if let Ok(executor_params) = + util::executor_params_at_relay_parent(relay_parent, sender).await + { + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + ?validation_code_hash, + "precheck: acquired executor params for the session: {:?}", + executor_params, + ); + executor_params + } else { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + ?validation_code_hash, + "precheck: failed to acquire executor params for the session, thus voting against.", + ); + return PreCheckOutcome::Invalid + }; let timeout = pvf_prep_timeout(&executor_params, PvfPrepKind::Precheck); - let pvf = match sp_maybe_compressed_blob::decompress( - &validation_code.0, - VALIDATION_CODE_BOMB_LIMIT, - ) { - Ok(code) => PvfPrepData::from_code( - code.into_owned(), - executor_params, - timeout, - PrepareJobKind::Prechecking, - ), - Err(e) => { - gum::debug!(target: LOG_TARGET, err=?e, "precheck: cannot decompress validation code"); - return PreCheckOutcome::Invalid - }, - }; + let pvf = PvfPrepData::from_code( + validation_code.0, + executor_params, + timeout, + PrepareJobKind::Prechecking, + ); match validation_backend.precheck_pvf(pvf).await { Ok(_) => PreCheckOutcome::Valid, @@ -622,41 +851,7 @@ async fn validate_candidate_exhaustive( return Ok(ValidationResult::Invalid(e)) } - let raw_validation_code = match sp_maybe_compressed_blob::decompress( - &validation_code.0, - VALIDATION_CODE_BOMB_LIMIT, - ) { - Ok(code) => code, - Err(e) => { - gum::info!(target: LOG_TARGET, ?para_id, err=?e, "Invalid candidate (validation code)"); - - // Code already passed pre-checking, if decompression fails now this most likely means - // some local corruption happened. - return Err(ValidationFailed("Code decompression failed".to_string())) - }, - }; - metrics.observe_code_size(raw_validation_code.len()); - - metrics.observe_pov_size(pov.block_data.0.len(), true); - let raw_block_data = - match sp_maybe_compressed_blob::decompress(&pov.block_data.0, POV_BOMB_LIMIT) { - Ok(block_data) => BlockData(block_data.to_vec()), - Err(e) => { - gum::info!(target: LOG_TARGET, ?para_id, err=?e, "Invalid candidate (PoV code)"); - - // If the PoV is invalid, the candidate certainly is. - return Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure)) - }, - }; - metrics.observe_pov_size(raw_block_data.0.len(), false); - - let params = ValidationParams { - parent_head: persisted_validation_data.parent_head.clone(), - block_data: raw_block_data, - relay_parent_number: persisted_validation_data.relay_parent_number, - relay_parent_storage_root: persisted_validation_data.relay_parent_storage_root, - }; - + let persisted_validation_data = Arc::new(persisted_validation_data); let result = match exec_kind { // Retry is disabled to reduce the chance of nondeterministic blocks getting backed and // honest backers getting slashed. @@ -664,7 +859,7 @@ async fn validate_candidate_exhaustive( let prep_timeout = pvf_prep_timeout(&executor_params, PvfPrepKind::Prepare); let exec_timeout = pvf_exec_timeout(&executor_params, exec_kind); let pvf = PvfPrepData::from_code( - raw_validation_code.to_vec(), + validation_code.0, executor_params, prep_timeout, PrepareJobKind::Compilation, @@ -674,7 +869,8 @@ async fn validate_candidate_exhaustive( .validate_candidate( pvf, exec_timeout, - params.encode(), + persisted_validation_data.clone(), + pov, polkadot_node_core_pvf::Priority::Normal, ) .await @@ -682,9 +878,10 @@ async fn validate_candidate_exhaustive( PvfExecKind::Approval => validation_backend .validate_candidate_with_retry( - raw_validation_code.to_vec(), + validation_code.0, pvf_exec_timeout(&executor_params, exec_kind), - params, + persisted_validation_data.clone(), + pov, executor_params, PVF_APPROVAL_EXECUTION_RETRY_DELAY, polkadot_node_core_pvf::Priority::Critical, @@ -710,6 +907,8 @@ async fn validate_candidate_exhaustive( Ok(ValidationResult::Invalid(InvalidCandidate::Timeout)), Err(ValidationError::Invalid(WasmInvalidCandidate::WorkerReportedInvalid(e))) => Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError(e))), + Err(ValidationError::Invalid(WasmInvalidCandidate::PoVDecompressionFailure)) => + Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure)), Err(ValidationError::PossiblyInvalid(PossiblyInvalidError::AmbiguousWorkerDeath)) => Ok(ValidationResult::Invalid(InvalidCandidate::ExecutionError( "ambiguous worker death".to_string(), @@ -756,7 +955,7 @@ async fn validate_candidate_exhaustive( // invalid. Ok(ValidationResult::Invalid(InvalidCandidate::CommitmentsHashMismatch)) } else { - Ok(ValidationResult::Valid(outputs, persisted_validation_data)) + Ok(ValidationResult::Valid(outputs, (*persisted_validation_data).clone())) } }, } @@ -769,7 +968,8 @@ trait ValidationBackend { &mut self, pvf: PvfPrepData, exec_timeout: Duration, - encoded_params: Vec, + pvd: Arc, + pov: Arc, // The priority for the preparation job. prepare_priority: polkadot_node_core_pvf::Priority, ) -> Result; @@ -784,9 +984,10 @@ trait ValidationBackend { /// preparation. async fn validate_candidate_with_retry( &mut self, - raw_validation_code: Vec, + code: Vec, exec_timeout: Duration, - params: ValidationParams, + pvd: Arc, + pov: Arc, executor_params: ExecutorParams, retry_delay: Duration, // The priority for the preparation job. @@ -795,7 +996,7 @@ trait ValidationBackend { let prep_timeout = pvf_prep_timeout(&executor_params, PvfPrepKind::Prepare); // Construct the PVF a single time, since it is an expensive operation. Cloning it is cheap. let pvf = PvfPrepData::from_code( - raw_validation_code, + code, executor_params, prep_timeout, PrepareJobKind::Compilation, @@ -806,7 +1007,13 @@ trait ValidationBackend { // Use `Priority::Critical` as finality trumps parachain liveliness. let mut validation_result = self - .validate_candidate(pvf.clone(), exec_timeout, params.encode(), prepare_priority) + .validate_candidate( + pvf.clone(), + exec_timeout, + pvd.clone(), + pov.clone(), + prepare_priority, + ) .await; if validation_result.is_ok() { return validation_result @@ -879,10 +1086,14 @@ trait ValidationBackend { validation_result ); - // Encode the params again when re-trying. We expect the retry case to be relatively - // rare, and we want to avoid unconditionally cloning data. validation_result = self - .validate_candidate(pvf.clone(), new_timeout, params.encode(), prepare_priority) + .validate_candidate( + pvf.clone(), + new_timeout, + pvd.clone(), + pov.clone(), + prepare_priority, + ) .await; } } @@ -891,6 +1102,8 @@ trait ValidationBackend { } async fn precheck_pvf(&mut self, pvf: PvfPrepData) -> Result<(), PrepareError>; + + async fn heads_up(&mut self, active_pvfs: Vec) -> Result<(), String>; } #[async_trait] @@ -900,13 +1113,13 @@ impl ValidationBackend for ValidationHost { &mut self, pvf: PvfPrepData, exec_timeout: Duration, - encoded_params: Vec, + pvd: Arc, + pov: Arc, // The priority for the preparation job. prepare_priority: polkadot_node_core_pvf::Priority, ) -> Result { let (tx, rx) = oneshot::channel(); - if let Err(err) = - self.execute_pvf(pvf, exec_timeout, encoded_params, prepare_priority, tx).await + if let Err(err) = self.execute_pvf(pvf, exec_timeout, pvd, pov, prepare_priority, tx).await { return Err(InternalValidationError::HostCommunication(format!( "cannot send pvf to the validation host, it might have shut down: {:?}", @@ -933,6 +1146,10 @@ impl ValidationBackend for ValidationHost { precheck_result } + + async fn heads_up(&mut self, active_pvfs: Vec) -> Result<(), String> { + self.heads_up(active_pvfs).await + } } /// Does basic checks of a candidate. Provide the encoded PoV-block. Returns `Ok` if basic checks diff --git a/polkadot/node/core/candidate-validation/src/metrics.rs b/polkadot/node/core/candidate-validation/src/metrics.rs index 28fc957ddb1a7acd0b5c67f4a52e70bf5e56f734..1459907aa5999980dd82ec0e08a5839959167cef 100644 --- a/polkadot/node/core/candidate-validation/src/metrics.rs +++ b/polkadot/node/core/candidate-validation/src/metrics.rs @@ -23,8 +23,6 @@ pub(crate) struct MetricsInner { pub(crate) validate_from_chain_state: prometheus::Histogram, pub(crate) validate_from_exhaustive: prometheus::Histogram, pub(crate) validate_candidate_exhaustive: prometheus::Histogram, - pub(crate) pov_size: prometheus::HistogramVec, - pub(crate) code_size: prometheus::Histogram, } /// Candidate validation metrics. @@ -70,21 +68,6 @@ impl Metrics { .as_ref() .map(|metrics| metrics.validate_candidate_exhaustive.start_timer()) } - - pub fn observe_code_size(&self, code_size: usize) { - if let Some(metrics) = &self.0 { - metrics.code_size.observe(code_size as f64); - } - } - - pub fn observe_pov_size(&self, pov_size: usize, compressed: bool) { - if let Some(metrics) = &self.0 { - metrics - .pov_size - .with_label_values(&[if compressed { "true" } else { "false" }]) - .observe(pov_size as f64); - } - } } impl metrics::Metrics for Metrics { @@ -121,33 +104,6 @@ impl metrics::Metrics for Metrics { ))?, registry, )?, - pov_size: prometheus::register( - prometheus::HistogramVec::new( - prometheus::HistogramOpts::new( - "polkadot_parachain_candidate_validation_pov_size", - "The compressed and decompressed size of the proof of validity of a candidate", - ) - .buckets( - prometheus::exponential_buckets(16384.0, 2.0, 10) - .expect("arguments are always valid; qed"), - ), - &["compressed"], - )?, - registry, - )?, - code_size: prometheus::register( - prometheus::Histogram::with_opts( - prometheus::HistogramOpts::new( - "polkadot_parachain_candidate_validation_code_size", - "The size of the decompressed WASM validation blob used for checking a candidate", - ) - .buckets( - prometheus::exponential_buckets(16384.0, 2.0, 10) - .expect("arguments are always valid; qed"), - ), - )?, - registry, - )?, }; Ok(Metrics(Some(metrics))) } diff --git a/polkadot/node/core/candidate-validation/src/tests.rs b/polkadot/node/core/candidate-validation/src/tests.rs index e492d51e239ed4bcdfd3a239f635fcd0b0f2154b..55282fdf4ee1da540f8aa95f272ccee0352a7390 100644 --- a/polkadot/node/core/candidate-validation/src/tests.rs +++ b/polkadot/node/core/candidate-validation/src/tests.rs @@ -14,17 +14,26 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use std::sync::atomic::{AtomicUsize, Ordering}; + use super::*; -use ::test_helpers::{dummy_hash, make_valid_candidate_descriptor}; use assert_matches::assert_matches; use futures::executor; use polkadot_node_core_pvf::PrepareError; +use polkadot_node_primitives::{BlockData, VALIDATION_CODE_BOMB_LIMIT}; use polkadot_node_subsystem::messages::AllMessages; -use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_node_subsystem_util::reexports::SubsystemContext; -use polkadot_primitives::{HeadData, Id as ParaId, UpwardMessage}; +use polkadot_overseer::ActivatedLeaf; +use polkadot_primitives::{ + CoreIndex, GroupIndex, HeadData, Id as ParaId, IndexedVec, SessionInfo, UpwardMessage, + ValidatorId, ValidatorIndex, +}; +use polkadot_primitives_test_helpers::{ + dummy_collator, dummy_collator_signature, dummy_hash, make_valid_candidate_descriptor, +}; use sp_core::testing::TaskExecutor; use sp_keyring::Sr25519Keyring; +use sp_keystore::{testing::MemoryKeystore, Keystore}; #[test] fn correctly_checks_included_assumption() { @@ -47,8 +56,10 @@ fn correctly_checks_included_assumption() { ); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = check_assumption_validation_data( ctx.sender(), @@ -119,8 +130,10 @@ fn correctly_checks_timed_out_assumption() { ); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = check_assumption_validation_data( ctx.sender(), @@ -189,8 +202,10 @@ fn check_is_bad_request_if_no_validation_data() { ); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = check_assumption_validation_data( ctx.sender(), @@ -243,8 +258,10 @@ fn check_is_bad_request_if_no_validation_code() { ); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = check_assumption_validation_data( ctx.sender(), @@ -309,8 +326,10 @@ fn check_does_not_match() { ); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = check_assumption_validation_data( ctx.sender(), @@ -367,7 +386,8 @@ impl ValidationBackend for MockValidateCandidateBackend { &mut self, _pvf: PvfPrepData, _timeout: Duration, - _encoded_params: Vec, + _pvd: Arc, + _pov: Arc, _prepare_priority: polkadot_node_core_pvf::Priority, ) -> Result { // This is expected to panic if called more times than expected, indicating an error in the @@ -381,6 +401,10 @@ impl ValidationBackend for MockValidateCandidateBackend { async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<(), PrepareError> { unreachable!() } + + async fn heads_up(&mut self, _active_pvfs: Vec) -> Result<(), String> { + unreachable!() + } } #[test] @@ -850,7 +874,10 @@ fn candidate_validation_code_mismatch_is_invalid() { let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() }; let pool = TaskExecutor::new(); - let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::(pool.clone()); + let (_ctx, _ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let v = executor::block_on(validate_candidate_exhaustive( MockValidateCandidateBackend::with_hardcoded_result(Err(ValidationError::Invalid( @@ -925,109 +952,6 @@ fn compressed_code_works() { assert_matches!(v, Ok(ValidationResult::Valid(_, _))); } -#[test] -fn code_decompression_failure_is_error() { - let validation_data = PersistedValidationData { max_pov_size: 1024, ..Default::default() }; - let pov = PoV { block_data: BlockData(vec![1; 32]) }; - let head_data = HeadData(vec![1, 1, 1]); - - let raw_code = vec![2u8; VALIDATION_CODE_BOMB_LIMIT + 1]; - let validation_code = - sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT + 1) - .map(ValidationCode) - .unwrap(); - - let descriptor = make_valid_candidate_descriptor( - ParaId::from(1_u32), - dummy_hash(), - validation_data.hash(), - pov.hash(), - validation_code.hash(), - head_data.hash(), - dummy_hash(), - Sr25519Keyring::Alice, - ); - - let validation_result = WasmValidationResult { - head_data, - new_validation_code: None, - upward_messages: Default::default(), - horizontal_messages: Default::default(), - processed_downward_messages: 0, - hrmp_watermark: 0, - }; - - let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() }; - - let pool = TaskExecutor::new(); - let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::(pool.clone()); - - let v = executor::block_on(validate_candidate_exhaustive( - MockValidateCandidateBackend::with_hardcoded_result(Ok(validation_result)), - validation_data, - validation_code, - candidate_receipt, - Arc::new(pov), - ExecutorParams::default(), - PvfExecKind::Backing, - &Default::default(), - )); - - assert_matches!(v, Err(_)); -} - -#[test] -fn pov_decompression_failure_is_invalid() { - let validation_data = - PersistedValidationData { max_pov_size: POV_BOMB_LIMIT as u32, ..Default::default() }; - let head_data = HeadData(vec![1, 1, 1]); - - let raw_block_data = vec![2u8; POV_BOMB_LIMIT + 1]; - let pov = sp_maybe_compressed_blob::compress(&raw_block_data, POV_BOMB_LIMIT + 1) - .map(|raw| PoV { block_data: BlockData(raw) }) - .unwrap(); - - let validation_code = ValidationCode(vec![2; 16]); - - let descriptor = make_valid_candidate_descriptor( - ParaId::from(1_u32), - dummy_hash(), - validation_data.hash(), - pov.hash(), - validation_code.hash(), - head_data.hash(), - dummy_hash(), - Sr25519Keyring::Alice, - ); - - let validation_result = WasmValidationResult { - head_data, - new_validation_code: None, - upward_messages: Default::default(), - horizontal_messages: Default::default(), - processed_downward_messages: 0, - hrmp_watermark: 0, - }; - - let candidate_receipt = CandidateReceipt { descriptor, commitments_hash: Hash::zero() }; - - let pool = TaskExecutor::new(); - let (_ctx, _ctx_handle) = test_helpers::make_subsystem_context::(pool.clone()); - - let v = executor::block_on(validate_candidate_exhaustive( - MockValidateCandidateBackend::with_hardcoded_result(Ok(validation_result)), - validation_data, - validation_code, - candidate_receipt, - Arc::new(pov), - ExecutorParams::default(), - PvfExecKind::Backing, - &Default::default(), - )); - - assert_matches!(v, Ok(ValidationResult::Invalid(InvalidCandidate::PoVDecompressionFailure))); -} - struct MockPreCheckBackend { result: Result<(), PrepareError>, } @@ -1044,7 +968,8 @@ impl ValidationBackend for MockPreCheckBackend { &mut self, _pvf: PvfPrepData, _timeout: Duration, - _encoded_params: Vec, + _pvd: Arc, + _pov: Arc, _prepare_priority: polkadot_node_core_pvf::Priority, ) -> Result { unreachable!() @@ -1053,6 +978,10 @@ impl ValidationBackend for MockPreCheckBackend { async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<(), PrepareError> { self.result.clone() } + + async fn heads_up(&mut self, _active_pvfs: Vec) -> Result<(), String> { + unreachable!() + } } #[test] @@ -1062,8 +991,10 @@ fn precheck_works() { let validation_code_hash = validation_code.hash(); let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + let (mut ctx, mut ctx_handle) = polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AllMessages, + _, + >(pool.clone()); let (check_fut, check_result) = precheck_pvf( ctx.sender(), @@ -1112,68 +1043,6 @@ fn precheck_works() { executor::block_on(test_fut); } -#[test] -fn precheck_invalid_pvf_blob_compression() { - let relay_parent = [3; 32].into(); - - let raw_code = vec![2u8; VALIDATION_CODE_BOMB_LIMIT + 1]; - let validation_code = - sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT + 1) - .map(ValidationCode) - .unwrap(); - let validation_code_hash = validation_code.hash(); - - let pool = TaskExecutor::new(); - let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); - - let (check_fut, check_result) = precheck_pvf( - ctx.sender(), - MockPreCheckBackend::with_hardcoded_result(Ok(())), - relay_parent, - validation_code_hash, - ) - .remote_handle(); - - let test_fut = async move { - assert_matches!( - ctx_handle.recv().await, - AllMessages::RuntimeApi(RuntimeApiMessage::Request( - rp, - RuntimeApiRequest::ValidationCodeByHash( - vch, - tx - ), - )) => { - assert_eq!(vch, validation_code_hash); - assert_eq!(rp, relay_parent); - - let _ = tx.send(Ok(Some(validation_code.clone()))); - } - ); - assert_matches!( - ctx_handle.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx)) - ) => { - tx.send(Ok(1u32.into())).unwrap(); - } - ); - assert_matches!( - ctx_handle.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(_, tx)) - ) => { - tx.send(Ok(Some(ExecutorParams::default()))).unwrap(); - } - ); - assert_matches!(check_result.await, PreCheckOutcome::Invalid); - }; - - let test_fut = future::join(test_fut, check_fut); - executor::block_on(test_fut); -} - #[test] fn precheck_properly_classifies_outcomes() { let inner = |prepare_result, precheck_outcome| { @@ -1183,7 +1052,9 @@ fn precheck_properly_classifies_outcomes() { let pool = TaskExecutor::new(); let (mut ctx, mut ctx_handle) = - test_helpers::make_subsystem_context::(pool.clone()); + polkadot_node_subsystem_test_helpers::make_subsystem_context::( + pool.clone(), + ); let (check_fut, check_result) = precheck_pvf( ctx.sender(), @@ -1239,3 +1110,629 @@ fn precheck_properly_classifies_outcomes() { inner(Err(PrepareError::TimedOut), PreCheckOutcome::Failed); inner(Err(PrepareError::IoErr("fizz".to_owned())), PreCheckOutcome::Failed); } + +#[derive(Default, Clone)] +struct MockHeadsUp { + heads_up_call_count: Arc, +} + +#[async_trait] +impl ValidationBackend for MockHeadsUp { + async fn validate_candidate( + &mut self, + _pvf: PvfPrepData, + _timeout: Duration, + _pvd: Arc, + _pov: Arc, + _prepare_priority: polkadot_node_core_pvf::Priority, + ) -> Result { + unreachable!() + } + + async fn precheck_pvf(&mut self, _pvf: PvfPrepData) -> Result<(), PrepareError> { + unreachable!() + } + + async fn heads_up(&mut self, _active_pvfs: Vec) -> Result<(), String> { + let _ = self.heads_up_call_count.fetch_add(1, Ordering::SeqCst); + Ok(()) + } +} + +fn alice_keystore() -> KeystorePtr { + let keystore: KeystorePtr = Arc::new(MemoryKeystore::new()); + let _ = Keystore::sr25519_generate_new( + &*keystore, + ValidatorId::ID, + Some(&Sr25519Keyring::Alice.to_seed()), + ) + .unwrap(); + let _ = Keystore::sr25519_generate_new( + &*keystore, + AuthorityDiscoveryId::ID, + Some(&Sr25519Keyring::Alice.to_seed()), + ) + .unwrap(); + + keystore +} + +fn dummy_active_leaves_update(hash: Hash) -> ActiveLeavesUpdate { + ActiveLeavesUpdate { + activated: Some(ActivatedLeaf { + hash, + number: 10, + unpin_handle: polkadot_node_subsystem_test_helpers::mock::dummy_unpin_handle(hash), + span: Arc::new(overseer::jaeger::Span::Disabled), + }), + ..Default::default() + } +} + +fn dummy_candidate_backed( + relay_parent: Hash, + validation_code_hash: ValidationCodeHash, +) -> CandidateEvent { + let zeros = dummy_hash(); + let descriptor = CandidateDescriptor { + para_id: ParaId::from(0_u32), + relay_parent, + collator: dummy_collator(), + persisted_validation_data_hash: zeros, + pov_hash: zeros, + erasure_root: zeros, + signature: dummy_collator_signature(), + para_head: zeros, + validation_code_hash, + }; + + CandidateEvent::CandidateBacked( + CandidateReceipt { descriptor, commitments_hash: zeros }, + HeadData(Vec::new()), + CoreIndex(0), + GroupIndex(0), + ) +} + +fn dummy_session_info(discovery_keys: Vec) -> SessionInfo { + SessionInfo { + validators: IndexedVec::::from(vec![]), + discovery_keys, + assignment_keys: vec![], + validator_groups: Default::default(), + n_cores: 4u32, + zeroth_delay_tranche_width: 0u32, + relay_vrf_modulo_samples: 0u32, + n_delay_tranches: 2u32, + no_show_slots: 0u32, + needed_approvals: 1u32, + active_validator_indices: vec![], + dispute_period: 6, + random_seed: [0u8; 32], + } +} + +#[test] +fn maybe_prepare_validation_golden_path() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState::default(); + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::Authorities(tx))) => { + let _ = tx.send(Ok(vec![Sr25519Keyring::Alice.public().into()])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionInfo(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(dummy_session_info(vec![Sr25519Keyring::Bob.public().into()])))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::CandidateEvents(tx))) => { + let _ = tx.send(Ok(vec![dummy_candidate_backed(activated_hash, dummy_hash().into())])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(ExecutorParams::default()))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))) => { + assert_eq!(hash, dummy_hash().into()); + let _ = tx.send(Ok(Some(ValidationCode(Vec::new())))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 1); + assert!(state.session_index.is_some()); + assert!(state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_checkes_authority_once_per_session() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { + session_index: Some(1), + is_next_session_authority: false, + ..Default::default() + }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 0); + assert!(state.session_index.is_some()); + assert!(!state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_resets_state_on_a_new_session() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { + session_index: Some(1), + is_next_session_authority: true, + already_prepared_code_hashes: HashSet::from_iter(vec![ValidationCode(vec![0; 16]).hash()]), + ..Default::default() + }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(2)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::Authorities(tx))) => { + let _ = tx.send(Ok(vec![Sr25519Keyring::Bob.public().into()])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionInfo(index, tx))) => { + assert_eq!(index, 2); + let _ = tx.send(Ok(Some(dummy_session_info(vec![Sr25519Keyring::Bob.public().into()])))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 0); + assert_eq!(state.session_index.unwrap(), 2); + assert!(!state.is_next_session_authority); + assert!(state.already_prepared_code_hashes.is_empty()); +} + +#[test] +fn maybe_prepare_validation_does_not_prepare_pvfs_if_no_new_session_and_not_a_validator() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { session_index: Some(1), ..Default::default() }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 0); + assert!(state.session_index.is_some()); + assert!(!state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_does_not_prepare_pvfs_if_no_new_session_but_a_validator() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { + session_index: Some(1), + is_next_session_authority: true, + ..Default::default() + }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::CandidateEvents(tx))) => { + let _ = tx.send(Ok(vec![dummy_candidate_backed(activated_hash, dummy_hash().into())])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(ExecutorParams::default()))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))) => { + assert_eq!(hash, dummy_hash().into()); + let _ = tx.send(Ok(Some(ValidationCode(Vec::new())))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 1); + assert!(state.session_index.is_some()); + assert!(state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_does_not_prepare_pvfs_if_not_a_validator_in_the_next_session() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState::default(); + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::Authorities(tx))) => { + let _ = tx.send(Ok(vec![Sr25519Keyring::Bob.public().into()])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionInfo(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(dummy_session_info(vec![Sr25519Keyring::Bob.public().into()])))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 0); + assert!(state.session_index.is_some()); + assert!(!state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_does_not_prepare_pvfs_if_a_validator_in_the_current_session() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState::default(); + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::Authorities(tx))) => { + let _ = tx.send(Ok(vec![Sr25519Keyring::Alice.public().into()])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionInfo(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(dummy_session_info(vec![Sr25519Keyring::Alice.public().into()])))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 0); + assert!(state.session_index.is_some()); + assert!(!state.is_next_session_authority); +} + +#[test] +fn maybe_prepare_validation_prepares_a_limited_number_of_pvfs() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { per_block_limit: 2, ..Default::default() }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::Authorities(tx))) => { + let _ = tx.send(Ok(vec![Sr25519Keyring::Alice.public().into()])); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionInfo(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(dummy_session_info(vec![Sr25519Keyring::Bob.public().into()])))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::CandidateEvents(tx))) => { + let candidates = vec![ + dummy_candidate_backed(activated_hash, ValidationCode(vec![0; 16]).hash()), + dummy_candidate_backed(activated_hash, ValidationCode(vec![1; 16]).hash()), + dummy_candidate_backed(activated_hash, ValidationCode(vec![2; 16]).hash()), + ]; + let _ = tx.send(Ok(candidates)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(ExecutorParams::default()))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))) => { + assert_eq!(hash, ValidationCode(vec![0; 16]).hash()); + let _ = tx.send(Ok(Some(ValidationCode(Vec::new())))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))) => { + assert_eq!(hash, ValidationCode(vec![1; 16]).hash()); + let _ = tx.send(Ok(Some(ValidationCode(Vec::new())))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 1); + assert!(state.session_index.is_some()); + assert!(state.is_next_session_authority); + assert_eq!(state.already_prepared_code_hashes.len(), 2); +} + +#[test] +fn maybe_prepare_validation_does_not_prepare_already_prepared_pvfs() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::(pool); + + let keystore = alice_keystore(); + let backend = MockHeadsUp::default(); + let activated_hash = Hash::random(); + let update = dummy_active_leaves_update(activated_hash); + let mut state = PrepareValidationState { + session_index: Some(1), + is_next_session_authority: true, + per_block_limit: 2, + already_prepared_code_hashes: HashSet::from_iter(vec![ + ValidationCode(vec![0; 16]).hash(), + ValidationCode(vec![1; 16]).hash(), + ]), + }; + + let check_fut = + maybe_prepare_validation(ctx.sender(), keystore, backend.clone(), update, &mut state); + + let test_fut = async move { + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::CandidateEvents(tx))) => { + let candidates = vec![ + dummy_candidate_backed(activated_hash, ValidationCode(vec![0; 16]).hash()), + dummy_candidate_backed(activated_hash, ValidationCode(vec![1; 16]).hash()), + dummy_candidate_backed(activated_hash, ValidationCode(vec![2; 16]).hash()), + ]; + let _ = tx.send(Ok(candidates)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionIndexForChild(tx))) => { + let _ = tx.send(Ok(1)); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::SessionExecutorParams(index, tx))) => { + assert_eq!(index, 1); + let _ = tx.send(Ok(Some(ExecutorParams::default()))); + } + ); + + assert_matches!( + ctx_handle.recv().await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request(_, RuntimeApiRequest::ValidationCodeByHash(hash, tx))) => { + assert_eq!(hash, ValidationCode(vec![2; 16]).hash()); + let _ = tx.send(Ok(Some(ValidationCode(Vec::new())))); + } + ); + }; + + let test_fut = future::join(test_fut, check_fut); + executor::block_on(test_fut); + + assert_eq!(backend.heads_up_call_count.load(Ordering::SeqCst), 1); + assert!(state.session_index.is_some()); + assert!(state.is_next_session_authority); + assert_eq!(state.already_prepared_code_hashes.len(), 3); +} diff --git a/polkadot/node/core/chain-api/Cargo.toml b/polkadot/node/core/chain-api/Cargo.toml index f4d02d3f47b23ac4e71fa44c790bf4b0d1538902..a8e911e0c5c9586c31109462e1a9527c9d8246f2 100644 --- a/polkadot/node/core/chain-api/Cargo.toml +++ b/polkadot/node/core/chain-api/Cargo.toml @@ -10,20 +10,20 @@ description = "The Chain API subsystem provides access to chain related utility workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-node-metrics = { path = "../../metrics" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-types = { path = "../../subsystem-types" } -sc-client-api = { path = "../../../../substrate/client/api" } -sc-consensus-babe = { path = "../../../../substrate/client/consensus/babe" } +futures = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } [dev-dependencies] -futures = { version = "0.3.30", features = ["thread-pool"] } -maplit = "1.0.2" -parity-scale-codec = "3.6.1" -polkadot-node-primitives = { path = "../../primitives" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } +futures = { features = ["thread-pool"], workspace = true } +maplit = { workspace = true } +codec = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-core = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } diff --git a/polkadot/node/core/chain-api/src/tests.rs b/polkadot/node/core/chain-api/src/tests.rs index eae8f6fa4ac591c565930047e4dcf590c914947f..4e85affc540fb1120222745dc9f7ddd5b1a7aacb 100644 --- a/polkadot/node/core/chain-api/src/tests.rs +++ b/polkadot/node/core/chain-api/src/tests.rs @@ -16,8 +16,8 @@ use super::*; +use codec::Encode; use futures::{channel::oneshot, future::BoxFuture}; -use parity_scale_codec::Encode; use std::collections::BTreeMap; use polkadot_node_primitives::BlockWeight; diff --git a/polkadot/node/core/chain-selection/Cargo.toml b/polkadot/node/core/chain-selection/Cargo.toml index 318f27a43086e4c6bee0bf0a0b18a78c9cf525be..755d5cadeaaf388a4e21eff79699ae06368e8010 100644 --- a/polkadot/node/core/chain-selection/Cargo.toml +++ b/polkadot/node/core/chain-selection/Cargo.toml @@ -10,20 +10,20 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -kvdb = "0.13.0" +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +kvdb = { workspace = true } thiserror = { workspace = true } -parity-scale-codec = "3.6.1" +codec = { workspace = true, default-features = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-core = { path = "../../../../substrate/primitives/core" } -parking_lot = "0.12.1" -assert_matches = "1" -kvdb-memorydb = "0.13.0" +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-core = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } +assert_matches = { workspace = true } +kvdb-memorydb = { workspace = true } diff --git a/polkadot/node/core/chain-selection/src/db_backend/v1.rs b/polkadot/node/core/chain-selection/src/db_backend/v1.rs index 7c7144bb763dfbf02adfcb958d18a97b6a96dbb8..8831b1e3c36cc1782036a7b5668bbdd0024bfed9 100644 --- a/polkadot/node/core/chain-selection/src/db_backend/v1.rs +++ b/polkadot/node/core/chain-selection/src/db_backend/v1.rs @@ -40,7 +40,7 @@ use crate::{ use polkadot_node_primitives::BlockWeight; use polkadot_primitives::{BlockNumber, Hash}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_subsystem_util::database::{DBTransaction, Database}; use std::sync::Arc; diff --git a/polkadot/node/core/chain-selection/src/lib.rs b/polkadot/node/core/chain-selection/src/lib.rs index 07c245e839bf18a55f5ec61f02824fa87e9c6ed9..6c091b02709b777cdf75a021799e2b9538d606c4 100644 --- a/polkadot/node/core/chain-selection/src/lib.rs +++ b/polkadot/node/core/chain-selection/src/lib.rs @@ -26,8 +26,8 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_util::database::Database; use polkadot_primitives::{BlockNumber, ConsensusLog, Hash, Header}; +use codec::Error as CodecError; use futures::{channel::oneshot, future::Either, prelude::*}; -use parity_scale_codec::Error as CodecError; use std::{ sync::Arc, diff --git a/polkadot/node/core/chain-selection/src/tests.rs b/polkadot/node/core/chain-selection/src/tests.rs index 1fe87f04cd585abc1674d3a20766e7172fd819fa..2b1e1196ede334f6c6eac6cd08e46665c6d043cf 100644 --- a/polkadot/node/core/chain-selection/src/tests.rs +++ b/polkadot/node/core/chain-selection/src/tests.rs @@ -30,8 +30,8 @@ use std::{ }; use assert_matches::assert_matches; +use codec::Encode; use futures::channel::oneshot; -use parity_scale_codec::Encode; use parking_lot::Mutex; use sp_core::testing::TaskExecutor; @@ -229,13 +229,15 @@ impl Clock for TestClock { const TEST_STAGNANT_INTERVAL: Duration = Duration::from_millis(20); -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; fn test_harness>( test: impl FnOnce(TestBackend, TestClock, VirtualOverseer) -> T, ) { let pool = TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool); let backend = TestBackend::default(); let clock = TestClock::new(0); diff --git a/polkadot/node/core/dispute-coordinator/Cargo.toml b/polkadot/node/core/dispute-coordinator/Cargo.toml index cd3238449bea9d19ec65f418237282523ff3448a..eb4600b235b9f2cfde8f030ebb3b9626d6ea8869 100644 --- a/polkadot/node/core/dispute-coordinator/Cargo.toml +++ b/polkadot/node/core/dispute-coordinator/Cargo.toml @@ -10,33 +10,33 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -parity-scale-codec = "3.6.1" -kvdb = "0.13.0" +futures = { workspace = true } +gum = { workspace = true, default-features = true } +codec = { workspace = true, default-features = true } +kvdb = { workspace = true } thiserror = { workspace = true } -schnellru = "0.2.1" -fatality = "0.0.6" +schnellru = { workspace = true } +fatality = { workspace = true } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } -sc-keystore = { path = "../../../../substrate/client/keystore" } +sc-keystore = { workspace = true, default-features = true } [dev-dependencies] -kvdb-memorydb = "0.13.0" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -assert_matches = "1.4.0" -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } -futures-timer = "3.0.2" -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } +kvdb-memorydb = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +assert_matches = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +futures-timer = { workspace = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } [features] # If not enabled, the dispute coordinator will do nothing. diff --git a/polkadot/node/core/dispute-coordinator/src/db/v1.rs b/polkadot/node/core/dispute-coordinator/src/db/v1.rs index 4950765cf510c047b811f50d0459c0add4c75d78..0101791550ee8192e705c84e06dbe9d269970fec 100644 --- a/polkadot/node/core/dispute-coordinator/src/db/v1.rs +++ b/polkadot/node/core/dispute-coordinator/src/db/v1.rs @@ -31,7 +31,7 @@ use polkadot_primitives::{ use std::sync::Arc; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use crate::{ backend::{Backend, BackendWriteOp, OverlayedBackend}, @@ -258,7 +258,7 @@ pub enum Error { #[error(transparent)] Io(#[from] std::io::Error), #[error(transparent)] - Codec(#[from] parity_scale_codec::Error), + Codec(#[from] codec::Error), } impl From for crate::error::Error { @@ -375,9 +375,9 @@ fn load_cleaned_votes_watermark( mod tests { use super::*; - use ::test_helpers::{dummy_candidate_receipt, dummy_hash}; use polkadot_node_primitives::DISPUTE_WINDOW; use polkadot_primitives::{Hash, Id as ParaId}; + use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; fn make_db() -> DbBackend { let db = kvdb_memorydb::create(1); diff --git a/polkadot/node/core/dispute-coordinator/src/error.rs b/polkadot/node/core/dispute-coordinator/src/error.rs index cbda3dc1d121a622f38848d32afb389d82e01ed9..94bc8e9c9497e31bafaea512a7990523b342099d 100644 --- a/polkadot/node/core/dispute-coordinator/src/error.rs +++ b/polkadot/node/core/dispute-coordinator/src/error.rs @@ -21,7 +21,7 @@ use polkadot_node_subsystem::{errors::ChainApiError, SubsystemError}; use polkadot_node_subsystem_util::runtime; use crate::{db, participation, LOG_TARGET}; -use parity_scale_codec::Error as CodecError; +use codec::Error as CodecError; pub type Result = std::result::Result; pub type FatalResult = std::result::Result; diff --git a/polkadot/node/core/dispute-coordinator/src/initialized.rs b/polkadot/node/core/dispute-coordinator/src/initialized.rs index 5f86da87f21ca060cfe14de536b39e652d12b7b1..5096fe5e6891cd6de7c93036837928fce6cb748a 100644 --- a/polkadot/node/core/dispute-coordinator/src/initialized.rs +++ b/polkadot/node/core/dispute-coordinator/src/initialized.rs @@ -1351,6 +1351,12 @@ impl Initialized { } } for validator_index in new_state.votes().invalid.keys() { + gum::debug!( + target: LOG_TARGET, + ?candidate_hash, + ?validator_index, + "Disabled offchain for voting invalid against a valid candidate", + ); self.offchain_disabled_validators .insert_against_valid(session, *validator_index); } @@ -1375,6 +1381,13 @@ impl Initialized { } for (validator_index, (kind, _sig)) in new_state.votes().valid.raw() { let is_backer = kind.is_backing(); + gum::debug!( + target: LOG_TARGET, + ?candidate_hash, + ?validator_index, + ?is_backer, + "Disabled offchain for voting valid for an invalid candidate", + ); self.offchain_disabled_validators.insert_for_invalid( session, *validator_index, diff --git a/polkadot/node/core/dispute-coordinator/src/lib.rs b/polkadot/node/core/dispute-coordinator/src/lib.rs index daa384b36ffbaf2c8d3c004e35eb537a3c33e4c0..34d9ddf3a97c0be0c7f6e3b43cbc3a1b126b2423 100644 --- a/polkadot/node/core/dispute-coordinator/src/lib.rs +++ b/polkadot/node/core/dispute-coordinator/src/lib.rs @@ -478,6 +478,18 @@ pub fn is_potential_spam( let all_invalid_votes_disabled = vote_state.invalid_votes_all_disabled(is_disabled); let ignore_disabled = !is_confirmed && all_invalid_votes_disabled; + gum::trace!( + target: LOG_TARGET, + ?candidate_hash, + ?is_disputed, + ?is_included, + ?is_backed, + ?is_confirmed, + ?all_invalid_votes_disabled, + ?ignore_disabled, + "Checking for potential spam" + ); + (is_disputed && !is_included && !is_backed && !is_confirmed) || ignore_disabled } diff --git a/polkadot/node/core/dispute-coordinator/src/participation/mod.rs b/polkadot/node/core/dispute-coordinator/src/participation/mod.rs index 05ea7323af1419d770cb7b68e15ee7887ceeaab8..b58ce570f8fff767a975487364cc6fe826c329e3 100644 --- a/polkadot/node/core/dispute-coordinator/src/participation/mod.rs +++ b/polkadot/node/core/dispute-coordinator/src/participation/mod.rs @@ -305,6 +305,7 @@ async fn participate( req.candidate_receipt().clone(), req.session(), None, + None, recover_available_data_tx, )) .await; diff --git a/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs b/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs index 63bfc1d7d026cc7ae406f138d332d42b56fb5949..9176d00b2f5c4ed25166f9c10d0718678653ec5d 100644 --- a/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs +++ b/polkadot/node/core/dispute-coordinator/src/participation/queues/tests.rs @@ -15,9 +15,9 @@ // along with Polkadot. If not, see . use crate::{metrics::Metrics, ParticipationPriority}; -use ::test_helpers::{dummy_candidate_receipt, dummy_hash}; use assert_matches::assert_matches; use polkadot_primitives::{BlockNumber, Hash}; +use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; use super::{CandidateComparator, ParticipationRequest, QueueError, Queues}; diff --git a/polkadot/node/core/dispute-coordinator/src/participation/tests.rs b/polkadot/node/core/dispute-coordinator/src/participation/tests.rs index 367454115f0be8e9aaccaf73b13e721a585c9dd7..a80553828ac69184d89695a3fe4ccc716e11b83f 100644 --- a/polkadot/node/core/dispute-coordinator/src/participation/tests.rs +++ b/polkadot/node/core/dispute-coordinator/src/participation/tests.rs @@ -22,10 +22,7 @@ use std::{sync::Arc, time::Duration}; use sp_core::testing::TaskExecutor; use super::*; -use ::test_helpers::{ - dummy_candidate_commitments, dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash, -}; -use parity_scale_codec::Encode; +use codec::Encode; use polkadot_node_primitives::{AvailableData, BlockData, InvalidCandidate, PoV}; use polkadot_node_subsystem::{ messages::{ @@ -40,6 +37,9 @@ use polkadot_node_subsystem_test_helpers::{ use polkadot_primitives::{ BlakeTwo256, CandidateCommitments, HashT, Header, PersistedValidationData, ValidationCode, }; +use polkadot_primitives_test_helpers::{ + dummy_candidate_commitments, dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash, +}; type VirtualOverseer = TestSubsystemContextHandle; @@ -132,7 +132,7 @@ pub async fn participation_missing_availability(ctx_handle: &mut VirtualOverseer assert_matches!( ctx_handle.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Err(RecoveryError::Unavailable)).unwrap(); }, @@ -151,7 +151,7 @@ async fn recover_available_data(virtual_overseer: &mut VirtualOverseer) { assert_matches!( virtual_overseer.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Ok(available_data)).unwrap(); }, @@ -195,7 +195,7 @@ fn same_req_wont_get_queued_if_participation_is_already_running() { assert_matches!( ctx_handle.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Err(RecoveryError::Unavailable)).unwrap(); }, @@ -260,7 +260,7 @@ fn reqs_get_queued_when_out_of_capacity() { { match ctx_handle.recv().await { AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx), + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx), ) => { tx.send(Err(RecoveryError::Unavailable)).unwrap(); recover_available_data_msg_count += 1; @@ -346,7 +346,7 @@ fn cannot_participate_if_cannot_recover_available_data() { assert_matches!( ctx_handle.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Err(RecoveryError::Unavailable)).unwrap(); }, @@ -412,7 +412,7 @@ fn cast_invalid_vote_if_available_data_is_invalid() { assert_matches!( ctx_handle.recv().await, AllMessages::AvailabilityRecovery( - AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, tx) + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) ) => { tx.send(Err(RecoveryError::Invalid)).unwrap(); }, diff --git a/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs b/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs index 726dda596d7b8be26da55358c95c9080ec89d962..ed2400387ef7f52693c3ab9d6f35f69234caab99 100644 --- a/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs +++ b/polkadot/node/core/dispute-coordinator/src/scraping/tests.rs @@ -18,11 +18,10 @@ use std::time::Duration; use assert_matches::assert_matches; +use codec::Encode; use futures::future::join; -use parity_scale_codec::Encode; use sp_core::testing::TaskExecutor; -use ::test_helpers::{dummy_collator, dummy_collator_signature, dummy_hash}; use polkadot_node_primitives::DISPUTE_CANDIDATE_LIFETIME_AFTER_FINALIZATION; use polkadot_node_subsystem::{ messages::{ @@ -40,6 +39,7 @@ use polkadot_primitives::{ BlakeTwo256, BlockNumber, CandidateDescriptor, CandidateEvent, CandidateReceipt, CoreIndex, GroupIndex, Hash, HashT, HeadData, Id as ParaId, }; +use polkadot_primitives_test_helpers::{dummy_collator, dummy_collator_signature, dummy_hash}; use crate::{scraping::Inclusions, LOG_TARGET}; diff --git a/polkadot/node/core/dispute-coordinator/src/tests.rs b/polkadot/node/core/dispute-coordinator/src/tests.rs index 13cf2df88223ead28dcd98aeaa3c36db13444991..f97a625a9528e1d6034500ee1e2fd2447af98de4 100644 --- a/polkadot/node/core/dispute-coordinator/src/tests.rs +++ b/polkadot/node/core/dispute-coordinator/src/tests.rs @@ -51,7 +51,6 @@ use sp_core::{sr25519::Pair, testing::TaskExecutor, Pair as PairT}; use sp_keyring::Sr25519Keyring; use sp_keystore::{Keystore, KeystorePtr}; -use ::test_helpers::{dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash}; use polkadot_node_primitives::{Timestamp, ACTIVE_DURATION_SECS}; use polkadot_node_subsystem::{ messages::{AllMessages, BlockDescription, RuntimeApiMessage, RuntimeApiRequest}, @@ -67,6 +66,7 @@ use polkadot_primitives::{ SessionInfo, SigningContext, ValidDisputeStatementKind, ValidatorId, ValidatorIndex, ValidatorSignature, }; +use polkadot_primitives_test_helpers::{dummy_candidate_receipt_bad_sig, dummy_digest, dummy_hash}; use crate::{ backend::Backend, diff --git a/polkadot/node/core/parachains-inherent/Cargo.toml b/polkadot/node/core/parachains-inherent/Cargo.toml index 4f6090f90e9535a7cee8da2e333d5e66a0dea972..1e4953f40d0bd87bd5ef69bf3b91b66935e90fdc 100644 --- a/polkadot/node/core/parachains-inherent/Cargo.toml +++ b/polkadot/node/core/parachains-inherent/Cargo.toml @@ -10,13 +10,13 @@ description = "Parachains inherent data provider for Polkadot node" workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } thiserror = { workspace = true } -async-trait = "0.1.79" -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-overseer = { path = "../../overseer" } -polkadot-primitives = { path = "../../../primitives" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-inherents = { path = "../../../../substrate/primitives/inherents" } +async-trait = { workspace = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } diff --git a/polkadot/node/core/prospective-parachains/Cargo.toml b/polkadot/node/core/prospective-parachains/Cargo.toml index ab3cef99e54ff6da279ec30728c308ed8bbf3da6..705014e67a05eff6a8c5954bdb0834faef10cc0e 100644 --- a/polkadot/node/core/prospective-parachains/Cargo.toml +++ b/polkadot/node/core/prospective-parachains/Cargo.toml @@ -10,26 +10,20 @@ description = "The Prospective Parachains subsystem. Tracks and handles prospect workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -parity-scale-codec = "3.6.4" +futures = { workspace = true } +gum = { workspace = true, default-features = true } thiserror = { workspace = true } -fatality = "0.0.6" -bitvec = "1" +fatality = { workspace = true } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } [dev-dependencies] -rstest = "0.18.2" -assert_matches = "1" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-node-subsystem-types = { path = "../../subsystem-types" } -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } -sp-core = { path = "../../../../substrate/primitives/core" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } +assert_matches = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +sp-tracing = { workspace = true } +sp-core = { workspace = true, default-features = true } +rand = { workspace = true } +rstest = { workspace = true } diff --git a/polkadot/node/core/prospective-parachains/src/error.rs b/polkadot/node/core/prospective-parachains/src/error.rs index 2b0933ab1c7e03e1a020d3cdc2c4953dfd9d294a..4b332b9c5de59aa49081bfeb3e8b2b7335c98717 100644 --- a/polkadot/node/core/prospective-parachains/src/error.rs +++ b/polkadot/node/core/prospective-parachains/src/error.rs @@ -30,18 +30,6 @@ use fatality::Nested; #[allow(missing_docs)] #[fatality::fatality(splitable)] pub enum Error { - #[fatal] - #[error("SubsystemError::Context error: {0}")] - SubsystemContext(String), - - #[fatal] - #[error("Spawning a task failed: {0}")] - SpawnFailed(SubsystemError), - - #[fatal] - #[error("Participation worker receiver exhausted.")] - ParticipationWorkerReceiverExhausted, - #[fatal] #[error("Receiving message from overseer failed: {0}")] SubsystemReceive(#[source] SubsystemError), @@ -55,9 +43,6 @@ pub enum Error { #[error(transparent)] ChainApi(#[from] ChainApiError), - #[error(transparent)] - Subsystem(SubsystemError), - #[error("Request to chain API subsystem dropped")] ChainApiRequestCanceled(oneshot::Canceled), diff --git a/polkadot/node/core/prospective-parachains/src/fragment_chain/mod.rs b/polkadot/node/core/prospective-parachains/src/fragment_chain/mod.rs index 86814b976d13424281203aa5bca59b0a918b7251..b060897d439168e4dd04acd1e3e896429d7c3ed4 100644 --- a/polkadot/node/core/prospective-parachains/src/fragment_chain/mod.rs +++ b/polkadot/node/core/prospective-parachains/src/fragment_chain/mod.rs @@ -14,35 +14,66 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! A tree utility for managing parachain fragments not referenced by the relay-chain. +//! Utility for managing parachain fragments not referenced by the relay-chain. //! //! # Overview //! -//! This module exposes two main types: [`FragmentTree`] and [`CandidateStorage`] which are meant to -//! be used in close conjunction. Each fragment tree is associated with a particular relay-parent -//! and each node in the tree represents a candidate. Each parachain has a single candidate storage, -//! but can have multiple trees for each relay chain block in the view. +//! The main type exposed by this module is the [`FragmentChain`]. //! -//! A tree has an associated [`Scope`] which defines limits on candidates within the tree. -//! Candidates themselves have their own [`Constraints`] which are either the constraints from the -//! scope, or, if there are previous nodes in the tree, a modified version of the previous -//! candidate's constraints. +//! Each fragment chain is associated with a particular relay-parent (an active leaf) and has a +//! [`Scope`], which contains the allowed relay parents (up to `allowed_ancestry_len`), the pending +//! availability candidates and base constraints derived from the latest included candidate. Each +//! parachain has a single `FragmentChain` for each active leaf where it's scheduled. +//! +//! A fragment chain consists mainly of the current best backable chain (we'll call this the best +//! chain) and a storage of unconnected potential candidates (we'll call this the unconnected +//! storage). +//! +//! The best chain contains all the candidates pending availability and a subsequent chain +//! of candidates that have reached the backing quorum and are better than any other backable forks +//! according to the fork selection rule (more on this rule later). It has a length of size at most +//! `max_candidate_depth + 1`. +//! +//! The unconnected storage keeps a record of seconded/backable candidates that may be +//! added to the best chain in the future. +//! Once a candidate is seconded, it becomes part of this unconnected storage. +//! Only after it is backed it may be added to the best chain (but not necessarily). It's only +//! added if it builds on the latest candidate in the chain and if there isn't a better backable +//! candidate according to the fork selection rule. +//! +//! An important thing to note is that the candidates present in the unconnected storage may have +//! any/no relationship between them. In other words, they may form N trees and may even form +//! cycles. This is needed so that we may begin validating candidates for which we don't yet know +//! their parent (so we may parallelize the backing process across different groups for elastic +//! scaling) and so that we accept parachain forks. +//! +//! We accept parachain forks only if the fork selection rule allows for it. In other words, if we +//! have a backed candidate, we begin seconding/validating a fork only if it has a lower candidate +//! hash. Once both forks are backed, we discard the one with the higher candidate hash. +//! We assume all validators pick the same fork according to the fork selection rule. If we decided +//! to not accept parachain forks, candidates could end up getting only half of the backing votes or +//! even less (for forks of larger arity). This would affect the validator rewards. Still, we don't +//! guarantee that a fork-producing parachains will be able to fully use elastic scaling. +//! +//! Once a candidate is backed and becomes part of the best chain, we can trim from the +//! unconnected storage candidates which constitute forks on the best chain and no longer have +//! potential. //! //! This module also makes use of types provided by the Inclusion Emulator module, such as //! [`Fragment`] and [`Constraints`]. These perform the actual job of checking for validity of //! prospective fragments. //! -//! # Usage +//! # Fork choice rule //! -//! It's expected that higher-level code will have a tree for each relay-chain block which might -//! reasonably have blocks built upon it. +//! The motivation for the fork choice rule is described in the previous chapter. //! -//! Because a para only has a single candidate storage, trees only store indices into the storage. -//! The storage is meant to be pruned when trees are dropped by higher-level code. +//! The current rule is: choose the candidate with the lower candidate hash. +//! The candidate hash is quite random and finding a candidate with a lower hash in order to favour +//! it would essentially mean solving a proof of work problem. //! -//! # Cycles +//! # Parachain cycles //! -//! Nodes do not uniquely refer to a parachain block for two reasons. +//! Parachains can create cycles, because: //! 1. There's no requirement that head-data is unique for a parachain. Furthermore, a parachain //! is under no obligation to be acyclic, and this is mostly just because it's totally //! inefficient to enforce it. Practical use-cases are acyclic, but there is still more than @@ -50,81 +81,118 @@ //! 2. and candidates only refer to their parent by its head-data. This whole issue could be //! resolved by having candidates reference their parent by candidate hash. //! -//! The implication is that when we receive a candidate receipt, there are actually multiple -//! possibilities for any candidates between the para-head recorded in the relay parent's state -//! and the candidate in question. +//! However, dealing with cycles increases complexity during the backing/inclusion process for no +//! practical reason. +//! These cycles may be accepted by fragment chains while candidates are part of the unconnected +//! storage, but they will definitely not make it to the best chain. //! -//! This means that our candidates need to handle multiple parents and that depth is an -//! attribute of a node in a tree, not a candidate. Put another way, the same candidate might -//! have different depths in different parts of the tree. +//! On the other hand, enforcing that a parachain will NEVER be acyclic would be very complicated +//! (looping through the entire parachain's history on every new candidate or changing the candidate +//! receipt to reference the parent's candidate hash). //! -//! As an extreme example, a candidate which produces head-data which is the same as its parent -//! can correspond to multiple nodes within the same [`FragmentTree`]. Such cycles are bounded -//! by the maximum depth allowed by the tree. An example with `max_depth: 4`: +//! Therefore, we don't provide a guarantee that a cycle-producing parachain will work (although in +//! practice they probably will if the cycle length is larger than the number of assigned cores +//! multiplied by two). //! -//! ```text -//! committed head -//! | -//! depth 0: head_a -//! | -//! depth 1: head_b -//! | -//! depth 2: head_a -//! | -//! depth 3: head_b -//! | -//! depth 4: head_a -//! ``` +//! # Spam protection //! -//! As long as the [`CandidateStorage`] has bounded input on the number of candidates supplied, -//! [`FragmentTree`] complexity is bounded. This means that higher-level code needs to be selective -//! about limiting the amount of candidates that are considered. +//! As long as the supplied number of candidates is bounded, [`FragmentChain`] complexity is +//! bounded. This means that higher-level code needs to be selective about limiting the amount of +//! candidates that are considered. +//! +//! Practically speaking, the collator-protocol will not allow more than `max_candidate_depth + 1` +//! collations to be fetched at a relay parent and statement-distribution will not allow more than +//! `max_candidate_depth + 1` seconded candidates at a relay parent per each validator in the +//! backing group. Considering the `allowed_ancestry_len` configuration value, the number of +//! candidates in a `FragmentChain` (including its unconnected storage) should not exceed: +//! +//! `allowed_ancestry_len * (max_candidate_depth + 1) * backing_group_size`. //! //! The code in this module is not designed for speed or efficiency, but conceptual simplicity. //! Our assumption is that the amount of candidates and parachains we consider will be reasonably //! bounded and in practice will not exceed a few thousand at any time. This naive implementation //! will still perform fairly well under these conditions, despite being somewhat wasteful of //! memory. +//! +//! Still, the expensive candidate data (CandidateCommitments) are wrapped in an `Arc` and shared +//! across fragment chains of the same para on different active leaves. #[cfg(test)] mod tests; use std::{ - borrow::Cow, + cmp::{min, Ordering}, collections::{ hash_map::{Entry, HashMap}, - BTreeMap, HashSet, + BTreeMap, HashSet, VecDeque, }, + sync::Arc, }; use super::LOG_TARGET; -use bitvec::prelude::*; use polkadot_node_subsystem::messages::Ancestors; use polkadot_node_subsystem_util::inclusion_emulator::{ - ConstraintModifications, Constraints, Fragment, ProspectiveCandidate, RelayChainBlockInfo, + self, ConstraintModifications, Constraints, Fragment, HypotheticalOrConcreteCandidate, + ProspectiveCandidate, RelayChainBlockInfo, }; use polkadot_primitives::{ - BlockNumber, CandidateHash, CommittedCandidateReceipt, Hash, HeadData, Id as ParaId, - PersistedValidationData, + BlockNumber, CandidateCommitments, CandidateHash, CommittedCandidateReceipt, Hash, HeadData, + PersistedValidationData, ValidationCodeHash, }; +use thiserror::Error; + +/// Fragment chain related errors. +#[derive(Debug, Clone, PartialEq, Error)] +pub(crate) enum Error { + #[error("Candidate already known")] + CandidateAlreadyKnown, + #[error("Candidate's parent head is equal to its output head. Would introduce a cycle.")] + ZeroLengthCycle, + #[error("Candidate would introduce a cycle")] + Cycle, + #[error("Candidate would introduce two paths to the same output state")] + MultiplePaths, + #[error("Attempting to directly introduce a Backed candidate. It should first be introduced as Seconded")] + IntroduceBackedCandidate, + #[error("Relay parent {0:?} of the candidate precedes the relay parent {1:?} of a pending availability candidate")] + RelayParentPrecedesCandidatePendingAvailability(Hash, Hash), + #[error("Candidate would introduce a fork with a pending availability candidate: {0:?}")] + ForkWithCandidatePendingAvailability(CandidateHash), + #[error("Fork selection rule favours another candidate: {0:?}")] + ForkChoiceRule(CandidateHash), + #[error("Could not find parent of the candidate")] + ParentCandidateNotFound, + #[error("Could not compute candidate constraints: {0:?}")] + ComputeConstraints(inclusion_emulator::ModificationError), + #[error("Candidate violates constraints: {0:?}")] + CheckAgainstConstraints(inclusion_emulator::FragmentValidityError), + #[error("Relay parent would move backwards from the latest candidate in the chain")] + RelayParentMovedBackwards, + #[error(transparent)] + CandidateEntry(#[from] CandidateEntryError), + #[error("Relay parent {0:?} not in scope. Earliest relay parent allowed {1:?}")] + RelayParentNotInScope(Hash, Hash), +} -/// Kinds of failures to import a candidate into storage. -#[derive(Debug, Clone, PartialEq)] -pub enum CandidateStorageInsertionError { - /// An error indicating that a supplied candidate didn't match the persisted - /// validation data provided alongside it. - PersistedValidationDataMismatch, - /// The candidate was already known. - CandidateAlreadyKnown(CandidateHash), +/// The rule for selecting between two backed candidate forks, when adding to the chain. +/// All validators should adhere to this rule, in order to not lose out on rewards in case of +/// forking parachains. +fn fork_selection_rule(hash1: &CandidateHash, hash2: &CandidateHash) -> Ordering { + hash1.cmp(hash2) } -/// Stores candidates and information about them such as their relay-parents and their backing -/// states. +/// Utility for storing candidates and information about them such as their relay-parents and their +/// backing states. This does not assume any restriction on whether or not the candidates form a +/// chain. Useful for storing all kinds of candidates. +#[derive(Clone, Default)] pub(crate) struct CandidateStorage { - // Index from head data hash to candidate hashes with that head data as a parent. + // Index from head data hash to candidate hashes with that head data as a parent. Useful for + // efficiency when responding to `ProspectiveValidationDataRequest`s or when trying to find a + // new candidate to push to a chain. by_parent_head: HashMap>, - // Index from head data hash to candidate hashes outputting that head data. + // Index from head data hash to candidate hashes outputting that head data. For + // efficiency when responding to `ProspectiveValidationDataRequest`s. by_output_head: HashMap>, // Index from candidate hash to fragment node. @@ -132,79 +200,69 @@ pub(crate) struct CandidateStorage { } impl CandidateStorage { - /// Create a new `CandidateStorage`. - pub fn new() -> Self { - CandidateStorage { - by_parent_head: HashMap::new(), - by_output_head: HashMap::new(), - by_candidate_hash: HashMap::new(), - } - } - - /// Introduce a new candidate. - pub fn add_candidate( + /// Introduce a new pending availability candidate. + pub fn add_pending_availability_candidate( &mut self, + candidate_hash: CandidateHash, candidate: CommittedCandidateReceipt, persisted_validation_data: PersistedValidationData, - ) -> Result { - let candidate_hash = candidate.hash(); + ) -> Result<(), Error> { + let entry = CandidateEntry::new( + candidate_hash, + candidate, + persisted_validation_data, + CandidateState::Backed, + )?; - if self.by_candidate_hash.contains_key(&candidate_hash) { - return Err(CandidateStorageInsertionError::CandidateAlreadyKnown(candidate_hash)) - } + self.add_candidate_entry(entry) + } - if persisted_validation_data.hash() != candidate.descriptor.persisted_validation_data_hash { - return Err(CandidateStorageInsertionError::PersistedValidationDataMismatch) - } + /// Return the number of stored candidates. + pub fn len(&self) -> usize { + self.by_candidate_hash.len() + } - let parent_head_hash = persisted_validation_data.parent_head.hash(); - let output_head_hash = candidate.commitments.head_data.hash(); - let entry = CandidateEntry { - candidate_hash, - relay_parent: candidate.descriptor.relay_parent, - state: CandidateState::Introduced, - candidate: ProspectiveCandidate { - commitments: Cow::Owned(candidate.commitments), - collator: candidate.descriptor.collator, - collator_signature: candidate.descriptor.signature, - persisted_validation_data, - pov_hash: candidate.descriptor.pov_hash, - validation_code_hash: candidate.descriptor.validation_code_hash, - }, - }; + /// Introduce a new candidate entry. + fn add_candidate_entry(&mut self, candidate: CandidateEntry) -> Result<(), Error> { + let candidate_hash = candidate.candidate_hash; + if self.by_candidate_hash.contains_key(&candidate_hash) { + return Err(Error::CandidateAlreadyKnown) + } - self.by_parent_head.entry(parent_head_hash).or_default().insert(candidate_hash); - self.by_output_head.entry(output_head_hash).or_default().insert(candidate_hash); - // sanity-checked already. - self.by_candidate_hash.insert(candidate_hash, entry); + self.by_parent_head + .entry(candidate.parent_head_data_hash) + .or_default() + .insert(candidate_hash); + self.by_output_head + .entry(candidate.output_head_data_hash) + .or_default() + .insert(candidate_hash); + self.by_candidate_hash.insert(candidate_hash, candidate); - Ok(candidate_hash) + Ok(()) } /// Remove a candidate from the store. - pub fn remove_candidate(&mut self, candidate_hash: &CandidateHash) { + fn remove_candidate(&mut self, candidate_hash: &CandidateHash) { if let Some(entry) = self.by_candidate_hash.remove(candidate_hash) { - let parent_head_hash = entry.candidate.persisted_validation_data.parent_head.hash(); - if let Entry::Occupied(mut e) = self.by_parent_head.entry(parent_head_hash) { + if let Entry::Occupied(mut e) = self.by_parent_head.entry(entry.parent_head_data_hash) { e.get_mut().remove(&candidate_hash); if e.get().is_empty() { e.remove(); } } - } - } - /// Note that an existing candidate has been seconded. - pub fn mark_seconded(&mut self, candidate_hash: &CandidateHash) { - if let Some(entry) = self.by_candidate_hash.get_mut(candidate_hash) { - if entry.state != CandidateState::Backed { - entry.state = CandidateState::Seconded; + if let Entry::Occupied(mut e) = self.by_output_head.entry(entry.output_head_data_hash) { + e.get_mut().remove(&candidate_hash); + if e.get().is_empty() { + e.remove(); + } } } } /// Note that an existing candidate has been backed. - pub fn mark_backed(&mut self, candidate_hash: &CandidateHash) { + fn mark_backed(&mut self, candidate_hash: &CandidateHash) { if let Some(entry) = self.by_candidate_hash.get_mut(candidate_hash) { gum::trace!(target: LOG_TARGET, ?candidate_hash, "Candidate marked as backed"); entry.state = CandidateState::Backed; @@ -213,33 +271,18 @@ impl CandidateStorage { } } - /// Whether a candidate is recorded as being backed. - pub fn is_backed(&self, candidate_hash: &CandidateHash) -> bool { - self.by_candidate_hash - .get(candidate_hash) - .map_or(false, |e| e.state == CandidateState::Backed) - } - /// Whether a candidate is contained within the storage already. - pub fn contains(&self, candidate_hash: &CandidateHash) -> bool { + fn contains(&self, candidate_hash: &CandidateHash) -> bool { self.by_candidate_hash.contains_key(candidate_hash) } - /// Retain only candidates which pass the predicate. - pub(crate) fn retain(&mut self, pred: impl Fn(&CandidateHash) -> bool) { - self.by_candidate_hash.retain(|h, _v| pred(h)); - self.by_parent_head.retain(|_parent, children| { - children.retain(|h| pred(h)); - !children.is_empty() - }); - self.by_output_head.retain(|_output, candidates| { - candidates.retain(|h| pred(h)); - !candidates.is_empty() - }); + /// Return an iterator over references to the stored candidates, in arbitrary order. + fn candidates(&self) -> impl Iterator { + self.by_candidate_hash.values() } - /// Get head-data by hash. - pub(crate) fn head_data_by_hash(&self, hash: &Hash) -> Option<&HeadData> { + /// Try getting head-data by hash. + fn head_data_by_hash(&self, hash: &Hash) -> Option<&HeadData> { // First, search for candidates outputting this head data and extract the head data // from their commitments if they exist. // @@ -259,58 +302,132 @@ impl CandidateStorage { }) } - /// Returns candidate's relay parent, if present. - pub(crate) fn relay_parent_by_candidate_hash( - &self, - candidate_hash: &CandidateHash, - ) -> Option { - self.by_candidate_hash.get(candidate_hash).map(|entry| entry.relay_parent) - } - - fn iter_para_children<'a>( + /// Returns the backed candidates which have the given head data hash as parent. + fn possible_backed_para_children<'a>( &'a self, - parent_head_hash: &Hash, + parent_head_hash: &'a Hash, ) -> impl Iterator + 'a { let by_candidate_hash = &self.by_candidate_hash; self.by_parent_head .get(parent_head_hash) .into_iter() .flat_map(|hashes| hashes.iter()) - .filter_map(move |h| by_candidate_hash.get(h)) - } - - fn get(&'_ self, candidate_hash: &CandidateHash) -> Option<&'_ CandidateEntry> { - self.by_candidate_hash.get(candidate_hash) - } - - #[cfg(test)] - pub fn len(&self) -> (usize, usize) { - (self.by_parent_head.len(), self.by_candidate_hash.len()) + .filter_map(move |h| { + by_candidate_hash.get(h).and_then(|candidate| { + (candidate.state == CandidateState::Backed).then_some(candidate) + }) + }) } } /// The state of a candidate. /// /// Candidates aren't even considered until they've at least been seconded. -#[derive(Debug, PartialEq)] +#[derive(Debug, PartialEq, Clone)] enum CandidateState { - /// The candidate has been introduced in a spam-protected way but - /// is not necessarily backed. - Introduced, /// The candidate has been seconded. Seconded, /// The candidate has been completely backed by the group. Backed, } -#[derive(Debug)] -struct CandidateEntry { +#[derive(Debug, Clone, PartialEq, Error)] +/// Possible errors when construcing a candidate entry. +pub enum CandidateEntryError { + #[error("Candidate does not match the persisted validation data provided alongside it")] + PersistedValidationDataMismatch, + #[error("Candidate's parent head is equal to its output head. Would introduce a cycle")] + ZeroLengthCycle, +} + +#[derive(Debug, Clone)] +/// Representation of a candidate into the [`CandidateStorage`]. +pub(crate) struct CandidateEntry { candidate_hash: CandidateHash, + parent_head_data_hash: Hash, + output_head_data_hash: Hash, relay_parent: Hash, - candidate: ProspectiveCandidate<'static>, + candidate: Arc, state: CandidateState, } +impl CandidateEntry { + /// Create a new seconded candidate entry. + pub fn new_seconded( + candidate_hash: CandidateHash, + candidate: CommittedCandidateReceipt, + persisted_validation_data: PersistedValidationData, + ) -> Result { + Self::new(candidate_hash, candidate, persisted_validation_data, CandidateState::Seconded) + } + + pub fn hash(&self) -> CandidateHash { + self.candidate_hash + } + + fn new( + candidate_hash: CandidateHash, + candidate: CommittedCandidateReceipt, + persisted_validation_data: PersistedValidationData, + state: CandidateState, + ) -> Result { + if persisted_validation_data.hash() != candidate.descriptor.persisted_validation_data_hash { + return Err(CandidateEntryError::PersistedValidationDataMismatch) + } + + let parent_head_data_hash = persisted_validation_data.parent_head.hash(); + let output_head_data_hash = candidate.commitments.head_data.hash(); + + if parent_head_data_hash == output_head_data_hash { + return Err(CandidateEntryError::ZeroLengthCycle) + } + + Ok(Self { + candidate_hash, + parent_head_data_hash, + output_head_data_hash, + relay_parent: candidate.descriptor.relay_parent, + state, + candidate: Arc::new(ProspectiveCandidate { + commitments: candidate.commitments, + persisted_validation_data, + pov_hash: candidate.descriptor.pov_hash, + validation_code_hash: candidate.descriptor.validation_code_hash, + }), + }) + } +} + +impl HypotheticalOrConcreteCandidate for CandidateEntry { + fn commitments(&self) -> Option<&CandidateCommitments> { + Some(&self.candidate.commitments) + } + + fn persisted_validation_data(&self) -> Option<&PersistedValidationData> { + Some(&self.candidate.persisted_validation_data) + } + + fn validation_code_hash(&self) -> Option<&ValidationCodeHash> { + Some(&self.candidate.validation_code_hash) + } + + fn parent_head_data_hash(&self) -> Hash { + self.parent_head_data_hash + } + + fn output_head_data_hash(&self) -> Option { + Some(self.output_head_data_hash) + } + + fn relay_parent(&self) -> Hash { + self.relay_parent + } + + fn candidate_hash(&self) -> CandidateHash { + self.candidate_hash + } +} + /// A candidate existing on-chain but pending availability, for special treatment /// in the [`Scope`]. #[derive(Debug, Clone)] @@ -321,25 +438,34 @@ pub(crate) struct PendingAvailability { pub relay_parent: RelayChainBlockInfo, } -/// The scope of a [`FragmentTree`]. -#[derive(Debug)] +/// The scope of a [`FragmentChain`]. +#[derive(Debug, Clone)] pub(crate) struct Scope { - para: ParaId, + /// The relay parent we're currently building on top of. relay_parent: RelayChainBlockInfo, + /// The other relay parents candidates are allowed to build upon, mapped by the block number. ancestors: BTreeMap, + /// The other relay parents candidates are allowed to build upon, mapped by the block hash. ancestors_by_hash: HashMap, + /// The candidates pending availability at this block. pending_availability: Vec, + /// The base constraints derived from the latest included candidate. base_constraints: Constraints, + /// Equal to `max_candidate_depth`. max_depth: usize, } /// An error variant indicating that ancestors provided to a scope /// had unexpected order. #[derive(Debug)] -pub struct UnexpectedAncestor { +pub(crate) struct UnexpectedAncestor { /// The block number that this error occurred at. + /// Allow as dead code, but it's being read in logs. + #[allow(dead_code)] pub number: BlockNumber, /// The previous seen block number, which did not match `number`. + /// Allow as dead code, but it's being read in logs. + #[allow(dead_code)] pub prev: BlockNumber, } @@ -361,7 +487,6 @@ impl Scope { /// /// It is allowed to provide zero ancestors. pub fn with_ancestors( - para: ParaId, relay_parent: RelayChainBlockInfo, base_constraints: Constraints, pending_availability: Vec, @@ -388,7 +513,6 @@ impl Scope { } Ok(Scope { - para, relay_parent, base_constraints, pending_availability, @@ -398,7 +522,7 @@ impl Scope { }) } - /// Get the earliest relay-parent allowed in the scope of the fragment tree. + /// Get the earliest relay-parent allowed in the scope of the fragment chain. pub fn earliest_relay_parent(&self) -> RelayChainBlockInfo { self.ancestors .iter() @@ -407,8 +531,8 @@ impl Scope { .unwrap_or_else(|| self.relay_parent.clone()) } - /// Get the ancestor of the fragment tree by hash. - pub fn ancestor_by_hash(&self, hash: &Hash) -> Option { + /// Get the relay ancestor of the fragment chain by hash. + pub fn ancestor(&self, hash: &Hash) -> Option { if hash == &self.relay_parent.hash { return Some(self.relay_parent.clone()) } @@ -416,667 +540,713 @@ impl Scope { self.ancestors_by_hash.get(hash).map(|info| info.clone()) } + /// Get the base constraints of the scope + pub fn base_constraints(&self) -> &Constraints { + &self.base_constraints + } + /// Whether the candidate in question is one pending availability in this scope. - pub fn get_pending_availability( + fn get_pending_availability( &self, candidate_hash: &CandidateHash, ) -> Option<&PendingAvailability> { self.pending_availability.iter().find(|c| &c.candidate_hash == candidate_hash) } +} - /// Get the base constraints of the scope - pub fn base_constraints(&self) -> &Constraints { - &self.base_constraints +#[cfg_attr(test, derive(Clone))] +/// A node that is part of a `BackedChain`. It holds constraints based on the ancestors in the +/// chain. +struct FragmentNode { + fragment: Fragment, + candidate_hash: CandidateHash, + cumulative_modifications: ConstraintModifications, + parent_head_data_hash: Hash, + output_head_data_hash: Hash, +} + +impl FragmentNode { + fn relay_parent(&self) -> Hash { + self.fragment.relay_parent().hash } } -/// We use indices into a flat vector to refer to nodes in the tree. -/// Every tree also has an implicit root. -#[derive(Debug, Clone, Copy, PartialEq)] -enum NodePointer { - Root, - Storage(usize), +impl From<&FragmentNode> for CandidateEntry { + fn from(node: &FragmentNode) -> Self { + // We don't need to perform the checks done in `CandidateEntry::new()`, since a + // `FragmentNode` always comes from a `CandidateEntry` + Self { + candidate_hash: node.candidate_hash, + parent_head_data_hash: node.parent_head_data_hash, + output_head_data_hash: node.output_head_data_hash, + candidate: node.fragment.candidate_clone(), + relay_parent: node.relay_parent(), + // A fragment node is always backed. + state: CandidateState::Backed, + } + } } -/// A hypothetical candidate, which may or may not exist in -/// the fragment tree already. -pub(crate) enum HypotheticalCandidate<'a> { - Complete { - receipt: Cow<'a, CommittedCandidateReceipt>, - persisted_validation_data: Cow<'a, PersistedValidationData>, - }, - Incomplete { - relay_parent: Hash, - parent_head_data_hash: Hash, - }, +/// A candidate chain of backed/backable candidates. +/// Includes the candidates pending availability and candidates which may be backed on-chain. +#[derive(Default)] +#[cfg_attr(test, derive(Clone))] +struct BackedChain { + // Holds the candidate chain. + chain: Vec, + // Index from head data hash to the candidate hash with that head data as a parent. + // Only contains the candidates present in the `chain`. + by_parent_head: HashMap, + // Index from head data hash to the candidate hash outputting that head data. + // Only contains the candidates present in the `chain`. + by_output_head: HashMap, + // A set of the candidate hashes in the `chain`. + candidates: HashSet, } -impl<'a> HypotheticalCandidate<'a> { - fn parent_head_data_hash(&self) -> Hash { - match *self { - HypotheticalCandidate::Complete { ref persisted_validation_data, .. } => - persisted_validation_data.as_ref().parent_head.hash(), - HypotheticalCandidate::Incomplete { ref parent_head_data_hash, .. } => - *parent_head_data_hash, - } +impl BackedChain { + fn push(&mut self, candidate: FragmentNode) { + self.candidates.insert(candidate.candidate_hash); + self.by_parent_head + .insert(candidate.parent_head_data_hash, candidate.candidate_hash); + self.by_output_head + .insert(candidate.output_head_data_hash, candidate.candidate_hash); + self.chain.push(candidate); } - fn relay_parent(&self) -> Hash { - match *self { - HypotheticalCandidate::Complete { ref receipt, .. } => - receipt.descriptor().relay_parent, - HypotheticalCandidate::Incomplete { ref relay_parent, .. } => *relay_parent, + fn clear(&mut self) -> Vec { + self.by_parent_head.clear(); + self.by_output_head.clear(); + self.candidates.clear(); + + std::mem::take(&mut self.chain) + } + + fn revert_to_parent_hash<'a>( + &'a mut self, + parent_head_data_hash: &Hash, + ) -> impl Iterator + 'a { + let mut found_index = None; + for index in 0..self.chain.len() { + let node = &self.chain[0]; + + if found_index.is_some() { + self.by_parent_head.remove(&node.parent_head_data_hash); + self.by_output_head.remove(&node.output_head_data_hash); + self.candidates.remove(&node.candidate_hash); + } else if &node.output_head_data_hash == parent_head_data_hash { + found_index = Some(index); + } + } + + if let Some(index) = found_index { + self.chain.drain(min(index + 1, self.chain.len())..) + } else { + // Don't remove anything, but use drain to satisfy the compiler. + self.chain.drain(0..0) } } + + fn contains(&self, hash: &CandidateHash) -> bool { + self.candidates.contains(hash) + } } -/// This is a tree of candidates based on some underlying storage of candidates and a scope. +/// This is the fragment chain specific to an active leaf. /// -/// All nodes in the tree must be either pending availability or within the scope. Within the scope -/// means it's built off of the relay-parent or an ancestor. -pub(crate) struct FragmentTree { +/// It holds the current best backable candidate chain, as well as potential candidates +/// which could become connected to the chain in the future or which could even overwrite the +/// existing chain. +#[cfg_attr(test, derive(Clone))] +pub(crate) struct FragmentChain { + // The current scope, which dictates the on-chain operating constraints that all future + // candidates must adhere to. scope: Scope, - // Invariant: a contiguous prefix of the 'nodes' storage will contain - // the top-level children. - nodes: Vec, + // The current best chain of backable candidates. It only contains candidates which build on + // top of each other and which have reached the backing quorum. In the presence of potential + // forks, this chain will pick a fork according to the `fork_selection_rule`. + best_chain: BackedChain, - // The candidates stored in this tree, mapped to a bitvec indicating the depths - // where the candidate is stored. - candidates: HashMap>, + // The potential candidate storage. Contains candidates which are not yet part of the `chain` + // but may become in the future. These can form any tree shape as well as contain any + // unconnected candidates for which we don't know the parent. + unconnected: CandidateStorage, } -impl FragmentTree { - /// Create a new [`FragmentTree`] with given scope and populated from the storage. - /// - /// Can be populated recursively (i.e. `populate` will pick up candidates that build on other - /// candidates). - pub fn populate(scope: Scope, storage: &CandidateStorage) -> Self { - gum::trace!( - target: LOG_TARGET, - relay_parent = ?scope.relay_parent.hash, - relay_parent_num = scope.relay_parent.number, - para_id = ?scope.para, - ancestors = scope.ancestors.len(), - "Instantiating Fragment Tree", - ); - - let mut tree = FragmentTree { scope, nodes: Vec::new(), candidates: HashMap::new() }; - - tree.populate_from_bases(storage, vec![NodePointer::Root]); - - tree +impl FragmentChain { + /// Create a new [`FragmentChain`] with the given scope and populate it with the candidates + /// pending availability. + pub fn init(scope: Scope, mut candidates_pending_availability: CandidateStorage) -> Self { + let mut fragment_chain = Self { + scope, + best_chain: BackedChain::default(), + unconnected: CandidateStorage::default(), + }; + + // We only need to populate the best backable chain. Candidates pending availability must + // form a chain with the latest included head. + fragment_chain.populate_chain(&mut candidates_pending_availability); + + fragment_chain + } + + /// Populate the [`FragmentChain`] given the new candidates pending availability and the + /// optional previous fragment chain (of the previous relay parent). + pub fn populate_from_previous(&mut self, prev_fragment_chain: &FragmentChain) { + let mut prev_storage = prev_fragment_chain.unconnected.clone(); + + for candidate in prev_fragment_chain.best_chain.chain.iter() { + // If they used to be pending availability, don't add them. This is fine + // because: + // - if they still are pending availability, they have already been added to the new + // storage. + // - if they were included, no point in keeping them. + // + // This cannot happen for the candidates in the unconnected storage. The pending + // availability candidates will always be part of the best chain. + if prev_fragment_chain + .scope + .get_pending_availability(&candidate.candidate_hash) + .is_none() + { + let _ = prev_storage.add_candidate_entry(candidate.into()); + } + } + + // First populate the best backable chain. + self.populate_chain(&mut prev_storage); + + // Now that we picked the best backable chain, trim the forks generated by candidates which + // are not present in the best chain. + self.trim_uneligible_forks(&mut prev_storage, None); + + // Finally, keep any candidates which haven't been trimmed but still have potential. + self.populate_unconnected_potential_candidates(prev_storage); } - /// Get the scope of the Fragment Tree. + /// Get the scope of the [`FragmentChain`]. pub fn scope(&self) -> &Scope { &self.scope } - // Inserts a node and updates child references in a non-root parent. - fn insert_node(&mut self, node: FragmentNode) { - let pointer = NodePointer::Storage(self.nodes.len()); - let parent_pointer = node.parent; - let candidate_hash = node.candidate_hash; - - let max_depth = self.scope.max_depth; - - self.candidates - .entry(candidate_hash) - .or_insert_with(|| bitvec![u16, Msb0; 0; max_depth + 1]) - .set(node.depth, true); - - match parent_pointer { - NodePointer::Storage(ptr) => { - self.nodes.push(node); - self.nodes[ptr].children.push((pointer, candidate_hash)) - }, - NodePointer::Root => { - // Maintain the invariant of node storage beginning with depth-0. - if self.nodes.last().map_or(true, |last| last.parent == NodePointer::Root) { - self.nodes.push(node); - } else { - let pos = - self.nodes.iter().take_while(|n| n.parent == NodePointer::Root).count(); - self.nodes.insert(pos, node); - } - }, - } + /// Returns the number of candidates in the best backable chain. + pub fn best_chain_len(&self) -> usize { + self.best_chain.chain.len() } - fn node_has_candidate_child( - &self, - pointer: NodePointer, - candidate_hash: &CandidateHash, - ) -> bool { - self.node_candidate_child(pointer, candidate_hash).is_some() + /// Returns the number of candidates in unconnected potential storage. + pub fn unconnected_len(&self) -> usize { + self.unconnected.len() } - fn node_candidate_child( - &self, - pointer: NodePointer, - candidate_hash: &CandidateHash, - ) -> Option { - match pointer { - NodePointer::Root => self - .nodes - .iter() - .take_while(|n| n.parent == NodePointer::Root) - .enumerate() - .find(|(_, n)| &n.candidate_hash == candidate_hash) - .map(|(i, _)| NodePointer::Storage(i)), - NodePointer::Storage(ptr) => - self.nodes.get(ptr).and_then(|n| n.candidate_child(candidate_hash)), - } + /// Whether the candidate exists as part of the unconnected potential candidates. + pub fn contains_unconnected_candidate(&self, candidate: &CandidateHash) -> bool { + self.unconnected.contains(candidate) } - /// Returns an O(n) iterator over the hashes of candidates contained in the - /// tree. - pub(crate) fn candidates(&self) -> impl Iterator + '_ { - self.candidates.keys().cloned() + /// Return a vector of the chain's candidate hashes, in-order. + pub fn best_chain_vec(&self) -> Vec { + self.best_chain.chain.iter().map(|candidate| candidate.candidate_hash).collect() } - /// Whether the candidate exists and at what depths. - pub(crate) fn candidate(&self, candidate: &CandidateHash) -> Option> { - self.candidates.get(candidate).map(|d| d.iter_ones().collect()) + /// Return a vector of the unconnected potential candidate hashes, in arbitrary order. + pub fn unconnected(&self) -> impl Iterator { + self.unconnected.candidates() } - /// Add a candidate and recursively populate from storage. - /// - /// Candidates can be added either as children of the root or children of other candidates. - pub(crate) fn add_and_populate(&mut self, hash: CandidateHash, storage: &CandidateStorage) { - let candidate_entry = match storage.get(&hash) { - None => return, - Some(e) => e, + /// Return whether this candidate is backed in this chain or the unconnected storage. + pub fn is_candidate_backed(&self, hash: &CandidateHash) -> bool { + self.best_chain.candidates.contains(hash) || + matches!( + self.unconnected.by_candidate_hash.get(hash), + Some(candidate) if candidate.state == CandidateState::Backed + ) + } + + /// Mark a candidate as backed. This can trigger a recreation of the best backable chain. + pub fn candidate_backed(&mut self, newly_backed_candidate: &CandidateHash) { + // Already backed. + if self.best_chain.candidates.contains(newly_backed_candidate) { + return + } + let Some(parent_head_hash) = self + .unconnected + .by_candidate_hash + .get(newly_backed_candidate) + .map(|entry| entry.parent_head_data_hash) + else { + // Candidate is not in unconnected storage. + return }; - let candidate_parent = &candidate_entry.candidate.persisted_validation_data.parent_head; + // Mark the candidate hash. + self.unconnected.mark_backed(newly_backed_candidate); - // Select an initial set of bases, whose required relay-parent matches that of the - // candidate. - let root_base = if &self.scope.base_constraints.required_parent == candidate_parent { - Some(NodePointer::Root) - } else { - None - }; + // Revert to parent_head_hash + if !self.revert_to(&parent_head_hash) { + // If nothing was reverted, there is nothing we can do for now. + return + } - let non_root_bases = self - .nodes - .iter() - .enumerate() - .filter(|(_, n)| { - n.cumulative_modifications.required_parent.as_ref() == Some(candidate_parent) - }) - .map(|(i, _)| NodePointer::Storage(i)); + let mut prev_storage = std::mem::take(&mut self.unconnected); - let bases = root_base.into_iter().chain(non_root_bases).collect(); + // Populate the chain. + self.populate_chain(&mut prev_storage); - // Pass this into the population function, which will sanity-check stuff like depth, - // fragments, etc. and then recursively populate. - self.populate_from_bases(storage, bases); + // Now that we picked the best backable chain, trim the forks generated by candidates + // which are not present in the best chain. We can start trimming from this candidate + // onwards. + self.trim_uneligible_forks(&mut prev_storage, Some(parent_head_hash)); + + // Finally, keep any candidates which haven't been trimmed but still have potential. + self.populate_unconnected_potential_candidates(prev_storage); } - /// Returns `true` if the path from the root to the node's parent (inclusive) - /// only contains backed candidates, `false` otherwise. - fn path_contains_backed_only_candidates( + /// Checks if this candidate could be added in the future to this chain. + /// This will return `Error::CandidateAlreadyKnown` if the candidate is already in the chain or + /// the unconnected candidate storage. + pub fn can_add_candidate_as_potential( &self, - mut parent_pointer: NodePointer, - candidate_storage: &CandidateStorage, - ) -> bool { - while let NodePointer::Storage(ptr) = parent_pointer { - let node = &self.nodes[ptr]; - let candidate_hash = &node.candidate_hash; - - if candidate_storage.get(candidate_hash).map_or(true, |candidate_entry| { - !matches!(candidate_entry.state, CandidateState::Backed) - }) { - return false - } - parent_pointer = node.parent; + candidate: &impl HypotheticalOrConcreteCandidate, + ) -> Result<(), Error> { + let candidate_hash = candidate.candidate_hash(); + + if self.best_chain.contains(&candidate_hash) || self.unconnected.contains(&candidate_hash) { + return Err(Error::CandidateAlreadyKnown) } - true + self.check_potential(candidate) } - /// Returns the hypothetical depths where a candidate with the given hash and parent head data - /// would be added to the tree, without applying other candidates recursively on top of it. - /// - /// If the candidate is already known, this returns the actual depths where this - /// candidate is part of the tree. - /// - /// Setting `backed_in_path_only` to `true` ensures this function only returns such membership - /// that every candidate in the path from the root is backed. - pub(crate) fn hypothetical_depths( - &self, - hash: CandidateHash, - candidate: HypotheticalCandidate, - candidate_storage: &CandidateStorage, - backed_in_path_only: bool, - ) -> Vec { - // if `true`, we always have to traverse the tree. - if !backed_in_path_only { - // if known. - if let Some(depths) = self.candidates.get(&hash) { - return depths.iter_ones().collect() - } + /// Try adding a seconded candidate, if the candidate has potential. It will never be added to + /// the chain directly in the seconded state, it will only be part of the unconnected storage. + pub fn try_adding_seconded_candidate( + &mut self, + candidate: &CandidateEntry, + ) -> Result<(), Error> { + if candidate.state == CandidateState::Backed { + return Err(Error::IntroduceBackedCandidate); } - // if out of scope. - let candidate_relay_parent = candidate.relay_parent(); - let candidate_relay_parent = if self.scope.relay_parent.hash == candidate_relay_parent { - self.scope.relay_parent.clone() - } else if let Some(info) = self.scope.ancestors_by_hash.get(&candidate_relay_parent) { - info.clone() - } else { - return Vec::new() - }; + self.can_add_candidate_as_potential(candidate)?; - let max_depth = self.scope.max_depth; - let mut depths = bitvec![u16, Msb0; 0; max_depth + 1]; - - // iterate over all nodes where parent head-data matches, - // relay-parent number is <= candidate, and depth < max_depth. - let node_pointers = (0..self.nodes.len()).map(NodePointer::Storage); - for parent_pointer in std::iter::once(NodePointer::Root).chain(node_pointers) { - let (modifications, child_depth, earliest_rp) = match parent_pointer { - NodePointer::Root => - (ConstraintModifications::identity(), 0, self.scope.earliest_relay_parent()), - NodePointer::Storage(ptr) => { - let node = &self.nodes[ptr]; - let parent_rp = self - .scope - .ancestor_by_hash(&node.relay_parent()) - .or_else(|| { - self.scope - .get_pending_availability(&node.candidate_hash) - .map(|_| self.scope.earliest_relay_parent()) - }) - .expect("All nodes in tree are either pending availability or within scope; qed"); + // This clone is cheap, as it uses an Arc for the expensive stuff. + // We can't consume the candidate because other fragment chains may use it also. + self.unconnected.add_candidate_entry(candidate.clone())?; - (node.cumulative_modifications.clone(), node.depth + 1, parent_rp) - }, - }; - - if child_depth > max_depth { - continue - } - - if earliest_rp.number > candidate_relay_parent.number { - continue - } - - let child_constraints = - match self.scope.base_constraints.apply_modifications(&modifications) { - Err(e) => { - gum::debug!( - target: LOG_TARGET, - new_parent_head = ?modifications.required_parent, - err = ?e, - "Failed to apply modifications", - ); - - continue - }, - Ok(c) => c, - }; - - let parent_head_hash = candidate.parent_head_data_hash(); - if parent_head_hash != child_constraints.required_parent.hash() { - continue - } + Ok(()) + } - // We do additional checks for complete candidates. - if let HypotheticalCandidate::Complete { ref receipt, ref persisted_validation_data } = - candidate - { - let prospective_candidate = ProspectiveCandidate { - commitments: Cow::Borrowed(&receipt.commitments), - collator: receipt.descriptor().collator.clone(), - collator_signature: receipt.descriptor().signature.clone(), - persisted_validation_data: persisted_validation_data.as_ref().clone(), - pov_hash: receipt.descriptor().pov_hash, - validation_code_hash: receipt.descriptor().validation_code_hash, - }; + /// Try getting the full head data associated with this hash. + pub fn get_head_data_by_hash(&self, head_data_hash: &Hash) -> Option { + // First, see if this is the head data of the latest included candidate. + let required_parent = &self.scope.base_constraints().required_parent; + if &required_parent.hash() == head_data_hash { + return Some(required_parent.clone()) + } - if Fragment::new( - candidate_relay_parent.clone(), - child_constraints, - prospective_candidate, - ) - .is_err() - { - continue + // Cheaply check if the head data is in the best backable chain. + let has_head_data_in_chain = self + .best_chain + .by_parent_head + .get(head_data_hash) + .or_else(|| self.best_chain.by_output_head.get(head_data_hash)) + .is_some(); + + if has_head_data_in_chain { + return self.best_chain.chain.iter().find_map(|candidate| { + if &candidate.parent_head_data_hash == head_data_hash { + Some( + candidate + .fragment + .candidate() + .persisted_validation_data + .parent_head + .clone(), + ) + } else if &candidate.output_head_data_hash == head_data_hash { + Some(candidate.fragment.candidate().commitments.head_data.clone()) + } else { + None } - } - - // Check that the path only contains backed candidates, if necessary. - if !backed_in_path_only || - self.path_contains_backed_only_candidates(parent_pointer, candidate_storage) - { - depths.set(child_depth, true); - } + }); } - depths.iter_ones().collect() + // Lastly, try getting the head data from the unconnected candidates. + self.unconnected.head_data_by_hash(head_data_hash).cloned() } - /// Select `count` candidates after the given `ancestors` which pass - /// the predicate and have not already been backed on chain. - /// - /// Does an exhaustive search into the tree after traversing the ancestors path. - /// If the ancestors draw out a path that can be traversed in multiple ways, no - /// candidates will be returned. - /// If the ancestors do not draw out a full path (the path contains holes), candidates will be - /// suggested that may fill these holes. - /// If the ancestors don't draw out a valid path, no candidates will be returned. If there are - /// multiple possibilities of the same size, this will select the first one. If there is no - /// chain of size `count` that matches the criteria, this will return the largest chain it could - /// find with the criteria. If there are no candidates meeting those criteria, returns an empty - /// `Vec`. - /// Cycles are accepted, but this code expects that the runtime will deduplicate - /// identical candidates when occupying the cores (when proposing to back A->B->A, only A will - /// be backed on chain). + /// Select `count` candidates after the given `ancestors` which can be backed on chain next. /// /// The intention of the `ancestors` is to allow queries on the basis of /// one or more candidates which were previously pending availability becoming /// available or candidates timing out. - pub(crate) fn find_backable_chain( + pub fn find_backable_chain( &self, ancestors: Ancestors, count: u32, - pred: impl Fn(&CandidateHash) -> bool, - ) -> Vec { + ) -> Vec<(CandidateHash, Hash)> { if count == 0 { return vec![] } - // First, we need to order the ancestors. - // The node returned is the one from which we can start finding new backable candidates. - let Some(base_node) = self.find_ancestor_path(ancestors) else { return vec![] }; - - self.find_backable_chain_inner( - base_node, - count, - count, - &pred, - &mut Vec::with_capacity(count as usize), - ) - } + let base_pos = self.find_ancestor_path(ancestors); - // Try finding a candidate chain starting from `base_node` of length `expected_count`. - // If not possible, return the longest one we could find. - // Does a depth-first search, since we're optimistic that there won't be more than one such - // chains (parachains shouldn't usually have forks). So in the usual case, this will conclude - // in `O(expected_count)`. - // Cycles are accepted, but this doesn't allow for infinite execution time, because the maximum - // depth we'll reach is `expected_count`. - // - // Worst case performance is `O(num_forks ^ expected_count)`, the same as populating the tree. - // Although an exponential function, this is actually a constant that can only be altered via - // sudo/governance, because: - // 1. `num_forks` at a given level is at most `max_candidate_depth * max_validators_per_core` - // (because each validator in the assigned group can second `max_candidate_depth` - // candidates). The prospective-parachains subsystem assumes that the number of para forks is - // limited by collator-protocol and backing subsystems. In practice, this is a constant which - // can only be altered by sudo or governance. - // 2. `expected_count` is equal to the number of cores a para is scheduled on (in an elastic - // scaling scenario). For non-elastic-scaling, this is just 1. In practice, this should be a - // small number (1-3), capped by the total number of available cores (a constant alterable - // only via governance/sudo). - fn find_backable_chain_inner( - &self, - base_node: NodePointer, - expected_count: u32, - remaining_count: u32, - pred: &dyn Fn(&CandidateHash) -> bool, - accumulator: &mut Vec, - ) -> Vec { - if remaining_count == 0 { - // The best option is the chain we've accumulated so far. - return accumulator.to_vec(); + let actual_end_index = + std::cmp::min(base_pos + (count as usize), self.best_chain.chain.len()); + let mut res = Vec::with_capacity(actual_end_index - base_pos); + + for elem in &self.best_chain.chain[base_pos..actual_end_index] { + // Only supply candidates which are not yet pending availability. `ancestors` should + // have already contained them, but check just in case. + if self.scope.get_pending_availability(&elem.candidate_hash).is_none() { + res.push((elem.candidate_hash, elem.relay_parent())); + } else { + break + } } - let children: Vec<_> = match base_node { - NodePointer::Root => self - .nodes - .iter() - .enumerate() - .take_while(|(_, n)| n.parent == NodePointer::Root) - .filter(|(_, n)| self.scope.get_pending_availability(&n.candidate_hash).is_none()) - .filter(|(_, n)| pred(&n.candidate_hash)) - .map(|(ptr, n)| (NodePointer::Storage(ptr), n.candidate_hash)) - .collect(), - NodePointer::Storage(base_node_ptr) => { - let base_node = &self.nodes[base_node_ptr]; - - base_node - .children - .iter() - .filter(|(_, hash)| self.scope.get_pending_availability(&hash).is_none()) - .filter(|(_, hash)| pred(&hash)) - .map(|(ptr, hash)| (*ptr, *hash)) - .collect() - }, - }; + res + } + + // Tries to orders the ancestors into a viable path from root to the last one. + // Stops when the ancestors are all used or when a node in the chain is not present in the + // ancestor set. Returns the index in the chain were the search stopped. + fn find_ancestor_path(&self, mut ancestors: Ancestors) -> usize { + if self.best_chain.chain.is_empty() { + return 0; + } - let mut best_result = accumulator.clone(); - for (child_ptr, child_hash) in children { - accumulator.push(child_hash); - - let result = self.find_backable_chain_inner( - child_ptr, - expected_count, - remaining_count - 1, - &pred, - accumulator, - ); - - accumulator.pop(); - - // Short-circuit the search if we've found the right length. Otherwise, we'll - // search for a max. - // Taking the first best selection doesn't introduce bias or become gameable, - // because `find_ancestor_path` uses a `HashSet` to track the ancestors, which - // makes the order in which ancestors are visited non-deterministic. - if result.len() == expected_count as usize { - return result - } else if best_result.len() < result.len() { - best_result = result; + for (index, candidate) in self.best_chain.chain.iter().enumerate() { + if !ancestors.remove(&candidate.candidate_hash) { + return index } } - best_result + // This means that we found the entire chain in the ancestor set. There won't be anything + // left to back. + self.best_chain.chain.len() } - // Orders the ancestors into a viable path from root to the last one. - // Returns a pointer to the last node in the path. - // We assume that the ancestors form a chain (that the - // av-cores do not back parachain forks), None is returned otherwise. - // If we cannot use all ancestors, stop at the first found hole in the chain. This usually - // translates to a timed out candidate. - fn find_ancestor_path(&self, mut ancestors: Ancestors) -> Option { - // The number of elements in the path we've processed so far. - let mut depth = 0; - let mut last_node = NodePointer::Root; - let mut next_node: Option = Some(NodePointer::Root); - - while let Some(node) = next_node { - if depth > self.scope.max_depth { - return None; - } + // Return the earliest relay parent a new candidate can have in order to be added to the chain + // right now. This is the relay parent of the last candidate in the chain. + // The value returned may not be valid if we want to add a candidate pending availability, which + // may have a relay parent which is out of scope. Special handling is needed in that case. + // `None` is returned if the candidate's relay parent info cannot be found. + fn earliest_relay_parent(&self) -> Option { + if let Some(last_candidate) = self.best_chain.chain.last() { + self.scope.ancestor(&last_candidate.relay_parent()).or_else(|| { + // if the relay-parent is out of scope _and_ it is in the chain, + // it must be a candidate pending availability. + self.scope + .get_pending_availability(&last_candidate.candidate_hash) + .map(|c| c.relay_parent.clone()) + }) + } else { + Some(self.scope.earliest_relay_parent()) + } + } - last_node = node; + // Return the earliest relay parent a potential candidate may have for it to ever be added to + // the chain. This is the relay parent of the last candidate pending availability or the + // earliest relay parent in scope. + fn earliest_relay_parent_pending_availability(&self) -> RelayChainBlockInfo { + self.best_chain + .chain + .iter() + .rev() + .find_map(|candidate| { + self.scope + .get_pending_availability(&candidate.candidate_hash) + .map(|c| c.relay_parent.clone()) + }) + .unwrap_or_else(|| self.scope.earliest_relay_parent()) + } - next_node = match node { - NodePointer::Root => { - let children = self - .nodes - .iter() - .enumerate() - .take_while(|n| n.1.parent == NodePointer::Root) - .map(|(index, node)| (NodePointer::Storage(index), node.candidate_hash)) - .collect::>(); + // Populate the unconnected potential candidate storage starting from a previous storage. + fn populate_unconnected_potential_candidates(&mut self, old_storage: CandidateStorage) { + for candidate in old_storage.by_candidate_hash.into_values() { + // Sanity check, all pending availability candidates should be already present in the + // chain. + if self.scope.get_pending_availability(&candidate.candidate_hash).is_some() { + continue + } - self.find_valid_child(&mut ancestors, children.iter()).ok()? - }, - NodePointer::Storage(ptr) => { - let children = self.nodes.get(ptr).and_then(|n| Some(n.children.iter())); - if let Some(children) = children { - self.find_valid_child(&mut ancestors, children).ok()? - } else { - None - } + match self.can_add_candidate_as_potential(&candidate) { + Ok(()) => { + let _ = self.unconnected.add_candidate_entry(candidate); }, + // Swallow these errors as they can legitimately happen when pruning stale + // candidates. + Err(_) => {}, }; + } + } + + // Check whether a candidate outputting this head data would introduce a cycle or multiple paths + // to the same state. Trivial 0-length cycles are checked in `CandidateEntry::new`. + fn check_cycles_or_invalid_tree(&self, output_head_hash: &Hash) -> Result<(), Error> { + // this should catch a cycle where this candidate would point back to the parent of some + // candidate in the chain. + if self.best_chain.by_parent_head.contains_key(output_head_hash) { + return Err(Error::Cycle) + } - depth += 1; + // multiple paths to the same state, which can't happen for a chain. + if self.best_chain.by_output_head.contains_key(output_head_hash) { + return Err(Error::MultiplePaths) } - Some(last_node) + Ok(()) } - // Find a node from the given iterator which is present in the ancestors - // collection. If there are multiple such nodes, return an error and log a warning. We don't - // accept forks in a parachain to be backed. The supplied ancestors should all form a chain. - // If there is no such node, return None. - fn find_valid_child<'a>( + // Checks the potential of a candidate to be added to the chain now or in the future. + // It works both with concrete candidates for which we have the full PVD and committed receipt, + // but also does some more basic checks for incomplete candidates (before even fetching them). + fn check_potential( &self, - ancestors: &'a mut Ancestors, - nodes: impl Iterator + 'a, - ) -> Result, ()> { - let mut possible_children = - nodes.filter_map(|(node_ptr, hash)| match ancestors.remove(&hash) { - true => Some(node_ptr), - false => None, - }); + candidate: &impl HypotheticalOrConcreteCandidate, + ) -> Result<(), Error> { + let relay_parent = candidate.relay_parent(); + let parent_head_hash = candidate.parent_head_data_hash(); + + // trivial 0-length cycle. + if let Some(output_head_hash) = candidate.output_head_data_hash() { + if parent_head_hash == output_head_hash { + return Err(Error::ZeroLengthCycle) + } + } - // We don't accept forks in a parachain to be backed. The supplied ancestors - // should all form a chain. - let next = possible_children.next(); - if let Some(second_child) = possible_children.next() { - if let (Some(NodePointer::Storage(first_child)), NodePointer::Storage(second_child)) = - (next, second_child) - { - gum::error!( - target: LOG_TARGET, - para_id = ?self.scope.para, - relay_parent = ?self.scope.relay_parent, - "Trying to find new backable candidates for a parachain for which we've backed a fork.\ - This is a bug and the runtime should not have allowed it.\n\ - Backed candidates with the same parent: {}, {}", - self.nodes[*first_child].candidate_hash, - self.nodes[*second_child].candidate_hash, - ); + // Check if the relay parent is in scope. + let Some(relay_parent) = self.scope.ancestor(&relay_parent) else { + return Err(Error::RelayParentNotInScope( + relay_parent, + self.scope.earliest_relay_parent().hash, + )) + }; + + // Check if the relay parent moved backwards from the latest candidate pending availability. + let earliest_rp_of_pending_availability = self.earliest_relay_parent_pending_availability(); + if relay_parent.number < earliest_rp_of_pending_availability.number { + return Err(Error::RelayParentPrecedesCandidatePendingAvailability( + relay_parent.hash, + earliest_rp_of_pending_availability.hash, + )) + } + + // If it's a fork with a backed candidate in the current chain. + if let Some(other_candidate) = self.best_chain.by_parent_head.get(&parent_head_hash) { + if self.scope().get_pending_availability(other_candidate).is_some() { + // Cannot accept a fork with a candidate pending availability. + return Err(Error::ForkWithCandidatePendingAvailability(*other_candidate)) } - Err(()) - } else { - Ok(next.copied()) + // If the candidate is backed and in the current chain, accept only a candidate + // according to the fork selection rule. + if fork_selection_rule(other_candidate, &candidate.candidate_hash()) == Ordering::Less { + return Err(Error::ForkChoiceRule(*other_candidate)) + } + } + + // Try seeing if the parent candidate is in the current chain or if it is the latest + // included candidate. If so, get the constraints the candidate must satisfy. + let (constraints, maybe_min_relay_parent_number) = + if let Some(parent_candidate) = self.best_chain.by_output_head.get(&parent_head_hash) { + let Some(parent_candidate) = + self.best_chain.chain.iter().find(|c| &c.candidate_hash == parent_candidate) + else { + // Should never really happen. + return Err(Error::ParentCandidateNotFound) + }; + + ( + self.scope + .base_constraints + .apply_modifications(&parent_candidate.cumulative_modifications) + .map_err(Error::ComputeConstraints)?, + self.scope.ancestor(&parent_candidate.relay_parent()).map(|rp| rp.number), + ) + } else if self.scope.base_constraints.required_parent.hash() == parent_head_hash { + // It builds on the latest included candidate. + (self.scope.base_constraints.clone(), None) + } else { + // If the parent is not yet part of the chain, there's nothing else we can check for + // now. + return Ok(()) + }; + + // Check for cycles or invalid tree transitions. + if let Some(ref output_head_hash) = candidate.output_head_data_hash() { + self.check_cycles_or_invalid_tree(output_head_hash)?; } + + // Check against constraints if we have a full concrete candidate. + if let (Some(commitments), Some(pvd), Some(validation_code_hash)) = ( + candidate.commitments(), + candidate.persisted_validation_data(), + candidate.validation_code_hash(), + ) { + Fragment::check_against_constraints( + &relay_parent, + &constraints, + commitments, + validation_code_hash, + pvd, + ) + .map_err(Error::CheckAgainstConstraints)?; + } + + if relay_parent.number < constraints.min_relay_parent_number { + return Err(Error::RelayParentMovedBackwards) + } + + if let Some(earliest_rp) = maybe_min_relay_parent_number { + if relay_parent.number < earliest_rp { + return Err(Error::RelayParentMovedBackwards) + } + } + + Ok(()) } - fn populate_from_bases(&mut self, storage: &CandidateStorage, initial_bases: Vec) { - // Populate the tree breadth-first. - let mut last_sweep_start = None; + // Once the backable chain was populated, trim the forks generated by candidates which + // are not present in the best chain. Fan this out into a full breadth-first search. + // If `starting_point` is `Some()`, start the search from the candidates having this parent head + // hash. + fn trim_uneligible_forks(&self, storage: &mut CandidateStorage, starting_point: Option) { + // Start out with the candidates in the chain. They are all valid candidates. + let mut queue: VecDeque<_> = if let Some(starting_point) = starting_point { + [(starting_point, true)].into_iter().collect() + } else { + if self.best_chain.chain.is_empty() { + [(self.scope.base_constraints.required_parent.hash(), true)] + .into_iter() + .collect() + } else { + self.best_chain.chain.iter().map(|c| (c.parent_head_data_hash, true)).collect() + } + }; + // To make sure that cycles don't make us loop forever, keep track of the visited parent + // heads. + let mut visited = HashSet::new(); - loop { - let sweep_start = self.nodes.len(); + while let Some((parent, parent_has_potential)) = queue.pop_front() { + visited.insert(parent); - if Some(sweep_start) == last_sweep_start { - break + let Some(children) = storage.by_parent_head.get(&parent) else { continue }; + // Cannot remove while iterating so store them here temporarily. + let mut to_remove = vec![]; + + for child_hash in children.iter() { + let Some(child) = storage.by_candidate_hash.get(child_hash) else { continue }; + + // Already visited this parent. Either is a cycle or multiple paths that lead to the + // same candidate. Either way, stop this branch to avoid looping forever. + if visited.contains(&child.output_head_data_hash) { + continue + } + + // Only keep a candidate if its full ancestry was already kept as potential and this + // candidate itself has potential. + if parent_has_potential && self.check_potential(child).is_ok() { + queue.push_back((child.output_head_data_hash, true)); + } else { + // Otherwise, remove this candidate and continue looping for its children, but + // mark the parent's potential as `false`. We only want to remove its + // children. + to_remove.push(*child_hash); + queue.push_back((child.output_head_data_hash, false)); + } } - let parents: Vec = if let Some(last_start) = last_sweep_start { - (last_start..self.nodes.len()).map(NodePointer::Storage).collect() + for hash in to_remove { + storage.remove_candidate(&hash); + } + } + } + + // Populate the fragment chain with candidates from the supplied `CandidateStorage`. + // Can be called by the constructor or when backing a new candidate. + // When this is called, it may cause the previous chain to be completely erased or it may add + // more than one candidate. + fn populate_chain(&mut self, storage: &mut CandidateStorage) { + let mut cumulative_modifications = + if let Some(last_candidate) = self.best_chain.chain.last() { + last_candidate.cumulative_modifications.clone() } else { - initial_bases.clone() + ConstraintModifications::identity() }; + let Some(mut earliest_rp) = self.earliest_relay_parent() else { return }; - // 1. get parent head and find constraints - // 2. iterate all candidates building on the right head and viable relay parent - // 3. add new node - for parent_pointer in parents { - let (modifications, child_depth, earliest_rp) = match parent_pointer { - NodePointer::Root => - (ConstraintModifications::identity(), 0, self.scope.earliest_relay_parent()), - NodePointer::Storage(ptr) => { - let node = &self.nodes[ptr]; - let parent_rp = self - .scope - .ancestor_by_hash(&node.relay_parent()) - .or_else(|| { - // if the relay-parent is out of scope _and_ it is in the tree, - // it must be a candidate pending availability. - self.scope - .get_pending_availability(&node.candidate_hash) - .map(|c| c.relay_parent.clone()) - }) - .expect("All nodes in tree are either pending availability or within scope; qed"); - - (node.cumulative_modifications.clone(), node.depth + 1, parent_rp) + loop { + if self.best_chain.chain.len() > self.scope.max_depth { + break; + } + + let child_constraints = + match self.scope.base_constraints.apply_modifications(&cumulative_modifications) { + Err(e) => { + gum::debug!( + target: LOG_TARGET, + new_parent_head = ?cumulative_modifications.required_parent, + err = ?e, + "Failed to apply modifications", + ); + + break }, + Ok(c) => c, }; - if child_depth > self.scope.max_depth { - continue - } + let required_head_hash = child_constraints.required_parent.hash(); - let child_constraints = - match self.scope.base_constraints.apply_modifications(&modifications) { - Err(e) => { - gum::debug!( - target: LOG_TARGET, - new_parent_head = ?modifications.required_parent, - err = ?e, - "Failed to apply modifications", - ); - - continue - }, - Ok(c) => c, - }; + // Select the few possible backed/backable children which can be added to the chain + // right now. + let possible_children = storage + .possible_backed_para_children(&required_head_hash) + .filter_map(|candidate| { + // Only select a candidate if: + // 1. it does not introduce a fork or a cycle. + // 2. parent hash is correct. + // 3. relay-parent does not move backwards. + // 4. all non-pending-availability candidates have relay-parent in scope. + // 5. candidate outputs fulfill constraints - // Add nodes to tree wherever - // 1. parent hash is correct - // 2. relay-parent does not move backwards. - // 3. all non-pending-availability candidates have relay-parent in scope. - // 4. candidate outputs fulfill constraints - let required_head_hash = child_constraints.required_parent.hash(); - for candidate in storage.iter_para_children(&required_head_hash) { let pending = self.scope.get_pending_availability(&candidate.candidate_hash); - let relay_parent = pending + let Some(relay_parent) = pending .map(|p| p.relay_parent.clone()) - .or_else(|| self.scope.ancestor_by_hash(&candidate.relay_parent)); - - let relay_parent = match relay_parent { - Some(r) => r, - None => continue, + .or_else(|| self.scope.ancestor(&candidate.relay_parent)) + else { + return None }; - // require: pending availability candidates don't move backwards - // and only those can be out-of-scope. + if self.check_cycles_or_invalid_tree(&candidate.output_head_data_hash).is_err() + { + return None + } + + // require: candidates don't move backwards + // and only pending availability candidates can be out-of-scope. // // earliest_rp can be before the earliest relay parent in the scope // when the parent is a pending availability candidate as well, but // only other pending candidates can have a relay parent out of scope. let min_relay_parent_number = pending - .map(|p| match parent_pointer { - NodePointer::Root => p.relay_parent.number, - NodePointer::Storage(_) => earliest_rp.number, + .map(|p| match self.best_chain.chain.len() { + 0 => p.relay_parent.number, + _ => earliest_rp.number, }) - .unwrap_or_else(|| { - std::cmp::max( - earliest_rp.number, - self.scope.earliest_relay_parent().number, - ) - }); + .unwrap_or_else(|| earliest_rp.number); if relay_parent.number < min_relay_parent_number { - continue // relay parent moved backwards. + return None // relay parent moved backwards. } - // don't add candidates where the parent already has it as a child. - if self.node_has_candidate_child(parent_pointer, &candidate.candidate_hash) { - continue + // don't add candidates if they're already present in the chain. + // this can never happen, as candidates can only be duplicated if there's a + // cycle and we shouldn't have allowed for a cycle to be chained. + if self.best_chain.contains(&candidate.candidate_hash) { + return None } let fragment = { @@ -1089,11 +1259,12 @@ impl FragmentTree { let f = Fragment::new( relay_parent.clone(), constraints, - candidate.candidate.partial_clone(), + // It's cheap to clone because it's wrapped in an Arc + candidate.candidate.clone(), ); match f { - Ok(f) => f.into_owned(), + Ok(f) => f, Err(e) => { gum::debug!( target: LOG_TARGET, @@ -1103,48 +1274,82 @@ impl FragmentTree { "Failed to instantiate fragment", ); - continue + return None }, } }; - let mut cumulative_modifications = modifications.clone(); - cumulative_modifications.stack(fragment.constraint_modifications()); - - let node = FragmentNode { - parent: parent_pointer, + Some(( fragment, - candidate_hash: candidate.candidate_hash, - depth: child_depth, - cumulative_modifications, - children: Vec::new(), - }; + candidate.candidate_hash, + candidate.output_head_data_hash, + candidate.parent_head_data_hash, + )) + }); + + // Choose the best candidate. + let best_candidate = + possible_children.min_by(|(_, ref child1, _, _), (_, ref child2, _, _)| { + // Always pick a candidate pending availability as best. + if self.scope.get_pending_availability(child1).is_some() { + Ordering::Less + } else if self.scope.get_pending_availability(child2).is_some() { + Ordering::Greater + } else { + // Otherwise, use the fork selection rule. + fork_selection_rule(child1, child2) + } + }); - self.insert_node(node); - } - } + if let Some((fragment, candidate_hash, output_head_data_hash, parent_head_data_hash)) = + best_candidate + { + // Remove the candidate from storage. + storage.remove_candidate(&candidate_hash); + + // Update the cumulative constraint modifications. + cumulative_modifications.stack(fragment.constraint_modifications()); + // Update the earliest rp + earliest_rp = fragment.relay_parent().clone(); + + let node = FragmentNode { + fragment, + candidate_hash, + parent_head_data_hash, + output_head_data_hash, + cumulative_modifications: cumulative_modifications.clone(), + }; - last_sweep_start = Some(sweep_start); + // Add the candidate to the chain now. + self.best_chain.push(node); + } else { + break + } } } -} -struct FragmentNode { - // A pointer to the parent node. - parent: NodePointer, - fragment: Fragment<'static>, - candidate_hash: CandidateHash, - depth: usize, - cumulative_modifications: ConstraintModifications, - children: Vec<(NodePointer, CandidateHash)>, -} + // Revert the best backable chain so that the last candidate will be one outputting the given + // `parent_head_hash`. If the `parent_head_hash` is exactly the required parent of the base + // constraints (builds on the latest included candidate), revert the entire chain. + // Return false if we couldn't find the parent head hash. + fn revert_to(&mut self, parent_head_hash: &Hash) -> bool { + let mut removed_items = None; + if &self.scope.base_constraints.required_parent.hash() == parent_head_hash { + removed_items = Some(self.best_chain.clear()); + } -impl FragmentNode { - fn relay_parent(&self) -> Hash { - self.fragment.relay_parent().hash - } + if removed_items.is_none() && self.best_chain.by_output_head.contains_key(parent_head_hash) + { + removed_items = Some(self.best_chain.revert_to_parent_hash(parent_head_hash).collect()); + } + + let Some(removed_items) = removed_items else { return false }; - fn candidate_child(&self, candidate_hash: &CandidateHash) -> Option { - self.children.iter().find(|(_, c)| c == candidate_hash).map(|(p, _)| *p) + // Even if it's empty, we need to return true, because we'll be able to add a new candidate + // to the chain. + for node in &removed_items { + let _ = self.unconnected.add_candidate_entry(node.into()); + } + true } } diff --git a/polkadot/node/core/prospective-parachains/src/fragment_chain/tests.rs b/polkadot/node/core/prospective-parachains/src/fragment_chain/tests.rs index fd41be55f7f960367ee0a57ccd4a4c2251b90d13..9886d19e5224efddf1ec13b630c9a4af2bd079e4 100644 --- a/polkadot/node/core/prospective-parachains/src/fragment_chain/tests.rs +++ b/polkadot/node/core/prospective-parachains/src/fragment_chain/tests.rs @@ -17,19 +17,12 @@ use super::*; use assert_matches::assert_matches; use polkadot_node_subsystem_util::inclusion_emulator::InboundHrmpLimitations; -use polkadot_primitives::{BlockNumber, CandidateCommitments, CandidateDescriptor, HeadData}; +use polkadot_primitives::{ + BlockNumber, CandidateCommitments, CandidateDescriptor, HeadData, Id as ParaId, +}; use polkadot_primitives_test_helpers as test_helpers; -use rstest::rstest; -use std::iter; - -impl NodePointer { - fn unwrap_idx(self) -> usize { - match self { - NodePointer::Root => panic!("Unexpected root"), - NodePointer::Storage(index) => index, - } - } -} +use rand::{seq::SliceRandom, thread_rng}; +use std::ops::Range; fn make_constraints( min_relay_parent_number: BlockNumber, @@ -65,7 +58,7 @@ fn make_committed_candidate( let persisted_validation_data = PersistedValidationData { parent_head, relay_parent_number, - relay_parent_storage_root: Hash::repeat_byte(69), + relay_parent_storage_root: Hash::zero(), max_pov_size: 1_000_000, }; @@ -94,9 +87,20 @@ fn make_committed_candidate( (persisted_validation_data, candidate) } +fn populate_chain_from_previous_storage( + scope: &Scope, + storage: &CandidateStorage, +) -> FragmentChain { + let mut chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + let mut prev_chain = chain.clone(); + prev_chain.unconnected = storage.clone(); + + chain.populate_from_previous(&prev_chain); + chain +} + #[test] fn scope_rejects_ancestors_that_skip_blocks() { - let para_id = ParaId::from(5u32); let relay_parent = RelayChainBlockInfo { number: 10, hash: Hash::repeat_byte(10), @@ -115,7 +119,6 @@ fn scope_rejects_ancestors_that_skip_blocks() { assert_matches!( Scope::with_ancestors( - para_id, relay_parent, base_constraints, pending_availability, @@ -128,7 +131,6 @@ fn scope_rejects_ancestors_that_skip_blocks() { #[test] fn scope_rejects_ancestor_for_0_block() { - let para_id = ParaId::from(5u32); let relay_parent = RelayChainBlockInfo { number: 0, hash: Hash::repeat_byte(0), @@ -147,7 +149,6 @@ fn scope_rejects_ancestor_for_0_block() { assert_matches!( Scope::with_ancestors( - para_id, relay_parent, base_constraints, pending_availability, @@ -160,7 +161,6 @@ fn scope_rejects_ancestor_for_0_block() { #[test] fn scope_only_takes_ancestors_up_to_min() { - let para_id = ParaId::from(5u32); let relay_parent = RelayChainBlockInfo { number: 5, hash: Hash::repeat_byte(0), @@ -190,7 +190,6 @@ fn scope_only_takes_ancestors_up_to_min() { let pending_availability = Vec::new(); let scope = Scope::with_ancestors( - para_id, relay_parent, base_constraints, pending_availability, @@ -204,8 +203,50 @@ fn scope_only_takes_ancestors_up_to_min() { } #[test] -fn storage_add_candidate() { - let mut storage = CandidateStorage::new(); +fn scope_rejects_unordered_ancestors() { + let relay_parent = RelayChainBlockInfo { + number: 5, + hash: Hash::repeat_byte(0), + storage_root: Hash::repeat_byte(69), + }; + + let ancestors = vec![ + RelayChainBlockInfo { + number: 4, + hash: Hash::repeat_byte(4), + storage_root: Hash::repeat_byte(69), + }, + RelayChainBlockInfo { + number: 2, + hash: Hash::repeat_byte(2), + storage_root: Hash::repeat_byte(69), + }, + RelayChainBlockInfo { + number: 3, + hash: Hash::repeat_byte(3), + storage_root: Hash::repeat_byte(69), + }, + ]; + + let max_depth = 2; + let base_constraints = make_constraints(0, vec![2], vec![1, 2, 3].into()); + let pending_availability = Vec::new(); + + assert_matches!( + Scope::with_ancestors( + relay_parent, + base_constraints, + pending_availability, + max_depth, + ancestors, + ), + Err(UnexpectedAncestor { number: 2, prev: 4 }) + ); +} + +#[test] +fn candidate_storage_methods() { + let mut storage = CandidateStorage::default(); let relay_parent = Hash::repeat_byte(69); let (pvd, candidate) = make_committed_candidate( @@ -220,1232 +261,1259 @@ fn storage_add_candidate() { let candidate_hash = candidate.hash(); let parent_head_hash = pvd.parent_head.hash(); - storage.add_candidate(candidate, pvd).unwrap(); + // Invalid pvd hash + let mut wrong_pvd = pvd.clone(); + wrong_pvd.max_pov_size = 0; + assert_matches!( + CandidateEntry::new( + candidate_hash, + candidate.clone(), + wrong_pvd.clone(), + CandidateState::Seconded + ), + Err(CandidateEntryError::PersistedValidationDataMismatch) + ); + assert_matches!( + CandidateEntry::new_seconded(candidate_hash, candidate.clone(), wrong_pvd), + Err(CandidateEntryError::PersistedValidationDataMismatch) + ); + // Zero-length cycle. + { + let mut candidate = candidate.clone(); + candidate.commitments.head_data = HeadData(vec![1; 10]); + let mut pvd = pvd.clone(); + pvd.parent_head = HeadData(vec![1; 10]); + candidate.descriptor.persisted_validation_data_hash = pvd.hash(); + assert_matches!( + CandidateEntry::new_seconded(candidate_hash, candidate, pvd), + Err(CandidateEntryError::ZeroLengthCycle) + ); + } + assert!(!storage.contains(&candidate_hash)); + assert_eq!(storage.possible_backed_para_children(&parent_head_hash).count(), 0); + assert_eq!(storage.head_data_by_hash(&candidate.descriptor.para_head), None); + assert_eq!(storage.head_data_by_hash(&parent_head_hash), None); + + // Add a valid candidate. + let candidate_entry = CandidateEntry::new( + candidate_hash, + candidate.clone(), + pvd.clone(), + CandidateState::Seconded, + ) + .unwrap(); + storage.add_candidate_entry(candidate_entry.clone()).unwrap(); assert!(storage.contains(&candidate_hash)); - assert_eq!(storage.iter_para_children(&parent_head_hash).count(), 1); + assert_eq!(storage.possible_backed_para_children(&parent_head_hash).count(), 0); + assert_eq!(storage.possible_backed_para_children(&candidate.descriptor.para_head).count(), 0); + assert_eq!( + storage.head_data_by_hash(&candidate.descriptor.para_head).unwrap(), + &candidate.commitments.head_data + ); + assert_eq!(storage.head_data_by_hash(&parent_head_hash).unwrap(), &pvd.parent_head); - assert_eq!(storage.relay_parent_by_candidate_hash(&candidate_hash), Some(relay_parent)); -} + // Now mark it as backed + storage.mark_backed(&candidate_hash); + // Marking it twice is fine. + storage.mark_backed(&candidate_hash); + assert_eq!( + storage + .possible_backed_para_children(&parent_head_hash) + .map(|c| c.candidate_hash) + .collect::>(), + vec![candidate_hash] + ); + assert_eq!(storage.possible_backed_para_children(&candidate.descriptor.para_head).count(), 0); -#[test] -fn storage_retain() { - let mut storage = CandidateStorage::new(); + // Re-adding a candidate fails. + assert_matches!( + storage.add_candidate_entry(candidate_entry), + Err(Error::CandidateAlreadyKnown) + ); - let (pvd, candidate) = make_committed_candidate( + // Remove candidate and re-add it later in backed state. + storage.remove_candidate(&candidate_hash); + assert!(!storage.contains(&candidate_hash)); + + // Removing it twice is fine. + storage.remove_candidate(&candidate_hash); + assert!(!storage.contains(&candidate_hash)); + assert_eq!(storage.possible_backed_para_children(&parent_head_hash).count(), 0); + assert_eq!(storage.head_data_by_hash(&candidate.descriptor.para_head), None); + assert_eq!(storage.head_data_by_hash(&parent_head_hash), None); + + storage + .add_pending_availability_candidate(candidate_hash, candidate.clone(), pvd) + .unwrap(); + assert!(storage.contains(&candidate_hash)); + + assert_eq!( + storage + .possible_backed_para_children(&parent_head_hash) + .map(|c| c.candidate_hash) + .collect::>(), + vec![candidate_hash] + ); + assert_eq!(storage.possible_backed_para_children(&candidate.descriptor.para_head).count(), 0); + + // Now add a second candidate in Seconded state. This will be a fork. + let (pvd_2, candidate_2) = make_committed_candidate( ParaId::from(5u32), - Hash::repeat_byte(69), + relay_parent, 8, vec![4, 5, 6].into(), - vec![1, 2, 3].into(), + vec![2, 3, 4].into(), 7, ); + let candidate_hash_2 = candidate_2.hash(); + let candidate_entry_2 = + CandidateEntry::new_seconded(candidate_hash_2, candidate_2, pvd_2).unwrap(); - let candidate_hash = candidate.hash(); - let output_head_hash = candidate.commitments.head_data.hash(); - let parent_head_hash = pvd.parent_head.hash(); + storage.add_candidate_entry(candidate_entry_2).unwrap(); + assert_eq!( + storage + .possible_backed_para_children(&parent_head_hash) + .map(|c| c.candidate_hash) + .collect::>(), + vec![candidate_hash] + ); - storage.add_candidate(candidate, pvd).unwrap(); - storage.retain(|_| true); - assert!(storage.contains(&candidate_hash)); - assert_eq!(storage.iter_para_children(&parent_head_hash).count(), 1); - assert!(storage.head_data_by_hash(&output_head_hash).is_some()); + // Now mark it as backed. + storage.mark_backed(&candidate_hash_2); + assert_eq!( + storage + .possible_backed_para_children(&parent_head_hash) + .map(|c| c.candidate_hash) + .collect::>(), + [candidate_hash, candidate_hash_2].into_iter().collect() + ); +} - storage.retain(|_| false); - assert!(!storage.contains(&candidate_hash)); - assert_eq!(storage.iter_para_children(&parent_head_hash).count(), 0); - assert!(storage.head_data_by_hash(&output_head_hash).is_none()); +#[test] +fn init_and_populate_from_empty() { + // Empty chain and empty storage. + let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); + + let scope = Scope::with_ancestors( + RelayChainBlockInfo { + number: 1, + hash: Hash::repeat_byte(1), + storage_root: Hash::repeat_byte(2), + }, + base_constraints, + Vec::new(), + 4, + vec![], + ) + .unwrap(); + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert_eq!(chain.best_chain_len(), 0); + assert_eq!(chain.unconnected_len(), 0); + + let mut new_chain = FragmentChain::init(scope, CandidateStorage::default()); + new_chain.populate_from_previous(&chain); + assert_eq!(chain.best_chain_len(), 0); + assert_eq!(chain.unconnected_len(), 0); } -// [`FragmentTree::populate`] should pick up candidates that build on other candidates. #[test] -fn populate_works_recursively() { - let mut storage = CandidateStorage::new(); +fn test_populate_and_check_potential() { + let mut storage = CandidateStorage::default(); let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - let relay_parent_b = Hash::repeat_byte(2); + let relay_parent_x = Hash::repeat_byte(1); + let relay_parent_y = Hash::repeat_byte(2); + let relay_parent_z = Hash::repeat_byte(3); + let relay_parent_x_info = + RelayChainBlockInfo { number: 0, hash: relay_parent_x, storage_root: Hash::zero() }; + let relay_parent_y_info = + RelayChainBlockInfo { number: 1, hash: relay_parent_y, storage_root: Hash::zero() }; + let relay_parent_z_info = + RelayChainBlockInfo { number: 2, hash: relay_parent_z, storage_root: Hash::zero() }; + + let ancestors = vec![ + // These need to be ordered in reverse. + relay_parent_y_info.clone(), + relay_parent_x_info.clone(), + ]; + + let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); + // Candidates A -> B -> C. They are all backed let (pvd_a, candidate_a) = make_committed_candidate( para_id, - relay_parent_a, - 0, + relay_parent_x_info.hash, + relay_parent_x_info.number, vec![0x0a].into(), vec![0x0b].into(), - 0, + relay_parent_x_info.number, ); let candidate_a_hash = candidate_a.hash(); - + let candidate_a_entry = + CandidateEntry::new(candidate_a_hash, candidate_a, pvd_a.clone(), CandidateState::Backed) + .unwrap(); + storage.add_candidate_entry(candidate_a_entry.clone()).unwrap(); let (pvd_b, candidate_b) = make_committed_candidate( para_id, - relay_parent_b, - 1, + relay_parent_y_info.hash, + relay_parent_y_info.number, vec![0x0b].into(), vec![0x0c].into(), - 1, + relay_parent_y_info.number, ); let candidate_b_hash = candidate_b.hash(); + let candidate_b_entry = + CandidateEntry::new(candidate_b_hash, candidate_b, pvd_b, CandidateState::Backed).unwrap(); + storage.add_candidate_entry(candidate_b_entry.clone()).unwrap(); + let (pvd_c, candidate_c) = make_committed_candidate( + para_id, + relay_parent_z_info.hash, + relay_parent_z_info.number, + vec![0x0c].into(), + vec![0x0d].into(), + relay_parent_z_info.number, + ); + let candidate_c_hash = candidate_c.hash(); + let candidate_c_entry = + CandidateEntry::new(candidate_c_hash, candidate_c, pvd_c, CandidateState::Backed).unwrap(); + storage.add_candidate_entry(candidate_c_entry.clone()).unwrap(); - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); + // Candidate A doesn't adhere to the base constraints. + { + for wrong_constraints in [ + // Different required parent + make_constraints( + relay_parent_x_info.number, + vec![relay_parent_x_info.number], + vec![0x0e].into(), + ), + // Min relay parent number is wrong + make_constraints(relay_parent_y_info.number, vec![0], vec![0x0a].into()), + ] { + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + wrong_constraints.clone(), + vec![], + 4, + ancestors.clone(), + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); + + assert!(chain.best_chain_vec().is_empty()); + + // If the min relay parent number is wrong, candidate A can never become valid. + // Otherwise, if only the required parent doesn't match, candidate A is still a + // potential candidate. + if wrong_constraints.min_relay_parent_number == relay_parent_y_info.number { + // If A is not a potential candidate, its descendants will also not be added. + assert_eq!(chain.unconnected_len(), 0); + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::RelayParentNotInScope(_, _)) + ); + // However, if taken independently, both B and C still have potential, since we + // don't know that A doesn't. + assert!(chain.can_add_candidate_as_potential(&candidate_b_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + } else { + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_a_hash, candidate_b_hash, candidate_c_hash].into_iter().collect() + ); + } + } + } - let ancestors = vec![RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }]; + // Various depths + { + // Depth is 0, only allows one candidate, but the others will be kept as potential. + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 0, + ancestors.clone(), + ) + .unwrap(); + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert!(chain.can_add_candidate_as_potential(&candidate_a_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_b_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash]); + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_b_hash, candidate_c_hash].into_iter().collect() + ); - let relay_parent_b_info = RelayChainBlockInfo { - number: pvd_b.relay_parent_number, - hash: relay_parent_b, - storage_root: pvd_b.relay_parent_storage_root, - }; + // depth is 1, allows two candidates + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 1, + ancestors.clone(), + ) + .unwrap(); + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert!(chain.can_add_candidate_as_potential(&candidate_a_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_b_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash]); + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_c_hash].into_iter().collect() + ); - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); - let scope = Scope::with_ancestors( - para_id, - relay_parent_b_info, - base_constraints, - pending_availability, - 4, - ancestors, - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); + // depth is larger than 2, allows all three candidates + for depth in 2..6 { + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + depth, + ancestors.clone(), + ) + .unwrap(); + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert!(chain.can_add_candidate_as_potential(&candidate_a_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_b_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!( + chain.best_chain_vec(), + vec![candidate_a_hash, candidate_b_hash, candidate_c_hash] + ); + assert_eq!(chain.unconnected_len(), 0); + } + } - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); - assert!(candidates.contains(&candidate_a_hash)); - assert!(candidates.contains(&candidate_b_hash)); + // Relay parents out of scope + { + // Candidate A has relay parent out of scope. Candidates B and C will also be deleted since + // they form a chain with A. + let ancestors_without_x = vec![relay_parent_y_info.clone()]; + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 4, + ancestors_without_x, + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert!(chain.best_chain_vec().is_empty()); + assert_eq!(chain.unconnected_len(), 0); + + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::RelayParentNotInScope(_, _)) + ); + // However, if taken independently, both B and C still have potential, since we + // don't know that A doesn't. + assert!(chain.can_add_candidate_as_potential(&candidate_b_entry).is_ok()); + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + + // Candidates A and B have relay parents out of scope. Candidate C will also be deleted + // since it forms a chain with A and B. + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 4, + vec![], + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); - assert_eq!(tree.nodes.len(), 2); - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[0].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[0].depth, 0); + assert!(chain.best_chain_vec().is_empty()); + assert_eq!(chain.unconnected_len(), 0); - assert_eq!(tree.nodes[1].parent, NodePointer::Storage(0)); - assert_eq!(tree.nodes[1].candidate_hash, candidate_b_hash); - assert_eq!(tree.nodes[1].depth, 1); -} + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::RelayParentNotInScope(_, _)) + ); + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_b_entry), + Err(Error::RelayParentNotInScope(_, _)) + ); + // However, if taken independently, C still has potential, since we + // don't know that A and B don't + assert!(chain.can_add_candidate_as_potential(&candidate_c_entry).is_ok()); + } -#[test] -fn children_of_root_are_contiguous() { - let mut storage = CandidateStorage::new(); + // Parachain cycle is not allowed. Make C have the same parent as A. + { + let mut modified_storage = storage.clone(); + modified_storage.remove_candidate(&candidate_c_hash); + let (wrong_pvd_c, wrong_candidate_c) = make_committed_candidate( + para_id, + relay_parent_z_info.hash, + relay_parent_z_info.number, + vec![0x0c].into(), + vec![0x0a].into(), + relay_parent_z_info.number, + ); + let wrong_candidate_c_entry = CandidateEntry::new( + wrong_candidate_c.hash(), + wrong_candidate_c, + wrong_pvd_c, + CandidateState::Backed, + ) + .unwrap(); + modified_storage.add_candidate_entry(wrong_candidate_c_entry.clone()).unwrap(); + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 4, + ancestors.clone(), + ) + .unwrap(); - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - let relay_parent_b = Hash::repeat_byte(2); + let chain = populate_chain_from_previous_storage(&scope, &modified_storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash]); + assert_eq!(chain.unconnected_len(), 0); - let (pvd_a, candidate_a) = make_committed_candidate( + assert_matches!( + chain.can_add_candidate_as_potential(&wrong_candidate_c_entry), + Err(Error::Cycle) + ); + // However, if taken independently, C still has potential, since we don't know A and B. + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert!(chain.can_add_candidate_as_potential(&wrong_candidate_c_entry).is_ok()); + } + + // Candidate C has the same relay parent as candidate A's parent. Relay parent not allowed + // to move backwards + let mut modified_storage = storage.clone(); + modified_storage.remove_candidate(&candidate_c_hash); + let (wrong_pvd_c, wrong_candidate_c) = make_committed_candidate( para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0x0c].into(), + vec![0x0d].into(), 0, ); + let wrong_candidate_c_entry = CandidateEntry::new( + wrong_candidate_c.hash(), + wrong_candidate_c, + wrong_pvd_c, + CandidateState::Backed, + ) + .unwrap(); + modified_storage.add_candidate_entry(wrong_candidate_c_entry.clone()).unwrap(); + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], + 4, + ancestors.clone(), + ) + .unwrap(); - let (pvd_b, candidate_b) = make_committed_candidate( - para_id, - relay_parent_b, - 1, - vec![0x0b].into(), - vec![0x0c].into(), - 1, + let chain = populate_chain_from_previous_storage(&scope, &modified_storage); + + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash]); + assert_eq!(chain.unconnected_len(), 0); + assert_matches!( + chain.can_add_candidate_as_potential(&wrong_candidate_c_entry), + Err(Error::RelayParentMovedBackwards) ); - let (pvd_a2, candidate_a2) = make_committed_candidate( + // Candidate C is an unconnected candidate. + // C's relay parent is allowed to move backwards from B's relay parent, because C may later on + // trigger a reorg and B may get removed. + let mut modified_storage = storage.clone(); + modified_storage.remove_candidate(&candidate_c_hash); + let (unconnected_pvd_c, unconnected_candidate_c) = make_committed_candidate( para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b, 1].into(), + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0x0d].into(), + vec![0x0e].into(), 0, ); - let candidate_a2_hash = candidate_a2.hash(); - - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); - - let ancestors = vec![RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }]; - - let relay_parent_b_info = RelayChainBlockInfo { - number: pvd_b.relay_parent_number, - hash: relay_parent_b, - storage_root: pvd_b.relay_parent_storage_root, - }; - - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); + let unconnected_candidate_c_hash = unconnected_candidate_c.hash(); + let unconnected_candidate_c_entry = CandidateEntry::new( + unconnected_candidate_c_hash, + unconnected_candidate_c, + unconnected_pvd_c, + CandidateState::Backed, + ) + .unwrap(); + modified_storage + .add_candidate_entry(unconnected_candidate_c_entry.clone()) + .unwrap(); let scope = Scope::with_ancestors( - para_id, - relay_parent_b_info, - base_constraints, - pending_availability, + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![], 4, - ancestors, + ancestors.clone(), ) .unwrap(); - let mut tree = FragmentTree::populate(scope, &storage); + let chain = FragmentChain::init(scope.clone(), CandidateStorage::default()); + assert!(chain.can_add_candidate_as_potential(&unconnected_candidate_c_entry).is_ok()); - storage.add_candidate(candidate_a2, pvd_a2).unwrap(); - tree.add_and_populate(candidate_a2_hash, &storage); - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 3); - - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[1].parent, NodePointer::Root); - assert_eq!(tree.nodes[2].parent, NodePointer::Storage(0)); -} + let chain = populate_chain_from_previous_storage(&scope, &modified_storage); -#[test] -fn add_candidate_child_of_root() { - let mut storage = CandidateStorage::new(); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash]); + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [unconnected_candidate_c_hash].into_iter().collect() + ); - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); + // Candidate A is a pending availability candidate and Candidate C is an unconnected candidate, + // C's relay parent is not allowed to move backwards from A's relay parent because we're sure A + // will not get removed in the future, as it's already on-chain (unless it times out + // availability, a case for which we don't care to optimise for) - let (pvd_a, candidate_a) = make_committed_candidate( + modified_storage.remove_candidate(&candidate_a_hash); + let (modified_pvd_a, modified_candidate_a) = make_committed_candidate( para_id, - relay_parent_a, - 0, + relay_parent_y_info.hash, + relay_parent_y_info.number, vec![0x0a].into(), vec![0x0b].into(), - 0, + relay_parent_y_info.number, ); + let modified_candidate_a_hash = modified_candidate_a.hash(); + modified_storage + .add_candidate_entry( + CandidateEntry::new( + modified_candidate_a_hash, + modified_candidate_a, + modified_pvd_a, + CandidateState::Backed, + ) + .unwrap(), + ) + .unwrap(); - let (pvd_b, candidate_b) = make_committed_candidate( + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![PendingAvailability { + candidate_hash: modified_candidate_a_hash, + relay_parent: relay_parent_y_info.clone(), + }], + 4, + ancestors.clone(), + ) + .unwrap(); + + let chain = populate_chain_from_previous_storage(&scope, &modified_storage); + assert_eq!(chain.best_chain_vec(), vec![modified_candidate_a_hash, candidate_b_hash]); + assert_eq!(chain.unconnected_len(), 0); + assert_matches!( + chain.can_add_candidate_as_potential(&unconnected_candidate_c_entry), + Err(Error::RelayParentPrecedesCandidatePendingAvailability(_, _)) + ); + + // Not allowed to fork from a candidate pending availability + let (wrong_pvd_c, wrong_candidate_c) = make_committed_candidate( para_id, - relay_parent_a, - 0, + relay_parent_y_info.hash, + relay_parent_y_info.number, vec![0x0a].into(), - vec![0x0c].into(), + vec![0x0b2].into(), 0, ); - let candidate_b_hash = candidate_b.hash(); - - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); + let wrong_candidate_c_hash = wrong_candidate_c.hash(); + let wrong_candidate_c_entry = CandidateEntry::new( + wrong_candidate_c_hash, + wrong_candidate_c, + wrong_pvd_c, + CandidateState::Backed, + ) + .unwrap(); + modified_storage.add_candidate_entry(wrong_candidate_c_entry.clone()).unwrap(); - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; + // Does not even matter if the fork selection rule would have picked up the new candidate, as + // the other is already pending availability. + assert_eq!( + fork_selection_rule(&wrong_candidate_c_hash, &modified_candidate_a_hash), + Ordering::Less + ); - storage.add_candidate(candidate_a, pvd_a).unwrap(); let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![PendingAvailability { + candidate_hash: modified_candidate_a_hash, + relay_parent: relay_parent_y_info.clone(), + }], 4, - vec![], + ancestors.clone(), ) .unwrap(); - let mut tree = FragmentTree::populate(scope, &storage); - storage.add_candidate(candidate_b, pvd_b).unwrap(); - tree.add_and_populate(candidate_b_hash, &storage); - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); + let chain = populate_chain_from_previous_storage(&scope, &modified_storage); + assert_eq!(chain.best_chain_vec(), vec![modified_candidate_a_hash, candidate_b_hash]); + assert_eq!(chain.unconnected_len(), 0); + assert_matches!( + chain.can_add_candidate_as_potential(&wrong_candidate_c_entry), + Err(Error::ForkWithCandidatePendingAvailability(_)) + ); - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[1].parent, NodePointer::Root); -} + // Test with candidates pending availability + { + // Valid options + for pending in [ + vec![PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: relay_parent_x_info.clone(), + }], + vec![ + PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: relay_parent_x_info.clone(), + }, + PendingAvailability { + candidate_hash: candidate_b_hash, + relay_parent: relay_parent_y_info.clone(), + }, + ], + vec![ + PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: relay_parent_x_info.clone(), + }, + PendingAvailability { + candidate_hash: candidate_b_hash, + relay_parent: relay_parent_y_info.clone(), + }, + PendingAvailability { + candidate_hash: candidate_c_hash, + relay_parent: relay_parent_z_info.clone(), + }, + ], + ] { + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + pending, + 3, + ancestors.clone(), + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!( + chain.best_chain_vec(), + vec![candidate_a_hash, candidate_b_hash, candidate_c_hash] + ); + assert_eq!(chain.unconnected_len(), 0); + } -#[test] -fn add_candidate_child_of_non_root() { - let mut storage = CandidateStorage::new(); + // Relay parents of pending availability candidates can be out of scope + // Relay parent of candidate A is out of scope. + let ancestors_without_x = vec![relay_parent_y_info.clone()]; + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: relay_parent_x_info.clone(), + }], + 4, + ancestors_without_x, + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); + assert_eq!( + chain.best_chain_vec(), + vec![candidate_a_hash, candidate_b_hash, candidate_c_hash] + ); + assert_eq!(chain.unconnected_len(), 0); + + // Even relay parents of pending availability candidates which are out of scope cannot + // move backwards. + let scope = Scope::with_ancestors( + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![ + PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: RelayChainBlockInfo { + hash: relay_parent_x_info.hash, + number: 1, + storage_root: relay_parent_x_info.storage_root, + }, + }, + PendingAvailability { + candidate_hash: candidate_b_hash, + relay_parent: RelayChainBlockInfo { + hash: relay_parent_y_info.hash, + number: 0, + storage_root: relay_parent_y_info.storage_root, + }, + }, + ], + 4, + vec![], + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert!(chain.best_chain_vec().is_empty()); + assert_eq!(chain.unconnected_len(), 0); + } - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), - 0, - ); - - let (pvd_b, candidate_b) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0b].into(), - vec![0x0c].into(), - 0, - ); - let candidate_b_hash = candidate_b.hash(); - - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); - - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; + // More complex case: + // max_depth is 2 (a chain of max depth 3). + // A -> B -> C are the best backable chain. + // D is backed but would exceed the max depth. + // F is unconnected and seconded. + // A1 has same parent as A, is backed but has a higher candidate hash. It'll therefore be + // deleted. + // A1 has underneath a subtree that will all need to be trimmed. A1 -> B1. B1 -> C1 + // and B1 -> C2. (C1 is backed). + // A2 is seconded but is kept because it has a lower candidate hash than A. + // A2 points to B2, which is backed. + // + // Check that D, F, A2 and B2 are kept as unconnected potential candidates. - storage.add_candidate(candidate_a, pvd_a).unwrap(); let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, - 4, + relay_parent_z_info.clone(), + base_constraints.clone(), vec![], + 2, + ancestors.clone(), ) .unwrap(); - let mut tree = FragmentTree::populate(scope, &storage); - - storage.add_candidate(candidate_b, pvd_b).unwrap(); - tree.add_and_populate(candidate_b_hash, &storage); - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[1].parent, NodePointer::Storage(0)); -} - -#[test] -fn test_find_ancestor_path_and_find_backable_chain_empty_tree() { - let para_id = ParaId::from(5u32); - let relay_parent = Hash::repeat_byte(1); - let required_parent: HeadData = vec![0xff].into(); - let max_depth = 10; - - // Empty tree - let storage = CandidateStorage::new(); - let base_constraints = make_constraints(0, vec![0], required_parent.clone()); - - let relay_parent_info = - RelayChainBlockInfo { number: 0, hash: relay_parent, storage_root: Hash::zero() }; - - let scope = Scope::with_ancestors( + // Candidate D + let (pvd_d, candidate_d) = make_committed_candidate( para_id, - relay_parent_info, - base_constraints, - vec![], - max_depth, - vec![], - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - assert_eq!(tree.candidates().collect::>().len(), 0); - assert_eq!(tree.nodes.len(), 0); - - assert_eq!(tree.find_ancestor_path(Ancestors::new()).unwrap(), NodePointer::Root); - assert_eq!(tree.find_backable_chain(Ancestors::new(), 2, |_| true), vec![]); - // Invalid candidate. - let ancestors: Ancestors = [CandidateHash::default()].into_iter().collect(); - assert_eq!(tree.find_ancestor_path(ancestors.clone()), Some(NodePointer::Root)); - assert_eq!(tree.find_backable_chain(ancestors, 2, |_| true), vec![]); -} + relay_parent_z_info.hash, + relay_parent_z_info.number, + vec![0x0d].into(), + vec![0x0e].into(), + relay_parent_z_info.number, + ); + let candidate_d_hash = candidate_d.hash(); + let candidate_d_entry = + CandidateEntry::new(candidate_d_hash, candidate_d, pvd_d, CandidateState::Backed).unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_d_entry) + .is_ok()); + storage.add_candidate_entry(candidate_d_entry).unwrap(); + + // Candidate F + let (pvd_f, candidate_f) = make_committed_candidate( + para_id, + relay_parent_z_info.hash, + relay_parent_z_info.number, + vec![0x0f].into(), + vec![0xf1].into(), + 1000, + ); + let candidate_f_hash = candidate_f.hash(); + let candidate_f_entry = + CandidateEntry::new(candidate_f_hash, candidate_f, pvd_f, CandidateState::Seconded) + .unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_f_entry) + .is_ok()); + storage.add_candidate_entry(candidate_f_entry.clone()).unwrap(); + + // Candidate A1 + let (pvd_a1, candidate_a1) = make_committed_candidate( + para_id, + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0x0a].into(), + vec![0xb1].into(), + relay_parent_x_info.number, + ); + let candidate_a1_hash = candidate_a1.hash(); + let candidate_a1_entry = + CandidateEntry::new(candidate_a1_hash, candidate_a1, pvd_a1, CandidateState::Backed) + .unwrap(); + // Candidate A1 is created so that its hash is greater than the candidate A hash. + assert_eq!(fork_selection_rule(&candidate_a_hash, &candidate_a1_hash), Ordering::Less); -#[rstest] -#[case(true, 13)] -#[case(false, 8)] -// The tree with no cycles looks like: -// Make a tree that looks like this (note that there's no cycle): -// +-(root)-+ -// | | -// +----0---+ 7 -// | | -// 1----+ 5 -// | | -// | | -// 2 6 -// | -// 3 -// | -// 4 -// -// The tree with cycles is the same as the first but has a cycle from 4 back to the state -// produced by 0 (It's bounded by the max_depth + 1). -// +-(root)-+ -// | | -// +----0---+ 7 -// | | -// 1----+ 5 -// | | -// | | -// 2 6 -// | -// 3 -// | -// 4---+ -// | | -// 1 5 -// | -// 2 -// | -// 3 -fn test_find_ancestor_path_and_find_backable_chain( - #[case] has_cycle: bool, - #[case] expected_node_count: usize, -) { - let para_id = ParaId::from(5u32); - let relay_parent = Hash::repeat_byte(1); - let required_parent: HeadData = vec![0xff].into(); - let max_depth = 7; - let relay_parent_number = 0; - let relay_parent_storage_root = Hash::repeat_byte(69); + assert_matches!( + populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_a1_entry), + Err(Error::ForkChoiceRule(other)) if candidate_a_hash == other + ); - let mut candidates = vec![]; + storage.add_candidate_entry(candidate_a1_entry.clone()).unwrap(); - // Candidate 0 - candidates.push(make_committed_candidate( - para_id, - relay_parent, - 0, - required_parent.clone(), - vec![0].into(), - 0, - )); - // Candidate 1 - candidates.push(make_committed_candidate( - para_id, - relay_parent, - 0, - vec![0].into(), - vec![1].into(), - 0, - )); - // Candidate 2 - candidates.push(make_committed_candidate( + // Candidate B1. + let (pvd_b1, candidate_b1) = make_committed_candidate( para_id, - relay_parent, - 0, - vec![1].into(), - vec![2].into(), - 0, - )); - // Candidate 3 - candidates.push(make_committed_candidate( - para_id, - relay_parent, - 0, - vec![2].into(), - vec![3].into(), - 0, - )); - // Candidate 4 - candidates.push(make_committed_candidate( - para_id, - relay_parent, - 0, - vec![3].into(), - vec![4].into(), - 0, - )); - // Candidate 5 - candidates.push(make_committed_candidate( + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0xb1].into(), + vec![0xc1].into(), + relay_parent_x_info.number, + ); + let candidate_b1_hash = candidate_b1.hash(); + let candidate_b1_entry = + CandidateEntry::new(candidate_b1_hash, candidate_b1, pvd_b1, CandidateState::Seconded) + .unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_b1_entry) + .is_ok()); + + storage.add_candidate_entry(candidate_b1_entry).unwrap(); + + // Candidate C1. + let (pvd_c1, candidate_c1) = make_committed_candidate( para_id, - relay_parent, - 0, - vec![0].into(), - vec![5].into(), - 0, - )); - // Candidate 6 - candidates.push(make_committed_candidate( + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0xc1].into(), + vec![0xd1].into(), + relay_parent_x_info.number, + ); + let candidate_c1_hash = candidate_c1.hash(); + let candidate_c1_entry = + CandidateEntry::new(candidate_c1_hash, candidate_c1, pvd_c1, CandidateState::Backed) + .unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_c1_entry) + .is_ok()); + + storage.add_candidate_entry(candidate_c1_entry).unwrap(); + + // Candidate C2. + let (pvd_c2, candidate_c2) = make_committed_candidate( para_id, - relay_parent, - 0, - vec![1].into(), - vec![6].into(), - 0, - )); - // Candidate 7 - candidates.push(make_committed_candidate( + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0xc1].into(), + vec![0xd2].into(), + relay_parent_x_info.number, + ); + let candidate_c2_hash = candidate_c2.hash(); + let candidate_c2_entry = + CandidateEntry::new(candidate_c2_hash, candidate_c2, pvd_c2, CandidateState::Seconded) + .unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_c2_entry) + .is_ok()); + storage.add_candidate_entry(candidate_c2_entry).unwrap(); + + // Candidate A2. + let (pvd_a2, candidate_a2) = make_committed_candidate( para_id, - relay_parent, - 0, - required_parent.clone(), - vec![7].into(), - 0, - )); + relay_parent_x_info.hash, + relay_parent_x_info.number, + vec![0x0a].into(), + vec![0xb3].into(), + relay_parent_x_info.number, + ); + let candidate_a2_hash = candidate_a2.hash(); + let candidate_a2_entry = + CandidateEntry::new(candidate_a2_hash, candidate_a2, pvd_a2, CandidateState::Seconded) + .unwrap(); + // Candidate A2 is created so that its hash is greater than the candidate A hash. + assert_eq!(fork_selection_rule(&candidate_a2_hash, &candidate_a_hash), Ordering::Less); - if has_cycle { - candidates[4] = make_committed_candidate( - para_id, - relay_parent, - 0, - vec![3].into(), - vec![0].into(), // put the cycle here back to the output state of 0. - 0, - ); - } + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_a2_entry) + .is_ok()); - let base_constraints = make_constraints(0, vec![0], required_parent.clone()); - let mut storage = CandidateStorage::new(); + storage.add_candidate_entry(candidate_a2_entry).unwrap(); - let relay_parent_info = RelayChainBlockInfo { - number: relay_parent_number, - hash: relay_parent, - storage_root: relay_parent_storage_root, - }; - - for (pvd, candidate) in candidates.iter() { - storage.add_candidate(candidate.clone(), pvd.clone()).unwrap(); - } - let candidates = candidates.into_iter().map(|(_pvd, candidate)| candidate).collect::>(); - let scope = Scope::with_ancestors( + // Candidate B2. + let (pvd_b2, candidate_b2) = make_committed_candidate( para_id, - relay_parent_info, - base_constraints, - vec![], - max_depth, - vec![], - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - - assert_eq!(tree.candidates().collect::>().len(), candidates.len()); - assert_eq!(tree.nodes.len(), expected_node_count); + relay_parent_y_info.hash, + relay_parent_y_info.number, + vec![0xb3].into(), + vec![0xb4].into(), + relay_parent_y_info.number, + ); + let candidate_b2_hash = candidate_b2.hash(); + let candidate_b2_entry = + CandidateEntry::new(candidate_b2_hash, candidate_b2, pvd_b2, CandidateState::Backed) + .unwrap(); + assert!(populate_chain_from_previous_storage(&scope, &storage) + .can_add_candidate_as_potential(&candidate_b2_entry) + .is_ok()); + storage.add_candidate_entry(candidate_b2_entry).unwrap(); + + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash, candidate_c_hash]); + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_d_hash, candidate_f_hash, candidate_a2_hash, candidate_b2_hash] + .into_iter() + .collect() + ); + // Cannot add as potential an already present candidate (whether it's in the best chain or in + // unconnected storage) + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::CandidateAlreadyKnown) + ); + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_f_entry), + Err(Error::CandidateAlreadyKnown) + ); - // Do some common tests on both trees. + // Simulate a best chain reorg by backing a2. { - // No ancestors supplied. - assert_eq!(tree.find_ancestor_path(Ancestors::new()).unwrap(), NodePointer::Root); + let mut chain = chain.clone(); + chain.candidate_backed(&candidate_a2_hash); + assert_eq!(chain.best_chain_vec(), vec![candidate_a2_hash, candidate_b2_hash]); + // F is kept as it was truly unconnected. The rest will be trimmed. assert_eq!( - tree.find_backable_chain(Ancestors::new(), 4, |_| true), - [0, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - // Ancestor which is not part of the tree. Will be ignored. - let ancestors: Ancestors = [CandidateHash::default()].into_iter().collect(); - assert_eq!(tree.find_ancestor_path(ancestors.clone()).unwrap(), NodePointer::Root); - assert_eq!( - tree.find_backable_chain(ancestors, 4, |_| true), - [0, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - // A chain fork. - let ancestors: Ancestors = - [(candidates[0].hash()), (candidates[7].hash())].into_iter().collect(); - assert_eq!(tree.find_ancestor_path(ancestors.clone()), None); - assert_eq!(tree.find_backable_chain(ancestors, 1, |_| true), vec![]); - - // Ancestors which are part of the tree but don't form a path. Will be ignored. - let ancestors: Ancestors = - [candidates[1].hash(), candidates[2].hash()].into_iter().collect(); - assert_eq!(tree.find_ancestor_path(ancestors.clone()).unwrap(), NodePointer::Root); - assert_eq!( - tree.find_backable_chain(ancestors, 4, |_| true), - [0, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_f_hash].into_iter().collect() ); - // Valid ancestors. - let ancestors: Ancestors = [candidates[7].hash()].into_iter().collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[7].hash()); - assert_eq!(tree.find_backable_chain(ancestors, 1, |_| true), vec![]); - - let ancestors: Ancestors = - [candidates[2].hash(), candidates[0].hash(), candidates[1].hash()] - .into_iter() - .collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[2].hash()); - assert_eq!( - tree.find_backable_chain(ancestors.clone(), 2, |_| true), - [3, 4].into_iter().map(|i| candidates[i].hash()).collect::>() + // A and A1 will never have potential again. + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a1_entry), + Err(Error::ForkChoiceRule(_)) ); - - // Valid ancestors with candidates which have been omitted due to timeouts - let ancestors: Ancestors = - [candidates[0].hash(), candidates[2].hash()].into_iter().collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[0].hash()); - assert_eq!( - tree.find_backable_chain(ancestors, 3, |_| true), - [1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::ForkChoiceRule(_)) ); - - let ancestors: Ancestors = - [candidates[0].hash(), candidates[1].hash(), candidates[3].hash()] - .into_iter() - .collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[1].hash()); - if has_cycle { - assert_eq!( - tree.find_backable_chain(ancestors, 2, |_| true), - [2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - } else { - assert_eq!( - tree.find_backable_chain(ancestors, 4, |_| true), - [2, 3, 4].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - } - - let ancestors: Ancestors = - [candidates[1].hash(), candidates[2].hash()].into_iter().collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - assert_eq!(res, NodePointer::Root); - assert_eq!( - tree.find_backable_chain(ancestors, 4, |_| true), - [0, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - - // Requested count is 0. - assert_eq!(tree.find_backable_chain(Ancestors::new(), 0, |_| true), vec![]); - - let ancestors: Ancestors = - [candidates[2].hash(), candidates[0].hash(), candidates[1].hash()] - .into_iter() - .collect(); - assert_eq!(tree.find_backable_chain(ancestors, 0, |_| true), vec![]); - - let ancestors: Ancestors = - [candidates[2].hash(), candidates[0].hash()].into_iter().collect(); - assert_eq!(tree.find_backable_chain(ancestors, 0, |_| true), vec![]); - } - - // Now do some tests only on the tree with cycles - if has_cycle { - // Exceeds the maximum tree depth. 0-1-2-3-4-1-2-3-4, when the tree stops at - // 0-1-2-3-4-1-2-3. - let ancestors: Ancestors = [ - candidates[0].hash(), - candidates[1].hash(), - candidates[2].hash(), - candidates[3].hash(), - candidates[4].hash(), - ] - .into_iter() - .collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[4].hash()); - assert_eq!( - tree.find_backable_chain(ancestors, 4, |_| true), - [1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - - // 0-1-2. - let ancestors: Ancestors = - [candidates[0].hash(), candidates[1].hash(), candidates[2].hash()] - .into_iter() - .collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[2].hash()); - assert_eq!( - tree.find_backable_chain(ancestors.clone(), 1, |_| true), - [3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - assert_eq!( - tree.find_backable_chain(ancestors, 5, |_| true), - [3, 4, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>() - ); - - // 0-1 - let ancestors: Ancestors = - [candidates[0].hash(), candidates[1].hash()].into_iter().collect(); - let res = tree.find_ancestor_path(ancestors.clone()).unwrap(); - let candidate = &tree.nodes[res.unwrap_idx()]; - assert_eq!(candidate.candidate_hash, candidates[1].hash()); - assert_eq!( - tree.find_backable_chain(ancestors, 6, |_| true), - [2, 3, 4, 1, 2, 3].into_iter().map(|i| candidates[i].hash()).collect::>(), - ); - - // For 0-1-2-3-4-5, there's more than 1 way of finding this path in - // the tree. `None` should be returned. The runtime should not have accepted this. - let ancestors: Ancestors = [ - candidates[0].hash(), - candidates[1].hash(), - candidates[2].hash(), - candidates[3].hash(), - candidates[4].hash(), - candidates[5].hash(), - ] - .into_iter() - .collect(); - let res = tree.find_ancestor_path(ancestors.clone()); - assert_eq!(res, None); - assert_eq!(tree.find_backable_chain(ancestors, 1, |_| true), vec![]); } -} -#[test] -fn graceful_cycle_of_0() { - let mut storage = CandidateStorage::new(); + // Candidate F has an invalid hrmp watermark. however, it was not checked beforehand as we don't + // have its parent yet. Add its parent now. This will not impact anything as E is not yet part + // of the best chain. - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0a].into(), // input same as output - 0, - ); - let candidate_a_hash = candidate_a.hash(); - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); - - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; - - let max_depth = 4; - storage.add_candidate(candidate_a, pvd_a).unwrap(); - let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, - max_depth, - vec![], - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 1); - assert_eq!(tree.nodes.len(), max_depth + 1); - - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[1].parent, NodePointer::Storage(0)); - assert_eq!(tree.nodes[2].parent, NodePointer::Storage(1)); - assert_eq!(tree.nodes[3].parent, NodePointer::Storage(2)); - assert_eq!(tree.nodes[4].parent, NodePointer::Storage(3)); - - assert_eq!(tree.nodes[0].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[1].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[2].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[3].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[4].candidate_hash, candidate_a_hash); - - for count in 1..10 { - assert_eq!( - tree.find_backable_chain(Ancestors::new(), count, |_| true), - iter::repeat(candidate_a_hash) - .take(std::cmp::min(count as usize, max_depth + 1)) - .collect::>() - ); - assert_eq!( - tree.find_backable_chain([candidate_a_hash].into_iter().collect(), count - 1, |_| true), - iter::repeat(candidate_a_hash) - .take(std::cmp::min(count as usize - 1, max_depth)) - .collect::>() - ); - } -} - -#[test] -fn graceful_cycle_of_1() { - let mut storage = CandidateStorage::new(); - - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - - let (pvd_a, candidate_a) = make_committed_candidate( + let (pvd_e, candidate_e) = make_committed_candidate( para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), // input same as output - 0, + relay_parent_z_info.hash, + relay_parent_z_info.number, + vec![0x0e].into(), + vec![0x0f].into(), + relay_parent_z_info.number, ); - let candidate_a_hash = candidate_a.hash(); + let candidate_e_hash = candidate_e.hash(); + storage + .add_candidate_entry( + CandidateEntry::new(candidate_e_hash, candidate_e, pvd_e, CandidateState::Seconded) + .unwrap(), + ) + .unwrap(); - let (pvd_b, candidate_b) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0b].into(), - vec![0x0a].into(), // input same as output - 0, + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash, candidate_c_hash]); + assert_eq!( + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [ + candidate_d_hash, + candidate_f_hash, + candidate_a2_hash, + candidate_b2_hash, + candidate_e_hash + ] + .into_iter() + .collect() ); - let candidate_b_hash = candidate_b.hash(); - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); - - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; - - let max_depth = 4; - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); + // Simulate the fact that candidates A, B, C are now pending availability. let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, - max_depth, - vec![], + relay_parent_z_info.clone(), + base_constraints.clone(), + vec![ + PendingAvailability { + candidate_hash: candidate_a_hash, + relay_parent: relay_parent_x_info, + }, + PendingAvailability { + candidate_hash: candidate_b_hash, + relay_parent: relay_parent_y_info, + }, + PendingAvailability { + candidate_hash: candidate_c_hash, + relay_parent: relay_parent_z_info.clone(), + }, + ], + 2, + ancestors.clone(), ) .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); - assert_eq!(tree.nodes.len(), max_depth + 1); - - assert_eq!(tree.nodes[0].parent, NodePointer::Root); - assert_eq!(tree.nodes[1].parent, NodePointer::Storage(0)); - assert_eq!(tree.nodes[2].parent, NodePointer::Storage(1)); - assert_eq!(tree.nodes[3].parent, NodePointer::Storage(2)); - assert_eq!(tree.nodes[4].parent, NodePointer::Storage(3)); - - assert_eq!(tree.nodes[0].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[1].candidate_hash, candidate_b_hash); - assert_eq!(tree.nodes[2].candidate_hash, candidate_a_hash); - assert_eq!(tree.nodes[3].candidate_hash, candidate_b_hash); - assert_eq!(tree.nodes[4].candidate_hash, candidate_a_hash); - - assert_eq!(tree.find_backable_chain(Ancestors::new(), 1, |_| true), vec![candidate_a_hash],); - assert_eq!( - tree.find_backable_chain(Ancestors::new(), 2, |_| true), - vec![candidate_a_hash, candidate_b_hash], - ); - assert_eq!( - tree.find_backable_chain(Ancestors::new(), 3, |_| true), - vec![candidate_a_hash, candidate_b_hash, candidate_a_hash], - ); + // A2 and B2 will now be trimmed + let chain = populate_chain_from_previous_storage(&scope, &storage); + assert_eq!(chain.best_chain_vec(), vec![candidate_a_hash, candidate_b_hash, candidate_c_hash]); assert_eq!( - tree.find_backable_chain([candidate_a_hash].into_iter().collect(), 2, |_| true), - vec![candidate_b_hash, candidate_a_hash], + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_d_hash, candidate_f_hash, candidate_e_hash].into_iter().collect() ); - - assert_eq!( - tree.find_backable_chain(Ancestors::new(), 6, |_| true), - vec![ - candidate_a_hash, - candidate_b_hash, - candidate_a_hash, - candidate_b_hash, - candidate_a_hash - ], - ); - - for count in 3..7 { - assert_eq!( - tree.find_backable_chain( - [candidate_a_hash, candidate_b_hash].into_iter().collect(), - count, - |_| true - ), - vec![candidate_a_hash, candidate_b_hash, candidate_a_hash], - ); - } -} - -#[test] -fn hypothetical_depths_known_and_unknown() { - let mut storage = CandidateStorage::new(); - - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), // input same as output - 0, - ); - let candidate_a_hash = candidate_a.hash(); - - let (pvd_b, candidate_b) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0b].into(), - vec![0x0a].into(), // input same as output - 0, + // Cannot add as potential an already pending availability candidate + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_a_entry), + Err(Error::CandidateAlreadyKnown) ); - let candidate_b_hash = candidate_b.hash(); - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); - - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; + // Simulate the fact that candidates A, B and C have been included. - let max_depth = 4; - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); + let base_constraints = make_constraints(0, vec![0], HeadData(vec![0x0d])); let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, - max_depth, + relay_parent_z_info.clone(), + base_constraints.clone(), vec![], + 2, + ancestors.clone(), ) .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); - assert_eq!(tree.nodes.len(), max_depth + 1); + let prev_chain = chain; + let mut chain = FragmentChain::init(scope, CandidateStorage::default()); + chain.populate_from_previous(&prev_chain); + assert_eq!(chain.best_chain_vec(), vec![candidate_d_hash]); assert_eq!( - tree.hypothetical_depths( - candidate_a_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0a]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![0, 2, 4], + chain.unconnected().map(|c| c.candidate_hash).collect::>(), + [candidate_e_hash, candidate_f_hash].into_iter().collect() ); - assert_eq!( - tree.hypothetical_depths( - candidate_b_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0b]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![1, 3], - ); + // Mark E as backed. F will be dropped for invalid watermark. No other unconnected candidates. + chain.candidate_backed(&candidate_e_hash); + assert_eq!(chain.best_chain_vec(), vec![candidate_d_hash, candidate_e_hash]); + assert_eq!(chain.unconnected_len(), 0); - assert_eq!( - tree.hypothetical_depths( - CandidateHash(Hash::repeat_byte(21)), - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0a]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![0, 2, 4], - ); - - assert_eq!( - tree.hypothetical_depths( - CandidateHash(Hash::repeat_byte(22)), - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0b]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![1, 3] + assert_matches!( + chain.can_add_candidate_as_potential(&candidate_f_entry), + Err(Error::CheckAgainstConstraints(_)) ); } #[test] -fn hypothetical_depths_stricter_on_complete() { - let storage = CandidateStorage::new(); - - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), - 1000, // watermark is illegal - ); - - let candidate_a_hash = candidate_a.hash(); - - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); +fn test_find_ancestor_path_and_find_backable_chain_empty_best_chain() { + let relay_parent = Hash::repeat_byte(1); + let required_parent: HeadData = vec![0xff].into(); + let max_depth = 10; - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; + // Empty chain + let base_constraints = make_constraints(0, vec![0], required_parent.clone()); - let max_depth = 4; - let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, - max_depth, - vec![], - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); + let relay_parent_info = + RelayChainBlockInfo { number: 0, hash: relay_parent, storage_root: Hash::zero() }; - assert_eq!( - tree.hypothetical_depths( - candidate_a_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0a]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![0], - ); + let scope = + Scope::with_ancestors(relay_parent_info, base_constraints, vec![], max_depth, vec![]) + .unwrap(); + let chain = FragmentChain::init(scope, CandidateStorage::default()); + assert_eq!(chain.best_chain_len(), 0); - assert!(tree - .hypothetical_depths( - candidate_a_hash, - HypotheticalCandidate::Complete { - receipt: Cow::Owned(candidate_a), - persisted_validation_data: Cow::Owned(pvd_a), - }, - &storage, - false, - ) - .is_empty()); + assert_eq!(chain.find_ancestor_path(Ancestors::new()), 0); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 2), vec![]); + // Invalid candidate. + let ancestors: Ancestors = [CandidateHash::default()].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 0); + assert_eq!(chain.find_backable_chain(ancestors, 2), vec![]); } #[test] -fn hypothetical_depths_backed_in_path() { - let mut storage = CandidateStorage::new(); - +fn test_find_ancestor_path_and_find_backable_chain() { let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); + let relay_parent = Hash::repeat_byte(1); + let required_parent: HeadData = vec![0xff].into(); + let max_depth = 5; + let relay_parent_number = 0; + let relay_parent_storage_root = Hash::zero(); - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), - 0, - ); - let candidate_a_hash = candidate_a.hash(); + let mut candidates = vec![]; - let (pvd_b, candidate_b) = make_committed_candidate( + // Candidate 0 + candidates.push(make_committed_candidate( para_id, - relay_parent_a, + relay_parent, 0, - vec![0x0b].into(), - vec![0x0c].into(), + required_parent.clone(), + vec![0].into(), 0, - ); - let candidate_b_hash = candidate_b.hash(); + )); - let (pvd_c, candidate_c) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0b].into(), - vec![0x0d].into(), - 0, - ); + // Candidates 1..=5 + for index in 1..=5 { + candidates.push(make_committed_candidate( + para_id, + relay_parent, + 0, + vec![index - 1].into(), + vec![index].into(), + 0, + )); + } - let base_constraints = make_constraints(0, vec![0], vec![0x0a].into()); - let pending_availability = Vec::new(); + let mut storage = CandidateStorage::default(); - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; + for (pvd, candidate) in candidates.iter() { + storage + .add_candidate_entry( + CandidateEntry::new_seconded(candidate.hash(), candidate.clone(), pvd.clone()) + .unwrap(), + ) + .unwrap(); + } - let max_depth = 4; - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); - storage.add_candidate(candidate_c, pvd_c).unwrap(); + let candidates = candidates + .into_iter() + .map(|(_pvd, candidate)| candidate.hash()) + .collect::>(); + let hashes = + |range: Range| range.map(|i| (candidates[i], relay_parent)).collect::>(); - // `A` and `B` are backed, `C` is not. - storage.mark_backed(&candidate_a_hash); - storage.mark_backed(&candidate_b_hash); + let relay_parent_info = RelayChainBlockInfo { + number: relay_parent_number, + hash: relay_parent, + storage_root: relay_parent_storage_root, + }; + let base_constraints = make_constraints(0, vec![0], required_parent.clone()); let scope = Scope::with_ancestors( - para_id, - relay_parent_a_info, - base_constraints, - pending_availability, + relay_parent_info.clone(), + base_constraints.clone(), + vec![], max_depth, vec![], ) .unwrap(); - let tree = FragmentTree::populate(scope, &storage); - - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 3); - assert_eq!(tree.nodes.len(), 3); - - let candidate_d_hash = CandidateHash(Hash::repeat_byte(0xAA)); - - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0a]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - true, - ), - vec![0], - ); + let mut chain = populate_chain_from_previous_storage(&scope, &storage); - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0c]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - true, - ), - vec![2], - ); + // For now, candidates are only seconded, not backed. So the best chain is empty and no + // candidate will be returned. + assert_eq!(candidates.len(), 6); + assert_eq!(chain.best_chain_len(), 0); + assert_eq!(chain.unconnected_len(), 6); - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0d]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - true, - ), - Vec::::new(), - ); - - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0d]).hash(), - relay_parent: relay_parent_a, - }, - &storage, - false, - ), - vec![2], // non-empty if `false`. - ); -} + for count in 0..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count).len(), 0); + } -#[test] -fn pending_availability_in_scope() { - let mut storage = CandidateStorage::new(); + // Do tests with only a couple of candidates being backed. + { + let mut chain = chain.clone(); + chain.candidate_backed(&&candidates[5]); + for count in 0..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count).len(), 0); + } + chain.candidate_backed(&&candidates[3]); + chain.candidate_backed(&&candidates[4]); + for count in 0..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count).len(), 0); + } - let para_id = ParaId::from(5u32); - let relay_parent_a = Hash::repeat_byte(1); - let relay_parent_b = Hash::repeat_byte(2); - let relay_parent_c = Hash::repeat_byte(3); + chain.candidate_backed(&&candidates[1]); + for count in 0..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count).len(), 0); + } - let (pvd_a, candidate_a) = make_committed_candidate( - para_id, - relay_parent_a, - 0, - vec![0x0a].into(), - vec![0x0b].into(), - 0, - ); - let candidate_a_hash = candidate_a.hash(); + chain.candidate_backed(&&candidates[0]); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 1), hashes(0..1)); + for count in 2..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count), hashes(0..2)); + } - let (pvd_b, candidate_b) = make_committed_candidate( - para_id, - relay_parent_b, - 1, - vec![0x0b].into(), - vec![0x0c].into(), - 1, - ); + // Now back the missing piece. + chain.candidate_backed(&&candidates[2]); + assert_eq!(chain.best_chain_len(), 6); + for count in 0..10 { + assert_eq!( + chain.find_backable_chain(Ancestors::new(), count), + (0..6) + .take(count as usize) + .map(|i| (candidates[i], relay_parent)) + .collect::>() + ); + } + } - // Note that relay parent `a` is not allowed. - let base_constraints = make_constraints(1, vec![], vec![0x0a].into()); + // Now back all candidates. Back them in a random order. The result should always be the same. + let mut candidates_shuffled = candidates.clone(); + candidates_shuffled.shuffle(&mut thread_rng()); + for candidate in candidates.iter() { + chain.candidate_backed(candidate); + storage.mark_backed(candidate); + } - let relay_parent_a_info = RelayChainBlockInfo { - number: pvd_a.relay_parent_number, - hash: relay_parent_a, - storage_root: pvd_a.relay_parent_storage_root, - }; - let pending_availability = vec![PendingAvailability { - candidate_hash: candidate_a_hash, - relay_parent: relay_parent_a_info, - }]; + // No ancestors supplied. + assert_eq!(chain.find_ancestor_path(Ancestors::new()), 0); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 0), vec![]); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 1), hashes(0..1)); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 2), hashes(0..2)); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 5), hashes(0..5)); - let relay_parent_b_info = RelayChainBlockInfo { - number: pvd_b.relay_parent_number, - hash: relay_parent_b, - storage_root: pvd_b.relay_parent_storage_root, - }; - let relay_parent_c_info = RelayChainBlockInfo { - number: pvd_b.relay_parent_number + 1, - hash: relay_parent_c, - storage_root: Hash::zero(), - }; + for count in 6..10 { + assert_eq!(chain.find_backable_chain(Ancestors::new(), count), hashes(0..6)); + } - let max_depth = 4; - storage.add_candidate(candidate_a, pvd_a).unwrap(); - storage.add_candidate(candidate_b, pvd_b).unwrap(); - storage.mark_backed(&candidate_a_hash); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 7), hashes(0..6)); + assert_eq!(chain.find_backable_chain(Ancestors::new(), 10), hashes(0..6)); - let scope = Scope::with_ancestors( - para_id, - relay_parent_c_info, - base_constraints, - pending_availability, - max_depth, - vec![relay_parent_b_info], - ) - .unwrap(); - let tree = FragmentTree::populate(scope, &storage); + // Ancestor which is not part of the chain. Will be ignored. + let ancestors: Ancestors = [CandidateHash::default()].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 0); + assert_eq!(chain.find_backable_chain(ancestors, 4), hashes(0..4)); + + let ancestors: Ancestors = [candidates[1], CandidateHash::default()].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 0); + assert_eq!(chain.find_backable_chain(ancestors, 4), hashes(0..4)); + + let ancestors: Ancestors = [candidates[0], CandidateHash::default()].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 1); + assert_eq!(chain.find_backable_chain(ancestors, 4), hashes(1..5)); + + // Ancestors which are part of the chain but don't form a path from root. Will be ignored. + let ancestors: Ancestors = [candidates[1], candidates[2]].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 0); + assert_eq!(chain.find_backable_chain(ancestors, 4), hashes(0..4)); + + // Valid ancestors. + let ancestors: Ancestors = [candidates[2], candidates[0], candidates[1]].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 3); + assert_eq!(chain.find_backable_chain(ancestors.clone(), 2), hashes(3..5)); + for count in 3..10 { + assert_eq!(chain.find_backable_chain(ancestors.clone(), count), hashes(3..6)); + } - let candidates: Vec<_> = tree.candidates().collect(); - assert_eq!(candidates.len(), 2); - assert_eq!(tree.nodes.len(), 2); + // Valid ancestors with candidates which have been omitted due to timeouts + let ancestors: Ancestors = [candidates[0], candidates[2]].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 1); + assert_eq!(chain.find_backable_chain(ancestors.clone(), 3), hashes(1..4)); + assert_eq!(chain.find_backable_chain(ancestors.clone(), 4), hashes(1..5)); + for count in 5..10 { + assert_eq!(chain.find_backable_chain(ancestors.clone(), count), hashes(1..6)); + } - let candidate_d_hash = CandidateHash(Hash::repeat_byte(0xAA)); + let ancestors: Ancestors = [candidates[0], candidates[1], candidates[3]].into_iter().collect(); + assert_eq!(chain.find_ancestor_path(ancestors.clone()), 2); + assert_eq!(chain.find_backable_chain(ancestors.clone(), 4), hashes(2..6)); - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0b]).hash(), - relay_parent: relay_parent_c, - }, - &storage, - false, - ), - vec![1], - ); + // Requested count is 0. + assert_eq!(chain.find_backable_chain(ancestors, 0), vec![]); - assert_eq!( - tree.hypothetical_depths( - candidate_d_hash, - HypotheticalCandidate::Incomplete { - parent_head_data_hash: HeadData::from(vec![0x0c]).hash(), - relay_parent: relay_parent_b, - }, - &storage, - false, - ), - vec![2], - ); + // Stop when we've found a candidate which is pending availability + { + let scope = Scope::with_ancestors( + relay_parent_info.clone(), + base_constraints, + // Mark the third candidate as pending availability + vec![PendingAvailability { + candidate_hash: candidates[3], + relay_parent: relay_parent_info, + }], + max_depth, + vec![], + ) + .unwrap(); + let chain = populate_chain_from_previous_storage(&scope, &storage); + let ancestors: Ancestors = [candidates[0], candidates[1]].into_iter().collect(); + assert_eq!( + // Stop at 4. + chain.find_backable_chain(ancestors.clone(), 3), + hashes(2..3) + ); + } } diff --git a/polkadot/node/core/prospective-parachains/src/lib.rs b/polkadot/node/core/prospective-parachains/src/lib.rs index 0b1a2e034a2893e6397b986405df28a91776d819..b8b5f159e71cdd9a6f01f1a4a30bad5f9f2dc912 100644 --- a/polkadot/node/core/prospective-parachains/src/lib.rs +++ b/polkadot/node/core/prospective-parachains/src/lib.rs @@ -21,31 +21,32 @@ //! This is the main coordinator of work within the node for the collation and //! backing phases of parachain consensus. //! -//! This is primarily an implementation of "Fragment Trees", as described in +//! This is primarily an implementation of "Fragment Chains", as described in //! [`polkadot_node_subsystem_util::inclusion_emulator`]. //! //! This subsystem also handles concerns such as the relay-chain being forkful and session changes. -use std::{ - borrow::Cow, - collections::{HashMap, HashSet}, -}; +#![deny(unused_crate_dependencies)] + +use std::collections::{HashMap, HashSet}; +use fragment_chain::CandidateStorage; use futures::{channel::oneshot, prelude::*}; use polkadot_node_subsystem::{ messages::{ - Ancestors, ChainApiMessage, FragmentTreeMembership, HypotheticalCandidate, - HypotheticalFrontierRequest, IntroduceCandidateRequest, ParentHeadData, + Ancestors, ChainApiMessage, HypotheticalCandidate, HypotheticalMembership, + HypotheticalMembershipRequest, IntroduceSecondedCandidateRequest, ParentHeadData, ProspectiveParachainsMessage, ProspectiveValidationDataRequest, RuntimeApiMessage, RuntimeApiRequest, }, overseer, ActiveLeavesUpdate, FromOrchestra, OverseerSignal, SpawnedSubsystem, SubsystemError, }; use polkadot_node_subsystem_util::{ + backing_implicit_view::{BlockInfoProspectiveParachains as BlockInfo, View as ImplicitView}, inclusion_emulator::{Constraints, RelayChainBlockInfo}, request_session_index_for_child, - runtime::{prospective_parachains_mode, ProspectiveParachainsMode}, + runtime::{fetch_claim_queue, prospective_parachains_mode, ProspectiveParachainsMode}, }; use polkadot_primitives::{ async_backing::CandidatePendingAvailability, BlockNumber, CandidateHash, @@ -56,7 +57,7 @@ use polkadot_primitives::{ use crate::{ error::{FatalError, FatalResult, JfyiError, JfyiErrorResult, Result}, fragment_chain::{ - CandidateStorage, CandidateStorageInsertionError, FragmentTree, Scope as TreeScope, + CandidateEntry, Error as FragmentChainError, FragmentChain, Scope as FragmentChainScope, }, }; @@ -71,20 +72,33 @@ use self::metrics::Metrics; const LOG_TARGET: &str = "parachain::prospective-parachains"; struct RelayBlockViewData { - // Scheduling info for paras and upcoming paras. - fragment_trees: HashMap, - pending_availability: HashSet, + // The fragment chains for current and upcoming scheduled paras. + fragment_chains: HashMap, } struct View { - // Active or recent relay-chain blocks by block hash. - active_leaves: HashMap, - candidate_storage: HashMap, + // Per relay parent fragment chains. These includes all relay parents under the implicit view. + per_relay_parent: HashMap, + // The hashes of the currently active leaves. This is a subset of the keys in + // `per_relay_parent`. + active_leaves: HashSet, + // The backing implicit view. + implicit_view: ImplicitView, } impl View { + // Initialize with empty values. fn new() -> Self { - View { active_leaves: HashMap::new(), candidate_storage: HashMap::new() } + View { + per_relay_parent: HashMap::new(), + active_leaves: HashSet::new(), + implicit_view: ImplicitView::default(), + } + } + + // Get the fragment chains of this leaf. + fn get_fragment_chains(&self, leaf: &Hash) -> Option<&HashMap> { + self.per_relay_parent.get(&leaf).map(|view_data| &view_data.fragment_chains) } } @@ -141,12 +155,10 @@ async fn run_iteration( }, FromOrchestra::Signal(OverseerSignal::BlockFinalized(..)) => {}, FromOrchestra::Communication { msg } => match msg { - ProspectiveParachainsMessage::IntroduceCandidate(request, tx) => - handle_candidate_introduced(&mut *ctx, view, request, tx).await?, - ProspectiveParachainsMessage::CandidateSeconded(para, candidate_hash) => - handle_candidate_seconded(view, para, candidate_hash), + ProspectiveParachainsMessage::IntroduceSecondedCandidate(request, tx) => + handle_introduce_seconded_candidate(view, request, tx, metrics).await, ProspectiveParachainsMessage::CandidateBacked(para, candidate_hash) => - handle_candidate_backed(&mut *ctx, view, para, candidate_hash).await?, + handle_candidate_backed(view, para, candidate_hash, metrics).await, ProspectiveParachainsMessage::GetBackableCandidates( relay_parent, para, @@ -154,10 +166,8 @@ async fn run_iteration( ancestors, tx, ) => answer_get_backable_candidates(&view, relay_parent, para, count, ancestors, tx), - ProspectiveParachainsMessage::GetHypotheticalFrontier(request, tx) => - answer_hypothetical_frontier_request(&view, request, tx), - ProspectiveParachainsMessage::GetTreeMembership(para, candidate, tx) => - answer_tree_membership_request(&view, para, candidate, tx), + ProspectiveParachainsMessage::GetHypotheticalMembership(request, tx) => + answer_hypothetical_membership_request(&view, request, tx, metrics), ProspectiveParachainsMessage::GetMinimumRelayParents(relay_parent, tx) => answer_minimum_relay_parents_request(&view, relay_parent, tx), ProspectiveParachainsMessage::GetProspectiveValidationData(request, tx) => @@ -174,17 +184,32 @@ async fn handle_active_leaves_update( update: ActiveLeavesUpdate, metrics: &Metrics, ) -> JfyiErrorResult<()> { - // 1. clean up inactive leaves - // 2. determine all scheduled para at new block - // 3. construct new fragment tree for each para for each new leaf - // 4. prune candidate storage. - - for deactivated in &update.deactivated { - view.active_leaves.remove(deactivated); - } + // For any new active leaf: + // - determine the scheduled paras + // - pre-populate the candidate storage with pending availability candidates and candidates from + // the parent leaf + // - populate the fragment chain + // - add it to the implicit view + // + // Then mark the newly-deactivated leaves as deactivated and update the implicit view. + // Finally, remove any relay parents that are no longer part of the implicit view. + + let _timer = metrics.time_handle_active_leaves_update(); + + gum::trace!( + target: LOG_TARGET, + activated = ?update.activated, + deactivated = ?update.deactivated, + "Handle ActiveLeavesUpdate" + ); let mut temp_header_cache = HashMap::new(); + // There can only be one newly activated leaf, `update.activated` is an `Option`. for activated in update.activated.into_iter() { + if update.deactivated.contains(&activated.hash) { + continue + } + let hash = activated.hash; let mode = prospective_parachains_mode(ctx.sender(), hash) @@ -203,52 +228,44 @@ async fn handle_active_leaves_update( return Ok(()) }; - let mut pending_availability = HashSet::new(); - let scheduled_paras = - fetch_upcoming_paras(&mut *ctx, hash, &mut pending_availability).await?; + let scheduled_paras = fetch_upcoming_paras(ctx, hash).await?; - let block_info: RelayChainBlockInfo = - match fetch_block_info(&mut *ctx, &mut temp_header_cache, hash).await? { - None => { - gum::warn!( - target: LOG_TARGET, - block_hash = ?hash, - "Failed to get block info for newly activated leaf block." - ); + let block_info = match fetch_block_info(ctx, &mut temp_header_cache, hash).await? { + None => { + gum::warn!( + target: LOG_TARGET, + block_hash = ?hash, + "Failed to get block info for newly activated leaf block." + ); - // `update.activated` is an option, but we can use this - // to exit the 'loop' and skip this block without skipping - // pruning logic. - continue - }, - Some(info) => info, - }; + // `update.activated` is an option, but we can use this + // to exit the 'loop' and skip this block without skipping + // pruning logic. + continue + }, + Some(info) => info, + }; let ancestry = - fetch_ancestry(&mut *ctx, &mut temp_header_cache, hash, allowed_ancestry_len).await?; + fetch_ancestry(ctx, &mut temp_header_cache, hash, allowed_ancestry_len).await?; - // Find constraints. - let mut fragment_trees = HashMap::new(); - for para in scheduled_paras { - let candidate_storage = - view.candidate_storage.entry(para).or_insert_with(CandidateStorage::new); + let prev_fragment_chains = + ancestry.first().and_then(|prev_leaf| view.get_fragment_chains(&prev_leaf.hash)); - let backing_state = fetch_backing_state(&mut *ctx, hash, para).await?; - - let (constraints, pending_availability) = match backing_state { - Some(c) => c, - None => { - // This indicates a runtime conflict of some kind. - - gum::debug!( - target: LOG_TARGET, - para_id = ?para, - relay_parent = ?hash, - "Failed to get inclusion backing state." - ); + let mut fragment_chains = HashMap::new(); + for para in scheduled_paras { + // Find constraints and pending availability candidates. + let backing_state = fetch_backing_state(ctx, hash, para).await?; + let Some((constraints, pending_availability)) = backing_state else { + // This indicates a runtime conflict of some kind. + gum::debug!( + target: LOG_TARGET, + para_id = ?para, + relay_parent = ?hash, + "Failed to get inclusion backing state." + ); - continue - }, + continue }; let pending_availability = preprocess_candidates_pending_availability( @@ -260,16 +277,18 @@ async fn handle_active_leaves_update( .await?; let mut compact_pending = Vec::with_capacity(pending_availability.len()); + let mut pending_availability_storage = CandidateStorage::default(); + for c in pending_availability { - let res = candidate_storage.add_candidate(c.candidate, c.persisted_validation_data); let candidate_hash = c.compact.candidate_hash; - compact_pending.push(c.compact); + let res = pending_availability_storage.add_pending_availability_candidate( + candidate_hash, + c.candidate, + c.persisted_validation_data, + ); match res { - Ok(_) | Err(CandidateStorageInsertionError::CandidateAlreadyKnown(_)) => { - // Anything on-chain is guaranteed to be backed. - candidate_storage.mark_backed(&candidate_hash); - }, + Ok(_) | Err(FragmentChainError::CandidateAlreadyKnown) => {}, Err(err) => { gum::warn!( target: LOG_TARGET, @@ -278,78 +297,146 @@ async fn handle_active_leaves_update( ?err, "Scraped invalid candidate pending availability", ); + + break }, } + + compact_pending.push(c.compact); } - let scope = TreeScope::with_ancestors( - para, - block_info.clone(), + let scope = match FragmentChainScope::with_ancestors( + block_info.clone().into(), constraints, compact_pending, max_candidate_depth, - ancestry.iter().cloned(), - ) - .expect("ancestors are provided in reverse order and correctly; qed"); + ancestry + .iter() + .map(|a| RelayChainBlockInfo::from(a.clone())) + .collect::>(), + ) { + Ok(scope) => scope, + Err(unexpected_ancestors) => { + gum::warn!( + target: LOG_TARGET, + para_id = ?para, + max_candidate_depth, + ?ancestry, + leaf = ?hash, + "Relay chain ancestors have wrong order: {:?}", + unexpected_ancestors + ); + continue + }, + }; gum::trace!( target: LOG_TARGET, relay_parent = ?hash, min_relay_parent = scope.earliest_relay_parent().number, para_id = ?para, - "Creating fragment tree" + ancestors = ?ancestry, + "Creating fragment chain" ); - let tree = FragmentTree::populate(scope, &*candidate_storage); + let number_of_pending_candidates = pending_availability_storage.len(); + + // Init the fragment chain with the pending availability candidates. + let mut chain = FragmentChain::init(scope, pending_availability_storage); + + if chain.best_chain_len() < number_of_pending_candidates { + gum::warn!( + target: LOG_TARGET, + relay_parent = ?hash, + para_id = ?para, + "Not all pending availability candidates could be introduced. Actual vs expected count: {}, {}", + chain.best_chain_len(), + number_of_pending_candidates + ) + } - fragment_trees.insert(para, tree); + // If we know the previous fragment chain, use that for further populating the fragment + // chain. + if let Some(prev_fragment_chain) = + prev_fragment_chains.and_then(|chains| chains.get(¶)) + { + chain.populate_from_previous(prev_fragment_chain); + } + + gum::trace!( + target: LOG_TARGET, + relay_parent = ?hash, + para_id = ?para, + "Populated fragment chain with {} candidates: {:?}", + chain.best_chain_len(), + chain.best_chain_vec() + ); + + gum::trace!( + target: LOG_TARGET, + relay_parent = ?hash, + para_id = ?para, + "Potential candidate storage for para: {:?}", + chain.unconnected().map(|candidate| candidate.hash()).collect::>() + ); + + fragment_chains.insert(para, chain); } - view.active_leaves - .insert(hash, RelayBlockViewData { fragment_trees, pending_availability }); + view.per_relay_parent.insert(hash, RelayBlockViewData { fragment_chains }); + + view.active_leaves.insert(hash); + + view.implicit_view + .activate_leaf_from_prospective_parachains(block_info, &ancestry); } - if !update.deactivated.is_empty() { - // This has potential to be a hotspot. - prune_view_candidate_storage(view, metrics); + for deactivated in update.deactivated { + view.active_leaves.remove(&deactivated); + view.implicit_view.deactivate_leaf(deactivated); } - Ok(()) -} + { + let remaining: HashSet<_> = view.implicit_view.all_allowed_relay_parents().collect(); -fn prune_view_candidate_storage(view: &mut View, metrics: &Metrics) { - metrics.time_prune_view_candidate_storage(); + view.per_relay_parent.retain(|r, _| remaining.contains(&r)); + } - let active_leaves = &view.active_leaves; - let mut live_candidates = HashSet::new(); - let mut live_paras = HashSet::new(); - for sub_view in active_leaves.values() { - for (para_id, fragment_tree) in &sub_view.fragment_trees { - live_candidates.extend(fragment_tree.candidates()); - live_paras.insert(*para_id); + if metrics.0.is_some() { + let mut active_connected = 0; + let mut active_unconnected = 0; + let mut candidates_in_implicit_view = 0; + + for (hash, RelayBlockViewData { fragment_chains, .. }) in view.per_relay_parent.iter() { + if view.active_leaves.contains(hash) { + for chain in fragment_chains.values() { + active_connected += chain.best_chain_len(); + active_unconnected += chain.unconnected_len(); + } + } else { + for chain in fragment_chains.values() { + candidates_in_implicit_view += chain.best_chain_len(); + candidates_in_implicit_view += chain.unconnected_len(); + } + } } - live_candidates.extend(sub_view.pending_availability.iter().cloned()); + metrics.record_candidate_count(active_connected as u64, active_unconnected as u64); + metrics.record_candidate_count_in_implicit_view(candidates_in_implicit_view as u64); } - view.candidate_storage.retain(|para_id, storage| { - if !live_paras.contains(¶_id) { - return false - } - - storage.retain(|h| live_candidates.contains(&h)); + let num_active_leaves = view.active_leaves.len() as u64; + let num_inactive_leaves = + (view.per_relay_parent.len() as u64).saturating_sub(num_active_leaves); + metrics.record_leaves_count(num_active_leaves, num_inactive_leaves); - // Even if `storage` is now empty, we retain. - // This maintains a convenient invariant that para-id storage exists - // as long as there's an active head which schedules the para. - true - }) + Ok(()) } struct ImportablePendingAvailability { candidate: CommittedCandidateReceipt, persisted_validation_data: PersistedValidationData, - compact: crate::fragment_chain::PendingAvailability, + compact: fragment_chain::PendingAvailability, } #[overseer::contextbounds(ProspectiveParachains, prefix = self::overseer)] @@ -365,22 +452,20 @@ async fn preprocess_candidates_pending_availability( let expected_count = pending_availability.len(); for (i, pending) in pending_availability.into_iter().enumerate() { - let relay_parent = - match fetch_block_info(ctx, cache, pending.descriptor.relay_parent).await? { - None => { - gum::debug!( - target: LOG_TARGET, - ?pending.candidate_hash, - ?pending.descriptor.para_id, - index = ?i, - ?expected_count, - "Had to stop processing pending candidates early due to missing info.", - ); + let Some(relay_parent) = + fetch_block_info(ctx, cache, pending.descriptor.relay_parent).await? + else { + gum::debug!( + target: LOG_TARGET, + ?pending.candidate_hash, + ?pending.descriptor.para_id, + index = ?i, + ?expected_count, + "Had to stop processing pending candidates early due to missing info.", + ); - break - }, - Some(b) => b, - }; + break + }; let next_required_parent = pending.commitments.head_data.clone(); importable.push(ImportablePendingAvailability { @@ -394,9 +479,9 @@ async fn preprocess_candidates_pending_availability( relay_parent_number: relay_parent.number, relay_parent_storage_root: relay_parent.storage_root, }, - compact: crate::fragment_chain::PendingAvailability { + compact: fragment_chain::PendingAvailability { candidate_hash: pending.candidate_hash, - relay_parent, + relay_parent: relay_parent.into(), }, }); @@ -406,152 +491,177 @@ async fn preprocess_candidates_pending_availability( Ok(importable) } -#[overseer::contextbounds(ProspectiveParachains, prefix = self::overseer)] -async fn handle_candidate_introduced( - _ctx: &mut Context, +async fn handle_introduce_seconded_candidate( view: &mut View, - request: IntroduceCandidateRequest, - tx: oneshot::Sender, -) -> JfyiErrorResult<()> { - let IntroduceCandidateRequest { + request: IntroduceSecondedCandidateRequest, + tx: oneshot::Sender, + metrics: &Metrics, +) { + let _timer = metrics.time_introduce_seconded_candidate(); + + let IntroduceSecondedCandidateRequest { candidate_para: para, candidate_receipt: candidate, persisted_validation_data: pvd, } = request; - // Add the candidate to storage. - // Then attempt to add it to all trees. - let storage = match view.candidate_storage.get_mut(¶) { - None => { + let candidate_hash = candidate.hash(); + let candidate_entry = match CandidateEntry::new_seconded(candidate_hash, candidate, pvd) { + Ok(candidate) => candidate, + Err(err) => { gum::warn!( target: LOG_TARGET, - para_id = ?para, - candidate_hash = ?candidate.hash(), - "Received seconded candidate for inactive para", + para = ?para, + "Cannot add seconded candidate: {}", + err ); - let _ = tx.send(Vec::new()); - return Ok(()) + let _ = tx.send(false); + return }, - Some(storage) => storage, }; - let candidate_hash = match storage.add_candidate(candidate, pvd) { - Ok(c) => c, - Err(CandidateStorageInsertionError::CandidateAlreadyKnown(c)) => { - // Candidate known - return existing fragment tree membership. - let _ = tx.send(fragment_tree_membership(&view.active_leaves, para, c)); - return Ok(()) - }, - Err(CandidateStorageInsertionError::PersistedValidationDataMismatch) => { - // We can't log the candidate hash without either doing more ~expensive - // hashing but this branch indicates something is seriously wrong elsewhere - // so it's doubtful that it would affect debugging. - - gum::warn!( - target: LOG_TARGET, - para = ?para, - "Received seconded candidate had mismatching validation data", - ); + let mut added = false; + let mut para_scheduled = false; + // We don't iterate only through the active leaves. We also update the deactivated parents in + // the implicit view, so that their upcoming children may see these candidates. + for (relay_parent, rp_data) in view.per_relay_parent.iter_mut() { + let Some(chain) = rp_data.fragment_chains.get_mut(¶) else { continue }; + let is_active_leaf = view.active_leaves.contains(relay_parent); - let _ = tx.send(Vec::new()); - return Ok(()) - }, - }; + para_scheduled = true; - let mut membership = Vec::new(); - for (relay_parent, leaf_data) in &mut view.active_leaves { - if let Some(tree) = leaf_data.fragment_trees.get_mut(¶) { - tree.add_and_populate(candidate_hash, &*storage); - if let Some(depths) = tree.candidate(&candidate_hash) { - membership.push((*relay_parent, depths)); - } + match chain.try_adding_seconded_candidate(&candidate_entry) { + Ok(()) => { + gum::debug!( + target: LOG_TARGET, + ?para, + ?relay_parent, + ?is_active_leaf, + "Added seconded candidate {:?}", + candidate_hash + ); + added = true; + }, + Err(FragmentChainError::CandidateAlreadyKnown) => { + gum::debug!( + target: LOG_TARGET, + ?para, + ?relay_parent, + ?is_active_leaf, + "Attempting to introduce an already known candidate: {:?}", + candidate_hash + ); + added = true; + }, + Err(err) => { + gum::debug!( + target: LOG_TARGET, + ?para, + ?relay_parent, + ?candidate_hash, + ?is_active_leaf, + "Cannot introduce seconded candidate: {}", + err + ) + }, } } - if membership.is_empty() { - storage.remove_candidate(&candidate_hash); - } - - let _ = tx.send(membership); - - Ok(()) -} - -fn handle_candidate_seconded(view: &mut View, para: ParaId, candidate_hash: CandidateHash) { - let storage = match view.candidate_storage.get_mut(¶) { - None => { - gum::warn!( - target: LOG_TARGET, - para_id = ?para, - ?candidate_hash, - "Received instruction to second unknown candidate", - ); - - return - }, - Some(storage) => storage, - }; - - if !storage.contains(&candidate_hash) { + if !para_scheduled { gum::warn!( target: LOG_TARGET, para_id = ?para, ?candidate_hash, - "Received instruction to second unknown candidate", + "Received seconded candidate for inactive para", ); + } - return + if !added { + gum::debug!( + target: LOG_TARGET, + para = ?para, + candidate = ?candidate_hash, + "Newly-seconded candidate cannot be kept under any relay parent", + ); } - storage.mark_seconded(&candidate_hash); + let _ = tx.send(added); } -#[overseer::contextbounds(ProspectiveParachains, prefix = self::overseer)] -async fn handle_candidate_backed( - _ctx: &mut Context, +async fn handle_candidate_backed( view: &mut View, para: ParaId, candidate_hash: CandidateHash, -) -> JfyiErrorResult<()> { - let storage = match view.candidate_storage.get_mut(¶) { - None => { - gum::warn!( + metrics: &Metrics, +) { + let _timer = metrics.time_candidate_backed(); + + let mut found_candidate = false; + let mut found_para = false; + + // We don't iterate only through the active leaves. We also update the deactivated parents in + // the implicit view, so that their upcoming children may see these candidates. + for (relay_parent, rp_data) in view.per_relay_parent.iter_mut() { + let Some(chain) = rp_data.fragment_chains.get_mut(¶) else { continue }; + let is_active_leaf = view.active_leaves.contains(relay_parent); + + found_para = true; + if chain.is_candidate_backed(&candidate_hash) { + gum::debug!( target: LOG_TARGET, - para_id = ?para, + ?para, ?candidate_hash, - "Received instruction to back unknown candidate", + ?is_active_leaf, + "Received redundant instruction to mark as backed an already backed candidate", ); + found_candidate = true; + } else if chain.contains_unconnected_candidate(&candidate_hash) { + found_candidate = true; + // Mark the candidate as backed. This can recreate the fragment chain. + chain.candidate_backed(&candidate_hash); - return Ok(()) - }, - Some(storage) => storage, - }; + gum::trace!( + target: LOG_TARGET, + ?relay_parent, + ?para, + ?is_active_leaf, + "Candidate backed. Candidate chain for para: {:?}", + chain.best_chain_vec() + ); + + gum::trace!( + target: LOG_TARGET, + ?relay_parent, + ?para, + ?is_active_leaf, + "Potential candidate storage for para: {:?}", + chain.unconnected().map(|candidate| candidate.hash()).collect::>() + ); + } + } - if !storage.contains(&candidate_hash) { + if !found_para { gum::warn!( target: LOG_TARGET, - para_id = ?para, + ?para, ?candidate_hash, - "Received instruction to back unknown candidate", + "Received instruction to back a candidate for unscheduled para", ); - return Ok(()) + return } - if storage.is_backed(&candidate_hash) { + if !found_candidate { + // This can be harmless. It can happen if we received a better backed candidate before and + // dropped this other candidate already. gum::debug!( target: LOG_TARGET, - para_id = ?para, + ?para, ?candidate_hash, - "Received redundant instruction to mark candidate as backed", + "Received instruction to back unknown candidate", ); - - return Ok(()) } - - storage.mark_backed(&candidate_hash); - Ok(()) } fn answer_get_backable_candidates( @@ -562,69 +672,58 @@ fn answer_get_backable_candidates( ancestors: Ancestors, tx: oneshot::Sender>, ) { - let data = match view.active_leaves.get(&relay_parent) { - None => { - gum::debug!( - target: LOG_TARGET, - ?relay_parent, - para_id = ?para, - "Requested backable candidate for inactive relay-parent." - ); + if !view.active_leaves.contains(&relay_parent) { + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + para_id = ?para, + "Requested backable candidate for inactive relay-parent." + ); - let _ = tx.send(vec![]); - return - }, - Some(d) => d, + let _ = tx.send(vec![]); + return + } + let Some(data) = view.per_relay_parent.get(&relay_parent) else { + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + para_id = ?para, + "Requested backable candidate for inexistent relay-parent." + ); + + let _ = tx.send(vec![]); + return }; - let tree = match data.fragment_trees.get(¶) { - None => { - gum::debug!( - target: LOG_TARGET, - ?relay_parent, - para_id = ?para, - "Requested backable candidate for inactive para." - ); + let Some(chain) = data.fragment_chains.get(¶) else { + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + para_id = ?para, + "Requested backable candidate for inactive para." + ); - let _ = tx.send(vec![]); - return - }, - Some(tree) => tree, + let _ = tx.send(vec![]); + return }; - let storage = match view.candidate_storage.get(¶) { - None => { - gum::warn!( - target: LOG_TARGET, - ?relay_parent, - para_id = ?para, - "No candidate storage for active para", - ); + gum::trace!( + target: LOG_TARGET, + ?relay_parent, + para_id = ?para, + "Candidate chain for para: {:?}", + chain.best_chain_vec() + ); - let _ = tx.send(vec![]); - return - }, - Some(s) => s, - }; + gum::trace!( + target: LOG_TARGET, + ?relay_parent, + para_id = ?para, + "Potential candidate storage for para: {:?}", + chain.unconnected().map(|candidate| candidate.hash()).collect::>() + ); - let backable_candidates: Vec<_> = tree - .find_backable_chain(ancestors.clone(), count, |candidate| storage.is_backed(candidate)) - .into_iter() - .filter_map(|child_hash| { - storage.relay_parent_by_candidate_hash(&child_hash).map_or_else( - || { - gum::error!( - target: LOG_TARGET, - ?child_hash, - para_id = ?para, - "Candidate is present in fragment tree but not in candidate's storage!", - ); - None - }, - |parent_hash| Some((child_hash, parent_hash)), - ) - }) - .collect(); + let backable_candidates = chain.find_backable_chain(ancestors.clone(), count); if backable_candidates.is_empty() { gum::trace!( @@ -639,6 +738,7 @@ fn answer_get_backable_candidates( target: LOG_TARGET, ?relay_parent, ?backable_candidates, + ?ancestors, "Found backable candidates", ); } @@ -646,99 +746,63 @@ fn answer_get_backable_candidates( let _ = tx.send(backable_candidates); } -fn answer_hypothetical_frontier_request( +fn answer_hypothetical_membership_request( view: &View, - request: HypotheticalFrontierRequest, - tx: oneshot::Sender>, + request: HypotheticalMembershipRequest, + tx: oneshot::Sender>, + metrics: &Metrics, ) { + let _timer = metrics.time_hypothetical_membership_request(); + let mut response = Vec::with_capacity(request.candidates.len()); for candidate in request.candidates { - response.push((candidate, Vec::new())); + response.push((candidate, vec![])); } - let required_active_leaf = request.fragment_tree_relay_parent; - for (active_leaf, leaf_view) in view + let required_active_leaf = request.fragment_chain_relay_parent; + for active_leaf in view .active_leaves .iter() - .filter(|(h, _)| required_active_leaf.as_ref().map_or(true, |x| h == &x)) + .filter(|h| required_active_leaf.as_ref().map_or(true, |x| h == &x)) { - for &mut (ref c, ref mut membership) in &mut response { - let fragment_tree = match leaf_view.fragment_trees.get(&c.candidate_para()) { - None => continue, - Some(f) => f, - }; - let candidate_storage = match view.candidate_storage.get(&c.candidate_para()) { - None => continue, - Some(storage) => storage, - }; - - let candidate_hash = c.candidate_hash(); - let hypothetical = match c { - HypotheticalCandidate::Complete { receipt, persisted_validation_data, .. } => - fragment_chain::HypotheticalCandidate::Complete { - receipt: Cow::Borrowed(receipt), - persisted_validation_data: Cow::Borrowed(persisted_validation_data), - }, - HypotheticalCandidate::Incomplete { - parent_head_data_hash, - candidate_relay_parent, - .. - } => fragment_chain::HypotheticalCandidate::Incomplete { - relay_parent: *candidate_relay_parent, - parent_head_data_hash: *parent_head_data_hash, + let Some(leaf_view) = view.per_relay_parent.get(&active_leaf) else { continue }; + for &mut (ref candidate, ref mut membership) in &mut response { + let para_id = &candidate.candidate_para(); + let Some(fragment_chain) = leaf_view.fragment_chains.get(para_id) else { continue }; + + let res = fragment_chain.can_add_candidate_as_potential(candidate); + match res { + Err(FragmentChainError::CandidateAlreadyKnown) | Ok(()) => { + membership.push(*active_leaf); + }, + Err(err) => { + gum::debug!( + target: LOG_TARGET, + para = ?para_id, + leaf = ?active_leaf, + candidate = ?candidate.candidate_hash(), + "Candidate is not a hypothetical member: {}", + err + ) }, }; - - let depths = fragment_tree.hypothetical_depths( - candidate_hash, - hypothetical, - candidate_storage, - request.backed_in_path_only, - ); - - if !depths.is_empty() { - membership.push((*active_leaf, depths)); - } } } let _ = tx.send(response); } -fn fragment_tree_membership( - active_leaves: &HashMap, - para: ParaId, - candidate: CandidateHash, -) -> FragmentTreeMembership { - let mut membership = Vec::new(); - for (relay_parent, view_data) in active_leaves { - if let Some(tree) = view_data.fragment_trees.get(¶) { - if let Some(depths) = tree.candidate(&candidate) { - membership.push((*relay_parent, depths)); - } - } - } - membership -} - -fn answer_tree_membership_request( - view: &View, - para: ParaId, - candidate: CandidateHash, - tx: oneshot::Sender, -) { - let _ = tx.send(fragment_tree_membership(&view.active_leaves, para, candidate)); -} - fn answer_minimum_relay_parents_request( view: &View, relay_parent: Hash, tx: oneshot::Sender>, ) { let mut v = Vec::new(); - if let Some(leaf_data) = view.active_leaves.get(&relay_parent) { - for (para_id, fragment_tree) in &leaf_data.fragment_trees { - v.push((*para_id, fragment_tree.scope().earliest_relay_parent().number)); + if view.active_leaves.contains(&relay_parent) { + if let Some(leaf_data) = view.per_relay_parent.get(&relay_parent) { + for (para_id, fragment_chain) in &leaf_data.fragment_chains { + v.push((*para_id, fragment_chain.scope().earliest_relay_parent().number)); + } } } @@ -750,61 +814,39 @@ fn answer_prospective_validation_data_request( request: ProspectiveValidationDataRequest, tx: oneshot::Sender>, ) { - // 1. Try to get the head-data from the candidate store if known. - // 2. Otherwise, it might exist as the base in some relay-parent and we can find it by iterating - // fragment trees. - // 3. Otherwise, it is unknown. - // 4. Also try to find the relay parent block info by scanning fragment trees. - // 5. If head data and relay parent block info are found - success. Otherwise, failure. - - let storage = match view.candidate_storage.get(&request.para_id) { - None => { - let _ = tx.send(None); - return - }, - Some(s) => s, - }; + // Try getting the needed data from any fragment chain. let (mut head_data, parent_head_data_hash) = match request.parent_head_data { - ParentHeadData::OnlyHash(parent_head_data_hash) => ( - storage.head_data_by_hash(&parent_head_data_hash).map(|x| x.clone()), - parent_head_data_hash, - ), + ParentHeadData::OnlyHash(parent_head_data_hash) => (None, parent_head_data_hash), ParentHeadData::WithData { head_data, hash } => (Some(head_data), hash), }; let mut relay_parent_info = None; let mut max_pov_size = None; - for fragment_tree in view - .active_leaves - .values() - .filter_map(|x| x.fragment_trees.get(&request.para_id)) - { + for fragment_chain in view.active_leaves.iter().filter_map(|x| { + view.per_relay_parent + .get(&x) + .and_then(|data| data.fragment_chains.get(&request.para_id)) + }) { if head_data.is_some() && relay_parent_info.is_some() && max_pov_size.is_some() { break } if relay_parent_info.is_none() { - relay_parent_info = - fragment_tree.scope().ancestor_by_hash(&request.candidate_relay_parent); + relay_parent_info = fragment_chain.scope().ancestor(&request.candidate_relay_parent); } if head_data.is_none() { - let required_parent = &fragment_tree.scope().base_constraints().required_parent; - if required_parent.hash() == parent_head_data_hash { - head_data = Some(required_parent.clone()); - } + head_data = fragment_chain.get_head_data_by_hash(&parent_head_data_hash); } if max_pov_size.is_none() { - let contains_ancestor = fragment_tree - .scope() - .ancestor_by_hash(&request.candidate_relay_parent) - .is_some(); + let contains_ancestor = + fragment_chain.scope().ancestor(&request.candidate_relay_parent).is_some(); if contains_ancestor { // We are leaning hard on two assumptions here. - // 1. That the fragment tree never contains allowed relay-parents whose session for + // 1. That the fragment chain never contains allowed relay-parents whose session for // children is different from that of the base block's. // 2. That the max_pov_size is only configurable per session. - max_pov_size = Some(fragment_tree.scope().base_constraints().max_pov_size); + max_pov_size = Some(fragment_chain.scope().base_constraints().max_pov_size); } } } @@ -843,40 +885,51 @@ async fn fetch_backing_state( async fn fetch_upcoming_paras( ctx: &mut Context, relay_parent: Hash, - pending_availability: &mut HashSet, -) -> JfyiErrorResult> { - let (tx, rx) = oneshot::channel(); - - // This'll have to get more sophisticated with parathreads, - // but for now we can just use the `AvailabilityCores`. - ctx.send_message(RuntimeApiMessage::Request( - relay_parent, - RuntimeApiRequest::AvailabilityCores(tx), - )) - .await; - - let cores = rx.await.map_err(JfyiError::RuntimeApiRequestCanceled)??; - let mut upcoming = HashSet::new(); - for core in cores { - match core { - CoreState::Occupied(occupied) => { - pending_availability.insert(occupied.candidate_hash); - - if let Some(next_up_on_available) = occupied.next_up_on_available { - upcoming.insert(next_up_on_available.para_id); - } - if let Some(next_up_on_time_out) = occupied.next_up_on_time_out { - upcoming.insert(next_up_on_time_out.para_id); +) -> JfyiErrorResult> { + Ok(match fetch_claim_queue(ctx.sender(), relay_parent).await? { + Some(claim_queue) => { + // Runtime supports claim queue - use it + claim_queue + .iter_all_claims() + .flat_map(|(_, paras)| paras.into_iter()) + .copied() + .collect() + }, + None => { + // fallback to availability cores - remove this branch once claim queue is released + // everywhere + let (tx, rx) = oneshot::channel(); + ctx.send_message(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::AvailabilityCores(tx), + )) + .await; + + let cores = rx.await.map_err(JfyiError::RuntimeApiRequestCanceled)??; + + let mut upcoming = HashSet::with_capacity(cores.len()); + for core in cores { + match core { + CoreState::Occupied(occupied) => { + // core sharing won't work optimally with this branch because the collations + // can't be prepared in advance. + if let Some(next_up_on_available) = occupied.next_up_on_available { + upcoming.insert(next_up_on_available.para_id); + } + if let Some(next_up_on_time_out) = occupied.next_up_on_time_out { + upcoming.insert(next_up_on_time_out.para_id); + } + }, + CoreState::Scheduled(scheduled) => { + upcoming.insert(scheduled.para_id); + }, + CoreState::Free => {}, } - }, - CoreState::Scheduled(scheduled) => { - upcoming.insert(scheduled.para_id); - }, - CoreState::Free => {}, - } - } + } - Ok(upcoming.into_iter().collect()) + upcoming + }, + }) } // Fetch ancestors in descending order, up to the amount requested. @@ -886,7 +939,7 @@ async fn fetch_ancestry( cache: &mut HashMap, relay_hash: Hash, ancestors: usize, -) -> JfyiErrorResult> { +) -> JfyiErrorResult> { if ancestors == 0 { return Ok(Vec::new()) } @@ -965,12 +1018,13 @@ async fn fetch_block_info( ctx: &mut Context, cache: &mut HashMap, relay_hash: Hash, -) -> JfyiErrorResult> { +) -> JfyiErrorResult> { let header = fetch_block_header_with_cache(ctx, cache, relay_hash).await?; - Ok(header.map(|header| RelayChainBlockInfo { + Ok(header.map(|header| BlockInfo { hash: relay_hash, number: header.number, + parent_hash: header.parent_hash, storage_root: header.state_root, })) } diff --git a/polkadot/node/core/prospective-parachains/src/metrics.rs b/polkadot/node/core/prospective-parachains/src/metrics.rs index 57061497a1c0d2923dedeea341a4cf4cf2ed8807..78561bc878ac8f76b54ac772a65469f5c06a4c0a 100644 --- a/polkadot/node/core/prospective-parachains/src/metrics.rs +++ b/polkadot/node/core/prospective-parachains/src/metrics.rs @@ -14,11 +14,21 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use polkadot_node_subsystem_util::metrics::{self, prometheus}; +use polkadot_node_subsystem::prometheus::Opts; +use polkadot_node_subsystem_util::metrics::{ + self, + prometheus::{self, Gauge, GaugeVec, U64}, +}; #[derive(Clone)] pub(crate) struct MetricsInner { - pub(crate) prune_view_candidate_storage: prometheus::Histogram, + time_active_leaves_update: prometheus::Histogram, + time_introduce_seconded_candidate: prometheus::Histogram, + time_candidate_backed: prometheus::Histogram, + time_hypothetical_membership: prometheus::Histogram, + candidate_count: prometheus::GaugeVec, + active_leaves_count: prometheus::GaugeVec, + implicit_view_candidate_count: prometheus::Gauge, } /// Candidate backing metrics. @@ -26,26 +36,122 @@ pub(crate) struct MetricsInner { pub struct Metrics(pub(crate) Option); impl Metrics { - /// Provide a timer for handling `prune_view_candidate_storage` which observes on drop. - pub fn time_prune_view_candidate_storage( + /// Provide a timer for handling `ActiveLeavesUpdate` which observes on drop. + pub fn time_handle_active_leaves_update( + &self, + ) -> Option { + self.0.as_ref().map(|metrics| metrics.time_active_leaves_update.start_timer()) + } + + /// Provide a timer for handling `IntroduceSecondedCandidate` which observes on drop. + pub fn time_introduce_seconded_candidate( + &self, + ) -> Option { + self.0 + .as_ref() + .map(|metrics| metrics.time_introduce_seconded_candidate.start_timer()) + } + + /// Provide a timer for handling `CandidateBacked` which observes on drop. + pub fn time_candidate_backed(&self) -> Option { + self.0.as_ref().map(|metrics| metrics.time_candidate_backed.start_timer()) + } + + /// Provide a timer for handling `GetHypotheticalMembership` which observes on drop. + pub fn time_hypothetical_membership_request( &self, ) -> Option { self.0 .as_ref() - .map(|metrics| metrics.prune_view_candidate_storage.start_timer()) + .map(|metrics| metrics.time_hypothetical_membership.start_timer()) + } + + /// Record number of candidates across all fragment chains. First param is the connected + /// candidates count, second param is the unconnected candidates count. + pub fn record_candidate_count(&self, connected_count: u64, unconnected_count: u64) { + self.0.as_ref().map(|metrics| { + metrics.candidate_count.with_label_values(&["connected"]).set(connected_count); + metrics + .candidate_count + .with_label_values(&["unconnected"]) + .set(unconnected_count); + }); + } + + /// Record the number of candidates present in the implicit view of the subsystem. + pub fn record_candidate_count_in_implicit_view(&self, count: u64) { + self.0.as_ref().map(|metrics| { + metrics.implicit_view_candidate_count.set(count); + }); + } + + /// Record the number of active/inactive leaves kept by the subsystem. + pub fn record_leaves_count(&self, active_count: u64, inactive_count: u64) { + self.0.as_ref().map(|metrics| { + metrics.active_leaves_count.with_label_values(&["active"]).set(active_count); + metrics.active_leaves_count.with_label_values(&["inactive"]).set(inactive_count); + }); } } impl metrics::Metrics for Metrics { fn try_register(registry: &prometheus::Registry) -> Result { let metrics = MetricsInner { - prune_view_candidate_storage: prometheus::register( + time_active_leaves_update: prometheus::register( prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( - "polkadot_parachain_prospective_parachains_prune_view_candidate_storage", - "Time spent within `prospective_parachains::prune_view_candidate_storage`", + "polkadot_parachain_prospective_parachains_time_active_leaves_update", + "Time spent within `prospective_parachains::handle_active_leaves_update`", ))?, registry, )?, + time_introduce_seconded_candidate: prometheus::register( + prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( + "polkadot_parachain_prospective_parachains_time_introduce_seconded_candidate", + "Time spent within `prospective_parachains::handle_introduce_seconded_candidate`", + ))?, + registry, + )?, + time_candidate_backed: prometheus::register( + prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( + "polkadot_parachain_prospective_parachains_time_candidate_backed", + "Time spent within `prospective_parachains::handle_candidate_backed`", + ))?, + registry, + )?, + time_hypothetical_membership: prometheus::register( + prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( + "polkadot_parachain_prospective_parachains_time_hypothetical_membership", + "Time spent responding to `GetHypotheticalMembership`", + ))?, + registry, + )?, + candidate_count: prometheus::register( + GaugeVec::new( + Opts::new( + "polkadot_parachain_prospective_parachains_candidate_count", + "Number of candidates present across all fragment chains, split by connected and unconnected" + ), + &["type"], + )?, + registry, + )?, + active_leaves_count: prometheus::register( + GaugeVec::new( + Opts::new( + "polkadot_parachain_prospective_parachains_active_leaves_count", + "Number of leaves kept by the subsystem, split by active/inactive" + ), + &["type"], + )?, + registry, + )?, + implicit_view_candidate_count: prometheus::register( + Gauge::new( + "polkadot_parachain_prospective_parachains_implicit_view_candidate_count", + "Number of candidates present in the implicit view" + )?, + registry + )?, }; Ok(Metrics(Some(metrics))) } diff --git a/polkadot/node/core/prospective-parachains/src/tests.rs b/polkadot/node/core/prospective-parachains/src/tests.rs index 8989911a33239d3b6f775bcf6271c6f40d9a0bac..14a093239e8ecbaa1fd6c4e3c294fddb21795af7 100644 --- a/polkadot/node/core/prospective-parachains/src/tests.rs +++ b/polkadot/node/core/prospective-parachains/src/tests.rs @@ -19,18 +19,22 @@ use assert_matches::assert_matches; use polkadot_node_subsystem::{ errors::RuntimeApiError, messages::{ - AllMessages, HypotheticalFrontierRequest, ParentHeadData, ProspectiveParachainsMessage, + AllMessages, HypotheticalMembershipRequest, ParentHeadData, ProspectiveParachainsMessage, ProspectiveValidationDataRequest, }, }; use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_primitives::{ async_backing::{AsyncBackingParams, BackingState, Constraints, InboundHrmpLimitations}, - CommittedCandidateReceipt, HeadData, Header, PersistedValidationData, ScheduledCore, + CommittedCandidateReceipt, CoreIndex, HeadData, Header, PersistedValidationData, ScheduledCore, ValidationCodeHash, }; use polkadot_primitives_test_helpers::make_candidate; -use std::sync::Arc; +use rstest::rstest; +use std::{ + collections::{BTreeMap, VecDeque}, + sync::Arc, +}; use test_helpers::mock::new_leaf; const ALLOWED_ANCESTRY_LEN: u32 = 3; @@ -42,7 +46,8 @@ const ASYNC_BACKING_DISABLED_ERROR: RuntimeApiError = const MAX_POV_SIZE: u32 = 1_000_000; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; fn dummy_constraints( min_relay_parent_number: BlockNumber, @@ -69,7 +74,8 @@ fn dummy_constraints( } struct TestState { - availability_cores: Vec, + claim_queue: BTreeMap>, + runtime_api_version: u32, validation_code_hash: ValidationCodeHash, } @@ -78,13 +84,23 @@ impl Default for TestState { let chain_a = ParaId::from(1); let chain_b = ParaId::from(2); - let availability_cores = vec![ - CoreState::Scheduled(ScheduledCore { para_id: chain_a, collator: None }), - CoreState::Scheduled(ScheduledCore { para_id: chain_b, collator: None }), - ]; + let mut claim_queue = BTreeMap::new(); + claim_queue.insert(CoreIndex(0), [chain_a].into_iter().collect()); + claim_queue.insert(CoreIndex(1), [chain_b].into_iter().collect()); + let validation_code_hash = Hash::repeat_byte(42).into(); - Self { availability_cores, validation_code_hash } + Self { + validation_code_hash, + claim_queue, + runtime_api_version: RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT, + } + } +} + +impl TestState { + fn set_runtime_api_version(&mut self, version: u32) { + self.runtime_api_version = version; } } @@ -95,9 +111,12 @@ fn get_parent_hash(hash: Hash) -> Hash { fn test_harness>( test: impl FnOnce(VirtualOverseer) -> T, ) -> View { + sp_tracing::init_for_tests(); + let pool = sp_core::testing::TaskExecutor::new(); - let (mut context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (mut context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let mut view = View::new(); let subsystem = async move { @@ -186,6 +205,32 @@ async fn activate_leaf( activate_leaf_with_params(virtual_overseer, leaf, test_state, ASYNC_BACKING_PARAMETERS).await; } +async fn activate_leaf_with_parent_hash_fn( + virtual_overseer: &mut VirtualOverseer, + leaf: &TestLeaf, + test_state: &TestState, + parent_hash_fn: impl Fn(Hash) -> Hash, +) { + let TestLeaf { number, hash, .. } = leaf; + + let activated = new_leaf(*hash, *number); + + virtual_overseer + .send(FromOrchestra::Signal(OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work( + activated, + )))) + .await; + + handle_leaf_activation( + virtual_overseer, + leaf, + test_state, + ASYNC_BACKING_PARAMETERS, + parent_hash_fn, + ) + .await; +} + async fn activate_leaf_with_params( virtual_overseer: &mut VirtualOverseer, leaf: &TestLeaf, @@ -202,7 +247,14 @@ async fn activate_leaf_with_params( )))) .await; - handle_leaf_activation(virtual_overseer, leaf, test_state, async_backing_params).await; + handle_leaf_activation( + virtual_overseer, + leaf, + test_state, + async_backing_params, + get_parent_hash, + ) + .await; } async fn handle_leaf_activation( @@ -210,6 +262,7 @@ async fn handle_leaf_activation( leaf: &TestLeaf, test_state: &TestState, async_backing_params: AsyncBackingParams, + parent_hash_fn: impl Fn(Hash) -> Hash, ) { let TestLeaf { number, hash, para_data } = leaf; @@ -225,19 +278,46 @@ async fn handle_leaf_activation( assert_matches!( virtual_overseer.recv().await, AllMessages::RuntimeApi( - RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx)) + RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx)) ) if parent == *hash => { - tx.send(Ok(test_state.availability_cores.clone())).unwrap(); + tx.send( + Ok(test_state.runtime_api_version) + ).unwrap(); } ); + if test_state.runtime_api_version < RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT { + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx)) + ) if parent == *hash => { + tx.send(Ok(test_state.claim_queue.values().map(|paras| CoreState::Scheduled( + ScheduledCore { + para_id: *paras.front().unwrap(), + collator: None + } + )).collect())).unwrap(); + } + ); + } else { + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx)) + ) if parent == *hash => { + tx.send(Ok(test_state.claim_queue.clone())).unwrap(); + } + ); + } + send_block_header(virtual_overseer, *hash, *number).await; // Check that subsystem job issues a request for ancestors. let min_min = para_data.iter().map(|(_, data)| data.min_relay_parent).min().unwrap_or(*number); let ancestry_len = number - min_min; let ancestry_hashes: Vec = - std::iter::successors(Some(*hash), |h| Some(get_parent_hash(*h))) + std::iter::successors(Some(*hash), |h| Some(parent_hash_fn(*h))) .skip(1) .take(ancestry_len as usize) .collect(); @@ -263,26 +343,32 @@ async fn handle_leaf_activation( ); } + let mut used_relay_parents = HashSet::new(); for (hash, number) in ancestry_iter { - send_block_header(virtual_overseer, hash, number).await; - assert_matches!( - virtual_overseer.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx)) - ) if parent == hash => { - tx.send(Ok(1)).unwrap(); - } - ); + if !used_relay_parents.contains(&hash) { + send_block_header(virtual_overseer, hash, number).await; + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::SessionIndexForChild(tx)) + ) if parent == hash => { + tx.send(Ok(1)).unwrap(); + } + ); + used_relay_parents.insert(hash); + } } - for _ in 0..test_state.availability_cores.len() { + let paras: HashSet<_> = test_state.claim_queue.values().flatten().collect(); + + for _ in 0..paras.len() { let message = virtual_overseer.recv().await; // Get the para we are working with since the order is not deterministic. - let para_id = match message { + let para_id = match &message { AllMessages::RuntimeApi(RuntimeApiMessage::Request( _, RuntimeApiRequest::ParaBackingState(p_id, _), - )) => p_id, + )) => *p_id, _ => panic!("received unexpected message {:?}", message), }; @@ -307,12 +393,16 @@ async fn handle_leaf_activation( ); for pending in pending_availability { - send_block_header( - virtual_overseer, - pending.descriptor.relay_parent, - pending.relay_parent_number, - ) - .await; + if !used_relay_parents.contains(&pending.descriptor.relay_parent) { + send_block_header( + virtual_overseer, + pending.descriptor.relay_parent, + pending.relay_parent_number, + ) + .await; + + used_relay_parents.insert(pending.descriptor.relay_parent); + } } } @@ -340,36 +430,42 @@ async fn deactivate_leaf(virtual_overseer: &mut VirtualOverseer, hash: Hash) { .await; } -async fn introduce_candidate( +async fn introduce_seconded_candidate( virtual_overseer: &mut VirtualOverseer, candidate: CommittedCandidateReceipt, pvd: PersistedValidationData, ) { - let req = IntroduceCandidateRequest { + let req = IntroduceSecondedCandidateRequest { candidate_para: candidate.descriptor().para_id, candidate_receipt: candidate, persisted_validation_data: pvd, }; - let (tx, _) = oneshot::channel(); + let (tx, rx) = oneshot::channel(); virtual_overseer .send(overseer::FromOrchestra::Communication { - msg: ProspectiveParachainsMessage::IntroduceCandidate(req, tx), + msg: ProspectiveParachainsMessage::IntroduceSecondedCandidate(req, tx), }) .await; + assert!(rx.await.unwrap()); } -async fn second_candidate( +async fn introduce_seconded_candidate_failed( virtual_overseer: &mut VirtualOverseer, candidate: CommittedCandidateReceipt, + pvd: PersistedValidationData, ) { + let req = IntroduceSecondedCandidateRequest { + candidate_para: candidate.descriptor().para_id, + candidate_receipt: candidate, + persisted_validation_data: pvd, + }; + let (tx, rx) = oneshot::channel(); virtual_overseer .send(overseer::FromOrchestra::Communication { - msg: ProspectiveParachainsMessage::CandidateSeconded( - candidate.descriptor.para_id, - candidate.hash(), - ), + msg: ProspectiveParachainsMessage::IntroduceSecondedCandidate(req, tx), }) .await; + assert!(!rx.await.unwrap()); } async fn back_candidate( @@ -387,22 +483,6 @@ async fn back_candidate( .await; } -async fn get_membership( - virtual_overseer: &mut VirtualOverseer, - para_id: ParaId, - candidate_hash: CandidateHash, - expected_membership_response: Vec<(Hash, Vec)>, -) { - let (tx, rx) = oneshot::channel(); - virtual_overseer - .send(overseer::FromOrchestra::Communication { - msg: ProspectiveParachainsMessage::GetTreeMembership(para_id, candidate_hash, tx), - }) - .await; - let resp = rx.await.unwrap(); - assert_eq!(resp, expected_membership_response); -} - async fn get_backable_candidates( virtual_overseer: &mut VirtualOverseer, leaf: &TestLeaf, @@ -420,42 +500,39 @@ async fn get_backable_candidates( }) .await; let resp = rx.await.unwrap(); - assert_eq!(resp.len(), expected_result.len()); assert_eq!(resp, expected_result); } -async fn get_hypothetical_frontier( +async fn get_hypothetical_membership( virtual_overseer: &mut VirtualOverseer, candidate_hash: CandidateHash, receipt: CommittedCandidateReceipt, persisted_validation_data: PersistedValidationData, - fragment_tree_relay_parent: Hash, - backed_in_path_only: bool, - expected_depths: Vec, + expected_membership: Vec, ) { let hypothetical_candidate = HypotheticalCandidate::Complete { candidate_hash, receipt: Arc::new(receipt), persisted_validation_data, }; - let request = HypotheticalFrontierRequest { + let request = HypotheticalMembershipRequest { candidates: vec![hypothetical_candidate.clone()], - fragment_tree_relay_parent: Some(fragment_tree_relay_parent), - backed_in_path_only, + fragment_chain_relay_parent: None, }; let (tx, rx) = oneshot::channel(); virtual_overseer .send(overseer::FromOrchestra::Communication { - msg: ProspectiveParachainsMessage::GetHypotheticalFrontier(request, tx), + msg: ProspectiveParachainsMessage::GetHypotheticalMembership(request, tx), }) .await; - let resp = rx.await.unwrap(); - let expected_frontier = if expected_depths.is_empty() { - vec![(hypothetical_candidate, vec![])] - } else { - vec![(hypothetical_candidate, vec![(fragment_tree_relay_parent, expected_depths)])] - }; - assert_eq!(resp, expected_frontier); + let mut resp = rx.await.unwrap(); + assert_eq!(resp.len(), 1); + let (candidate, membership) = resp.remove(0); + assert_eq!(candidate, hypothetical_candidate); + assert_eq!( + membership.into_iter().collect::>(), + expected_membership.into_iter().collect::>() + ); } async fn get_pvd( @@ -480,6 +557,26 @@ async fn get_pvd( assert_eq!(resp, expected_pvd); } +macro_rules! make_and_back_candidate { + ($test_state:ident, $virtual_overseer:ident, $leaf:ident, $parent:expr, $index:expr) => {{ + let (mut candidate, pvd) = make_candidate( + $leaf.hash, + $leaf.number, + 1.into(), + $parent.commitments.head_data.clone(), + HeadData(vec![$index]), + $test_state.validation_code_hash, + ); + // Set a field to make this candidate unique. + candidate.descriptor.para_head = Hash::from_low_u64_le($index); + let candidate_hash = candidate.hash(); + introduce_seconded_candidate(&mut $virtual_overseer, candidate.clone(), pvd).await; + back_candidate(&mut $virtual_overseer, &candidate, candidate_hash).await; + + (candidate, candidate_hash) + }}; +} + #[test] fn should_do_no_work_if_async_backing_disabled_for_leaf() { async fn activate_leaf_async_backing_disabled(virtual_overseer: &mut VirtualOverseer) { @@ -509,16 +606,24 @@ fn should_do_no_work_if_async_backing_disabled_for_leaf() { }); assert!(view.active_leaves.is_empty()); - assert!(view.candidate_storage.is_empty()); } // Send some candidates and make sure all are found: -// - Two for the same leaf A +// - Two for the same leaf A (one for parachain 1 and one for parachain 2) // - One for leaf B on parachain 1 // - One for leaf C on parachain 2 +// Also tests a claim queue size larger than 1. #[test] -fn send_candidates_and_check_if_found() { - let test_state = TestState::default(); +fn introduce_candidates_basic() { + let mut test_state = TestState::default(); + + let chain_a = ParaId::from(1); + let chain_b = ParaId::from(2); + let mut claim_queue = BTreeMap::new(); + claim_queue.insert(CoreIndex(0), [chain_a, chain_b].into_iter().collect()); + + test_state.claim_queue = claim_queue; + let view = test_harness(|mut virtual_overseer| async move { // Leaf A let leaf_a = TestLeaf { @@ -563,7 +668,7 @@ fn send_candidates_and_check_if_found() { test_state.validation_code_hash, ); let candidate_hash_a1 = candidate_a1.hash(); - let response_a1 = vec![(leaf_a.hash, vec![0])]; + let response_a1 = vec![(candidate_hash_a1, leaf_a.hash)]; // Candidate A2 let (candidate_a2, pvd_a2) = make_candidate( @@ -575,7 +680,7 @@ fn send_candidates_and_check_if_found() { test_state.validation_code_hash, ); let candidate_hash_a2 = candidate_a2.hash(); - let response_a2 = vec![(leaf_a.hash, vec![0])]; + let response_a2 = vec![(candidate_hash_a2, leaf_a.hash)]; // Candidate B let (candidate_b, pvd_b) = make_candidate( @@ -587,7 +692,7 @@ fn send_candidates_and_check_if_found() { test_state.validation_code_hash, ); let candidate_hash_b = candidate_b.hash(); - let response_b = vec![(leaf_b.hash, vec![0])]; + let response_b = vec![(candidate_hash_b, leaf_b.hash)]; // Candidate C let (candidate_c, pvd_c) = make_candidate( @@ -599,40 +704,87 @@ fn send_candidates_and_check_if_found() { test_state.validation_code_hash, ); let candidate_hash_c = candidate_c.hash(); - let response_c = vec![(leaf_c.hash, vec![0])]; + let response_c = vec![(candidate_hash_c, leaf_c.hash)]; // Introduce candidates. - introduce_candidate(&mut virtual_overseer, candidate_a1, pvd_a1).await; - introduce_candidate(&mut virtual_overseer, candidate_a2, pvd_a2).await; - introduce_candidate(&mut virtual_overseer, candidate_b, pvd_b).await; - introduce_candidate(&mut virtual_overseer, candidate_c, pvd_c).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a1.clone(), pvd_a1).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a2.clone(), pvd_a2).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c).await; + + // Back candidates. Otherwise, we cannot check membership with GetBackableCandidates. + back_candidate(&mut virtual_overseer, &candidate_a1, candidate_hash_a1).await; + back_candidate(&mut virtual_overseer, &candidate_a2, candidate_hash_a2).await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_hash_b).await; + back_candidate(&mut virtual_overseer, &candidate_c, candidate_hash_c).await; // Check candidate tree membership. - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a1, response_a1).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_a2, response_a2).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_b, response_b).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_c, response_c).await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + response_a1, + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + Ancestors::default(), + 5, + response_a2, + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + 1.into(), + Ancestors::default(), + 5, + response_b, + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + 2.into(), + Ancestors::default(), + 5, + response_c, + ) + .await; + + // Check membership on other leaves. + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + 2.into(), + Ancestors::default(), + 5, + vec![], + ) + .await; - // The candidates should not be found on other parachains. - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_a1, vec![]).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a2, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_b, vec![]).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_c, vec![]).await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + 1.into(), + Ancestors::default(), + 5, + vec![], + ) + .await; virtual_overseer }); assert_eq!(view.active_leaves.len(), 3); - assert_eq!(view.candidate_storage.len(), 2); - // Two parents and two candidates per para. - assert_eq!(view.candidate_storage.get(&1.into()).unwrap().len(), (2, 2)); - assert_eq!(view.candidate_storage.get(&2.into()).unwrap().len(), (2, 2)); } -// Send some candidates, check if the candidate won't be found once its relay parent leaves the -// view. #[test] -fn check_candidate_parent_leaving_view() { +fn introduce_candidate_multiple_times() { let test_state = TestState::default(); let view = test_harness(|mut virtual_overseer| async move { // Leaf A @@ -644,32 +796,11 @@ fn check_candidate_parent_leaving_view() { (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), ], }; - // Leaf B - let leaf_b = TestLeaf { - number: 101, - hash: Hash::from_low_u64_be(131), - para_data: vec![ - (1.into(), PerParaData::new(99, HeadData(vec![3, 4, 5]))), - (2.into(), PerParaData::new(101, HeadData(vec![4, 5, 6]))), - ], - }; - // Leaf C - let leaf_c = TestLeaf { - number: 102, - hash: Hash::from_low_u64_be(132), - para_data: vec![ - (1.into(), PerParaData::new(102, HeadData(vec![5, 6, 7]))), - (2.into(), PerParaData::new(98, HeadData(vec![6, 7, 8]))), - ], - }; - // Activate leaves. activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; - activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; - activate_leaf(&mut virtual_overseer, &leaf_c, &test_state).await; - // Candidate A1 - let (candidate_a1, pvd_a1) = make_candidate( + // Candidate A. + let (candidate_a, pvd_a) = make_candidate( leaf_a.hash, leaf_a.number, 1.into(), @@ -677,86 +808,53 @@ fn check_candidate_parent_leaving_view() { HeadData(vec![1]), test_state.validation_code_hash, ); - let candidate_hash_a1 = candidate_a1.hash(); - - // Candidate A2 - let (candidate_a2, pvd_a2) = make_candidate( - leaf_a.hash, - leaf_a.number, - 2.into(), - HeadData(vec![2, 3, 4]), - HeadData(vec![2]), - test_state.validation_code_hash, - ); - let candidate_hash_a2 = candidate_a2.hash(); - - // Candidate B - let (candidate_b, pvd_b) = make_candidate( - leaf_b.hash, - leaf_b.number, - 1.into(), - HeadData(vec![3, 4, 5]), - HeadData(vec![3]), - test_state.validation_code_hash, - ); - let candidate_hash_b = candidate_b.hash(); - let response_b = vec![(leaf_b.hash, vec![0])]; - - // Candidate C - let (candidate_c, pvd_c) = make_candidate( - leaf_c.hash, - leaf_c.number, - 2.into(), - HeadData(vec![6, 7, 8]), - HeadData(vec![4]), - test_state.validation_code_hash, - ); - let candidate_hash_c = candidate_c.hash(); - let response_c = vec![(leaf_c.hash, vec![0])]; + let candidate_hash_a = candidate_a.hash(); + let response_a = vec![(candidate_hash_a, leaf_a.hash)]; // Introduce candidates. - introduce_candidate(&mut virtual_overseer, candidate_a1, pvd_a1).await; - introduce_candidate(&mut virtual_overseer, candidate_a2, pvd_a2).await; - introduce_candidate(&mut virtual_overseer, candidate_b, pvd_b).await; - introduce_candidate(&mut virtual_overseer, candidate_c, pvd_c).await; - - // Deactivate leaf A. - deactivate_leaf(&mut virtual_overseer, leaf_a.hash).await; - - // Candidates A1 and A2 should be gone. Candidates B and C should remain. - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a1, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_a2, vec![]).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_b, response_b).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_c, response_c.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) + .await; - // Deactivate leaf B. - deactivate_leaf(&mut virtual_overseer, leaf_b.hash).await; + // Back candidates. Otherwise, we cannot check membership with GetBackableCandidates. + back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; - // Candidate B should be gone, C should remain. - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a1, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_a2, vec![]).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_b, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_c, response_c).await; + // Check candidate tree membership. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + response_a.clone(), + ) + .await; - // Deactivate leaf C. - deactivate_leaf(&mut virtual_overseer, leaf_c.hash).await; + // Introduce the same candidate multiple times. It'll return true but it will only be added + // once. + for _ in 0..5 { + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) + .await; + } - // Candidate C should be gone. - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a1, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_a2, vec![]).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_b, vec![]).await; - get_membership(&mut virtual_overseer, 2.into(), candidate_hash_c, vec![]).await; + // Check candidate tree membership. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + response_a, + ) + .await; virtual_overseer }); - assert_eq!(view.active_leaves.len(), 0); - assert_eq!(view.candidate_storage.len(), 0); + assert_eq!(view.active_leaves.len(), 1); } -// Introduce a candidate to multiple forks, see how the membership is returned. #[test] -fn check_candidate_on_multiple_forks() { +fn fragment_chain_best_chain_length_is_bounded() { let test_state = TestState::default(); let view = test_harness(|mut virtual_overseer| async move { // Leaf A @@ -768,31 +866,16 @@ fn check_candidate_on_multiple_forks() { (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), ], }; - // Leaf B - let leaf_b = TestLeaf { - number: 101, - hash: Hash::from_low_u64_be(131), - para_data: vec![ - (1.into(), PerParaData::new(99, HeadData(vec![3, 4, 5]))), - (2.into(), PerParaData::new(101, HeadData(vec![4, 5, 6]))), - ], - }; - // Leaf C - let leaf_c = TestLeaf { - number: 102, - hash: Hash::from_low_u64_be(132), - para_data: vec![ - (1.into(), PerParaData::new(102, HeadData(vec![5, 6, 7]))), - (2.into(), PerParaData::new(98, HeadData(vec![6, 7, 8]))), - ], - }; - // Activate leaves. - activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; - activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; - activate_leaf(&mut virtual_overseer, &leaf_c, &test_state).await; + activate_leaf_with_params( + &mut virtual_overseer, + &leaf_a, + &test_state, + AsyncBackingParams { max_candidate_depth: 1, allowed_ancestry_len: 3 }, + ) + .await; - // Candidate on leaf A. + // Candidates A, B and C form a chain. let (candidate_a, pvd_a) = make_candidate( leaf_a.hash, leaf_a.number, @@ -801,56 +884,68 @@ fn check_candidate_on_multiple_forks() { HeadData(vec![1]), test_state.validation_code_hash, ); - let candidate_hash_a = candidate_a.hash(); - let response_a = vec![(leaf_a.hash, vec![0])]; - - // Candidate on leaf B. let (candidate_b, pvd_b) = make_candidate( - leaf_b.hash, - leaf_b.number, + leaf_a.hash, + leaf_a.number, 1.into(), - HeadData(vec![3, 4, 5]), HeadData(vec![1]), + HeadData(vec![2]), test_state.validation_code_hash, ); - let candidate_hash_b = candidate_b.hash(); - let response_b = vec![(leaf_b.hash, vec![0])]; - - // Candidate on leaf C. let (candidate_c, pvd_c) = make_candidate( - leaf_c.hash, - leaf_c.number, + leaf_a.hash, + leaf_a.number, 1.into(), - HeadData(vec![5, 6, 7]), - HeadData(vec![1]), + HeadData(vec![2]), + HeadData(vec![3]), test_state.validation_code_hash, ); - let candidate_hash_c = candidate_c.hash(); - let response_c = vec![(leaf_c.hash, vec![0])]; - // Introduce candidates on all three leaves. - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; - introduce_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; - introduce_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c).await; + // Introduce candidates A and B. Since max depth is 1, only these two will be allowed. + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; + + // Back candidates. Otherwise, we cannot check membership with GetBackableCandidates and + // they won't be part of the best chain. + back_candidate(&mut virtual_overseer, &candidate_a, candidate_a.hash()).await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_b.hash()).await; // Check candidate tree membership. - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_a, response_a).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_b, response_b).await; - get_membership(&mut virtual_overseer, 1.into(), candidate_hash_c, response_c).await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + vec![(candidate_a.hash(), leaf_a.hash), (candidate_b.hash(), leaf_a.hash)], + ) + .await; + + // Introducing C will not fail. It will be kept as unconnected storage. + introduce_seconded_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c).await; + // When being backed, candidate C will be dropped. + back_candidate(&mut virtual_overseer, &candidate_c, candidate_c.hash()).await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + vec![(candidate_a.hash(), leaf_a.hash), (candidate_b.hash(), leaf_a.hash)], + ) + .await; virtual_overseer }); - assert_eq!(view.active_leaves.len(), 3); - assert_eq!(view.candidate_storage.len(), 2); - // Three parents and three candidates on para 1. - assert_eq!(view.candidate_storage.get(&1.into()).unwrap().len(), (3, 3)); - assert_eq!(view.candidate_storage.get(&2.into()).unwrap().len(), (0, 0)); + assert_eq!(view.active_leaves.len(), 1); } -// Backs some candidates and tests `GetBackableCandidates` when requesting a single candidate. +// Send some candidates, check if the candidate won't be found once its relay parent leaves the +// view. #[test] -fn check_backable_query_single_candidate() { +fn introduce_candidate_parent_leaving_view() { let test_state = TestState::default(); let view = test_harness(|mut virtual_overseer| async move { // Leaf A @@ -862,12 +957,32 @@ fn check_backable_query_single_candidate() { (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), ], }; + // Leaf B + let leaf_b = TestLeaf { + number: 101, + hash: Hash::from_low_u64_be(131), + para_data: vec![ + (1.into(), PerParaData::new(99, HeadData(vec![3, 4, 5]))), + (2.into(), PerParaData::new(101, HeadData(vec![4, 5, 6]))), + ], + }; + // Leaf C + let leaf_c = TestLeaf { + number: 102, + hash: Hash::from_low_u64_be(132), + para_data: vec![ + (1.into(), PerParaData::new(102, HeadData(vec![5, 6, 7]))), + (2.into(), PerParaData::new(98, HeadData(vec![6, 7, 8]))), + ], + }; // Activate leaves. activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; + activate_leaf(&mut virtual_overseer, &leaf_c, &test_state).await; - // Candidate A - let (candidate_a, pvd_a) = make_candidate( + // Candidate A1 + let (candidate_a1, pvd_a1) = make_candidate( leaf_a.hash, leaf_a.number, 1.into(), @@ -875,536 +990,808 @@ fn check_backable_query_single_candidate() { HeadData(vec![1]), test_state.validation_code_hash, ); - let candidate_hash_a = candidate_a.hash(); + let candidate_hash_a1 = candidate_a1.hash(); - // Candidate B - let (mut candidate_b, pvd_b) = make_candidate( + // Candidate A2 + let (candidate_a2, pvd_a2) = make_candidate( leaf_a.hash, leaf_a.number, - 1.into(), - HeadData(vec![1]), + 2.into(), + HeadData(vec![2, 3, 4]), HeadData(vec![2]), test_state.validation_code_hash, ); - // Set a field to make this candidate unique. - candidate_b.descriptor.para_head = Hash::from_low_u64_le(1000); + let candidate_hash_a2 = candidate_a2.hash(); + + // Candidate B + let (candidate_b, pvd_b) = make_candidate( + leaf_b.hash, + leaf_b.number, + 1.into(), + HeadData(vec![3, 4, 5]), + HeadData(vec![3]), + test_state.validation_code_hash, + ); let candidate_hash_b = candidate_b.hash(); + let response_b = vec![(candidate_hash_b, leaf_b.hash)]; + + // Candidate C + let (candidate_c, pvd_c) = make_candidate( + leaf_c.hash, + leaf_c.number, + 2.into(), + HeadData(vec![6, 7, 8]), + HeadData(vec![4]), + test_state.validation_code_hash, + ); + let candidate_hash_c = candidate_c.hash(); + let response_c = vec![(candidate_hash_c, leaf_c.hash)]; // Introduce candidates. - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; - introduce_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a1.clone(), pvd_a1).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a2.clone(), pvd_a2).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c).await; + + // Back candidates. Otherwise, we cannot check membership with GetBackableCandidates. + back_candidate(&mut virtual_overseer, &candidate_a1, candidate_hash_a1).await; + back_candidate(&mut virtual_overseer, &candidate_a2, candidate_hash_a2).await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_hash_b).await; + back_candidate(&mut virtual_overseer, &candidate_c, candidate_hash_c).await; - // Should not get any backable candidates. + // Deactivate leaf A. + deactivate_leaf(&mut virtual_overseer, leaf_a.hash).await; + + // Candidates A1 and A2 should be gone. Candidates B and C should remain. get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, + Ancestors::default(), + 5, vec![], ) .await; get_backable_candidates( &mut virtual_overseer, &leaf_a, - 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 0, + 2.into(), + Ancestors::default(), + 5, vec![], ) .await; get_backable_candidates( &mut virtual_overseer, - &leaf_a, + &leaf_b, 1.into(), - Ancestors::new(), - 0, - vec![], + Ancestors::default(), + 5, + response_b, + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + 2.into(), + Ancestors::default(), + 5, + response_c.clone(), ) .await; - // Second candidates. - second_candidate(&mut virtual_overseer, candidate_a.clone()).await; - second_candidate(&mut virtual_overseer, candidate_b.clone()).await; + // Deactivate leaf B. + deactivate_leaf(&mut virtual_overseer, leaf_b.hash).await; - // Should not get any backable candidates. + // Candidate B should be gone, C should remain. get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, + Ancestors::default(), + 5, vec![], ) .await; - - // Back candidates. - back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; - back_candidate(&mut virtual_overseer, &candidate_b, candidate_hash_b).await; - - // Should not get any backable candidates for the other para. get_backable_candidates( &mut virtual_overseer, &leaf_a, 2.into(), - Ancestors::new(), - 1, + Ancestors::default(), + 5, vec![], ) .await; get_backable_candidates( &mut virtual_overseer, - &leaf_a, - 2.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, + &leaf_b, + 1.into(), + Ancestors::default(), + 5, vec![], ) .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + 2.into(), + Ancestors::default(), + 5, + response_c, + ) + .await; - // Get backable candidate. + // Deactivate leaf C. + deactivate_leaf(&mut virtual_overseer, leaf_c.hash).await; + + // Candidate C should be gone. get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - Ancestors::new(), - 1, - vec![(candidate_hash_a, leaf_a.hash)], + Ancestors::default(), + 5, + vec![], ) .await; get_backable_candidates( &mut virtual_overseer, &leaf_a, + 2.into(), + Ancestors::default(), + 5, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, - vec![(candidate_hash_b, leaf_a.hash)], + Ancestors::default(), + 5, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + 2.into(), + Ancestors::default(), + 5, + vec![], ) .await; - // Wrong path + virtual_overseer + }); + + assert_eq!(view.active_leaves.len(), 0); +} + +// Introduce a candidate to multiple forks, see how the membership is returned. +#[test] +fn introduce_candidate_on_multiple_forks() { + let test_state = TestState::default(); + let view = test_harness(|mut virtual_overseer| async move { + // Leaf B + let leaf_b = TestLeaf { + number: 101, + hash: Hash::from_low_u64_be(131), + para_data: vec![ + (1.into(), PerParaData::new(99, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(101, HeadData(vec![4, 5, 6]))), + ], + }; + // Leaf A + let leaf_a = TestLeaf { + number: 100, + hash: get_parent_hash(leaf_b.hash), + para_data: vec![ + (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), + ], + }; + + // Activate leaves. + activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; + + // Candidate built on leaf A. + let (candidate_a, pvd_a) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1, 2, 3]), + HeadData(vec![1]), + test_state.validation_code_hash, + ); + let candidate_hash_a = candidate_a.hash(); + let response_a = vec![(candidate_hash_a, leaf_a.hash)]; + + // Introduce candidate. Should be present on leaves B and C. + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; + back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; + + // Check candidate tree membership. get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_b].into_iter().collect(), - 1, - vec![(candidate_hash_a, leaf_a.hash)], + Ancestors::default(), + 5, + response_a.clone(), + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + 1.into(), + Ancestors::default(), + 5, + response_a.clone(), ) .await; virtual_overseer }); - assert_eq!(view.active_leaves.len(), 1); - assert_eq!(view.candidate_storage.len(), 2); - // Two parents and two candidates on para 1. - assert_eq!(view.candidate_storage.get(&1.into()).unwrap().len(), (2, 2)); - assert_eq!(view.candidate_storage.get(&2.into()).unwrap().len(), (0, 0)); + assert_eq!(view.active_leaves.len(), 2); } -// Backs some candidates and tests `GetBackableCandidates` when requesting a multiple candidates. #[test] -fn check_backable_query_multiple_candidates() { - macro_rules! make_and_back_candidate { - ($test_state:ident, $virtual_overseer:ident, $leaf:ident, $parent:expr, $index:expr) => {{ - let (mut candidate, pvd) = make_candidate( - $leaf.hash, - $leaf.number, - 1.into(), - $parent.commitments.head_data.clone(), - HeadData(vec![$index]), - $test_state.validation_code_hash, - ); - // Set a field to make this candidate unique. - candidate.descriptor.para_head = Hash::from_low_u64_le($index); - let candidate_hash = candidate.hash(); - introduce_candidate(&mut $virtual_overseer, candidate.clone(), pvd).await; - second_candidate(&mut $virtual_overseer, candidate.clone()).await; - back_candidate(&mut $virtual_overseer, &candidate, candidate_hash).await; - - (candidate, candidate_hash) - }}; - } +fn unconnected_candidates_become_connected() { + // This doesn't test all the complicated cases with many unconnected candidates, as it's more + // extensively tested in the `fragment_chain::tests` module. + let test_state = TestState::default(); + let view = test_harness(|mut virtual_overseer| async move { + // Leaf A + let leaf_a = TestLeaf { + number: 100, + hash: Hash::from_low_u64_be(130), + para_data: vec![ + (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), + ], + }; + // Activate leaves. + activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; - // Parachain 1 looks like this: - // +---A----+ - // | | - // +----B---+ C - // | | | | - // D E F H - // | | - // G I - // | - // J - { - let test_state = TestState::default(); - let view = test_harness(|mut virtual_overseer| async move { - // Leaf A - let leaf_a = TestLeaf { - number: 100, - hash: Hash::from_low_u64_be(130), - para_data: vec![ - (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), - (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), - ], - }; - - // Activate leaves. - activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; - - // Candidate A - let (candidate_a, pvd_a) = make_candidate( - leaf_a.hash, - leaf_a.number, - 1.into(), - HeadData(vec![1, 2, 3]), - HeadData(vec![1]), - test_state.validation_code_hash, - ); - let candidate_hash_a = candidate_a.hash(); - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; - second_candidate(&mut virtual_overseer, candidate_a.clone()).await; - back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; - - let (candidate_b, candidate_hash_b) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_a, 2); - let (candidate_c, candidate_hash_c) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_a, 3); - let (_candidate_d, candidate_hash_d) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_b, 4); - let (_candidate_e, candidate_hash_e) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_b, 5); - let (candidate_f, candidate_hash_f) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_b, 6); - let (_candidate_g, candidate_hash_g) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_f, 7); - let (candidate_h, candidate_hash_h) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_c, 8); - let (candidate_i, candidate_hash_i) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_h, 9); - let (_candidate_j, candidate_hash_j) = - make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_i, 10); - - // Should not get any backable candidates for the other para. - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 2.into(), - Ancestors::new(), - 1, - vec![], - ) + // Candidates A, B, C and D all form a chain, but we'll first introduce A, C and D. + let (candidate_a, pvd_a) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1, 2, 3]), + HeadData(vec![1]), + test_state.validation_code_hash, + ); + let (candidate_b, pvd_b) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1]), + HeadData(vec![2]), + test_state.validation_code_hash, + ); + let (candidate_c, pvd_c) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![2]), + HeadData(vec![3]), + test_state.validation_code_hash, + ); + let (candidate_d, pvd_d) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![3]), + HeadData(vec![4]), + test_state.validation_code_hash, + ); + + // Introduce candidates A, C and D. + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 2.into(), - Ancestors::new(), - 5, - vec![], - ) + introduce_seconded_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c.clone()) .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 2.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, - vec![], - ) + introduce_seconded_candidate(&mut virtual_overseer, candidate_d.clone(), pvd_d.clone()) .await; - // Test various scenarios with various counts. + // Back candidates. Otherwise, we cannot check membership with GetBackableCandidates. + back_candidate(&mut virtual_overseer, &candidate_a, candidate_a.hash()).await; + back_candidate(&mut virtual_overseer, &candidate_c, candidate_c.hash()).await; + back_candidate(&mut virtual_overseer, &candidate_d, candidate_d.hash()).await; - // empty required_path - { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - Ancestors::new(), - 1, - vec![(candidate_hash_a, leaf_a.hash)], - ) - .await; + // Check candidate tree membership. Only A should be returned. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + vec![(candidate_a.hash(), leaf_a.hash)], + ) + .await; + + // Introduce C and check membership. Full chain should be returned. + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b.clone()) + .await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_b.hash()).await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::default(), + 5, + vec![ + (candidate_a.hash(), leaf_a.hash), + (candidate_b.hash(), leaf_a.hash), + (candidate_c.hash(), leaf_a.hash), + (candidate_d.hash(), leaf_a.hash), + ], + ) + .await; + + virtual_overseer + }); + + assert_eq!(view.active_leaves.len(), 1); +} + +// Backs some candidates and tests `GetBackableCandidates` when requesting a single candidate. +#[test] +fn check_backable_query_single_candidate() { + let test_state = TestState::default(); + let view = test_harness(|mut virtual_overseer| async move { + // Leaf A + let leaf_a = TestLeaf { + number: 100, + hash: Hash::from_low_u64_be(130), + para_data: vec![ + (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), + ], + }; + + // Activate leaves. + activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + + // Candidate A + let (candidate_a, pvd_a) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1, 2, 3]), + HeadData(vec![1]), + test_state.validation_code_hash, + ); + let candidate_hash_a = candidate_a.hash(); + + // Candidate B + let (mut candidate_b, pvd_b) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1]), + HeadData(vec![2]), + test_state.validation_code_hash, + ); + // Set a field to make this candidate unique. + candidate_b.descriptor.para_head = Hash::from_low_u64_le(1000); + let candidate_hash_b = candidate_b.hash(); + + // Introduce candidates. + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; + + // Should not get any backable candidates. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a].into_iter().collect(), + 1, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a].into_iter().collect(), + 0, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::new(), + 0, + vec![], + ) + .await; + + // Back candidates. + back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_hash_b).await; + + // Back an unknown candidate. It doesn't return anything but it's ignored. Will not have any + // effect on the backable candidates. + back_candidate(&mut virtual_overseer, &candidate_b, CandidateHash(Hash::random())).await; + + // Should not get any backable candidates for the other para. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + Ancestors::new(), + 1, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + vec![candidate_hash_a].into_iter().collect(), + 1, + vec![], + ) + .await; + + // Get backable candidate. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::new(), + 1, + vec![(candidate_hash_a, leaf_a.hash)], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a].into_iter().collect(), + 1, + vec![(candidate_hash_b, leaf_a.hash)], + ) + .await; + + // Wrong path + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_b].into_iter().collect(), + 1, + vec![(candidate_hash_a, leaf_a.hash)], + ) + .await; + + virtual_overseer + }); + + assert_eq!(view.active_leaves.len(), 1); +} + +// Backs some candidates and tests `GetBackableCandidates` when requesting a multiple candidates. +#[test] +fn check_backable_query_multiple_candidates() { + let test_state = TestState::default(); + let view = test_harness(|mut virtual_overseer| async move { + // Leaf A + let leaf_a = TestLeaf { + number: 100, + hash: Hash::from_low_u64_be(130), + para_data: vec![ + (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), + ], + }; + + // Activate leaves. + activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + + // Candidate A + let (candidate_a, pvd_a) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![1, 2, 3]), + HeadData(vec![1]), + test_state.validation_code_hash, + ); + let candidate_hash_a = candidate_a.hash(); + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; + back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; + + let (candidate_b, candidate_hash_b) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_a, 2); + let (candidate_c, candidate_hash_c) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_b, 3); + let (_candidate_d, candidate_hash_d) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_c, 4); + + // Should not get any backable candidates for the other para. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + Ancestors::new(), + 1, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + Ancestors::new(), + 5, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 2.into(), + vec![candidate_hash_a].into_iter().collect(), + 1, + vec![], + ) + .await; + + // Test various scenarios with various counts. + + // empty ancestors + { + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::new(), + 1, + vec![(candidate_hash_a, leaf_a.hash)], + ) + .await; + for count in 4..10 { get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), Ancestors::new(), - 4, + count, vec![ (candidate_hash_a, leaf_a.hash), (candidate_hash_b, leaf_a.hash), - (candidate_hash_f, leaf_a.hash), - (candidate_hash_g, leaf_a.hash), - ], - ) - .await; - } - - // required path of 1 - { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 1, - vec![(candidate_hash_b, leaf_a.hash)], - ) - .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 3, - vec![ - (candidate_hash_b, leaf_a.hash), - (candidate_hash_f, leaf_a.hash), - (candidate_hash_g, leaf_a.hash), + (candidate_hash_c, leaf_a.hash), + (candidate_hash_d, leaf_a.hash), ], ) .await; - - // If the requested count exceeds the largest chain, return the longest - // chain we can get. - for count in 5..10 { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a].into_iter().collect(), - count, - vec![ - (candidate_hash_c, leaf_a.hash), - (candidate_hash_h, leaf_a.hash), - (candidate_hash_i, leaf_a.hash), - (candidate_hash_j, leaf_a.hash), - ], - ) - .await; - } - } - - // required path of 2 and higher - { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_i, candidate_hash_h, candidate_hash_c] - .into_iter() - .collect(), - 1, - vec![(candidate_hash_j, leaf_a.hash)], - ) - .await; - - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_b].into_iter().collect(), - 1, - vec![(candidate_hash_d, leaf_a.hash)], - ) - .await; - - // If the requested count exceeds the largest chain, return the longest - // chain we can get. - for count in 4..10 { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_c].into_iter().collect(), - count, - vec![ - (candidate_hash_h, leaf_a.hash), - (candidate_hash_i, leaf_a.hash), - (candidate_hash_j, leaf_a.hash), - ], - ) - .await; - } - } - - // No more candidates in any chain. - { - for count in 1..4 { - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_b, candidate_hash_e] - .into_iter() - .collect(), - count, - vec![], - ) - .await; - - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![ - candidate_hash_a, - candidate_hash_c, - candidate_hash_h, - candidate_hash_i, - candidate_hash_j, - ] - .into_iter() - .collect(), - count, - vec![], - ) - .await; - } } + } - // Wrong paths. + // ancestors of size 1 + { get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_b].into_iter().collect(), + vec![candidate_hash_a].into_iter().collect(), 1, - vec![(candidate_hash_a, leaf_a.hash)], - ) - .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_b, candidate_hash_f].into_iter().collect(), - 3, - vec![ - (candidate_hash_a, leaf_a.hash), - (candidate_hash_b, leaf_a.hash), - (candidate_hash_d, leaf_a.hash), - ], - ) - .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_h].into_iter().collect(), - 4, - vec![ - (candidate_hash_c, leaf_a.hash), - (candidate_hash_h, leaf_a.hash), - (candidate_hash_i, leaf_a.hash), - (candidate_hash_j, leaf_a.hash), - ], + vec![(candidate_hash_b, leaf_a.hash)], ) .await; get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_e, candidate_hash_h].into_iter().collect(), + vec![candidate_hash_a].into_iter().collect(), 2, - vec![(candidate_hash_a, leaf_a.hash), (candidate_hash_b, leaf_a.hash)], + vec![(candidate_hash_b, leaf_a.hash), (candidate_hash_c, leaf_a.hash)], ) .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a, candidate_hash_c, candidate_hash_d].into_iter().collect(), - 2, - vec![(candidate_hash_h, leaf_a.hash), (candidate_hash_i, leaf_a.hash)], - ) - .await; + // If the requested count exceeds the largest chain, return the longest + // chain we can get. + for count in 3..10 { + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a].into_iter().collect(), + count, + vec![ + (candidate_hash_b, leaf_a.hash), + (candidate_hash_c, leaf_a.hash), + (candidate_hash_d, leaf_a.hash), + ], + ) + .await; + } + } - // Parachain fork. + // ancestor count 2 and higher + { get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), vec![candidate_hash_a, candidate_hash_b, candidate_hash_c].into_iter().collect(), 1, - vec![], + vec![(candidate_hash_d, leaf_a.hash)], ) .await; - // Non-existent candidate. get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_a, CandidateHash(Hash::from_low_u64_be(100))] - .into_iter() - .collect(), - 2, - vec![(candidate_hash_b, leaf_a.hash), (candidate_hash_d, leaf_a.hash)], + vec![candidate_hash_a, candidate_hash_b].into_iter().collect(), + 1, + vec![(candidate_hash_c, leaf_a.hash)], ) .await; - // Requested count is zero. - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - Ancestors::new(), - 0, - vec![], - ) - .await; - get_backable_candidates( - &mut virtual_overseer, - &leaf_a, - 1.into(), - vec![candidate_hash_a].into_iter().collect(), - 0, - vec![], - ) - .await; + // If the requested count exceeds the largest chain, return the longest + // chain we can get. + for count in 3..10 { + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a, candidate_hash_b].into_iter().collect(), + count, + vec![(candidate_hash_c, leaf_a.hash), (candidate_hash_d, leaf_a.hash)], + ) + .await; + } + } + + // No more candidates in the chain. + for count in 1..4 { get_backable_candidates( &mut virtual_overseer, &leaf_a, 1.into(), - vec![candidate_hash_a, candidate_hash_b].into_iter().collect(), - 0, + vec![candidate_hash_a, candidate_hash_b, candidate_hash_c, candidate_hash_d] + .into_iter() + .collect(), + count, vec![], ) .await; + } - virtual_overseer - }); + // Wrong paths. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_b].into_iter().collect(), + 1, + vec![(candidate_hash_a, leaf_a.hash)], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_b, candidate_hash_c].into_iter().collect(), + 3, + vec![ + (candidate_hash_a, leaf_a.hash), + (candidate_hash_b, leaf_a.hash), + (candidate_hash_c, leaf_a.hash), + ], + ) + .await; - assert_eq!(view.active_leaves.len(), 1); - assert_eq!(view.candidate_storage.len(), 2); - // 10 candidates and 7 parents on para 1. - assert_eq!(view.candidate_storage.get(&1.into()).unwrap().len(), (7, 10)); - assert_eq!(view.candidate_storage.get(&2.into()).unwrap().len(), (0, 0)); - } + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a, candidate_hash_c, candidate_hash_d].into_iter().collect(), + 2, + vec![(candidate_hash_b, leaf_a.hash), (candidate_hash_c, leaf_a.hash)], + ) + .await; + + // Non-existent candidate. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a, CandidateHash(Hash::from_low_u64_be(100))] + .into_iter() + .collect(), + 2, + vec![(candidate_hash_b, leaf_a.hash), (candidate_hash_c, leaf_a.hash)], + ) + .await; + + // Requested count is zero. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + Ancestors::new(), + 0, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a].into_iter().collect(), + 0, + vec![], + ) + .await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + 1.into(), + vec![candidate_hash_a, candidate_hash_b].into_iter().collect(), + 0, + vec![], + ) + .await; + + virtual_overseer + }); + + assert_eq!(view.active_leaves.len(), 1); } -// Test depth query. +// Test hypothetical membership query. #[test] -fn check_hypothetical_frontier_query() { +fn check_hypothetical_membership_query() { let test_state = TestState::default(); let view = test_harness(|mut virtual_overseer| async move { + // Leaf B + let leaf_b = TestLeaf { + number: 101, + hash: Hash::from_low_u64_be(131), + para_data: vec![ + (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), + ], + }; // Leaf A let leaf_a = TestLeaf { number: 100, - hash: Hash::from_low_u64_be(130), + hash: get_parent_hash(leaf_b.hash), para_data: vec![ - (1.into(), PerParaData::new(97, HeadData(vec![1, 2, 3]))), + (1.into(), PerParaData::new(98, HeadData(vec![1, 2, 3]))), (2.into(), PerParaData::new(100, HeadData(vec![2, 3, 4]))), ], }; // Activate leaves. - activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + activate_leaf_with_params( + &mut virtual_overseer, + &leaf_a, + &test_state, + AsyncBackingParams { allowed_ancestry_len: 3, max_candidate_depth: 1 }, + ) + .await; + activate_leaf_with_params( + &mut virtual_overseer, + &leaf_b, + &test_state, + AsyncBackingParams { allowed_ancestry_len: 3, max_candidate_depth: 1 }, + ) + .await; + + // Candidates will be valid on both leaves. // Candidate A. let (candidate_a, pvd_a) = make_candidate( @@ -1415,7 +1802,6 @@ fn check_hypothetical_frontier_query() { HeadData(vec![1]), test_state.validation_code_hash, ); - let candidate_hash_a = candidate_a.hash(); // Candidate B. let (candidate_b, pvd_b) = make_candidate( @@ -1426,7 +1812,6 @@ fn check_hypothetical_frontier_query() { HeadData(vec![2]), test_state.validation_code_hash, ); - let candidate_hash_b = candidate_b.hash(); // Candidate C. let (candidate_c, pvd_c) = make_candidate( @@ -1437,127 +1822,100 @@ fn check_hypothetical_frontier_query() { HeadData(vec![3]), test_state.validation_code_hash, ); - let candidate_hash_c = candidate_c.hash(); - // Get hypothetical frontier of candidate A before adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_a, - candidate_a.clone(), - pvd_a.clone(), - leaf_a.hash, - false, - vec![0], - ) - .await; - // Should work with `backed_in_path_only: true`, too. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_a, - candidate_a.clone(), - pvd_a.clone(), - leaf_a.hash, - true, - vec![0], - ) - .await; + // Get hypothetical membership of candidates before adding candidate A. + // Candidate A can be added directly, candidates B and C are potential candidates. + for (candidate, pvd) in [ + (candidate_a.clone(), pvd_a.clone()), + (candidate_b.clone(), pvd_b.clone()), + (candidate_c.clone(), pvd_c.clone()), + ] { + get_hypothetical_membership( + &mut virtual_overseer, + candidate.hash(), + candidate, + pvd, + vec![leaf_a.hash, leaf_b.hash], + ) + .await; + } // Add candidate A. - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()).await; - - // Get frontier of candidate A after adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_a, - candidate_a.clone(), - pvd_a.clone(), - leaf_a.hash, - false, - vec![0], - ) - .await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) + .await; - // Get hypothetical frontier of candidate B before adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_b, - candidate_b.clone(), - pvd_b.clone(), - leaf_a.hash, - false, - vec![1], - ) - .await; + // Get membership of candidates after adding A. They all are still unconnected candidates + // (not part of the best backable chain). + for (candidate, pvd) in [ + (candidate_a.clone(), pvd_a.clone()), + (candidate_b.clone(), pvd_b.clone()), + (candidate_c.clone(), pvd_c.clone()), + ] { + get_hypothetical_membership( + &mut virtual_overseer, + candidate.hash(), + candidate, + pvd, + vec![leaf_a.hash, leaf_b.hash], + ) + .await; + } - // Add candidate B. - introduce_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b.clone()).await; + // Back A. Now A is part of the best chain the rest can be added as unconnected. - // Get frontier of candidate B after adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_b, - candidate_b, - pvd_b.clone(), - leaf_a.hash, - false, - vec![1], - ) - .await; + back_candidate(&mut virtual_overseer, &candidate_a, candidate_a.hash()).await; - // Get hypothetical frontier of candidate C before adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_c, - candidate_c.clone(), - pvd_c.clone(), - leaf_a.hash, - false, - vec![2], - ) - .await; - // Should be empty with `backed_in_path_only` because we haven't backed anything. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_c, - candidate_c.clone(), - pvd_c.clone(), - leaf_a.hash, - true, - vec![], - ) - .await; + for (candidate, pvd) in [ + (candidate_a.clone(), pvd_a.clone()), + (candidate_b.clone(), pvd_b.clone()), + (candidate_c.clone(), pvd_c.clone()), + ] { + get_hypothetical_membership( + &mut virtual_overseer, + candidate.hash(), + candidate, + pvd, + vec![leaf_a.hash, leaf_b.hash], + ) + .await; + } - // Add candidate C. - introduce_candidate(&mut virtual_overseer, candidate_c.clone(), pvd_c.clone()).await; + // Candidate D has invalid relay parent. + let (candidate_d, pvd_d) = make_candidate( + Hash::from_low_u64_be(200), + leaf_a.number, + 1.into(), + HeadData(vec![1]), + HeadData(vec![2]), + test_state.validation_code_hash, + ); + introduce_seconded_candidate_failed(&mut virtual_overseer, candidate_d, pvd_d).await; - // Get frontier of candidate C after adding it. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_c, - candidate_c.clone(), - pvd_c.clone(), - leaf_a.hash, - false, - vec![2], - ) - .await; - // Should be empty with `backed_in_path_only` because we haven't backed anything. - get_hypothetical_frontier( - &mut virtual_overseer, - candidate_hash_c, - candidate_c.clone(), - pvd_c.clone(), - leaf_a.hash, - true, - vec![], - ) - .await; + // Add candidate B and back it. + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b.clone()) + .await; + back_candidate(&mut virtual_overseer, &candidate_b, candidate_b.hash()).await; + + // Get membership of candidates after adding B. + for (candidate, pvd) in [ + (candidate_a.clone(), pvd_a.clone()), + (candidate_b.clone(), pvd_b.clone()), + (candidate_c.clone(), pvd_c.clone()), + ] { + get_hypothetical_membership( + &mut virtual_overseer, + candidate.hash(), + candidate, + pvd, + vec![leaf_a.hash, leaf_b.hash], + ) + .await; + } virtual_overseer }); - assert_eq!(view.active_leaves.len(), 1); - assert_eq!(view.candidate_storage.len(), 2); + assert_eq!(view.active_leaves.len(), 2); } #[test] @@ -1607,6 +1965,16 @@ fn check_pvd_query() { test_state.validation_code_hash, ); + // Candidate E. + let (candidate_e, pvd_e) = make_candidate( + leaf_a.hash, + leaf_a.number, + 1.into(), + HeadData(vec![5]), + HeadData(vec![6]), + test_state.validation_code_hash, + ); + // Get pvd of candidate A before adding it. get_pvd( &mut virtual_overseer, @@ -1618,7 +1986,8 @@ fn check_pvd_query() { .await; // Add candidate A. - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) + .await; back_candidate(&mut virtual_overseer, &candidate_a, candidate_a.hash()).await; // Get pvd of candidate A after adding it. @@ -1642,7 +2011,7 @@ fn check_pvd_query() { .await; // Add candidate B. - introduce_candidate(&mut virtual_overseer, candidate_b, pvd_b.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_b, pvd_b.clone()).await; // Get pvd of candidate B after adding it. get_pvd( @@ -1665,30 +2034,36 @@ fn check_pvd_query() { .await; // Add candidate C. - introduce_candidate(&mut virtual_overseer, candidate_c, pvd_c.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_c, pvd_c.clone()).await; // Get pvd of candidate C after adding it. - get_pvd( - &mut virtual_overseer, - 1.into(), - leaf_a.hash, - HeadData(vec![2]), - Some(pvd_c.clone()), - ) - .await; + get_pvd(&mut virtual_overseer, 1.into(), leaf_a.hash, HeadData(vec![2]), Some(pvd_c)).await; + + // Get pvd of candidate E before adding it. It won't be found, as we don't have its parent. + get_pvd(&mut virtual_overseer, 1.into(), leaf_a.hash, HeadData(vec![5]), None).await; + + // Add candidate E and check again. Should succeed this time. + introduce_seconded_candidate(&mut virtual_overseer, candidate_e, pvd_e.clone()).await; + + get_pvd(&mut virtual_overseer, 1.into(), leaf_a.hash, HeadData(vec![5]), Some(pvd_e)).await; virtual_overseer }); assert_eq!(view.active_leaves.len(), 1); - assert_eq!(view.candidate_storage.len(), 2); } // Test simultaneously activating and deactivating leaves, and simultaneously deactivating // multiple leaves. -#[test] -fn correctly_updates_leaves() { - let test_state = TestState::default(); +// This test is parametrised with the runtime api version. For versions that don't support the claim +// queue API, we check that av-cores are used. +#[rstest] +#[case(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)] +#[case(8)] +fn correctly_updates_leaves(#[case] runtime_api_version: u32) { + let mut test_state = TestState::default(); + test_state.set_runtime_api_version(runtime_api_version); + let view = test_harness(|mut virtual_overseer| async move { // Leaf A let leaf_a = TestLeaf { @@ -1745,6 +2120,7 @@ fn correctly_updates_leaves() { &leaf_c, &test_state, ASYNC_BACKING_PARAMETERS, + get_parent_hash, ) .await; @@ -1766,13 +2142,6 @@ fn correctly_updates_leaves() { virtual_overseer .send(FromOrchestra::Signal(OverseerSignal::ActiveLeaves(update))) .await; - handle_leaf_activation( - &mut virtual_overseer, - &leaf_a, - &test_state, - ASYNC_BACKING_PARAMETERS, - ) - .await; // Remove the leaf again. Send some unnecessary hashes. let update = ActiveLeavesUpdate { @@ -1787,22 +2156,334 @@ fn correctly_updates_leaves() { }); assert_eq!(view.active_leaves.len(), 0); - assert_eq!(view.candidate_storage.len(), 0); +} + +#[test] +fn handle_active_leaves_update_gets_candidates_from_parent() { + let para_id = ParaId::from(1); + let mut test_state = TestState::default(); + test_state.claim_queue = test_state + .claim_queue + .into_iter() + .filter(|(_, paras)| matches!(paras.front(), Some(para) if para == ¶_id)) + .collect(); + assert_eq!(test_state.claim_queue.len(), 1); + let view = test_harness(|mut virtual_overseer| async move { + // Leaf A + let leaf_a = TestLeaf { + number: 100, + hash: Hash::from_low_u64_be(130), + para_data: vec![(para_id, PerParaData::new(97, HeadData(vec![1, 2, 3])))], + }; + // Activate leaf A. + activate_leaf(&mut virtual_overseer, &leaf_a, &test_state).await; + + // Candidates A, B, C and D all form a chain + let (candidate_a, pvd_a) = make_candidate( + leaf_a.hash, + leaf_a.number, + para_id, + HeadData(vec![1, 2, 3]), + HeadData(vec![1]), + test_state.validation_code_hash, + ); + let candidate_hash_a = candidate_a.hash(); + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; + back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; + + let (candidate_b, candidate_hash_b) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_a, 2); + let (candidate_c, candidate_hash_c) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_b, 3); + let (candidate_d, candidate_hash_d) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_c, 4); + + let mut all_candidates_resp = vec![ + (candidate_hash_a, leaf_a.hash), + (candidate_hash_b, leaf_a.hash), + (candidate_hash_c, leaf_a.hash), + (candidate_hash_d, leaf_a.hash), + ]; + + // Check candidate tree membership. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + para_id, + Ancestors::default(), + 5, + all_candidates_resp.clone(), + ) + .await; + + // Activate leaf B, which makes candidates A and B pending availability. + // Leaf B + let leaf_b = TestLeaf { + number: 101, + hash: Hash::from_low_u64_be(129), + para_data: vec![( + para_id, + PerParaData::new_with_pending( + 98, + HeadData(vec![1, 2, 3]), + vec![ + CandidatePendingAvailability { + candidate_hash: candidate_a.hash(), + descriptor: candidate_a.descriptor.clone(), + commitments: candidate_a.commitments.clone(), + relay_parent_number: leaf_a.number, + max_pov_size: MAX_POV_SIZE, + }, + CandidatePendingAvailability { + candidate_hash: candidate_b.hash(), + descriptor: candidate_b.descriptor.clone(), + commitments: candidate_b.commitments.clone(), + relay_parent_number: leaf_a.number, + max_pov_size: MAX_POV_SIZE, + }, + ], + ), + )], + }; + // Activate leaf B. + activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + Ancestors::default(), + 5, + vec![], + ) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + [candidate_a.hash(), candidate_b.hash()].into_iter().collect(), + 5, + vec![(candidate_c.hash(), leaf_a.hash), (candidate_d.hash(), leaf_a.hash)], + ) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + Ancestors::default(), + 5, + vec![], + ) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + para_id, + Ancestors::default(), + 5, + all_candidates_resp.clone(), + ) + .await; + + // Now deactivate leaf A. + deactivate_leaf(&mut virtual_overseer, leaf_a.hash).await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + Ancestors::default(), + 5, + vec![], + ) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + [candidate_a.hash(), candidate_b.hash()].into_iter().collect(), + 5, + vec![(candidate_c.hash(), leaf_a.hash), (candidate_d.hash(), leaf_a.hash)], + ) + .await; + + // Now add leaf C, which will be a sibling (fork) of leaf B. It should also inherit the + // candidates of leaf A (their common parent). + let leaf_c = TestLeaf { + number: 101, + hash: Hash::from_low_u64_be(12), + para_data: vec![( + para_id, + PerParaData::new_with_pending(98, HeadData(vec![1, 2, 3]), vec![]), + )], + }; + + activate_leaf_with_parent_hash_fn(&mut virtual_overseer, &leaf_c, &test_state, |hash| { + if hash == leaf_c.hash { + leaf_a.hash + } else { + get_parent_hash(hash) + } + }) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + [candidate_a.hash(), candidate_b.hash()].into_iter().collect(), + 5, + vec![(candidate_c.hash(), leaf_a.hash), (candidate_d.hash(), leaf_a.hash)], + ) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + para_id, + Ancestors::new(), + 5, + all_candidates_resp.clone(), + ) + .await; + + // Deactivate C and add another candidate that will be present on the deactivated parent A. + // When activating C again it should also get the new candidate. Deactivated leaves are + // still updated with new candidates. + deactivate_leaf(&mut virtual_overseer, leaf_c.hash).await; + + let (candidate_e, _) = + make_and_back_candidate!(test_state, virtual_overseer, leaf_a, &candidate_d, 5); + activate_leaf_with_parent_hash_fn(&mut virtual_overseer, &leaf_c, &test_state, |hash| { + if hash == leaf_c.hash { + leaf_a.hash + } else { + get_parent_hash(hash) + } + }) + .await; + + get_backable_candidates( + &mut virtual_overseer, + &leaf_b, + para_id, + [candidate_a.hash(), candidate_b.hash()].into_iter().collect(), + 5, + vec![ + (candidate_c.hash(), leaf_a.hash), + (candidate_d.hash(), leaf_a.hash), + (candidate_e.hash(), leaf_a.hash), + ], + ) + .await; + + all_candidates_resp.push((candidate_e.hash(), leaf_a.hash)); + get_backable_candidates( + &mut virtual_overseer, + &leaf_c, + para_id, + Ancestors::new(), + 5, + all_candidates_resp, + ) + .await; + + // Querying the backable candidates for deactivated leaf won't work. + get_backable_candidates( + &mut virtual_overseer, + &leaf_a, + para_id, + Ancestors::new(), + 5, + vec![], + ) + .await; + + virtual_overseer + }); + + assert_eq!(view.active_leaves.len(), 2); + assert_eq!(view.per_relay_parent.len(), 3); +} + +#[test] +fn handle_active_leaves_update_bounded_implicit_view() { + let para_id = ParaId::from(1); + let mut test_state = TestState::default(); + test_state.claim_queue = test_state + .claim_queue + .into_iter() + .filter(|(_, paras)| matches!(paras.front(), Some(para) if para == ¶_id)) + .collect(); + assert_eq!(test_state.claim_queue.len(), 1); + + let mut leaves = vec![TestLeaf { + number: 100, + hash: Hash::from_low_u64_be(130), + para_data: vec![( + para_id, + PerParaData::new(100 - ALLOWED_ANCESTRY_LEN, HeadData(vec![1, 2, 3])), + )], + }]; + + for index in 1..10 { + let prev_leaf = &leaves[index - 1]; + leaves.push(TestLeaf { + number: prev_leaf.number - 1, + hash: get_parent_hash(prev_leaf.hash), + para_data: vec![( + para_id, + PerParaData::new( + prev_leaf.number - 1 - ALLOWED_ANCESTRY_LEN, + HeadData(vec![1, 2, 3]), + ), + )], + }); + } + leaves.reverse(); + + let view = test_harness(|mut virtual_overseer| async { + // Activate first 10 leaves. + for leaf in &leaves[0..10] { + activate_leaf(&mut virtual_overseer, leaf, &test_state).await; + } + + // Now deactivate first 9 leaves. + for leaf in &leaves[0..9] { + deactivate_leaf(&mut virtual_overseer, leaf.hash).await; + } + + virtual_overseer + }); + + // Only latest leaf is active. + assert_eq!(view.active_leaves.len(), 1); + // We keep allowed_ancestry_len implicit leaves. The latest leaf is also present here. + assert_eq!( + view.per_relay_parent.len() as u32, + ASYNC_BACKING_PARAMETERS.allowed_ancestry_len + 1 + ); + + assert_eq!(view.active_leaves, [leaves[9].hash].into_iter().collect()); + assert_eq!( + view.per_relay_parent.into_keys().collect::>(), + leaves[6..].into_iter().map(|l| l.hash).collect::>() + ); } #[test] fn persists_pending_availability_candidate() { let mut test_state = TestState::default(); let para_id = ParaId::from(1); - test_state.availability_cores = test_state - .availability_cores + test_state.claim_queue = test_state + .claim_queue .into_iter() - .filter(|core| match core { - CoreState::Scheduled(scheduled_core) => scheduled_core.para_id == para_id, - _ => false, - }) + .filter(|(_, paras)| matches!(paras.front(), Some(para) if para == ¶_id)) .collect(); - assert_eq!(test_state.availability_cores.len(), 1); + assert_eq!(test_state.claim_queue.len(), 1); test_harness(|mut virtual_overseer| async move { let para_head = HeadData(vec![1, 2, 3]); @@ -1849,8 +2530,8 @@ fn persists_pending_availability_candidate() { ); let candidate_hash_b = candidate_b.hash(); - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; - second_candidate(&mut virtual_overseer, candidate_a.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a.clone()) + .await; back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; let candidate_a_pending_av = CandidatePendingAvailability { @@ -1874,8 +2555,16 @@ fn persists_pending_availability_candidate() { }; activate_leaf(&mut virtual_overseer, &leaf_b, &test_state).await; - introduce_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; - second_candidate(&mut virtual_overseer, candidate_b.clone()).await; + get_hypothetical_membership( + &mut virtual_overseer, + candidate_hash_a, + candidate_a, + pvd_a, + vec![leaf_a.hash, leaf_b.hash], + ) + .await; + + introduce_seconded_candidate(&mut virtual_overseer, candidate_b.clone(), pvd_b).await; back_candidate(&mut virtual_overseer, &candidate_b, candidate_hash_b).await; get_backable_candidates( @@ -1893,18 +2582,15 @@ fn persists_pending_availability_candidate() { } #[test] -fn backwards_compatible() { +fn backwards_compatible_with_non_async_backing_params() { let mut test_state = TestState::default(); let para_id = ParaId::from(1); - test_state.availability_cores = test_state - .availability_cores + test_state.claim_queue = test_state + .claim_queue .into_iter() - .filter(|core| match core { - CoreState::Scheduled(scheduled_core) => scheduled_core.para_id == para_id, - _ => false, - }) + .filter(|(_, paras)| matches!(paras.front(), Some(para) if para == ¶_id)) .collect(); - assert_eq!(test_state.availability_cores.len(), 1); + assert_eq!(test_state.claim_queue.len(), 1); test_harness(|mut virtual_overseer| async move { let para_head = HeadData(vec![1, 2, 3]); @@ -1942,8 +2628,7 @@ fn backwards_compatible() { ); let candidate_hash_a = candidate_a.hash(); - introduce_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; - second_candidate(&mut virtual_overseer, candidate_a.clone()).await; + introduce_seconded_candidate(&mut virtual_overseer, candidate_a.clone(), pvd_a).await; back_candidate(&mut virtual_overseer, &candidate_a, candidate_hash_a).await; get_backable_candidates( @@ -2007,20 +2692,30 @@ fn uses_ancestry_only_within_session() { .await; assert_matches!( - virtual_overseer.recv().await, - AllMessages::RuntimeApi( - RuntimeApiMessage::Request(parent, RuntimeApiRequest::AsyncBackingParams(tx)) - ) if parent == hash => { - tx.send(Ok(AsyncBackingParams { max_candidate_depth: 0, allowed_ancestry_len: ancestry_len - })).unwrap(); } - ); + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + parent, + RuntimeApiRequest::AsyncBackingParams(tx) + )) if parent == hash => { + tx.send(Ok(AsyncBackingParams { max_candidate_depth: 0, allowed_ancestry_len: ancestry_len})).unwrap(); + }); + + assert_matches!( + virtual_overseer.recv().await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request(parent, RuntimeApiRequest::Version(tx)) + ) if parent == hash => { + tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap(); + } + ); assert_matches!( virtual_overseer.recv().await, AllMessages::RuntimeApi( - RuntimeApiMessage::Request(parent, RuntimeApiRequest::AvailabilityCores(tx)) + RuntimeApiMessage::Request(parent, RuntimeApiRequest::ClaimQueue(tx)) ) if parent == hash => { - tx.send(Ok(Vec::new())).unwrap(); + tx.send(Ok(BTreeMap::new())).unwrap(); } ); diff --git a/polkadot/node/core/provisioner/Cargo.toml b/polkadot/node/core/provisioner/Cargo.toml index ec1a4abb3ece0a3dc8a01e090f9bf3302dde3294..5869e494c70ff40365397d3ffa104f5bad6c421e 100644 --- a/polkadot/node/core/provisioner/Cargo.toml +++ b/polkadot/node/core/provisioner/Cargo.toml @@ -10,21 +10,21 @@ license.workspace = true workspace = true [dependencies] -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } +bitvec = { features = ["alloc"], workspace = true } +futures = { workspace = true } +gum = { workspace = true, default-features = true } thiserror = { workspace = true } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -futures-timer = "3.0.2" -fatality = "0.0.6" -schnellru = "0.2.1" +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +futures-timer = { workspace = true } +fatality = { workspace = true } +schnellru = { workspace = true } [dev-dependencies] -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } -rstest = "0.18.2" +sp-application-crypto = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +rstest = { workspace = true } diff --git a/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs b/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs index f6c49e52eeb981d6a6a22a6d9a85301933d3fde4..ecb7aac78396c8769170ca720addf91f056e09bc 100644 --- a/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs +++ b/polkadot/node/core/provisioner/src/disputes/prioritized_selection/tests.rs @@ -29,7 +29,6 @@ use polkadot_primitives::{ CandidateHash, DisputeState, InvalidDisputeStatementKind, SessionIndex, ValidDisputeStatementKind, ValidatorSignature, }; -use test_helpers; // // Unit tests for various functions @@ -428,7 +427,7 @@ impl TestDisputes { let onchain_votes_count = self.validators_count * 80 / 100; let session_idx = 0; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -446,7 +445,7 @@ impl TestDisputes { let onchain_votes_count = self.validators_count * 40 / 100; let session_idx = 1; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -463,7 +462,7 @@ impl TestDisputes { let local_votes_count = self.validators_count * 90 / 100; let session_idx = 2; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Confirmed); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -479,7 +478,7 @@ impl TestDisputes { let onchain_votes_count = self.validators_count * 75 / 100; let session_idx = 3; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::ConcludedFor(0)); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -495,7 +494,7 @@ impl TestDisputes { let local_votes_count = self.validators_count * 90 / 100; let session_idx = 4; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::ConcludedFor(0)); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -511,7 +510,7 @@ impl TestDisputes { let onchain_votes_count = self.validators_count * 10 / 100; let session_idx = 5; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -528,7 +527,7 @@ impl TestDisputes { let local_votes_count = self.validators_count * 10 / 100; let session_idx = 6; let lf = leaf(); - let dummy_receipt = test_helpers::dummy_candidate_receipt(lf.hash); + let dummy_receipt = polkadot_primitives_test_helpers::dummy_candidate_receipt(lf.hash); for _ in 0..dispute_count { let d = (session_idx, CandidateHash(Hash::random()), DisputeStatus::Active); self.add_offchain_dispute(d, local_votes_count, dummy_receipt.clone()); @@ -547,7 +546,7 @@ impl TestDisputes { .map(|idx| { ( ValidatorIndex(idx as u32), - (statement_kind.clone(), test_helpers::dummy_signature()), + (statement_kind.clone(), polkadot_primitives_test_helpers::dummy_signature()), ) }) .collect::>() diff --git a/polkadot/node/core/provisioner/src/lib.rs b/polkadot/node/core/provisioner/src/lib.rs index 5cfcb96dc2bc710c42400fa49fa888195c79aa48..ffc5859b7756cad5a2818138d6c8921a617f36ea 100644 --- a/polkadot/node/core/provisioner/src/lib.rs +++ b/polkadot/node/core/provisioner/src/lib.rs @@ -273,7 +273,7 @@ async fn handle_communication( let span = state.span.child("provisionable-data"); let _timer = metrics.time_provisionable_data(); - gum::trace!(target: LOG_TARGET, ?relay_parent, "Received provisionable data."); + gum::trace!(target: LOG_TARGET, ?relay_parent, "Received provisionable data: {:?}", &data); note_provisionable_data(state, &span, data); } @@ -794,9 +794,11 @@ async fn select_candidates( relay_parent: Hash, sender: &mut impl overseer::ProvisionerSenderTrait, ) -> Result, Error> { - gum::trace!(target: LOG_TARGET, + gum::trace!( + target: LOG_TARGET, leaf_hash=?relay_parent, - "before GetBackedCandidates"); + "before GetBackedCandidates" + ); let selected_candidates = match prospective_parachains_mode { ProspectiveParachainsMode::Enabled { .. } => @@ -822,7 +824,7 @@ async fn select_candidates( // now get the backed candidates corresponding to these candidate receipts let (tx, rx) = oneshot::channel(); - sender.send_unbounded_message(CandidateBackingMessage::GetBackedCandidates( + sender.send_unbounded_message(CandidateBackingMessage::GetBackableCandidates( selected_candidates.clone(), tx, )); @@ -877,7 +879,7 @@ async fn get_block_number_under_construction( } /// Requests backable candidates from Prospective Parachains based on -/// the given ancestors in the fragment tree. The ancestors may not be ordered. +/// the given ancestors in the fragment chain. The ancestors may not be ordered. async fn get_backable_candidates( relay_parent: Hash, para_id: ParaId, diff --git a/polkadot/node/core/provisioner/src/tests.rs b/polkadot/node/core/provisioner/src/tests.rs index d463b7f1663374618621d5ffb3a491feeab69ddc..b38459302c8f18721b4ceb0515fdeac3d116cea8 100644 --- a/polkadot/node/core/provisioner/src/tests.rs +++ b/polkadot/node/core/provisioner/src/tests.rs @@ -15,9 +15,9 @@ // along with Polkadot. If not, see . use super::*; -use ::test_helpers::{dummy_candidate_descriptor, dummy_hash}; use bitvec::bitvec; use polkadot_primitives::{OccupiedCore, ScheduledCore}; +use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash}; const MOCK_GROUP_SIZE: usize = 5; @@ -244,7 +244,6 @@ mod select_candidates { super::*, build_occupied_core, common::test_harness, default_bitvec, occupied_core, scheduled_core, MOCK_GROUP_SIZE, }; - use ::test_helpers::{dummy_candidate_descriptor, dummy_hash}; use futures::channel::mpsc; use polkadot_node_subsystem::messages::{ AllMessages, RuntimeApiMessage, @@ -257,6 +256,7 @@ mod select_candidates { use polkadot_primitives::{ BlockNumber, CandidateCommitments, CommittedCandidateReceipt, PersistedValidationData, }; + use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash}; use rstest::rstest; use std::ops::Not; use CoreState::{Free, Scheduled}; @@ -578,7 +578,7 @@ mod select_candidates { )) => tx.send(Ok(Some(Default::default()))).unwrap(), AllMessages::RuntimeApi(Request(_parent_hash, AvailabilityCores(tx))) => tx.send(Ok(mock_availability_cores.clone())).unwrap(), - AllMessages::CandidateBacking(CandidateBackingMessage::GetBackedCandidates( + AllMessages::CandidateBacking(CandidateBackingMessage::GetBackableCandidates( hashes, sender, )) => { diff --git a/polkadot/node/core/pvf-checker/Cargo.toml b/polkadot/node/core/pvf-checker/Cargo.toml index 91b12b8680977fba345e0ccfa9b06f1bcb24ef79..73ef17a2843aedcffc40c6456d5519e62265b605 100644 --- a/polkadot/node/core/pvf-checker/Cargo.toml +++ b/polkadot/node/core/pvf-checker/Cargo.toml @@ -10,24 +10,24 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" +futures = { workspace = true } thiserror = { workspace = true } -gum = { package = "tracing-gum", path = "../../gum" } +gum = { workspace = true, default-features = true } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-overseer = { path = "../../overseer" } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } +sp-keystore = { workspace = true, default-features = true } [dev-dependencies] -sp-core = { path = "../../../../substrate/primitives/core" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -futures-timer = "3.0.2" +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +sp-application-crypto = { workspace = true, default-features = true } +futures-timer = { workspace = true } diff --git a/polkadot/node/core/pvf-checker/src/tests.rs b/polkadot/node/core/pvf-checker/src/tests.rs index b2365fe53e52c0f2e1c7cb18768c33cdd6801ca9..e12a44ddd2afc3f253063875b78b96d7f414116e 100644 --- a/polkadot/node/core/pvf-checker/src/tests.rs +++ b/polkadot/node/core/pvf-checker/src/tests.rs @@ -14,7 +14,6 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use ::test_helpers::{dummy_digest, dummy_hash, validator_pubkeys}; use futures::{channel::oneshot, future::BoxFuture, prelude::*}; use polkadot_node_subsystem::{ messages::{ @@ -30,6 +29,7 @@ use polkadot_primitives::{ BlockNumber, Hash, Header, PvfCheckStatement, SessionIndex, ValidationCode, ValidationCodeHash, ValidatorId, }; +use polkadot_primitives_test_helpers::{dummy_digest, dummy_hash, validator_pubkeys}; use sp_application_crypto::AppCrypto; use sp_core::testing::TaskExecutor; use sp_keyring::Sr25519Keyring; diff --git a/polkadot/node/core/pvf/Cargo.toml b/polkadot/node/core/pvf/Cargo.toml index 9666206b1e7dcb053c39353c46c1613f062866be..d603af04bf061fc16dfb00979e3aaf85b21adb60 100644 --- a/polkadot/node/core/pvf/Cargo.toml +++ b/polkadot/node/core/pvf/Cargo.toml @@ -10,60 +10,60 @@ license.workspace = true workspace = true [dependencies] -always-assert = "0.1" -array-bytes = "6.2.2" -blake3 = "1.5" -cfg-if = "1.0" -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } -is_executable = { version = "1.0.1", optional = true } -pin-project = "1.0.9" -rand = "0.8.5" -slotmap = "1.0" -tempfile = "3.3.0" +always-assert = { workspace = true } +array-bytes = { workspace = true, default-features = true } +blake3 = { workspace = true } +cfg-if = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +is_executable = { optional = true, workspace = true } +pin-project = { workspace = true } +rand = { workspace = true, default-features = true } +slotmap = { workspace = true } +tempfile = { workspace = true } thiserror = { workspace = true } -tokio = { version = "1.24.2", features = ["fs", "process"] } +tokio = { features = ["fs", "process"], workspace = true, default-features = true } -parity-scale-codec = { version = "3.6.1", default-features = false, features = [ +codec = { features = [ "derive", -] } +], workspace = true } -polkadot-parachain-primitives = { path = "../../../parachain" } -polkadot-core-primitives = { path = "../../../core-primitives" } -polkadot-node-core-pvf-common = { path = "common" } -polkadot-node-metrics = { path = "../../metrics" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-primitives = { path = "../../../primitives" } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-node-core-pvf-common = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-maybe-compressed-blob = { path = "../../../../substrate/primitives/maybe-compressed-blob", optional = true } -polkadot-node-core-pvf-prepare-worker = { path = "prepare-worker", optional = true } -polkadot-node-core-pvf-execute-worker = { path = "execute-worker", optional = true } +sp-core = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { optional = true, workspace = true, default-features = true } +polkadot-node-core-pvf-prepare-worker = { optional = true, workspace = true, default-features = true } +polkadot-node-core-pvf-execute-worker = { optional = true, workspace = true, default-features = true } [dev-dependencies] -assert_matches = "1.4.0" -criterion = { version = "0.5.1", default-features = false, features = [ +assert_matches = { workspace = true } +criterion = { features = [ "async_tokio", "cargo_bench_support", -] } -hex-literal = "0.4.1" +], workspace = true } +hex-literal = { workspace = true, default-features = true } -polkadot-node-core-pvf-common = { path = "common", features = ["test-utils"] } +polkadot-node-core-pvf-common = { features = ["test-utils"], workspace = true, default-features = true } # For benches and integration tests, depend on ourselves with the test-utils # feature. -polkadot-node-core-pvf = { path = "", features = ["test-utils"] } -rococo-runtime = { path = "../../../runtime/rococo" } +polkadot-node-core-pvf = { features = ["test-utils"], workspace = true, default-features = true } +rococo-runtime = { workspace = true } -adder = { package = "test-parachain-adder", path = "../../../parachain/test-parachains/adder" } -halt = { package = "test-parachain-halt", path = "../../../parachain/test-parachains/halt" } +test-parachain-adder = { workspace = true } +test-parachain-halt = { workspace = true } [target.'cfg(target_os = "linux")'.dev-dependencies] -libc = "0.2.153" +libc = "0.2.155" procfs = "0.16.0" rusty-fork = "0.3.0" -sc-sysinfo = { path = "../../../../substrate/client/sysinfo" } +sc-sysinfo = { workspace = true, default-features = true } [[bench]] name = "host_prepare_rococo_runtime" diff --git a/polkadot/node/core/pvf/benches/host_prepare_rococo_runtime.rs b/polkadot/node/core/pvf/benches/host_prepare_rococo_runtime.rs index 97a03e6596d16e2d10219331e58dd2d19647b531..342128b7cca21d5fd00544062e1cb35ba4126239 100644 --- a/polkadot/node/core/pvf/benches/host_prepare_rococo_runtime.rs +++ b/polkadot/node/core/pvf/benches/host_prepare_rococo_runtime.rs @@ -116,7 +116,7 @@ fn host_prepare_rococo_runtime(c: &mut Criterion) { cfg.prepare_workers_hard_max_num = 1; }) .await, - pvf.clone().code(), + pvf.clone().maybe_compressed_code(), ) }, |result| async move { diff --git a/polkadot/node/core/pvf/common/Cargo.toml b/polkadot/node/core/pvf/common/Cargo.toml index e1ce6e79cb99038bcdd183c32096432e8e8428be..903c8dd1af2970adca2ff4f62b8d243f87bc88e0 100644 --- a/polkadot/node/core/pvf/common/Cargo.toml +++ b/polkadot/node/core/pvf/common/Cargo.toml @@ -10,29 +10,27 @@ license.workspace = true workspace = true [dependencies] -cpu-time = "1.0.0" -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../../gum" } -libc = "0.2.152" -nix = { version = "0.27.1", features = ["resource", "sched"] } +cpu-time = { workspace = true } +futures = { workspace = true } +gum = { workspace = true, default-features = true } +libc = { workspace = true } +nix = { features = ["resource", "sched"], workspace = true } thiserror = { workspace = true } -parity-scale-codec = { version = "3.6.1", default-features = false, features = [ - "derive", -] } +codec = { features = ["derive"], workspace = true } -polkadot-parachain-primitives = { path = "../../../../parachain" } -polkadot-primitives = { path = "../../../../primitives" } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } -sc-executor = { path = "../../../../../substrate/client/executor" } -sc-executor-common = { path = "../../../../../substrate/client/executor/common" } -sc-executor-wasmtime = { path = "../../../../../substrate/client/executor/wasmtime" } +sc-executor = { workspace = true, default-features = true } +sc-executor-common = { workspace = true, default-features = true } +sc-executor-wasmtime = { workspace = true, default-features = true } -sp-core = { path = "../../../../../substrate/primitives/core" } -sp-crypto-hashing = { path = "../../../../../substrate/primitives/crypto/hashing" } -sp-externalities = { path = "../../../../../substrate/primitives/externalities" } -sp-io = { path = "../../../../../substrate/primitives/io" } -sp-tracing = { path = "../../../../../substrate/primitives/tracing" } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-externalities = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } [target.'cfg(target_os = "linux")'.dependencies] landlock = "0.3.0" @@ -41,8 +39,10 @@ landlock = "0.3.0" seccompiler = "0.4.0" [dev-dependencies] -assert_matches = "1.4.0" -tempfile = "3.3.0" +assert_matches = { workspace = true } + +[target.'cfg(target_os = "linux")'.dev-dependencies] +tempfile = { workspace = true } [features] # This feature is used to export test code to other crates without putting it in the production build. diff --git a/polkadot/node/core/pvf/common/src/error.rs b/polkadot/node/core/pvf/common/src/error.rs index adeb40c0b1958df624662f8e7533b6d06f49f543..b0cdba9501dbeec396c2262da8d02f2627992ed0 100644 --- a/polkadot/node/core/pvf/common/src/error.rs +++ b/polkadot/node/core/pvf/common/src/error.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::prepare::{PrepareSuccess, PrepareWorkerSuccess}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; pub use sc_executor_common::error::Error as ExecuteError; /// Result of PVF preparation from a worker, with checksum of the compiled PVF and stats of the @@ -94,6 +94,10 @@ pub enum PrepareError { #[codec(index = 11)] #[error("prepare: error interfacing with the kernel: {0}")] Kernel(String), + /// Code blob failed to decompress + #[codec(index = 12)] + #[error("prepare: could not decompress code blob: {0}")] + CouldNotDecompressCodeBlob(String), } impl PrepareError { @@ -106,7 +110,11 @@ impl PrepareError { pub fn is_deterministic(&self) -> bool { use PrepareError::*; match self { - Prevalidation(_) | Preparation(_) | JobError(_) | OutOfMemory => true, + Prevalidation(_) | + Preparation(_) | + JobError(_) | + OutOfMemory | + CouldNotDecompressCodeBlob(_) => true, IoErr(_) | JobDied { .. } | CreateTmpFile(_) | diff --git a/polkadot/node/core/pvf/common/src/execute.rs b/polkadot/node/core/pvf/common/src/execute.rs index ae6096cacec457a209d656541999f915f4dbbc3b..cff3f3b86e95265956ef935427a570e8565a7d7f 100644 --- a/polkadot/node/core/pvf/common/src/execute.rs +++ b/polkadot/node/core/pvf/common/src/execute.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::error::InternalValidationError; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_parachain_primitives::primitives::ValidationResult; use polkadot_primitives::ExecutorParams; use std::time::Duration; @@ -35,6 +35,8 @@ pub struct WorkerResponse { pub job_response: JobResponse, /// The amount of CPU time taken by the job. pub duration: Duration, + /// The uncompressed PoV size. + pub pov_size: u32, } /// An error occurred in the worker process. @@ -77,6 +79,8 @@ pub enum JobResponse { RuntimeConstruction(String), /// The candidate is invalid. InvalidCandidate(String), + /// PoV decompression failed + PoVDecompressionFailure, } impl JobResponse { diff --git a/polkadot/node/core/pvf/common/src/executor_interface.rs b/polkadot/node/core/pvf/common/src/executor_interface.rs index 252e611db8a488cff776b5d7863c987318e7e013..47f9ed1604e781c045ea643d251da8e324c98287 100644 --- a/polkadot/node/core/pvf/common/src/executor_interface.rs +++ b/polkadot/node/core/pvf/common/src/executor_interface.rs @@ -215,19 +215,19 @@ type HostFunctions = ( struct ValidationExternalities(sp_externalities::Extensions); impl sp_externalities::Externalities for ValidationExternalities { - fn storage(&self, _: &[u8]) -> Option> { + fn storage(&mut self, _: &[u8]) -> Option> { panic!("storage: unsupported feature for parachain validation") } - fn storage_hash(&self, _: &[u8]) -> Option> { + fn storage_hash(&mut self, _: &[u8]) -> Option> { panic!("storage_hash: unsupported feature for parachain validation") } - fn child_storage_hash(&self, _: &ChildInfo, _: &[u8]) -> Option> { + fn child_storage_hash(&mut self, _: &ChildInfo, _: &[u8]) -> Option> { panic!("child_storage_hash: unsupported feature for parachain validation") } - fn child_storage(&self, _: &ChildInfo, _: &[u8]) -> Option> { + fn child_storage(&mut self, _: &ChildInfo, _: &[u8]) -> Option> { panic!("child_storage: unsupported feature for parachain validation") } @@ -275,11 +275,11 @@ impl sp_externalities::Externalities for ValidationExternalities { panic!("child_storage_root: unsupported feature for parachain validation") } - fn next_child_storage_key(&self, _: &ChildInfo, _: &[u8]) -> Option> { + fn next_child_storage_key(&mut self, _: &ChildInfo, _: &[u8]) -> Option> { panic!("next_child_storage_key: unsupported feature for parachain validation") } - fn next_storage_key(&self, _: &[u8]) -> Option> { + fn next_storage_key(&mut self, _: &[u8]) -> Option> { panic!("next_storage_key: unsupported feature for parachain validation") } @@ -372,7 +372,7 @@ impl sp_core::traits::ReadRuntimeVersion for ReadRuntimeVersion { .map_err(|e| format!("Failed to read the static section from the PVF blob: {:?}", e))? { Some(version) => { - use parity_scale_codec::Encode; + use codec::Encode; Ok(version.encode()) }, None => Err("runtime version section is not found".to_string()), diff --git a/polkadot/node/core/pvf/common/src/lib.rs b/polkadot/node/core/pvf/common/src/lib.rs index 0cd928201639636bd1e5725685e97ea57361313a..30d0aa4452811e76fa417c36c9ac395d5f5ae62d 100644 --- a/polkadot/node/core/pvf/common/src/lib.rs +++ b/polkadot/node/core/pvf/common/src/lib.rs @@ -32,7 +32,7 @@ pub use sp_tracing; const LOG_TARGET: &str = "parachain::pvf-common"; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use std::{ io::{self, Read, Write}, mem, diff --git a/polkadot/node/core/pvf/common/src/prepare.rs b/polkadot/node/core/pvf/common/src/prepare.rs index 28ab682ec136d962364019f2623f80d8e7ad6194..4cd1beb309918b1dedb7e3a0e7ee2dd03794c50d 100644 --- a/polkadot/node/core/pvf/common/src/prepare.rs +++ b/polkadot/node/core/pvf/common/src/prepare.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use std::path::PathBuf; /// Result from prepare worker if successful. @@ -31,6 +31,8 @@ pub struct PrepareWorkerSuccess { pub struct PrepareSuccess { /// Canonical path to the compiled artifact. pub path: PathBuf, + /// Size in bytes + pub size: u64, /// Stats of the current preparation run. pub stats: PrepareStats, } @@ -42,6 +44,8 @@ pub struct PrepareStats { pub cpu_time_elapsed: std::time::Duration, /// The observed memory statistics for the preparation job. pub memory_stats: MemoryStats, + /// The decompressed Wasm code length observed during the preparation. + pub observed_wasm_code_len: u32, } /// Helper struct to contain all the memory stats, including `MemoryAllocationStats` and, if diff --git a/polkadot/node/core/pvf/common/src/pvf.rs b/polkadot/node/core/pvf/common/src/pvf.rs index 5f248f49b9a381c9f250f911bc1989518280c6de..4019a8d8b0d0031a1a44b345b59124a994606d32 100644 --- a/polkadot/node/core/pvf/common/src/pvf.rs +++ b/polkadot/node/core/pvf/common/src/pvf.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::prepare::PrepareJobKind; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_parachain_primitives::primitives::ValidationCodeHash; use polkadot_primitives::ExecutorParams; use std::{fmt, sync::Arc, time::Duration}; @@ -26,9 +26,9 @@ use std::{fmt, sync::Arc, time::Duration}; /// Should be cheap to clone. #[derive(Clone, Encode, Decode)] pub struct PvfPrepData { - /// Wasm code (uncompressed) - code: Arc>, - /// Wasm code hash + /// Wasm code (maybe compressed) + maybe_compressed_code: Arc>, + /// Wasm code hash. code_hash: ValidationCodeHash, /// Executor environment parameters for the session for which artifact is prepared executor_params: Arc, @@ -46,20 +46,20 @@ impl PvfPrepData { prep_timeout: Duration, prep_kind: PrepareJobKind, ) -> Self { - let code = Arc::new(code); - let code_hash = sp_crypto_hashing::blake2_256(&code).into(); + let maybe_compressed_code = Arc::new(code); + let code_hash = sp_crypto_hashing::blake2_256(&maybe_compressed_code).into(); let executor_params = Arc::new(executor_params); - Self { code, code_hash, executor_params, prep_timeout, prep_kind } + Self { maybe_compressed_code, code_hash, executor_params, prep_timeout, prep_kind } } - /// Returns validation code hash for the PVF + /// Returns validation code hash pub fn code_hash(&self) -> ValidationCodeHash { self.code_hash } - /// Returns PVF code - pub fn code(&self) -> Arc> { - self.code.clone() + /// Returns PVF code blob + pub fn maybe_compressed_code(&self) -> Arc> { + self.maybe_compressed_code.clone() } /// Returns executor params diff --git a/polkadot/node/core/pvf/common/src/worker/mod.rs b/polkadot/node/core/pvf/common/src/worker/mod.rs index 67e7bece407d13b012d85ee28bd369fc585a6c6f..70dcf055a2628707e8b70f98a0ab460074832da9 100644 --- a/polkadot/node/core/pvf/common/src/worker/mod.rs +++ b/polkadot/node/core/pvf/common/src/worker/mod.rs @@ -21,10 +21,10 @@ pub mod security; use crate::{ framed_recv_blocking, framed_send_blocking, SecurityStatus, WorkerHandshake, LOG_TARGET, }; +use codec::{Decode, Encode}; use cpu_time::ProcessTime; use futures::never::Never; use nix::{errno::Errno, sys::resource::Usage}; -use parity_scale_codec::{Decode, Encode}; use std::{ any::Any, fmt::{self}, diff --git a/polkadot/node/core/pvf/execute-worker/Cargo.toml b/polkadot/node/core/pvf/execute-worker/Cargo.toml index 04a620573b2eceb311bdce67006e282778442191..6ad340d25612860f87469497c332079e11eda266 100644 --- a/polkadot/node/core/pvf/execute-worker/Cargo.toml +++ b/polkadot/node/core/pvf/execute-worker/Cargo.toml @@ -10,17 +10,20 @@ license.workspace = true workspace = true [dependencies] -cpu-time = "1.0.0" -gum = { package = "tracing-gum", path = "../../../gum" } -cfg-if = "1.0" -nix = { version = "0.27.1", features = ["process", "resource", "sched"] } -libc = "0.2.152" +cpu-time = { workspace = true } +gum = { workspace = true, default-features = true } +cfg-if = { workspace = true } +nix = { features = ["process", "resource", "sched"], workspace = true } +libc = { workspace = true } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } -polkadot-node-core-pvf-common = { path = "../common" } -polkadot-parachain-primitives = { path = "../../../../parachain" } -polkadot-primitives = { path = "../../../../primitives" } +polkadot-node-core-pvf-common = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } + +sp-maybe-compressed-blob = { workspace = true, default-features = true } [features] builder = [] diff --git a/polkadot/node/core/pvf/execute-worker/src/lib.rs b/polkadot/node/core/pvf/execute-worker/src/lib.rs index 55f5290bd87ee88ce55157a1988c63a2c9670bbf..4b7c167cc9ec322f070e9e964fecc5b782d68063 100644 --- a/polkadot/node/core/pvf/execute-worker/src/lib.rs +++ b/polkadot/node/core/pvf/execute-worker/src/lib.rs @@ -22,11 +22,13 @@ pub use polkadot_node_core_pvf_common::{ error::ExecuteError, executor_interface::execute_artifact, }; +use polkadot_parachain_primitives::primitives::ValidationParams; // NOTE: Initializing logging in e.g. tests will not have an effect in the workers, as they are // separate spawned processes. Run with e.g. `RUST_LOG=parachain::pvf-execute-worker=trace`. const LOG_TARGET: &str = "parachain::pvf-execute-worker"; +use codec::{Decode, Encode}; use cpu_time::ProcessTime; use nix::{ errno::Errno, @@ -36,7 +38,6 @@ use nix::{ }, unistd::{ForkResult, Pid}, }; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_core_pvf_common::{ error::InternalValidationError, execute::{Handshake, JobError, JobResponse, JobResult, WorkerError, WorkerResponse}, @@ -50,8 +51,9 @@ use polkadot_node_core_pvf_common::{ }, worker_dir, }; +use polkadot_node_primitives::{BlockData, PoV, POV_BOMB_LIMIT}; use polkadot_parachain_primitives::primitives::ValidationResult; -use polkadot_primitives::ExecutorParams; +use polkadot_primitives::{ExecutorParams, PersistedValidationData}; use std::{ io::{self, Read}, os::{ @@ -85,8 +87,23 @@ fn recv_execute_handshake(stream: &mut UnixStream) -> io::Result { Ok(handshake) } -fn recv_request(stream: &mut UnixStream) -> io::Result<(Vec, Duration)> { - let params = framed_recv_blocking(stream)?; +fn recv_request(stream: &mut UnixStream) -> io::Result<(PersistedValidationData, PoV, Duration)> { + let pvd = framed_recv_blocking(stream)?; + let pvd = PersistedValidationData::decode(&mut &pvd[..]).map_err(|_| { + io::Error::new( + io::ErrorKind::Other, + "execute pvf recv_request: failed to decode persisted validation data".to_string(), + ) + })?; + + let pov = framed_recv_blocking(stream)?; + let pov = PoV::decode(&mut &pov[..]).map_err(|_| { + io::Error::new( + io::ErrorKind::Other, + "execute pvf recv_request: failed to decode PoV".to_string(), + ) + })?; + let execution_timeout = framed_recv_blocking(stream)?; let execution_timeout = Duration::decode(&mut &execution_timeout[..]).map_err(|_| { io::Error::new( @@ -94,7 +111,7 @@ fn recv_request(stream: &mut UnixStream) -> io::Result<(Vec, Duration)> { "execute pvf recv_request: failed to decode duration".to_string(), ) })?; - Ok((params, execution_timeout)) + Ok((pvd, pov, execution_timeout)) } /// Sends an error to the host and returns the original error wrapped in `io::Error`. @@ -149,7 +166,7 @@ pub fn worker_entrypoint( let execute_thread_stack_size = max_stack_size(&executor_params); loop { - let (params, execution_timeout) = recv_request(&mut stream).map_err(|e| { + let (pvd, pov, execution_timeout) = recv_request(&mut stream).map_err(|e| { map_and_send_err!( e, InternalValidationError::HostCommunication, @@ -197,7 +214,33 @@ pub fn worker_entrypoint( let stream_fd = stream.as_raw_fd(); let compiled_artifact_blob = Arc::new(compiled_artifact_blob); - let params = Arc::new(params); + + let raw_block_data = + match sp_maybe_compressed_blob::decompress(&pov.block_data.0, POV_BOMB_LIMIT) { + Ok(data) => data, + Err(_) => { + send_result::( + &mut stream, + Ok(WorkerResponse { + job_response: JobResponse::PoVDecompressionFailure, + duration: Duration::ZERO, + pov_size: 0, + }), + worker_info, + )?; + continue; + }, + }; + + let pov_size = raw_block_data.len() as u32; + + let params = ValidationParams { + parent_head: pvd.parent_head.clone(), + block_data: BlockData(raw_block_data.to_vec()), + relay_parent_number: pvd.relay_parent_number, + relay_parent_storage_root: pvd.relay_parent_storage_root, + }; + let params = Arc::new(params.encode()); cfg_if::cfg_if! { if #[cfg(target_os = "linux")] { @@ -214,6 +257,7 @@ pub fn worker_entrypoint( worker_info, security_status.can_unshare_user_namespace_and_change_root, usage_before, + pov_size, )? } else { // Fall back to using fork. @@ -228,6 +272,7 @@ pub fn worker_entrypoint( execute_thread_stack_size, worker_info, usage_before, + pov_size, )? }; } else { @@ -242,6 +287,7 @@ pub fn worker_entrypoint( execute_thread_stack_size, worker_info, usage_before, + pov_size, )?; } } @@ -300,6 +346,7 @@ fn handle_clone( worker_info: &WorkerInfo, have_unshare_newuser: bool, usage_before: Usage, + pov_size: u32, ) -> io::Result> { use polkadot_node_core_pvf_common::worker::security; @@ -329,6 +376,7 @@ fn handle_clone( worker_info, child, usage_before, + pov_size, execution_timeout, ), Err(security::clone::Error::Clone(errno)) => @@ -347,6 +395,7 @@ fn handle_fork( execute_worker_stack_size: usize, worker_info: &WorkerInfo, usage_before: Usage, + pov_size: u32, ) -> io::Result> { // SAFETY: new process is spawned within a single threaded process. This invariant // is enforced by tests. @@ -367,6 +416,7 @@ fn handle_fork( worker_info, child, usage_before, + pov_size, execution_timeout, ), Err(errno) => Ok(Err(internal_error_from_errno("fork", errno))), @@ -513,6 +563,7 @@ fn handle_parent_process( worker_info: &WorkerInfo, job_pid: Pid, usage_before: Usage, + pov_size: u32, timeout: Duration, ) -> io::Result> { // the read end will wait until all write ends have been closed, @@ -578,7 +629,7 @@ fn handle_parent_process( )))); } - Ok(Ok(WorkerResponse { job_response, duration: cpu_tv })) + Ok(Ok(WorkerResponse { job_response, pov_size, duration: cpu_tv })) }, Err(job_error) => { gum::warn!( diff --git a/polkadot/node/core/pvf/prepare-worker/Cargo.toml b/polkadot/node/core/pvf/prepare-worker/Cargo.toml index 9ecf1c8af501130822fed983f4105c23f01c89a6..56235bd82192f2e671eb0b9e08006a186966a814 100644 --- a/polkadot/node/core/pvf/prepare-worker/Cargo.toml +++ b/polkadot/node/core/pvf/prepare-worker/Cargo.toml @@ -10,23 +10,25 @@ license.workspace = true workspace = true [dependencies] -blake3 = "1.5" -cfg-if = "1.0" -gum = { package = "tracing-gum", path = "../../../gum" } -libc = "0.2.152" -rayon = "1.5.1" -tracking-allocator = { package = "staging-tracking-allocator", path = "../../../tracking-allocator" } -tikv-jemalloc-ctl = { version = "0.5.0", optional = true } -tikv-jemallocator = { version = "0.5.0", optional = true } -nix = { version = "0.27.1", features = ["process", "resource", "sched"] } - -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } - -polkadot-node-core-pvf-common = { path = "../common" } -polkadot-primitives = { path = "../../../../primitives" } - -sc-executor-common = { path = "../../../../../substrate/client/executor/common" } -sc-executor-wasmtime = { path = "../../../../../substrate/client/executor/wasmtime" } +blake3 = { workspace = true } +cfg-if = { workspace = true } +gum = { workspace = true, default-features = true } +libc = { workspace = true } +rayon = { workspace = true } +tracking-allocator = { workspace = true, default-features = true } +tikv-jemalloc-ctl = { optional = true, workspace = true } +tikv-jemallocator = { optional = true, workspace = true } +nix = { features = ["process", "resource", "sched"], workspace = true } + +codec = { features = ["derive"], workspace = true } + +polkadot-node-core-pvf-common = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } + +sc-executor-common = { workspace = true, default-features = true } +sc-executor-wasmtime = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } [target.'cfg(target_os = "linux")'.dependencies] tikv-jemallocator = "0.5.0" @@ -41,9 +43,9 @@ jemalloc-allocator = [ ] [dev-dependencies] -criterion = { version = "0.5.1", default-features = false, features = ["cargo_bench_support"] } -rococo-runtime = { path = "../../../../runtime/rococo" } -sp-maybe-compressed-blob = { path = "../../../../../substrate/primitives/maybe-compressed-blob" } +criterion = { features = ["cargo_bench_support"], workspace = true } +rococo-runtime = { workspace = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } [[bench]] name = "prepare_rococo_runtime" diff --git a/polkadot/node/core/pvf/prepare-worker/benches/prepare_rococo_runtime.rs b/polkadot/node/core/pvf/prepare-worker/benches/prepare_rococo_runtime.rs index d531c90b64b578e31f42a13f2399b4343469fa6d..49b30dc33ceb7695f0c6aba19279d6ed870edb7b 100644 --- a/polkadot/node/core/pvf/prepare-worker/benches/prepare_rococo_runtime.rs +++ b/polkadot/node/core/pvf/prepare-worker/benches/prepare_rococo_runtime.rs @@ -24,7 +24,11 @@ use polkadot_primitives::ExecutorParams; use std::time::Duration; fn do_prepare_runtime(pvf: PvfPrepData) { - let blob = match prevalidate(&pvf.code()) { + let maybe_compressed_code = pvf.maybe_compressed_code(); + let raw_validation_code = + sp_maybe_compressed_blob::decompress(&maybe_compressed_code, usize::MAX).unwrap(); + + let blob = match prevalidate(&raw_validation_code) { Err(err) => panic!("{:?}", err), Ok(b) => b, }; diff --git a/polkadot/node/core/pvf/prepare-worker/src/lib.rs b/polkadot/node/core/pvf/prepare-worker/src/lib.rs index d1b218f48ae897fb663f8285521f251f8a6817d3..f8ebb6effcecdc4d3e71a95bbdaecfe51705352e 100644 --- a/polkadot/node/core/pvf/prepare-worker/src/lib.rs +++ b/polkadot/node/core/pvf/prepare-worker/src/lib.rs @@ -38,8 +38,9 @@ use polkadot_node_core_pvf_common::{ executor_interface::{prepare, prevalidate}, worker::{pipe2_cloexec, PipeFd, WorkerInfo}, }; +use polkadot_node_primitives::VALIDATION_CODE_BOMB_LIMIT; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_core_pvf_common::{ error::{PrepareError, PrepareWorkerResult}, executor_interface::create_runtime_from_artifact_bytes, @@ -105,6 +106,12 @@ impl AsRef<[u8]> for CompiledArtifact { } } +#[derive(Encode, Decode)] +pub struct PrepareOutcome { + pub compiled_artifact: CompiledArtifact, + pub observed_wasm_code_len: u32, +} + /// Get a worker request. fn recv_request(stream: &mut UnixStream) -> io::Result { let pvf = framed_recv_blocking(stream)?; @@ -294,14 +301,23 @@ pub fn worker_entrypoint( ); } -fn prepare_artifact(pvf: PvfPrepData) -> Result { - let blob = match prevalidate(&pvf.code()) { +fn prepare_artifact(pvf: PvfPrepData) -> Result { + let maybe_compressed_code = pvf.maybe_compressed_code(); + let raw_validation_code = + sp_maybe_compressed_blob::decompress(&maybe_compressed_code, VALIDATION_CODE_BOMB_LIMIT) + .map_err(|e| PrepareError::CouldNotDecompressCodeBlob(e.to_string()))?; + let observed_wasm_code_len = raw_validation_code.len() as u32; + + let blob = match prevalidate(&raw_validation_code) { Err(err) => return Err(PrepareError::Prevalidation(format!("{:?}", err))), Ok(b) => b, }; match prepare(blob, &pvf.executor_params()) { - Ok(compiled_artifact) => Ok(CompiledArtifact::new(compiled_artifact)), + Ok(compiled_artifact) => Ok(PrepareOutcome { + compiled_artifact: CompiledArtifact::new(compiled_artifact), + observed_wasm_code_len, + }), Err(err) => Err(PrepareError::Preparation(format!("{:?}", err))), } } @@ -322,6 +338,7 @@ fn runtime_construction_check( struct JobResponse { artifact: CompiledArtifact, memory_stats: MemoryStats, + observed_wasm_code_len: u32, } #[cfg(target_os = "linux")] @@ -500,11 +517,11 @@ fn handle_child_process( "prepare worker", move || { #[allow(unused_mut)] - let mut result = prepare_artifact(pvf); + let mut result = prepare_artifact(pvf).map(|o| (o,)); // Get the `ru_maxrss` stat. If supported, call getrusage for the thread. #[cfg(target_os = "linux")] - let mut result = result.map(|artifact| (artifact, get_max_rss_thread())); + let mut result = result.map(|outcome| (outcome.0, get_max_rss_thread())); // If we are pre-checking, check for runtime construction errors. // @@ -513,7 +530,10 @@ fn handle_child_process( // anyway. if let PrepareJobKind::Prechecking = prepare_job_kind { result = result.and_then(|output| { - runtime_construction_check(output.0.as_ref(), &executor_params)?; + runtime_construction_check( + output.0.compiled_artifact.as_ref(), + &executor_params, + )?; Ok(output) }); } @@ -553,9 +573,9 @@ fn handle_child_process( Ok(ok) => { cfg_if::cfg_if! { if #[cfg(target_os = "linux")] { - let (artifact, max_rss) = ok; + let (PrepareOutcome { compiled_artifact, observed_wasm_code_len }, max_rss) = ok; } else { - let artifact = ok; + let (PrepareOutcome { compiled_artifact, observed_wasm_code_len },) = ok; } } @@ -574,7 +594,11 @@ fn handle_child_process( peak_tracked_alloc: if peak_alloc > 0 { peak_alloc as u64 } else { 0u64 }, }; - Ok(JobResponse { artifact, memory_stats }) + Ok(JobResponse { + artifact: compiled_artifact, + observed_wasm_code_len, + memory_stats, + }) }, } }, @@ -665,7 +689,7 @@ fn handle_parent_process( match result { Err(err) => Err(err), - Ok(JobResponse { artifact, memory_stats }) => { + Ok(JobResponse { artifact, memory_stats, observed_wasm_code_len }) => { // The exit status should have been zero if no error occurred. if exit_status != 0 { return Err(PrepareError::JobError(format!( @@ -696,7 +720,11 @@ fn handle_parent_process( let checksum = blake3::hash(&artifact.as_ref()).to_hex().to_string(); Ok(PrepareWorkerSuccess { checksum, - stats: PrepareStats { memory_stats, cpu_time_elapsed: cpu_tv }, + stats: PrepareStats { + memory_stats, + cpu_time_elapsed: cpu_tv, + observed_wasm_code_len, + }, }) }, } diff --git a/polkadot/node/core/pvf/src/artifacts.rs b/polkadot/node/core/pvf/src/artifacts.rs index a3a48b61acb1743d2ed5df62457c6f9f4ba5fa79..119af34082a97f412a5a9135c1f92da3fd5ee9d9 100644 --- a/polkadot/node/core/pvf/src/artifacts.rs +++ b/polkadot/node/core/pvf/src/artifacts.rs @@ -142,6 +142,8 @@ pub enum ArtifactState { /// This is updated when we get the heads up for this artifact or when we just discover /// this file. last_time_needed: SystemTime, + /// Size in bytes + size: u64, /// Stats produced by successful preparation. prepare_stats: PrepareStats, }, @@ -169,6 +171,33 @@ pub struct Artifacts { inner: HashMap, } +/// Parameters we use to cleanup artifacts +/// After we hit the cache limit we remove the least used artifacts +/// but only if they are stale more than minimum stale time +#[derive(Debug)] +pub struct ArtifactsCleanupConfig { + // Max size in bytes. Reaching it the least used artefacts are deleted + cache_limit: u64, + // Inactive time after which artefact is allowed to be deleted + min_stale_time: Duration, +} + +impl Default for ArtifactsCleanupConfig { + fn default() -> Self { + Self { + cache_limit: 10 * 1024 * 1024 * 1024, // 10 GiB + min_stale_time: Duration::from_secs(24 * 60 * 60), // 24 hours + } + } +} + +#[cfg(test)] +impl ArtifactsCleanupConfig { + pub fn new(cache_limit: u64, min_stale_time: Duration) -> Self { + Self { cache_limit, min_stale_time } + } +} + impl Artifacts { #[cfg(test)] pub(crate) fn empty() -> Self { @@ -180,6 +209,11 @@ impl Artifacts { self.inner.len() } + #[cfg(test)] + fn artifact_ids(&self) -> Vec { + self.inner.keys().cloned().collect() + } + /// Create an empty table and the cache directory on-disk if it doesn't exist. pub async fn new(cache_path: &Path) -> Self { // Make sure that the cache path directory and all its parents are created. @@ -234,12 +268,16 @@ impl Artifacts { artifact_id: ArtifactId, path: PathBuf, last_time_needed: SystemTime, + size: u64, prepare_stats: PrepareStats, ) { // See the precondition. always!(self .inner - .insert(artifact_id, ArtifactState::Prepared { path, last_time_needed, prepare_stats }) + .insert( + artifact_id, + ArtifactState::Prepared { path, last_time_needed, size, prepare_stats } + ) .is_none()); } @@ -251,25 +289,40 @@ impl Artifacts { }) } - /// Remove artifacts older than the given TTL and return id and path of the removed ones. - pub fn prune(&mut self, artifact_ttl: Duration) -> Vec<(ArtifactId, PathBuf)> { + /// Remove artifacts older than the given TTL when the total artifact size reaches the limit + /// and return id and path of the removed ones + pub fn prune(&mut self, cleanup_config: &ArtifactsCleanupConfig) -> Vec<(ArtifactId, PathBuf)> { + let mut to_remove = vec![]; let now = SystemTime::now(); - let mut to_remove = vec![]; + let mut total_size = 0; + let mut artifact_sizes = vec![]; + for (k, v) in self.inner.iter() { - if let ArtifactState::Prepared { last_time_needed, ref path, .. } = *v { - if now - .duration_since(last_time_needed) - .map(|age| age > artifact_ttl) - .unwrap_or(false) - { - to_remove.push((k.clone(), path.clone())); - } + if let ArtifactState::Prepared { ref path, last_time_needed, size, .. } = *v { + total_size += size; + artifact_sizes.push((k.clone(), path.clone(), size, last_time_needed)); } } + artifact_sizes + .sort_by_key(|&(_, _, _, last_time_needed)| std::cmp::Reverse(last_time_needed)); + + while total_size > cleanup_config.cache_limit { + let Some((artifact_id, path, size, last_time_needed)) = artifact_sizes.pop() else { + break + }; + + let used_recently = now + .duration_since(last_time_needed) + .map(|stale_time| stale_time < cleanup_config.min_stale_time) + .unwrap_or(true); + if used_recently { + break; + } - for artifact in &to_remove { - self.inner.remove(&artifact.0); + self.inner.remove(&artifact_id); + to_remove.push((artifact_id, path)); + total_size -= size; } to_remove @@ -278,6 +331,8 @@ impl Artifacts { #[cfg(test)] mod tests { + use crate::testing::artifact_id; + use super::*; #[tokio::test] @@ -307,4 +362,100 @@ mod tests { assert!(entries.contains(&String::from("worker-prepare-test"))); assert_eq!(artifacts.len(), 0); } + + #[tokio::test] + async fn test_pruned_by_cache_size() { + let mock_now = SystemTime::now(); + let tempdir = tempfile::tempdir().unwrap(); + let cache_path = tempdir.path(); + + let path1 = generate_artifact_path(cache_path); + let path2 = generate_artifact_path(cache_path); + let path3 = generate_artifact_path(cache_path); + let artifact_id1 = artifact_id(1); + let artifact_id2 = artifact_id(2); + let artifact_id3 = artifact_id(3); + + let mut artifacts = Artifacts::new(cache_path).await; + let cleanup_config = ArtifactsCleanupConfig::new(1500, Duration::from_secs(0)); + + artifacts.insert_prepared( + artifact_id1.clone(), + path1.clone(), + mock_now - Duration::from_secs(5), + 1024, + PrepareStats::default(), + ); + artifacts.insert_prepared( + artifact_id2.clone(), + path2.clone(), + mock_now - Duration::from_secs(10), + 1024, + PrepareStats::default(), + ); + artifacts.insert_prepared( + artifact_id3.clone(), + path3.clone(), + mock_now - Duration::from_secs(15), + 1024, + PrepareStats::default(), + ); + + let pruned = artifacts.prune(&cleanup_config); + + assert!(artifacts.artifact_ids().contains(&artifact_id1)); + assert!(!pruned.contains(&(artifact_id1, path1))); + assert!(!artifacts.artifact_ids().contains(&artifact_id2)); + assert!(pruned.contains(&(artifact_id2, path2))); + assert!(!artifacts.artifact_ids().contains(&artifact_id3)); + assert!(pruned.contains(&(artifact_id3, path3))); + } + + #[tokio::test] + async fn test_did_not_prune_by_cache_size_because_of_stale_time() { + let mock_now = SystemTime::now(); + let tempdir = tempfile::tempdir().unwrap(); + let cache_path = tempdir.path(); + + let path1 = generate_artifact_path(cache_path); + let path2 = generate_artifact_path(cache_path); + let path3 = generate_artifact_path(cache_path); + let artifact_id1 = artifact_id(1); + let artifact_id2 = artifact_id(2); + let artifact_id3 = artifact_id(3); + + let mut artifacts = Artifacts::new(cache_path).await; + let cleanup_config = ArtifactsCleanupConfig::new(1500, Duration::from_secs(12)); + + artifacts.insert_prepared( + artifact_id1.clone(), + path1.clone(), + mock_now - Duration::from_secs(5), + 1024, + PrepareStats::default(), + ); + artifacts.insert_prepared( + artifact_id2.clone(), + path2.clone(), + mock_now - Duration::from_secs(10), + 1024, + PrepareStats::default(), + ); + artifacts.insert_prepared( + artifact_id3.clone(), + path3.clone(), + mock_now - Duration::from_secs(15), + 1024, + PrepareStats::default(), + ); + + let pruned = artifacts.prune(&cleanup_config); + + assert!(artifacts.artifact_ids().contains(&artifact_id1)); + assert!(!pruned.contains(&(artifact_id1, path1))); + assert!(artifacts.artifact_ids().contains(&artifact_id2)); + assert!(!pruned.contains(&(artifact_id2, path2))); + assert!(!artifacts.artifact_ids().contains(&artifact_id3)); + assert!(pruned.contains(&(artifact_id3, path3))); + } } diff --git a/polkadot/node/core/pvf/src/error.rs b/polkadot/node/core/pvf/src/error.rs index 8dc96305eadb8f3ced1231889f5fa6c5ffaeac57..a0634106052d7fb197c0662854415190a59a0e70 100644 --- a/polkadot/node/core/pvf/src/error.rs +++ b/polkadot/node/core/pvf/src/error.rs @@ -52,6 +52,9 @@ pub enum InvalidCandidate { /// PVF execution (compilation is not included) took more time than was allotted. #[error("invalid: hard timeout")] HardTimeout, + /// Proof-of-validity failed to decompress correctly + #[error("invalid: PoV failed to decompress")] + PoVDecompressionFailure, } /// Possibly transient issue that may resolve after retries. diff --git a/polkadot/node/core/pvf/src/execute/queue.rs b/polkadot/node/core/pvf/src/execute/queue.rs index bb00a5a652d6434cd06327803d9ce51a3d5c1e93..11031bf1074a297e246a4e341efe8488a2692b1b 100644 --- a/polkadot/node/core/pvf/src/execute/queue.rs +++ b/polkadot/node/core/pvf/src/execute/queue.rs @@ -34,12 +34,14 @@ use polkadot_node_core_pvf_common::{ execute::{JobResponse, WorkerError, WorkerResponse}, SecurityStatus, }; -use polkadot_primitives::{ExecutorParams, ExecutorParamsHash}; +use polkadot_node_primitives::PoV; +use polkadot_primitives::{ExecutorParams, ExecutorParamsHash, PersistedValidationData}; use slotmap::HopSlotMap; use std::{ collections::VecDeque, fmt, path::PathBuf, + sync::Arc, time::{Duration, Instant}, }; @@ -68,7 +70,8 @@ pub enum FromQueue { #[derive(Debug)] pub struct PendingExecutionRequest { pub exec_timeout: Duration, - pub params: Vec, + pub pvd: Arc, + pub pov: Arc, pub executor_params: ExecutorParams, pub result_tx: ResultSender, } @@ -76,7 +79,8 @@ pub struct PendingExecutionRequest { struct ExecuteJob { artifact: ArtifactPathId, exec_timeout: Duration, - params: Vec, + pvd: Arc, + pov: Arc, executor_params: ExecutorParams, result_tx: ResultSender, waiting_since: Instant, @@ -293,18 +297,20 @@ async fn purge_dead(metrics: &Metrics, workers: &mut Workers) { fn handle_to_queue(queue: &mut Queue, to_queue: ToQueue) { let ToQueue::Enqueue { artifact, pending_execution_request } = to_queue; - let PendingExecutionRequest { exec_timeout, params, executor_params, result_tx } = + let PendingExecutionRequest { exec_timeout, pvd, pov, executor_params, result_tx } = pending_execution_request; gum::debug!( target: LOG_TARGET, validation_code_hash = ?artifact.id.code_hash, "enqueueing an artifact for execution", ); + queue.metrics.observe_pov_size(pov.block_data.0.len(), true); queue.metrics.execute_enqueued(); let job = ExecuteJob { artifact, exec_timeout, - params, + pvd, + pov, executor_params, result_tx, waiting_since: Instant::now(), @@ -352,15 +358,19 @@ async fn handle_job_finish( artifact_id: ArtifactId, result_tx: ResultSender, ) { - let (idle_worker, result, duration, sync_channel) = match worker_result { + let (idle_worker, result, duration, sync_channel, pov_size) = match worker_result { Ok(WorkerInterfaceResponse { worker_response: - WorkerResponse { job_response: JobResponse::Ok { result_descriptor }, duration }, + WorkerResponse { + job_response: JobResponse::Ok { result_descriptor }, + duration, + pov_size, + }, idle_worker, }) => { // TODO: propagate the soft timeout - (Some(idle_worker), Ok(result_descriptor), Some(duration), None) + (Some(idle_worker), Ok(result_descriptor), Some(duration), None, Some(pov_size)) }, Ok(WorkerInterfaceResponse { worker_response: WorkerResponse { job_response: JobResponse::InvalidCandidate(err), .. }, @@ -370,6 +380,18 @@ async fn handle_job_finish( Err(ValidationError::Invalid(InvalidCandidate::WorkerReportedInvalid(err))), None, None, + None, + ), + Ok(WorkerInterfaceResponse { + worker_response: + WorkerResponse { job_response: JobResponse::PoVDecompressionFailure, .. }, + idle_worker, + }) => ( + Some(idle_worker), + Err(ValidationError::Invalid(InvalidCandidate::PoVDecompressionFailure)), + None, + None, + None, ), Ok(WorkerInterfaceResponse { worker_response: @@ -393,39 +415,46 @@ async fn handle_job_finish( ))), None, Some(result_rx), + None, ) }, Err(WorkerInterfaceError::InternalError(err)) | Err(WorkerInterfaceError::WorkerError(WorkerError::InternalError(err))) => - (None, Err(ValidationError::Internal(err)), None, None), + (None, Err(ValidationError::Internal(err)), None, None, None), // Either the worker or the job timed out. Kill the worker in either case. Treated as // definitely-invalid, because if we timed out, there's no time left for a retry. Err(WorkerInterfaceError::HardTimeout) | Err(WorkerInterfaceError::WorkerError(WorkerError::JobTimedOut)) => - (None, Err(ValidationError::Invalid(InvalidCandidate::HardTimeout)), None, None), + (None, Err(ValidationError::Invalid(InvalidCandidate::HardTimeout)), None, None, None), // "Maybe invalid" errors (will retry). Err(WorkerInterfaceError::CommunicationErr(_err)) => ( None, Err(ValidationError::PossiblyInvalid(PossiblyInvalidError::AmbiguousWorkerDeath)), None, None, + None, ), Err(WorkerInterfaceError::WorkerError(WorkerError::JobDied { err, .. })) => ( None, Err(ValidationError::PossiblyInvalid(PossiblyInvalidError::AmbiguousJobDeath(err))), None, None, + None, ), Err(WorkerInterfaceError::WorkerError(WorkerError::JobError(err))) => ( None, Err(ValidationError::PossiblyInvalid(PossiblyInvalidError::JobError(err.to_string()))), None, None, + None, ), }; queue.metrics.execute_finished(); + if let Some(pov_size) = pov_size { + queue.metrics.observe_pov_size(pov_size as usize, false) + } if let Err(ref err) = result { gum::warn!( target: LOG_TARGET, @@ -573,7 +602,8 @@ fn assign(queue: &mut Queue, worker: Worker, job: ExecuteJob) { idle, job.artifact.clone(), job.exec_timeout, - job.params, + job.pvd, + job.pov, ) .await; QueueEvent::StartWork(worker, result, job.artifact.id, job.result_tx) diff --git a/polkadot/node/core/pvf/src/execute/worker_interface.rs b/polkadot/node/core/pvf/src/execute/worker_interface.rs index 9dcadfb4c2a73fbbb27532709de8dd410146fd11..77bd6bedd75c7f9932bc548d019870f87a1e201e 100644 --- a/polkadot/node/core/pvf/src/execute/worker_interface.rs +++ b/polkadot/node/core/pvf/src/execute/worker_interface.rs @@ -24,16 +24,17 @@ use crate::{ }, LOG_TARGET, }; +use codec::{Decode, Encode}; use futures::FutureExt; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_core_pvf_common::{ error::InternalValidationError, execute::{Handshake, WorkerError, WorkerResponse}, worker_dir, SecurityStatus, }; -use polkadot_primitives::ExecutorParams; -use std::{path::Path, time::Duration}; +use polkadot_node_primitives::PoV; +use polkadot_primitives::{ExecutorParams, PersistedValidationData}; +use std::{path::Path, sync::Arc, time::Duration}; use tokio::{io, net::UnixStream}; /// Spawns a new worker with the given program path that acts as the worker and the spawn timeout. @@ -123,7 +124,8 @@ pub async fn start_work( worker: IdleWorker, artifact: ArtifactPathId, execution_timeout: Duration, - validation_params: Vec, + pvd: Arc, + pov: Arc, ) -> Result { let IdleWorker { mut stream, pid, worker_dir } = worker; @@ -137,18 +139,16 @@ pub async fn start_work( ); with_worker_dir_setup(worker_dir, pid, &artifact.path, |worker_dir| async move { - send_request(&mut stream, &validation_params, execution_timeout).await.map_err( - |error| { - gum::warn!( - target: LOG_TARGET, - worker_pid = %pid, - validation_code_hash = ?artifact.id.code_hash, - "failed to send an execute request: {}", - error, - ); - Error::InternalError(InternalValidationError::HostCommunication(error.to_string())) - }, - )?; + send_request(&mut stream, pvd, pov, execution_timeout).await.map_err(|error| { + gum::warn!( + target: LOG_TARGET, + worker_pid = %pid, + validation_code_hash = ?artifact.id.code_hash, + "failed to send an execute request: {}", + error, + ); + Error::InternalError(InternalValidationError::HostCommunication(error.to_string())) + })?; // We use a generous timeout here. This is in addition to the one in the child process, in // case the child stalls. We have a wall clock timeout here in the host, but a CPU timeout @@ -288,10 +288,12 @@ async fn send_execute_handshake(stream: &mut UnixStream, handshake: Handshake) - async fn send_request( stream: &mut UnixStream, - validation_params: &[u8], + pvd: Arc, + pov: Arc, execution_timeout: Duration, ) -> io::Result<()> { - framed_send(stream, validation_params).await?; + framed_send(stream, &pvd.encode()).await?; + framed_send(stream, &pov.encode()).await?; framed_send(stream, &execution_timeout.encode()).await } diff --git a/polkadot/node/core/pvf/src/host.rs b/polkadot/node/core/pvf/src/host.rs index 4065598a3ac46c32b4d821aac7712f62767a973e..44a4cba2fbf864d16117ee98ff4034e2469f55a2 100644 --- a/polkadot/node/core/pvf/src/host.rs +++ b/polkadot/node/core/pvf/src/host.rs @@ -21,7 +21,7 @@ //! [`ValidationHost`], that allows communication with that event-loop. use crate::{ - artifacts::{ArtifactId, ArtifactPathId, ArtifactState, Artifacts}, + artifacts::{ArtifactId, ArtifactPathId, ArtifactState, Artifacts, ArtifactsCleanupConfig}, execute::{self, PendingExecutionRequest}, metrics::Metrics, prepare, Priority, SecurityStatus, ValidationError, LOG_TARGET, @@ -36,11 +36,14 @@ use polkadot_node_core_pvf_common::{ prepare::PrepareSuccess, pvf::PvfPrepData, }; +use polkadot_node_primitives::PoV; use polkadot_node_subsystem::{SubsystemError, SubsystemResult}; use polkadot_parachain_primitives::primitives::ValidationResult; +use polkadot_primitives::PersistedValidationData; use std::{ collections::HashMap, path::PathBuf, + sync::Arc, time::{Duration, SystemTime}, }; @@ -108,7 +111,8 @@ impl ValidationHost { &mut self, pvf: PvfPrepData, exec_timeout: Duration, - params: Vec, + pvd: Arc, + pov: Arc, priority: Priority, result_tx: ResultSender, ) -> Result<(), String> { @@ -116,7 +120,8 @@ impl ValidationHost { .send(ToHost::ExecutePvf(ExecutePvfInputs { pvf, exec_timeout, - params, + pvd, + pov, priority, result_tx, })) @@ -147,7 +152,8 @@ enum ToHost { struct ExecutePvfInputs { pvf: PvfPrepData, exec_timeout: Duration, - params: Vec, + pvd: Arc, + pov: Arc, priority: Priority, result_tx: ResultSender, } @@ -293,7 +299,7 @@ pub async fn start( let run_host = async move { run(Inner { cleanup_pulse_interval: Duration::from_secs(3600), - artifact_ttl: Duration::from_secs(3600 * 24), + cleanup_config: ArtifactsCleanupConfig::default(), artifacts, to_host_rx, to_prepare_queue_tx, @@ -337,7 +343,7 @@ impl AwaitingPrepare { struct Inner { cleanup_pulse_interval: Duration, - artifact_ttl: Duration, + cleanup_config: ArtifactsCleanupConfig, artifacts: Artifacts, to_host_rx: mpsc::Receiver, @@ -359,7 +365,7 @@ struct Fatal; async fn run( Inner { cleanup_pulse_interval, - artifact_ttl, + cleanup_config, mut artifacts, to_host_rx, from_prepare_queue_rx, @@ -415,7 +421,7 @@ async fn run( break_if_fatal!(handle_cleanup_pulse( &mut to_sweeper_tx, &mut artifacts, - artifact_ttl, + &cleanup_config, ).await); }, to_host = to_host_rx.next() => { @@ -539,7 +545,7 @@ async fn handle_execute_pvf( awaiting_prepare: &mut AwaitingPrepare, inputs: ExecutePvfInputs, ) -> Result<(), Fatal> { - let ExecutePvfInputs { pvf, exec_timeout, params, priority, result_tx } = inputs; + let ExecutePvfInputs { pvf, exec_timeout, pvd, pov, priority, result_tx } = inputs; let artifact_id = ArtifactId::from_pvf_prep_data(&pvf); let executor_params = (*pvf.executor_params()).clone(); @@ -558,7 +564,8 @@ async fn handle_execute_pvf( artifact: ArtifactPathId::new(artifact_id, path), pending_execution_request: PendingExecutionRequest { exec_timeout, - params, + pvd, + pov, executor_params, result_tx, }, @@ -587,7 +594,8 @@ async fn handle_execute_pvf( artifact_id, PendingExecutionRequest { exec_timeout, - params, + pvd, + pov, executor_params, result_tx, }, @@ -598,7 +606,7 @@ async fn handle_execute_pvf( ArtifactState::Preparing { .. } => { awaiting_prepare.add( artifact_id, - PendingExecutionRequest { exec_timeout, params, executor_params, result_tx }, + PendingExecutionRequest { exec_timeout, pvd, pov, executor_params, result_tx }, ); }, ArtifactState::FailedToProcess { last_time_failed, num_failures, error } => { @@ -627,7 +635,8 @@ async fn handle_execute_pvf( artifact_id, PendingExecutionRequest { exec_timeout, - params, + pvd, + pov, executor_params, result_tx, }, @@ -648,7 +657,7 @@ async fn handle_execute_pvf( pvf, priority, artifact_id, - PendingExecutionRequest { exec_timeout, params, executor_params, result_tx }, + PendingExecutionRequest { exec_timeout, pvd, pov, executor_params, result_tx }, ) .await?; } @@ -770,7 +779,7 @@ async fn handle_prepare_done( // It's finally time to dispatch all the execution requests that were waiting for this artifact // to be prepared. let pending_requests = awaiting_prepare.take(&artifact_id); - for PendingExecutionRequest { exec_timeout, params, executor_params, result_tx } in + for PendingExecutionRequest { exec_timeout, pvd, pov, executor_params, result_tx } in pending_requests { if result_tx.is_canceled() { @@ -793,7 +802,8 @@ async fn handle_prepare_done( artifact: ArtifactPathId::new(artifact_id.clone(), &path), pending_execution_request: PendingExecutionRequest { exec_timeout, - params, + pvd, + pov, executor_params, result_tx, }, @@ -803,8 +813,12 @@ async fn handle_prepare_done( } *state = match result { - Ok(PrepareSuccess { path, stats: prepare_stats }) => - ArtifactState::Prepared { path, last_time_needed: SystemTime::now(), prepare_stats }, + Ok(PrepareSuccess { path, stats: prepare_stats, size }) => ArtifactState::Prepared { + path, + last_time_needed: SystemTime::now(), + size, + prepare_stats, + }, Err(error) => { let last_time_failed = SystemTime::now(); let num_failures = *num_failures + 1; @@ -859,9 +873,9 @@ async fn enqueue_prepare_for_execute( async fn handle_cleanup_pulse( sweeper_tx: &mut mpsc::Sender, artifacts: &mut Artifacts, - artifact_ttl: Duration, + cleanup_config: &ArtifactsCleanupConfig, ) -> Result<(), Fatal> { - let to_remove = artifacts.prune(artifact_ttl); + let to_remove = artifacts.prune(cleanup_config); gum::debug!( target: LOG_TARGET, "PVF pruning: {} artifacts reached their end of life", @@ -959,10 +973,12 @@ fn pulse_every(interval: std::time::Duration) -> impl futures::Stream #[cfg(test)] pub(crate) mod tests { use super::*; - use crate::{artifacts::generate_artifact_path, PossiblyInvalidError}; + use crate::{artifacts::generate_artifact_path, testing::artifact_id, PossiblyInvalidError}; use assert_matches::assert_matches; use futures::future::BoxFuture; use polkadot_node_core_pvf_common::prepare::PrepareStats; + use polkadot_node_primitives::BlockData; + use sp_core::H256; const TEST_EXECUTION_TIMEOUT: Duration = Duration::from_secs(3); pub(crate) const TEST_PREPARATION_TIMEOUT: Duration = Duration::from_secs(30); @@ -981,14 +997,9 @@ pub(crate) mod tests { } } - /// Creates a new PVF which artifact id can be uniquely identified by the given number. - fn artifact_id(discriminator: u32) -> ArtifactId { - ArtifactId::from_pvf_prep_data(&PvfPrepData::from_discriminator(discriminator)) - } - struct Builder { cleanup_pulse_interval: Duration, - artifact_ttl: Duration, + cleanup_config: ArtifactsCleanupConfig, artifacts: Artifacts, } @@ -997,8 +1008,7 @@ pub(crate) mod tests { Self { // these are selected high to not interfere in tests in which pruning is irrelevant. cleanup_pulse_interval: Duration::from_secs(3600), - artifact_ttl: Duration::from_secs(3600), - + cleanup_config: ArtifactsCleanupConfig::default(), artifacts: Artifacts::empty(), } } @@ -1022,7 +1032,7 @@ pub(crate) mod tests { } impl Test { - fn new(Builder { cleanup_pulse_interval, artifact_ttl, artifacts }: Builder) -> Self { + fn new(Builder { cleanup_pulse_interval, artifacts, cleanup_config }: Builder) -> Self { let (to_host_tx, to_host_rx) = mpsc::channel(10); let (to_prepare_queue_tx, to_prepare_queue_rx) = mpsc::channel(10); let (from_prepare_queue_tx, from_prepare_queue_rx) = mpsc::unbounded(); @@ -1032,7 +1042,7 @@ pub(crate) mod tests { let run = run(Inner { cleanup_pulse_interval, - artifact_ttl, + cleanup_config, artifacts, to_host_rx, to_prepare_queue_tx, @@ -1183,19 +1193,21 @@ pub(crate) mod tests { let mut builder = Builder::default(); builder.cleanup_pulse_interval = Duration::from_millis(100); - builder.artifact_ttl = Duration::from_millis(500); + builder.cleanup_config = ArtifactsCleanupConfig::new(1024, Duration::from_secs(0)); let path1 = generate_artifact_path(cache_path); let path2 = generate_artifact_path(cache_path); builder.artifacts.insert_prepared( artifact_id(1), path1.clone(), mock_now, + 1024, PrepareStats::default(), ); builder.artifacts.insert_prepared( artifact_id(2), path2.clone(), mock_now, + 1024, PrepareStats::default(), ); let mut test = builder.build(); @@ -1223,12 +1235,21 @@ pub(crate) mod tests { async fn execute_pvf_requests() { let mut test = Builder::default().build(); let mut host = test.host_handle(); + let pvd = Arc::new(PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }); + let pov1 = Arc::new(PoV { block_data: BlockData(b"pov1".to_vec()) }); + let pov2 = Arc::new(PoV { block_data: BlockData(b"pov2".to_vec()) }); let (result_tx, result_rx_pvf_1_1) = oneshot::channel(); host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf1".to_vec(), + pvd.clone(), + pov1.clone(), Priority::Normal, result_tx, ) @@ -1239,7 +1260,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf1".to_vec(), + pvd.clone(), + pov1, Priority::Critical, result_tx, ) @@ -1250,7 +1272,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(2), TEST_EXECUTION_TIMEOUT, - b"pvf2".to_vec(), + pvd, + pov2, Priority::Normal, result_tx, ) @@ -1382,6 +1405,13 @@ pub(crate) mod tests { async fn test_prepare_done() { let mut test = Builder::default().build(); let mut host = test.host_handle(); + let pvd = Arc::new(PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }); + let pov = Arc::new(PoV { block_data: BlockData(b"pov".to_vec()) }); // Test mixed cases of receiving execute and precheck requests // for the same PVF. @@ -1391,7 +1421,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf2".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx, ) @@ -1438,7 +1469,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(2), TEST_EXECUTION_TIMEOUT, - b"pvf2".to_vec(), + pvd, + pov, Priority::Critical, result_tx, ) @@ -1534,13 +1566,21 @@ pub(crate) mod tests { async fn test_execute_prepare_retry() { let mut test = Builder::default().build(); let mut host = test.host_handle(); + let pvd = Arc::new(PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }); + let pov = Arc::new(PoV { block_data: BlockData(b"pov".to_vec()) }); // Submit a execute request that fails. let (result_tx, result_rx) = oneshot::channel(); host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx, ) @@ -1570,7 +1610,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx_2, ) @@ -1592,7 +1633,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx_3, ) @@ -1636,13 +1678,21 @@ pub(crate) mod tests { async fn test_execute_prepare_no_retry() { let mut test = Builder::default().build(); let mut host = test.host_handle(); + let pvd = Arc::new(PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }); + let pov = Arc::new(PoV { block_data: BlockData(b"pov".to_vec()) }); // Submit an execute request that fails. let (result_tx, result_rx) = oneshot::channel(); host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx, ) @@ -1672,7 +1722,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx_2, ) @@ -1694,7 +1745,8 @@ pub(crate) mod tests { host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf".to_vec(), + pvd.clone(), + pov.clone(), Priority::Critical, result_tx_3, ) @@ -1755,12 +1807,20 @@ pub(crate) mod tests { async fn cancellation() { let mut test = Builder::default().build(); let mut host = test.host_handle(); + let pvd = Arc::new(PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }); + let pov = Arc::new(PoV { block_data: BlockData(b"pov".to_vec()) }); let (result_tx, result_rx) = oneshot::channel(); host.execute_pvf( PvfPrepData::from_discriminator(1), TEST_EXECUTION_TIMEOUT, - b"pvf1".to_vec(), + pvd, + pov, Priority::Normal, result_tx, ) diff --git a/polkadot/node/core/pvf/src/metrics.rs b/polkadot/node/core/pvf/src/metrics.rs index bc8d300037fe8e1d7c70b575d99b101b8343e94b..c59cab4641805eca5dac8d60e554e21b79c97606 100644 --- a/polkadot/node/core/pvf/src/metrics.rs +++ b/polkadot/node/core/pvf/src/metrics.rs @@ -105,6 +105,21 @@ impl Metrics { .observe((memory_stats.peak_tracked_alloc / 1024) as f64); } } + + pub(crate) fn observe_code_size(&self, code_size: usize) { + if let Some(metrics) = &self.0 { + metrics.code_size.observe(code_size as f64); + } + } + + pub(crate) fn observe_pov_size(&self, pov_size: usize, compressed: bool) { + if let Some(metrics) = &self.0 { + metrics + .pov_size + .with_label_values(&[if compressed { "true" } else { "false" }]) + .observe(pov_size as f64); + } + } } #[derive(Clone)] @@ -129,6 +144,8 @@ struct MetricsInner { preparation_max_resident: prometheus::Histogram, // Peak allocation value, tracked by tracking-allocator preparation_peak_tracked_allocation: prometheus::Histogram, + pov_size: prometheus::HistogramVec, + code_size: prometheus::Histogram, } impl metrics::Metrics for Metrics { @@ -323,6 +340,35 @@ impl metrics::Metrics for Metrics { )?, registry, )?, + // The following metrics was moved here from the candidate valiidation subsystem. + // Names are kept to avoid breaking dashboards and stuff. + pov_size: prometheus::register( + prometheus::HistogramVec::new( + prometheus::HistogramOpts::new( + "polkadot_parachain_candidate_validation_pov_size", + "The compressed and decompressed size of the proof of validity of a candidate", + ) + .buckets( + prometheus::exponential_buckets(16384.0, 2.0, 10) + .expect("arguments are always valid; qed"), + ), + &["compressed"], + )?, + registry, + )?, + code_size: prometheus::register( + prometheus::Histogram::with_opts( + prometheus::HistogramOpts::new( + "polkadot_parachain_candidate_validation_code_size", + "The size of the decompressed WASM validation blob used for checking a candidate", + ) + .buckets( + prometheus::exponential_buckets(16384.0, 2.0, 10) + .expect("arguments are always valid; qed"), + ), + )?, + registry, + )?, }; Ok(Metrics(Some(inner))) } diff --git a/polkadot/node/core/pvf/src/prepare/worker_interface.rs b/polkadot/node/core/pvf/src/prepare/worker_interface.rs index d64ee1510cad79a4ed1df808668d203b5817121b..d29d2717c4b6e38239c8357a711a2899f4010274 100644 --- a/polkadot/node/core/pvf/src/prepare/worker_interface.rs +++ b/polkadot/node/core/pvf/src/prepare/worker_interface.rs @@ -25,7 +25,7 @@ use crate::{ }, LOG_TARGET, }; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_core_pvf_common::{ error::{PrepareError, PrepareResult, PrepareWorkerResult}, prepare::{PrepareStats, PrepareSuccess, PrepareWorkerSuccess}, @@ -211,7 +211,7 @@ async fn handle_response( // https://github.com/paritytech/polkadot-sdk/issues/2399 let PrepareWorkerSuccess { checksum: _, - stats: PrepareStats { cpu_time_elapsed, memory_stats }, + stats: PrepareStats { cpu_time_elapsed, memory_stats, observed_wasm_code_len }, } = match result.clone() { Ok(result) => result, // Timed out on the child. This should already be logged by the child. @@ -221,6 +221,8 @@ async fn handle_response( Err(err) => return Outcome::Concluded { worker, result: Err(err) }, }; + metrics.observe_code_size(observed_wasm_code_len as usize); + if cpu_time_elapsed > preparation_timeout { // The job didn't complete within the timeout. gum::warn!( @@ -234,6 +236,19 @@ async fn handle_response( return Outcome::TimedOut } + let size = match tokio::fs::metadata(cache_path).await { + Ok(metadata) => metadata.len(), + Err(err) => { + gum::warn!( + target: LOG_TARGET, + ?cache_path, + "failed to read size of the artifact: {}", + err, + ); + return Outcome::IoErr(err.to_string()) + }, + }; + // The file name should uniquely identify the artifact even across restarts. In case the cache // for some reason is not cleared correctly, we cannot // accidentally execute an artifact compiled under a different wasmtime version, host @@ -253,7 +268,12 @@ async fn handle_response( worker, result: Ok(PrepareSuccess { path: artifact_path, - stats: PrepareStats { cpu_time_elapsed, memory_stats: memory_stats.clone() }, + size, + stats: PrepareStats { + cpu_time_elapsed, + memory_stats: memory_stats.clone(), + observed_wasm_code_len, + }, }), }, Err(err) => { diff --git a/polkadot/node/core/pvf/src/testing.rs b/polkadot/node/core/pvf/src/testing.rs index 60b0b4b8d3d0c49199800194570d8ef2783fc67f..8c75dafa69c2554df5d7739ae4bfe9b1ccdf5c87 100644 --- a/polkadot/node/core/pvf/src/testing.rs +++ b/polkadot/node/core/pvf/src/testing.rs @@ -21,8 +21,9 @@ pub use crate::{ worker_interface::{spawn_with_program_path, SpawnErr}, }; -use crate::get_worker_version; +use crate::{artifacts::ArtifactId, get_worker_version}; use is_executable::IsExecutable; +use polkadot_node_core_pvf_common::pvf::PvfPrepData; use polkadot_node_primitives::NODE_VERSION; use polkadot_primitives::ExecutorParams; use std::{ @@ -126,3 +127,8 @@ pub fn build_workers_and_get_paths() -> (PathBuf, PathBuf) { let guard = mutex.lock().unwrap(); (guard.0.clone(), guard.1.clone()) } + +/// Creates a new PVF which artifact id can be uniquely identified by the given number. +pub fn artifact_id(discriminator: u32) -> ArtifactId { + ArtifactId::from_pvf_prep_data(&PvfPrepData::from_discriminator(discriminator)) +} diff --git a/polkadot/node/core/pvf/src/worker_interface.rs b/polkadot/node/core/pvf/src/worker_interface.rs index 93fffc80662266a6a1112f6d5120cb454bca6276..e63778d4692fb45f2c9ffd67ac1c6a07eab87a6d 100644 --- a/polkadot/node/core/pvf/src/worker_interface.rs +++ b/polkadot/node/core/pvf/src/worker_interface.rs @@ -17,9 +17,9 @@ //! Common logic for implementation of worker processes. use crate::LOG_TARGET; +use codec::Encode; use futures::FutureExt as _; use futures_timer::Delay; -use parity_scale_codec::Encode; use pin_project::pin_project; use polkadot_node_core_pvf_common::{SecurityStatus, WorkerHandshake}; use rand::Rng; diff --git a/polkadot/node/core/pvf/tests/it/adder.rs b/polkadot/node/core/pvf/tests/it/adder.rs index 9a7ddcb408909e6fcac2c812921174e81b7911bb..1a95a28fe07732f51d5a8bdd988ee51c79e66a3e 100644 --- a/polkadot/node/core/pvf/tests/it/adder.rs +++ b/polkadot/node/core/pvf/tests/it/adder.rs @@ -17,30 +17,34 @@ //! PVF host integration tests checking the chain production pipeline. use super::TestHost; -use adder::{hash_state, BlockData, HeadData}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; +use polkadot_node_primitives::PoV; use polkadot_parachain_primitives::primitives::{ - BlockData as GenericBlockData, HeadData as GenericHeadData, RelayChainBlockNumber, - ValidationParams, + BlockData as GenericBlockData, HeadData as GenericHeadData, }; +use polkadot_primitives::PersistedValidationData; +use sp_core::H256; +use test_parachain_adder::{hash_state, BlockData, HeadData}; #[tokio::test] async fn execute_good_block_on_parent() { let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) }; - let block_data = BlockData { state: 0, add: 512 }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; let host = TestHost::new().await; let ret = host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await @@ -63,18 +67,20 @@ async fn execute_good_chain_on_parent() { for (number, add) in (0..10).enumerate() { let parent_head = HeadData { number: number as u64, parent_hash, post_state: hash_state(last_state) }; - let block_data = BlockData { state: last_state, add }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; let ret = host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: number as RelayChainBlockNumber + 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await @@ -94,23 +100,25 @@ async fn execute_good_chain_on_parent() { #[tokio::test] async fn execute_bad_block_on_parent() { let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) }; - let block_data = BlockData { state: 256, // start state is wrong. add: 256, }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; let host = TestHost::new().await; let _err = host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await @@ -124,15 +132,18 @@ async fn stress_spawn() { async fn execute(host: std::sync::Arc) { let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) }; let block_data = BlockData { state: 0, add: 512 }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; let ret = host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await @@ -161,15 +172,18 @@ async fn execute_can_run_serially() { async fn execute(host: std::sync::Arc) { let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) }; let block_data = BlockData { state: 0, add: 512 }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; let ret = host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await diff --git a/polkadot/node/core/pvf/tests/it/main.rs b/polkadot/node/core/pvf/tests/it/main.rs index 6961b93832abed0d8608e8363a1fac3d2d510fdf..a4a0853189579ce96cf96d49f685c3de7de5af00 100644 --- a/polkadot/node/core/pvf/tests/it/main.rs +++ b/polkadot/node/core/pvf/tests/it/main.rs @@ -17,7 +17,6 @@ //! General PVF host integration tests checking the functionality of the PVF host itself. use assert_matches::assert_matches; -use parity_scale_codec::Encode as _; #[cfg(all(feature = "ci-only-tests", target_os = "linux"))] use polkadot_node_core_pvf::SecurityStatus; use polkadot_node_core_pvf::{ @@ -25,10 +24,14 @@ use polkadot_node_core_pvf::{ PossiblyInvalidError, PrepareError, PrepareJobKind, PvfPrepData, ValidationError, ValidationHost, JOB_TIMEOUT_WALL_CLOCK_FACTOR, }; -use polkadot_parachain_primitives::primitives::{BlockData, ValidationParams, ValidationResult}; -use polkadot_primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind}; +use polkadot_node_primitives::{PoV, POV_BOMB_LIMIT, VALIDATION_CODE_BOMB_LIMIT}; +use polkadot_parachain_primitives::primitives::{BlockData, ValidationResult}; +use polkadot_primitives::{ + ExecutorParam, ExecutorParams, PersistedValidationData, PvfExecKind, PvfPrepKind, +}; +use sp_core::H256; -use std::{io::Write, time::Duration}; +use std::{io::Write, sync::Arc, time::Duration}; use tokio::sync::Mutex; mod adder; @@ -80,9 +83,6 @@ impl TestHost { ) -> Result<(), PrepareError> { let (result_tx, result_rx) = futures::channel::oneshot::channel(); - let code = sp_maybe_compressed_blob::decompress(code, 16 * 1024 * 1024) - .expect("Compression works"); - self.host .lock() .await @@ -103,14 +103,12 @@ impl TestHost { async fn validate_candidate( &self, code: &[u8], - params: ValidationParams, + pvd: PersistedValidationData, + pov: PoV, executor_params: ExecutorParams, ) -> Result { let (result_tx, result_rx) = futures::channel::oneshot::channel(); - let code = sp_maybe_compressed_blob::decompress(code, 16 * 1024 * 1024) - .expect("Compression works"); - self.host .lock() .await @@ -122,7 +120,8 @@ impl TestHost { PrepareJobKind::Compilation, ), TEST_EXECUTION_TIMEOUT, - params.encode(), + Arc::new(pvd), + Arc::new(pov), polkadot_node_core_pvf::Priority::Normal, result_tx, ) @@ -159,19 +158,17 @@ async fn prepare_job_terminates_on_timeout() { #[tokio::test] async fn execute_job_terminates_on_timeout() { let host = TestHost::new().await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; let start = std::time::Instant::now(); let result = host - .validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, - Default::default(), - ) + .validate_candidate(test_parachain_halt::wasm_binary_unwrap(), pvd, pov, Default::default()) .await; match result { @@ -189,24 +186,23 @@ async fn execute_job_terminates_on_timeout() { async fn ensure_parallel_execution() { // Run some jobs that do not complete, thus timing out. let host = TestHost::new().await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; let execute_pvf_future_1 = host.validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_halt::wasm_binary_unwrap(), + pvd.clone(), + pov.clone(), Default::default(), ); let execute_pvf_future_2 = host.validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_halt::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ); @@ -237,6 +233,13 @@ async fn execute_queue_doesnt_stall_if_workers_died() { cfg.execute_workers_max_num = 5; }) .await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; // Here we spawn 8 validation jobs for the `halt` PVF and share those between 5 workers. The // first five jobs should timeout and the workers killed. For the next 3 jobs a new batch of @@ -244,13 +247,9 @@ async fn execute_queue_doesnt_stall_if_workers_died() { let start = std::time::Instant::now(); futures::future::join_all((0u8..=8).map(|_| { host.validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_halt::wasm_binary_unwrap(), + pvd.clone(), + pov.clone(), Default::default(), ) })) @@ -275,6 +274,13 @@ async fn execute_queue_doesnt_stall_with_varying_executor_params() { cfg.execute_workers_max_num = 2; }) .await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; let executor_params_1 = ExecutorParams::default(); let executor_params_2 = ExecutorParams::from(&[ExecutorParam::StackLogicalMax(1024)][..]); @@ -287,13 +293,9 @@ async fn execute_queue_doesnt_stall_with_varying_executor_params() { let start = std::time::Instant::now(); futures::future::join_all((0u8..6).map(|i| { host.validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_halt::wasm_binary_unwrap(), + pvd.clone(), + pov.clone(), match i % 3 { 0 => executor_params_1.clone(), _ => executor_params_2.clone(), @@ -324,8 +326,18 @@ async fn execute_queue_doesnt_stall_with_varying_executor_params() { async fn deleting_prepared_artifact_does_not_dispute() { let host = TestHost::new().await; let cache_dir = host.cache_dir.path(); + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default()) + .await + .unwrap(); // Manually delete the prepared artifact from disk. The in-memory artifacts table won't change. { @@ -344,16 +356,7 @@ async fn deleting_prepared_artifact_does_not_dispute() { // Try to validate, artifact should get recreated. let result = host - .validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, - Default::default(), - ) + .validate_candidate(test_parachain_halt::wasm_binary_unwrap(), pvd, pov, Default::default()) .await; assert_matches!(result, Err(ValidationError::Invalid(InvalidCandidate::HardTimeout))); @@ -364,8 +367,18 @@ async fn deleting_prepared_artifact_does_not_dispute() { async fn corrupted_prepared_artifact_does_not_dispute() { let host = TestHost::new().await; let cache_dir = host.cache_dir.path(); + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default()) + .await + .unwrap(); // Manually corrupting the prepared artifact from disk. The in-memory artifacts table won't // change. @@ -394,16 +407,7 @@ async fn corrupted_prepared_artifact_does_not_dispute() { // Try to validate, artifact should get removed because of the corruption. let result = host - .validate_candidate( - halt::wasm_binary_unwrap(), - ValidationParams { - block_data: BlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, - Default::default(), - ) + .validate_candidate(test_parachain_halt::wasm_binary_unwrap(), pvd, pov, Default::default()) .await; assert_matches!( @@ -412,7 +416,9 @@ async fn corrupted_prepared_artifact_does_not_dispute() { ); // because of RuntimeConstruction we may retry - host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap(); + host.precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default()) + .await + .unwrap(); // The actual artifact removal is done concurrently // with sending of the result of the execution @@ -437,7 +443,10 @@ async fn cache_cleared_on_startup() { // Don't drop this host, it owns the `TempDir` which gets cleared on drop. let host = TestHost::new().await; - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default()) + .await + .unwrap(); // The cache dir should contain one artifact and one worker dir. let cache_dir = host.cache_dir.path().to_owned(); @@ -461,7 +470,7 @@ async fn prechecking_within_memory_limits() { let host = TestHost::new().await; let result = host .precheck_pvf( - ::adder::wasm_binary_unwrap(), + ::test_parachain_adder::wasm_binary_unwrap(), ExecutorParams::from(&[ExecutorParam::PrecheckingMaxMemory(10 * 1024 * 1024)][..]), ) .await; @@ -480,7 +489,7 @@ async fn prechecking_out_of_memory() { let host = TestHost::new().await; let result = host .precheck_pvf( - ::adder::wasm_binary_unwrap(), + ::test_parachain_adder::wasm_binary_unwrap(), ExecutorParams::from(&[ExecutorParam::PrecheckingMaxMemory(512 * 1024)][..]), ) .await; @@ -497,32 +506,32 @@ async fn prepare_can_run_serially() { .await; let _stats = host - .precheck_pvf(::adder::wasm_binary_unwrap(), Default::default()) + .precheck_pvf(::test_parachain_adder::wasm_binary_unwrap(), Default::default()) .await .unwrap(); // Prepare a different wasm blob to prevent skipping work. - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), Default::default()).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), Default::default()) + .await + .unwrap(); } // CI machines should be able to enable all the security features. #[cfg(all(feature = "ci-only-tests", target_os = "linux"))] #[tokio::test] async fn all_security_features_work() { - // Landlock is only available starting Linux 5.13, and we may be testing on an old kernel. let can_enable_landlock = { - let sysinfo = sc_sysinfo::gather_sysinfo(); - // The version will look something like "5.15.0-87-generic". - let version = sysinfo.linux_kernel.unwrap(); - let version_split: Vec<&str> = version.split(".").collect(); - let major: u32 = version_split[0].parse().unwrap(); - let minor: u32 = version_split[1].parse().unwrap(); - if major >= 6 { - true - } else if major == 5 { - minor >= 13 + let res = unsafe { libc::syscall(libc::SYS_landlock_create_ruleset, 0usize, 0usize, 1u32) }; + if res == -1 { + let err = std::io::Error::last_os_error().raw_os_error().unwrap(); + if err == libc::ENOSYS { + false + } else { + panic!("Unexpected errno from landlock check: {err}"); + } } else { - false + true } }; @@ -555,7 +564,7 @@ async fn nonexistent_cache_dir() { assert!(host.security_status().await.can_unshare_user_namespace_and_change_root); let _stats = host - .precheck_pvf(::adder::wasm_binary_unwrap(), Default::default()) + .precheck_pvf(::test_parachain_adder::wasm_binary_unwrap(), Default::default()) .await .unwrap(); } @@ -574,7 +583,10 @@ async fn artifact_does_not_reprepare_on_non_meaningful_exec_parameter_change() { let set2 = ExecutorParams::from(&[ExecutorParam::PvfExecTimeout(PvfExecKind::Backing, 2500)][..]); - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set1).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set1) + .await + .unwrap(); let md1 = { let mut cache_dir: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect(); @@ -590,7 +602,10 @@ async fn artifact_does_not_reprepare_on_non_meaningful_exec_parameter_change() { // second attifact will be different tokio::time::sleep(Duration::from_secs(2)).await; - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set2).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set2) + .await + .unwrap(); let md2 = { let mut cache_dir: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect(); @@ -619,13 +634,81 @@ async fn artifact_does_reprepare_on_meaningful_exec_parameter_change() { let set2 = ExecutorParams::from(&[ExecutorParam::PvfPrepTimeout(PvfPrepKind::Prepare, 60000)][..]); - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set1).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set1) + .await + .unwrap(); let cache_dir_contents: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect(); assert_eq!(cache_dir_contents.len(), 2); - let _stats = host.precheck_pvf(halt::wasm_binary_unwrap(), set2).await.unwrap(); + let _stats = host + .precheck_pvf(test_parachain_halt::wasm_binary_unwrap(), set2) + .await + .unwrap(); let cache_dir_contents: Vec<_> = std::fs::read_dir(cache_dir).unwrap().collect(); assert_eq!(cache_dir_contents.len(), 3); // new artifact has been added } + +// Checks that we cannot prepare oversized compressed code +#[tokio::test] +async fn invalid_compressed_code_fails_prechecking() { + let host = TestHost::new().await; + let raw_code = vec![2u8; VALIDATION_CODE_BOMB_LIMIT + 1]; + let validation_code = + sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT + 1).unwrap(); + + let res = host.precheck_pvf(&validation_code, Default::default()).await; + + assert_matches!(res, Err(PrepareError::CouldNotDecompressCodeBlob(_))); +} + +// Checks that we cannot validate with oversized compressed code +#[tokio::test] +async fn invalid_compressed_code_fails_validation() { + let host = TestHost::new().await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: BlockData(Vec::new()) }; + + let raw_code = vec![2u8; VALIDATION_CODE_BOMB_LIMIT + 1]; + let validation_code = + sp_maybe_compressed_blob::compress(&raw_code, VALIDATION_CODE_BOMB_LIMIT + 1).unwrap(); + + let result = host.validate_candidate(&validation_code, pvd, pov, Default::default()).await; + + assert_matches!( + result, + Err(ValidationError::Preparation(PrepareError::CouldNotDecompressCodeBlob(_))) + ); +} + +// Checks that we cannot validate with an oversized PoV +#[tokio::test] +async fn invalid_compressed_pov_fails_validation() { + let host = TestHost::new().await; + let pvd = PersistedValidationData { + parent_head: Default::default(), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let raw_block_data = vec![1u8; POV_BOMB_LIMIT + 1]; + let block_data = + sp_maybe_compressed_blob::compress(&raw_block_data, POV_BOMB_LIMIT + 1).unwrap(); + let pov = PoV { block_data: BlockData(block_data) }; + + let result = host + .validate_candidate(test_parachain_halt::wasm_binary_unwrap(), pvd, pov, Default::default()) + .await; + + assert_matches!( + result, + Err(ValidationError::Invalid(InvalidCandidate::PoVDecompressionFailure)) + ); +} diff --git a/polkadot/node/core/pvf/tests/it/process.rs b/polkadot/node/core/pvf/tests/it/process.rs index e989eb874ba956da83fccd653f978a041f2411ea..b3023c8a45c3b3087015e714c22f9bd0474d251e 100644 --- a/polkadot/node/core/pvf/tests/it/process.rs +++ b/polkadot/node/core/pvf/tests/it/process.rs @@ -18,18 +18,21 @@ //! spawned by the host) and job processes (spawned by the workers to securely perform PVF jobs). use super::TestHost; -use adder::{hash_state, BlockData, HeadData}; use assert_matches::assert_matches; -use parity_scale_codec::Encode; +use codec::Encode; use polkadot_node_core_pvf::{ InvalidCandidate, PossiblyInvalidError, PrepareError, ValidationError, }; +use polkadot_node_primitives::PoV; use polkadot_parachain_primitives::primitives::{ - BlockData as GenericBlockData, HeadData as GenericHeadData, ValidationParams, + BlockData as GenericBlockData, HeadData as GenericHeadData, }; +use polkadot_primitives::PersistedValidationData; use procfs::process; use rusty_fork::rusty_fork_test; +use sp_core::H256; use std::{future::Future, sync::Arc, time::Duration}; +use test_parachain_adder::{hash_state, BlockData, HeadData}; const PREPARE_PROCESS_NAME: &'static str = "polkadot-prepare-worker"; const EXECUTE_PROCESS_NAME: &'static str = "polkadot-execute-worker"; @@ -125,15 +128,18 @@ rusty_fork_test! { test_wrapper(|host, _sid| async move { let parent_head = HeadData { number: 0, parent_hash: [0; 32], post_state: hash_state(0) }; let block_data = BlockData { state: 0, add: 512 }; + let pvd = PersistedValidationData { + parent_head: GenericHeadData(parent_head.encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(block_data.encode()) }; host .validate_candidate( - adder::wasm_binary_unwrap(), - ValidationParams { - parent_head: GenericHeadData(parent_head.encode()), - block_data: GenericBlockData(block_data.encode()), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + test_parachain_adder::wasm_binary_unwrap(), + pvd, + pov, Default::default(), ) .await @@ -164,19 +170,22 @@ rusty_fork_test! { fn execute_worker_timeout() { test_wrapper(|host, sid| async move { // Prepare the artifact ahead of time. - let binary = halt::wasm_binary_unwrap(); + let binary = test_parachain_halt::wasm_binary_unwrap(); host.precheck_pvf(binary, Default::default()).await.unwrap(); + let pvd = PersistedValidationData { + parent_head: GenericHeadData(HeadData::default().encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(Vec::new()) }; let (result, _) = futures::join!( // Choose an job that would normally take the entire timeout. host.validate_candidate( binary, - ValidationParams { - block_data: GenericBlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + pvd, + pov, Default::default(), ), // Send a stop signal to pause the worker. @@ -216,19 +225,22 @@ rusty_fork_test! { fn execute_worker_killed_during_job() { test_wrapper(|host, sid| async move { // Prepare the artifact ahead of time. - let binary = halt::wasm_binary_unwrap(); + let binary = test_parachain_halt::wasm_binary_unwrap(); host.precheck_pvf(binary, Default::default()).await.unwrap(); + let pvd = PersistedValidationData { + parent_head: GenericHeadData(HeadData::default().encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(Vec::new()) }; let (result, _) = futures::join!( // Choose an job that would normally take the entire timeout. host.validate_candidate( binary, - ValidationParams { - block_data: GenericBlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + pvd, + pov, Default::default(), ), // Run a future that kills the job while it's running. @@ -272,19 +284,22 @@ rusty_fork_test! { fn forked_execute_job_killed_during_job() { test_wrapper(|host, sid| async move { // Prepare the artifact ahead of time. - let binary = halt::wasm_binary_unwrap(); + let binary = test_parachain_halt::wasm_binary_unwrap(); host.precheck_pvf(binary, Default::default()).await.unwrap(); + let pvd = PersistedValidationData { + parent_head: GenericHeadData(HeadData::default().encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(Vec::new()) }; let (result, _) = futures::join!( // Choose a job that would normally take the entire timeout. host.validate_candidate( binary, - ValidationParams { - block_data: GenericBlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + pvd, + pov, Default::default(), ), // Run a future that kills the job while it's running. @@ -340,19 +355,22 @@ rusty_fork_test! { fn ensure_execute_processes_have_correct_num_threads() { test_wrapper(|host, sid| async move { // Prepare the artifact ahead of time. - let binary = halt::wasm_binary_unwrap(); + let binary = test_parachain_halt::wasm_binary_unwrap(); host.precheck_pvf(binary, Default::default()).await.unwrap(); + let pvd = PersistedValidationData { + parent_head: GenericHeadData(HeadData::default().encode()), + relay_parent_number: 1u32, + relay_parent_storage_root: H256::default(), + max_pov_size: 4096 * 1024, + }; + let pov = PoV { block_data: GenericBlockData(Vec::new()) }; let _ = futures::join!( // Choose a job that would normally take the entire timeout. host.validate_candidate( binary, - ValidationParams { - block_data: GenericBlockData(Vec::new()), - parent_head: Default::default(), - relay_parent_number: 1, - relay_parent_storage_root: Default::default(), - }, + pvd, + pov, Default::default(), ), // Run a future that tests the thread count while the worker is running. diff --git a/polkadot/node/core/runtime-api/Cargo.toml b/polkadot/node/core/runtime-api/Cargo.toml index 91f5c35b27949f9e0918eaad7adbe5f2557576e8..834e4b300b9eba67c4764ac60e00261b66215250 100644 --- a/polkadot/node/core/runtime-api/Cargo.toml +++ b/polkadot/node/core/runtime-api/Cargo.toml @@ -10,23 +10,23 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -schnellru = "0.2.1" +futures = { workspace = true } +gum = { workspace = true, default-features = true } +schnellru = { workspace = true } -sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" } +sp-consensus-babe = { workspace = true, default-features = true } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-metrics = { path = "../../metrics" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-types = { path = "../../subsystem-types" } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } [dev-dependencies] -sp-api = { path = "../../../../substrate/primitives/api" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -async-trait = "0.1.79" -futures = { version = "0.3.30", features = ["thread-pool"] } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-node-primitives = { path = "../../primitives" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../../primitives/test-helpers" } +sp-api = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +async-trait = { workspace = true } +futures = { features = ["thread-pool"], workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/core/runtime-api/src/tests.rs b/polkadot/node/core/runtime-api/src/tests.rs index 0113de83c89ec56403fec0e42207bc5d4e0c552e..7c382707264f117b45469a2de28ac4d3c957309b 100644 --- a/polkadot/node/core/runtime-api/src/tests.rs +++ b/polkadot/node/core/runtime-api/src/tests.rs @@ -27,13 +27,13 @@ use polkadot_primitives::{ PersistedValidationData, PvfCheckStatement, ScrapedOnChainVotes, SessionIndex, SessionInfo, Slot, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, }; +use polkadot_primitives_test_helpers::{dummy_committed_candidate_receipt, dummy_validation_code}; use sp_api::ApiError; use sp_core::testing::TaskExecutor; use std::{ collections::{BTreeMap, HashMap, VecDeque}, sync::{Arc, Mutex}, }; -use test_helpers::{dummy_committed_candidate_receipt, dummy_validation_code}; #[derive(Default)] struct MockSubsystemClient { diff --git a/polkadot/node/gum/Cargo.toml b/polkadot/node/gum/Cargo.toml index 0d887b9be5394c6b36f882d60f57d4ee2d9bf8eb..9b2df435a06a90e4cb0561e19ce4a85dd281b127 100644 --- a/polkadot/node/gum/Cargo.toml +++ b/polkadot/node/gum/Cargo.toml @@ -10,7 +10,7 @@ description = "Stick logs together with the TraceID as provided by tempo" workspace = true [dependencies] -coarsetime = "0.1.22" -tracing = "0.1.35" -gum-proc-macro = { package = "tracing-gum-proc-macro", path = "proc-macro" } -polkadot-primitives = { path = "../../primitives", features = ["std"] } +coarsetime = { workspace = true } +tracing = { workspace = true, default-features = true } +gum-proc-macro = { workspace = true, default-features = true } +polkadot-primitives = { features = ["std"], workspace = true, default-features = true } diff --git a/polkadot/node/gum/proc-macro/Cargo.toml b/polkadot/node/gum/proc-macro/Cargo.toml index 70126b4f43367ce11a1a23d462392b513ca1c028..da6364977cae25f16e8605f8024dc96aa86f6120 100644 --- a/polkadot/node/gum/proc-macro/Cargo.toml +++ b/polkadot/node/gum/proc-macro/Cargo.toml @@ -18,12 +18,12 @@ proc-macro = true [dependencies] syn = { features = ["extra-traits", "full"], workspace = true } quote = { workspace = true } -proc-macro2 = "1.0.56" -proc-macro-crate = "3.0.0" -expander = "2.0.0" +proc-macro2 = { workspace = true } +proc-macro-crate = { workspace = true } +expander = { workspace = true } [dev-dependencies] -assert_matches = "1.5.0" +assert_matches = { workspace = true } [features] diff --git a/polkadot/node/gum/src/lib.rs b/polkadot/node/gum/src/lib.rs index dad5887af224382ec384b4d354fd74fb2d9c31f5..f78e20cdecfca214b4d936d55cfc8ea5bdd60e15 100644 --- a/polkadot/node/gum/src/lib.rs +++ b/polkadot/node/gum/src/lib.rs @@ -40,7 +40,7 @@ //! //! ### Log levels //! -//! All of the the [`tracing` macros](https://docs.rs/tracing/latest/tracing/index.html#macros) are available. +//! All of the [`tracing` macros](https://docs.rs/tracing/latest/tracing/index.html#macros) are available. //! In decreasing order of priority they are: //! //! - `error!` diff --git a/polkadot/node/jaeger/Cargo.toml b/polkadot/node/jaeger/Cargo.toml index bee725c0876f0cd57692d754738219dd731f8d62..90a6c80e3d0bd3ab2567933bf94d89b7a00dc1e9 100644 --- a/polkadot/node/jaeger/Cargo.toml +++ b/polkadot/node/jaeger/Cargo.toml @@ -10,15 +10,15 @@ description = "Polkadot Jaeger primitives, but equally useful for Grafana/Tempo" workspace = true [dependencies] -mick-jaeger = "0.1.8" -lazy_static = "1.4" -parking_lot = "0.12.1" -polkadot-primitives = { path = "../../primitives" } -polkadot-node-primitives = { path = "../primitives" } -sc-network = { path = "../../../substrate/client/network" } -sc-network-types = { path = "../../../substrate/client/network/types" } -sp-core = { path = "../../../substrate/primitives/core" } +mick-jaeger = { workspace = true } +lazy_static = { workspace = true } +parking_lot = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } thiserror = { workspace = true } -tokio = "1.37" +tokio = { workspace = true, default-features = true } log = { workspace = true, default-features = true } -parity-scale-codec = { version = "3.6.1", default-features = false } +codec = { workspace = true } diff --git a/polkadot/node/jaeger/src/spans.rs b/polkadot/node/jaeger/src/spans.rs index 68fa57e2ca14f859b7bcfcf02884deaa34d7d156..efc1a9f91d195eeeae3191bcccecec611250f3eb 100644 --- a/polkadot/node/jaeger/src/spans.rs +++ b/polkadot/node/jaeger/src/spans.rs @@ -83,9 +83,11 @@ //! # } //! ``` -use parity_scale_codec::Encode; +use codec::Encode; use polkadot_node_primitives::PoV; -use polkadot_primitives::{BlakeTwo256, CandidateHash, Hash, HashT, Id as ParaId, ValidatorIndex}; +use polkadot_primitives::{ + BlakeTwo256, CandidateHash, ChunkIndex, Hash, HashT, Id as ParaId, ValidatorIndex, +}; use sc_network_types::PeerId; use std::{fmt, sync::Arc}; @@ -338,8 +340,8 @@ impl Span { } #[inline(always)] - pub fn with_chunk_index(self, chunk_index: u32) -> Self { - self.with_string_tag("chunk-index", chunk_index) + pub fn with_chunk_index(self, chunk_index: ChunkIndex) -> Self { + self.with_string_tag("chunk-index", &chunk_index.0) } #[inline(always)] diff --git a/polkadot/node/malus/Cargo.toml b/polkadot/node/malus/Cargo.toml index 750074fa9b3cb6209d640b75189768fd94faccf2..49434606a61c8dff08a7c075c06c998cc8395a5b 100644 --- a/polkadot/node/malus/Cargo.toml +++ b/polkadot/node/malus/Cargo.toml @@ -29,40 +29,40 @@ path = "../../src/bin/prepare-worker.rs" doc = false [dependencies] -polkadot-cli = { path = "../../cli", features = ["malus", "rococo-native", "westend-native"] } -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-node-subsystem-util = { path = "../subsystem-util" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-node-core-dispute-coordinator = { path = "../core/dispute-coordinator" } -polkadot-node-core-candidate-validation = { path = "../core/candidate-validation" } -polkadot-node-core-backing = { path = "../core/backing" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-node-network-protocol = { path = "../network/protocol" } -polkadot-primitives = { path = "../../primitives" } -color-eyre = { version = "0.6.1", default-features = false } -assert_matches = "1.5" -async-trait = "0.1.79" -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sp-core = { path = "../../../substrate/primitives/core" } -clap = { version = "4.5.3", features = ["derive"] } -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../gum" } -erasure = { package = "polkadot-erasure-coding", path = "../../erasure-coding" } -rand = "0.8.5" +polkadot-cli = { features = ["malus", "rococo-native", "westend-native"], workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-node-core-dispute-coordinator = { workspace = true, default-features = true } +polkadot-node-core-candidate-validation = { workspace = true, default-features = true } +polkadot-node-core-backing = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +color-eyre = { workspace = true } +assert_matches = { workspace = true } +async-trait = { workspace = true } +sp-keystore = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +clap = { features = ["derive"], workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } # Required for worker binaries to build. -polkadot-node-core-pvf-common = { path = "../core/pvf/common" } -polkadot-node-core-pvf-execute-worker = { path = "../core/pvf/execute-worker" } -polkadot-node-core-pvf-prepare-worker = { path = "../core/pvf/prepare-worker" } +polkadot-node-core-pvf-common = { workspace = true, default-features = true } +polkadot-node-core-pvf-execute-worker = { workspace = true, default-features = true } +polkadot-node-core-pvf-prepare-worker = { workspace = true, default-features = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" } -sp-core = { path = "../../../substrate/primitives/core" } -futures = { version = "0.3.30", features = ["thread-pool"] } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-core = { workspace = true, default-features = true } +futures = { features = ["thread-pool"], workspace = true } [build-dependencies] -substrate-build-script-utils = { path = "../../../substrate/utils/build-script-utils" } +substrate-build-script-utils = { workspace = true, default-features = true } [features] default = [] diff --git a/polkadot/node/malus/src/interceptor.rs b/polkadot/node/malus/src/interceptor.rs index b44ffc8956b52581f0d27eeb7e794ffacc922fb7..2181118646d568e2b59db6dbf61e24dfac90257b 100644 --- a/polkadot/node/malus/src/interceptor.rs +++ b/polkadot/node/malus/src/interceptor.rs @@ -90,6 +90,10 @@ where >::Error: std::fmt::Debug, { async fn send_message(&mut self, msg: OutgoingMessage) { + self.send_message_with_priority::(msg).await; + } + + async fn send_message_with_priority(&mut self, msg: OutgoingMessage) { let msg = < <>::Message as overseer::AssociateOutgoing >::OutgoingMessages as From>::from(msg); @@ -103,7 +107,14 @@ where } } - fn try_send_message(&mut self, msg: OutgoingMessage) -> Result<(), TrySendError> { + fn try_send_message( + &mut self, + msg: OutgoingMessage, + ) -> Result<(), polkadot_node_subsystem_util::metered::TrySendError> { + self.try_send_message_with_priority::(msg) + } + + fn try_send_message_with_priority(&mut self, msg: OutgoingMessage) -> Result<(), TrySendError> { let msg = < <>::Message as overseer::AssociateOutgoing >::OutgoingMessages as From>::from(msg); diff --git a/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs b/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs index 739ed40db362a2ae330f14b7a24cc77c1ab76159..6921352cdfc29c6fc6593e609e30bcee876c4557 100644 --- a/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs +++ b/polkadot/node/malus/src/variants/suggest_garbage_candidate.rs @@ -197,13 +197,13 @@ where let pov_hash = pov.hash(); let erasure_root = { - let chunks = erasure::obtain_chunks_v1( + let chunks = polkadot_erasure_coding::obtain_chunks_v1( n_validators as usize, &malicious_available_data, ) .unwrap(); - let branches = erasure::branches(chunks.as_ref()); + let branches = polkadot_erasure_coding::branches(chunks.as_ref()); branches.root() }; diff --git a/polkadot/node/metrics/Cargo.toml b/polkadot/node/metrics/Cargo.toml index fbf0abf829e136a139f3de0db3aef216b2e49679..41b08b66e9b4881bf93285b02076714bf41dfb0f 100644 --- a/polkadot/node/metrics/Cargo.toml +++ b/polkadot/node/metrics/Cargo.toml @@ -10,38 +10,40 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../gum" } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } -metered = { package = "prioritized-metered-channel", version = "0.6.1", default-features = false, features = ["futures_channel"] } +metered = { features = ["futures_channel"], workspace = true } # Both `sc-service` and `sc-cli` are required by runtime metrics `logger_hook()`. -sc-service = { path = "../../../substrate/client/service" } -sc-cli = { path = "../../../substrate/client/cli" } +sc-service = { workspace = true, default-features = true } +sc-cli = { workspace = true, default-features = true } -substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" } -sc-tracing = { path = "../../../substrate/client/tracing" } -codec = { package = "parity-scale-codec", version = "3.6.1" } -primitives = { package = "polkadot-primitives", path = "../../primitives" } -bs58 = { version = "0.5.0", features = ["alloc"] } +prometheus-endpoint = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +codec = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +bs58 = { features = ["alloc"], workspace = true, default-features = true } log = { workspace = true, default-features = true } [dev-dependencies] -assert_cmd = "2.0.4" -tempfile = "3.2.0" -hyper = { version = "0.14.20", default-features = false, features = ["http1", "tcp"] } -tokio = "1.37" -polkadot-test-service = { path = "../test/service", features = ["runtime-metrics"] } -substrate-test-utils = { path = "../../../substrate/test-utils" } -sc-service = { path = "../../../substrate/client/service" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -prometheus-parse = { version = "0.2.2" } +assert_cmd = { workspace = true } +tempfile = { workspace = true } +hyper-util = { features = ["client-legacy", "tokio"], workspace = true } +hyper = { workspace = true } +http-body-util = { workspace = true } +tokio = { workspace = true, default-features = true } +polkadot-test-service = { features = ["runtime-metrics"], workspace = true } +substrate-test-utils = { workspace = true } +sc-service = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +prometheus-parse = { workspace = true } [features] default = [] runtime-metrics = [] runtime-benchmarks = [ + "polkadot-primitives/runtime-benchmarks", "polkadot-test-service/runtime-benchmarks", - "primitives/runtime-benchmarks", "sc-service/runtime-benchmarks", ] diff --git a/polkadot/node/metrics/src/lib.rs b/polkadot/node/metrics/src/lib.rs index 9cb0f289a580ccadc68d2dd8197c46f162845b22..3445c3de107aacf138c5a790a306c547aa36329b 100644 --- a/polkadot/node/metrics/src/lib.rs +++ b/polkadot/node/metrics/src/lib.rs @@ -45,7 +45,7 @@ pub fn logger_hook() -> impl FnOnce(&mut sc_cli::LoggerBuilder, &sc_service::Con /// This module reexports Prometheus types and defines the [`Metrics`](metrics::Metrics) trait. pub mod metrics { /// Reexport Substrate Prometheus types. - pub use substrate_prometheus_endpoint as prometheus; + pub use prometheus_endpoint as prometheus; /// Subsystem- or job-specific Prometheus metrics. /// diff --git a/polkadot/node/metrics/src/runtime/mod.rs b/polkadot/node/metrics/src/runtime/mod.rs index 7cd24b01c117f24d9c4c41f367ab3b53f8aa504c..c5ece849aa3e01361880b0c1875d5c6a87936012 100644 --- a/polkadot/node/metrics/src/runtime/mod.rs +++ b/polkadot/node/metrics/src/runtime/mod.rs @@ -28,17 +28,17 @@ #![cfg(feature = "runtime-metrics")] use codec::Decode; -use primitives::{ +use polkadot_primitives::{ metric_definitions::{CounterDefinition, CounterVecDefinition, HistogramDefinition}, RuntimeMetricLabelValues, RuntimeMetricOp, RuntimeMetricUpdate, }; +use prometheus_endpoint::{ + register, Counter, CounterVec, Histogram, HistogramOpts, Opts, PrometheusError, Registry, U64, +}; use std::{ collections::hash_map::HashMap, sync::{Arc, Mutex, MutexGuard}, }; -use substrate_prometheus_endpoint::{ - register, Counter, CounterVec, Histogram, HistogramOpts, Opts, PrometheusError, Registry, U64, -}; mod parachain; /// Holds the registered Prometheus metric collections. diff --git a/polkadot/node/metrics/src/runtime/parachain.rs b/polkadot/node/metrics/src/runtime/parachain.rs index becc7c64d59d08b4896ee102d5c27a72e61cfd08..7aecaf5590f185398227fbf0b201d3b1890f3cf5 100644 --- a/polkadot/node/metrics/src/runtime/parachain.rs +++ b/polkadot/node/metrics/src/runtime/parachain.rs @@ -18,7 +18,7 @@ //! All of the metrics have a correspondent runtime metric definition. use crate::runtime::RuntimeMetricsProvider; -use primitives::metric_definitions::{ +use polkadot_primitives::metric_definitions::{ PARACHAIN_CREATE_INHERENT_BITFIELDS_SIGNATURE_CHECKS, PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED, PARACHAIN_INHERENT_DATA_CANDIDATES_PROCESSED, PARACHAIN_INHERENT_DATA_DISPUTE_SETS_PROCESSED, PARACHAIN_INHERENT_DATA_WEIGHT, diff --git a/polkadot/node/metrics/src/tests.rs b/polkadot/node/metrics/src/tests.rs index 861080228cd8dc90f9d074d54355983ab30e8e53..e720924feb60c6d4ef3828d52312f96521a6f989 100644 --- a/polkadot/node/metrics/src/tests.rs +++ b/polkadot/node/metrics/src/tests.rs @@ -16,9 +16,11 @@ //! Polkadot runtime metrics integration test. -use hyper::{Client, Uri}; +use http_body_util::BodyExt; +use hyper::Uri; +use hyper_util::{client::legacy::Client, rt::TokioExecutor}; +use polkadot_primitives::metric_definitions::PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED; use polkadot_test_service::{node_config, run_validator_node, test_prometheus_config}; -use primitives::metric_definitions::PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED; use sp_keyring::AccountKeyring::*; use std::collections::HashMap; @@ -66,14 +68,20 @@ async fn runtime_can_publish_metrics() { } async fn scrape_prometheus_metrics(metrics_uri: &str) -> HashMap { - let res = Client::new() + let res = Client::builder(TokioExecutor::new()) + .build_http::>() .get(Uri::try_from(metrics_uri).expect("bad URI")) .await .expect("GET request failed"); // Retrieve the `HTTP` response body. let body = String::from_utf8( - hyper::body::to_bytes(res).await.expect("can't get body as bytes").to_vec(), + res.into_body() + .collect() + .await + .expect("can't get body as bytes") + .to_bytes() + .to_vec(), ) .expect("body is not an UTF8 string"); diff --git a/polkadot/node/network/approval-distribution/Cargo.toml b/polkadot/node/network/approval-distribution/Cargo.toml index d80519b9e2e95aa4d958bff5b9a08e3bddb2cf3c..1bd3d51b5c933f2b7fe5bf5396687f3e7c59bca7 100644 --- a/polkadot/node/network/approval-distribution/Cargo.toml +++ b/polkadot/node/network/approval-distribution/Cargo.toml @@ -10,32 +10,32 @@ license.workspace = true workspace = true [dependencies] -polkadot-node-metrics = { path = "../../metrics" } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-jaeger = { path = "../../jaeger" } -rand = "0.8" -itertools = "0.11" +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } +itertools = { workspace = true } -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +bitvec = { features = ["alloc"], workspace = true } [dev-dependencies] -sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" } -sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] } +sp-authority-discovery = { workspace = true, default-features = true } +sp-core = { features = ["std"], workspace = true, default-features = true } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } -assert_matches = "1.4.0" -schnorrkel = { version = "0.11.4", default-features = false } +assert_matches = { workspace = true } +schnorrkel = { workspace = true } # rand_core should match schnorrkel -rand_core = "0.6.2" -rand_chacha = "0.3.1" -env_logger = "0.11" +rand_core = { workspace = true } +rand_chacha = { workspace = true, default-features = true } +sp-tracing = { workspace = true } log = { workspace = true, default-features = true } diff --git a/polkadot/node/network/approval-distribution/src/lib.rs b/polkadot/node/network/approval-distribution/src/lib.rs index 369d82b45b094b30f0b65d72d54d5c14c1e28440..a1bdc47e9fb251762e3a8c80e4d56ab3aa6eb7e2 100644 --- a/polkadot/node/network/approval-distribution/src/lib.rs +++ b/polkadot/node/network/approval-distribution/src/lib.rs @@ -161,7 +161,7 @@ impl ApprovalEntry { Self { validator_index: assignment.validator, assignment, - approvals: HashMap::with_capacity(candidates.len()), + approvals: HashMap::new(), assignment_claimed_candidates: candidates, routing_info, } @@ -320,7 +320,7 @@ enum Resend { /// It tracks metadata about our view of the unfinalized chain, /// which assignments and approvals we have seen, and our peers' views. #[derive(Default)] -struct State { +pub struct State { /// These two fields are used in conjunction to construct a view over the unfinalized chain. blocks_by_number: BTreeMap>, blocks: HashMap, @@ -662,9 +662,13 @@ enum PendingMessage { #[overseer::contextbounds(ApprovalDistribution, prefix = self::overseer)] impl State { - async fn handle_network_msg( + async fn handle_network_msg< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, event: NetworkBridgeEvent, rng: &mut (impl CryptoRng + Rng), @@ -689,7 +693,7 @@ impl State { }, NetworkBridgeEvent::NewGossipTopology(topology) => { self.handle_new_session_topology( - ctx, + network_sender, topology.session, topology.topology, topology.local_index, @@ -697,7 +701,7 @@ impl State { .await; }, NetworkBridgeEvent::PeerViewChange(peer_id, view) => { - self.handle_peer_view_change(ctx, metrics, peer_id, view, rng).await; + self.handle_peer_view_change(network_sender, metrics, peer_id, view, rng).await; }, NetworkBridgeEvent::OurViewChange(view) => { gum::trace!(target: LOG_TARGET, ?view, "Own view change"); @@ -720,7 +724,15 @@ impl State { }); }, NetworkBridgeEvent::PeerMessage(peer_id, message) => { - self.process_incoming_peer_message(ctx, metrics, peer_id, message, rng).await; + self.process_incoming_peer_message( + approval_voting_sender, + network_sender, + metrics, + peer_id, + message, + rng, + ) + .await; }, NetworkBridgeEvent::UpdatedAuthorityIds(peer_id, authority_ids) => { gum::debug!(target: LOG_TARGET, ?peer_id, ?authority_ids, "Update Authority Ids"); @@ -743,7 +755,7 @@ impl State { let view_intersection = View::new(intersection.cloned(), view.finalized_number); Self::unify_with_peer( - ctx.sender(), + network_sender, metrics, &mut self.blocks, &self.topologies, @@ -761,9 +773,13 @@ impl State { } } - async fn handle_new_blocks( + async fn handle_new_blocks< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, metas: Vec, rng: &mut (impl CryptoRng + Rng), @@ -814,12 +830,11 @@ impl State { ); { - let sender = ctx.sender(); for (peer_id, PeerEntry { view, version }) in self.peer_views.iter() { let intersection = view.iter().filter(|h| new_hashes.contains(h)); let view_intersection = View::new(intersection.cloned(), view.finalized_number); Self::unify_with_peer( - sender, + network_sender, metrics, &mut self.blocks, &self.topologies, @@ -866,7 +881,8 @@ impl State { match message { PendingMessage::Assignment(assignment, claimed_indices) => { self.import_and_circulate_assignment( - ctx, + approval_voting_sender, + network_sender, metrics, MessageSource::Peer(peer_id), assignment, @@ -877,7 +893,8 @@ impl State { }, PendingMessage::Approval(approval_vote) => { self.import_and_circulate_approval( - ctx, + approval_voting_sender, + network_sender, metrics, MessageSource::Peer(peer_id), approval_vote, @@ -889,12 +906,12 @@ impl State { } } - self.enable_aggression(ctx, Resend::Yes, metrics).await; + self.enable_aggression(network_sender, Resend::Yes, metrics).await; } - async fn handle_new_session_topology( + async fn handle_new_session_topology>( &mut self, - ctx: &mut Context, + network_sender: &mut N, session: SessionIndex, topology: SessionGridTopology, local_index: Option, @@ -908,7 +925,7 @@ impl State { let topology = self.topologies.get_topology(session).expect("just inserted above; qed"); adjust_required_routing_and_propagate( - ctx, + network_sender, &mut self.blocks, &self.topologies, |block_entry| block_entry.session == session, @@ -926,14 +943,17 @@ impl State { .await; } - async fn process_incoming_assignments( + async fn process_incoming_assignments( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, peer_id: PeerId, assignments: Vec<(IndirectAssignmentCertV2, CandidateBitfield)>, rng: &mut R, ) where + A: overseer::SubsystemSender, + N: overseer::SubsystemSender, R: CryptoRng + Rng, { for (assignment, claimed_indices) in assignments { @@ -956,7 +976,8 @@ impl State { } self.import_and_circulate_assignment( - ctx, + approval_voting_sender, + network_sender, metrics, MessageSource::Peer(peer_id), assignment, @@ -968,9 +989,13 @@ impl State { } // Entry point for processing an approval coming from a peer. - async fn process_incoming_approvals( + async fn process_incoming_approvals< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, peer_id: PeerId, approvals: Vec, @@ -1001,7 +1026,8 @@ impl State { } self.import_and_circulate_approval( - ctx, + approval_voting_sender, + network_sender, metrics, MessageSource::Peer(peer_id), approval_vote, @@ -1010,9 +1036,10 @@ impl State { } } - async fn process_incoming_peer_message( + async fn process_incoming_peer_message( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, peer_id: PeerId, msg: Versioned< @@ -1022,6 +1049,8 @@ impl State { >, rng: &mut R, ) where + A: overseer::SubsystemSender, + N: overseer::SubsystemSender, R: CryptoRng + Rng, { match msg { @@ -1033,10 +1062,11 @@ impl State { "Processing assignments from a peer", ); let sanitized_assignments = - self.sanitize_v2_assignments(peer_id, ctx.sender(), assignments).await; + self.sanitize_v2_assignments(peer_id, network_sender, assignments).await; self.process_incoming_assignments( - ctx, + approval_voting_sender, + network_sender, metrics, peer_id, sanitized_assignments, @@ -1054,10 +1084,11 @@ impl State { ); let sanitized_assignments = - self.sanitize_v1_assignments(peer_id, ctx.sender(), assignments).await; + self.sanitize_v1_assignments(peer_id, network_sender, assignments).await; self.process_incoming_assignments( - ctx, + approval_voting_sender, + network_sender, metrics, peer_id, sanitized_assignments, @@ -1067,25 +1098,37 @@ impl State { }, Versioned::V3(protocol_v3::ApprovalDistributionMessage::Approvals(approvals)) => { let sanitized_approvals = - self.sanitize_v2_approvals(peer_id, ctx.sender(), approvals).await; - self.process_incoming_approvals(ctx, metrics, peer_id, sanitized_approvals) - .await; + self.sanitize_v2_approvals(peer_id, network_sender, approvals).await; + self.process_incoming_approvals( + approval_voting_sender, + network_sender, + metrics, + peer_id, + sanitized_approvals, + ) + .await; }, Versioned::V1(protocol_v1::ApprovalDistributionMessage::Approvals(approvals)) | Versioned::V2(protocol_v2::ApprovalDistributionMessage::Approvals(approvals)) => { let sanitized_approvals = - self.sanitize_v1_approvals(peer_id, ctx.sender(), approvals).await; - self.process_incoming_approvals(ctx, metrics, peer_id, sanitized_approvals) - .await; + self.sanitize_v1_approvals(peer_id, network_sender, approvals).await; + self.process_incoming_approvals( + approval_voting_sender, + network_sender, + metrics, + peer_id, + sanitized_approvals, + ) + .await; }, } } // handle a peer view change: requires that the peer is already connected // and has an entry in the `PeerData` struct. - async fn handle_peer_view_change( + async fn handle_peer_view_change, R>( &mut self, - ctx: &mut Context, + network_sender: &mut N, metrics: &Metrics, peer_id: PeerId, view: View, @@ -1132,7 +1175,7 @@ impl State { } Self::unify_with_peer( - ctx.sender(), + network_sender, metrics, &mut self.blocks, &self.topologies, @@ -1146,9 +1189,9 @@ impl State { .await; } - async fn handle_block_finalized( + async fn handle_block_finalized>( &mut self, - ctx: &mut Context, + network_sender: &mut N, metrics: &Metrics, finalized_number: BlockNumber, ) { @@ -1172,18 +1215,21 @@ impl State { // If a block was finalized, this means we may need to move our aggression // forward to the now oldest block(s). - self.enable_aggression(ctx, Resend::No, metrics).await; + self.enable_aggression(network_sender, Resend::No, metrics).await; } - async fn import_and_circulate_assignment( + async fn import_and_circulate_assignment( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, source: MessageSource, assignment: IndirectAssignmentCertV2, claimed_candidate_indices: CandidateBitfield, rng: &mut R, ) where + A: overseer::SubsystemSender, + N: overseer::SubsystemSender, R: CryptoRng + Rng, { let _span = self @@ -1218,7 +1264,7 @@ impl State { if !self.recent_outdated_blocks.is_recent_outdated(&block_hash) { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_UNEXPECTED_MESSAGE, ) @@ -1255,7 +1301,7 @@ impl State { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_DUPLICATE_MESSAGE, ) @@ -1283,7 +1329,7 @@ impl State { ); modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_UNEXPECTED_MESSAGE, ) @@ -1296,7 +1342,7 @@ impl State { if entry.knowledge.contains(&message_subject, message_kind) { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, BENEFIT_VALID_MESSAGE, ) @@ -1311,12 +1357,13 @@ impl State { let (tx, rx) = oneshot::channel(); - ctx.send_message(ApprovalVotingMessage::CheckAndImportAssignment( - assignment.clone(), - claimed_candidate_indices.clone(), - tx, - )) - .await; + approval_voting_sender + .send_message(ApprovalVotingMessage::CheckAndImportAssignment( + assignment.clone(), + claimed_candidate_indices.clone(), + tx, + )) + .await; let timer = metrics.time_awaiting_approval_voting(); let result = match rx.await { @@ -1339,7 +1386,7 @@ impl State { AssignmentCheckResult::Accepted => { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, BENEFIT_VALID_MESSAGE_FIRST, ) @@ -1375,7 +1422,7 @@ impl State { ); modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_ASSIGNMENT_TOO_FAR_IN_THE_FUTURE, ) @@ -1394,7 +1441,7 @@ impl State { ); modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_INVALID_MESSAGE, ) @@ -1431,6 +1478,21 @@ impl State { let required_routing = topology.map_or(RequiredRouting::PendingTopology, |t| { t.local_grid_neighbors().required_routing_by_index(validator_index, local) }); + // Peers that we will send the assignment to. + let mut peers = HashSet::new(); + + let peers_to_route_to = topology + .as_ref() + .map(|t| t.peers_to_route(required_routing)) + .unwrap_or_default(); + + for peer in peers_to_route_to { + if !entry.known_by.contains_key(&peer) { + continue + } + + peers.insert(peer); + } // All the peers that know the relay chain block. let peers_to_filter = entry.known_by(); @@ -1456,20 +1518,13 @@ impl State { let n_peers_total = self.peer_views.len(); let source_peer = source.peer_id(); - // Peers that we will send the assignment to. - let mut peers = Vec::new(); - // Filter destination peers for peer in peers_to_filter.into_iter() { if Some(peer) == source_peer { continue } - if let Some(true) = topology - .as_ref() - .map(|t| t.local_grid_neighbors().route_to_peer(required_routing, &peer)) - { - peers.push(peer); + if peers.contains(&peer) { continue } @@ -1485,7 +1540,11 @@ impl State { if route_random { approval_entry.routing_info_mut().mark_randomly_sent(peer); - peers.push(peer); + peers.insert(peer); + } + + if approval_entry.routing_info().random_routing.is_complete() { + break } } @@ -1514,14 +1573,16 @@ impl State { }) .collect::>(); - send_assignments_batched(ctx.sender(), assignments, &peers).await; + send_assignments_batched(network_sender, assignments, &peers).await; } } // Checks if an approval can be processed. // Returns true if we can continue with processing the approval and false otherwise. - async fn check_approval_can_be_processed( - ctx: &mut Context, + async fn check_approval_can_be_processed< + N: overseer::SubsystemSender, + >( + network_sender: &mut N, assignments_knowledge_key: &Vec<(MessageSubject, MessageKind)>, approval_knowledge_key: &(MessageSubject, MessageKind), entry: &mut BlockEntry, @@ -1537,7 +1598,8 @@ impl State { ?message_subject, "Unknown approval assignment", ); - modify_reputation(reputation, ctx.sender(), peer_id, COST_UNEXPECTED_MESSAGE).await; + modify_reputation(reputation, network_sender, peer_id, COST_UNEXPECTED_MESSAGE) + .await; metrics.on_approval_unknown_assignment(); return false } @@ -1561,7 +1623,7 @@ impl State { modify_reputation( reputation, - ctx.sender(), + network_sender, peer_id, COST_DUPLICATE_MESSAGE, ) @@ -1578,7 +1640,8 @@ impl State { ?approval_knowledge_key, "Approval from a peer is out of view", ); - modify_reputation(reputation, ctx.sender(), peer_id, COST_UNEXPECTED_MESSAGE).await; + modify_reputation(reputation, network_sender, peer_id, COST_UNEXPECTED_MESSAGE) + .await; metrics.on_approval_out_of_view(); }, } @@ -1593,16 +1656,20 @@ impl State { // We already processed this approval no need to continue. gum::trace!(target: LOG_TARGET, ?peer_id, ?approval_knowledge_key, "Known approval"); metrics.on_approval_good_known(); - modify_reputation(reputation, ctx.sender(), peer_id, BENEFIT_VALID_MESSAGE).await; + modify_reputation(reputation, network_sender, peer_id, BENEFIT_VALID_MESSAGE).await; false } else { true } } - async fn import_and_circulate_approval( + async fn import_and_circulate_approval< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( &mut self, - ctx: &mut Context, + approval_voting_sender: &mut A, + network_sender: &mut N, metrics: &Metrics, source: MessageSource, vote: IndirectSignedApprovalVoteV2, @@ -1640,7 +1707,7 @@ impl State { ); modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_UNEXPECTED_MESSAGE, ) @@ -1660,7 +1727,7 @@ impl State { if let Some(peer_id) = source.peer_id() { if !Self::check_approval_can_be_processed( - ctx, + network_sender, &assignments_knowledge_keys, &approval_knwowledge_key, entry, @@ -1675,7 +1742,8 @@ impl State { let (tx, rx) = oneshot::channel(); - ctx.send_message(ApprovalVotingMessage::CheckAndImportApproval(vote.clone(), tx)) + approval_voting_sender + .send_message(ApprovalVotingMessage::CheckAndImportApproval(vote.clone(), tx)) .await; let timer = metrics.time_awaiting_approval_voting(); @@ -1699,7 +1767,7 @@ impl State { ApprovalCheckResult::Accepted => { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, BENEFIT_VALID_MESSAGE_FIRST, ) @@ -1717,7 +1785,7 @@ impl State { ApprovalCheckResult::Bad(error) => { modify_reputation( &mut self.reputation, - ctx.sender(), + network_sender, peer_id, COST_INVALID_MESSAGE, ) @@ -1819,7 +1887,7 @@ impl State { num_peers = peers.len(), "Sending an approval to peers", ); - send_approvals_batched(ctx.sender(), approvals, &peers).await; + send_approvals_batched(network_sender, approvals, &peers).await; } } @@ -1870,7 +1938,7 @@ impl State { } async fn unify_with_peer( - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, metrics: &Metrics, entries: &mut HashMap, topologies: &SessionGridTopologies, @@ -2015,9 +2083,9 @@ impl State { // // In order to switch to using approval lag as a trigger we need a request/response protocol // to fetch votes from validators rather than use gossip. - async fn enable_aggression( + async fn enable_aggression>( &mut self, - ctx: &mut Context, + network_sender: &mut N, resend: Resend, metrics: &Metrics, ) { @@ -2046,7 +2114,7 @@ impl State { gum::debug!(target: LOG_TARGET, min_age, max_age, "Aggression enabled",); adjust_required_routing_and_propagate( - ctx, + network_sender, &mut self.blocks, &self.topologies, |block_entry| { @@ -2074,7 +2142,7 @@ impl State { .await; adjust_required_routing_and_propagate( - ctx, + network_sender, &mut self.blocks, &self.topologies, |block_entry| { @@ -2125,7 +2193,7 @@ impl State { async fn sanitize_v1_assignments( &mut self, peer_id: PeerId, - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, assignments: Vec<(IndirectAssignmentCert, CandidateIndex)>, ) -> Vec<(IndirectAssignmentCertV2, CandidateBitfield)> { let mut sanitized_assignments = Vec::new(); @@ -2160,7 +2228,7 @@ impl State { async fn sanitize_v2_assignments( &mut self, peer_id: PeerId, - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, assignments: Vec<(IndirectAssignmentCertV2, CandidateBitfield)>, ) -> Vec<(IndirectAssignmentCertV2, CandidateBitfield)> { let mut sanitized_assignments = Vec::new(); @@ -2204,7 +2272,7 @@ impl State { async fn sanitize_v1_approvals( &mut self, peer_id: PeerId, - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, approval: Vec, ) -> Vec { let mut sanitized_approvals = Vec::new(); @@ -2231,7 +2299,7 @@ impl State { async fn sanitize_v2_approvals( &mut self, peer_id: PeerId, - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, approval: Vec, ) -> Vec { let mut sanitized_approvals = Vec::new(); @@ -2268,8 +2336,12 @@ impl State { // Note that the required routing of a message can be modified even if the // topology is unknown yet. #[overseer::contextbounds(ApprovalDistribution, prefix = self::overseer)] -async fn adjust_required_routing_and_propagate( - ctx: &mut Context, +async fn adjust_required_routing_and_propagate< + N: overseer::SubsystemSender, + BlockFilter, + RoutingModifier, +>( + network_sender: &mut N, blocks: &mut HashMap, topologies: &SessionGridTopologies, block_filter: BlockFilter, @@ -2351,7 +2423,7 @@ async fn adjust_required_routing_and_propagate, peer_id: PeerId, rep: Rep, ) { @@ -2402,7 +2474,6 @@ impl ApprovalDistribution { async fn run(self, ctx: Context) { let mut state = State::default(); - // According to the docs of `rand`, this is a ChaCha12 RNG in practice // and will always be chosen for strong performance and security properties. let mut rng = rand::rngs::StdRng::from_entropy(); @@ -2419,7 +2490,8 @@ impl ApprovalDistribution { ) { let new_reputation_delay = || futures_timer::Delay::new(reputation_interval).fuse(); let mut reputation_delay = new_reputation_delay(); - + let mut approval_voting_sender = ctx.sender().clone(); + let mut network_sender = ctx.sender().clone(); loop { select! { _ = reputation_delay => { @@ -2434,35 +2506,70 @@ impl ApprovalDistribution { return }, }; - match message { - FromOrchestra::Communication { msg } => - Self::handle_incoming(&mut ctx, state, msg, &self.metrics, rng).await, - FromOrchestra::Signal(OverseerSignal::ActiveLeaves(update)) => { - gum::trace!(target: LOG_TARGET, "active leaves signal (ignored)"); - // the relay chain blocks relevant to the approval subsystems - // are those that are available, but not finalized yet - // activated and deactivated heads hence are irrelevant to this subsystem, other than - // for tracing purposes. - if let Some(activated) = update.activated { - let head = activated.hash; - let approval_distribution_span = - jaeger::PerLeafSpan::new(activated.span, "approval-distribution"); - state.spans.insert(head, approval_distribution_span); - } - }, - FromOrchestra::Signal(OverseerSignal::BlockFinalized(_hash, number)) => { - gum::trace!(target: LOG_TARGET, number = %number, "finalized signal"); - state.handle_block_finalized(&mut ctx, &self.metrics, number).await; - }, - FromOrchestra::Signal(OverseerSignal::Conclude) => return, + + + if self.handle_from_orchestra(message, &mut approval_voting_sender, &mut network_sender, state, rng).await { + return; } + }, } } } - async fn handle_incoming( - ctx: &mut Context, + /// Handles a from orchestra message received by approval distribution subystem. + /// + /// Returns `true` if the subsystem should be stopped. + pub async fn handle_from_orchestra< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( + &self, + message: FromOrchestra, + approval_voting_sender: &mut A, + network_sender: &mut N, + state: &mut State, + rng: &mut (impl CryptoRng + Rng), + ) -> bool { + match message { + FromOrchestra::Communication { msg } => + Self::handle_incoming( + approval_voting_sender, + network_sender, + state, + msg, + &self.metrics, + rng, + ) + .await, + FromOrchestra::Signal(OverseerSignal::ActiveLeaves(update)) => { + gum::trace!(target: LOG_TARGET, "active leaves signal (ignored)"); + // the relay chain blocks relevant to the approval subsystems + // are those that are available, but not finalized yet + // activated and deactivated heads hence are irrelevant to this subsystem, other + // than for tracing purposes. + if let Some(activated) = update.activated { + let head = activated.hash; + let approval_distribution_span = + jaeger::PerLeafSpan::new(activated.span, "approval-distribution"); + state.spans.insert(head, approval_distribution_span); + } + }, + FromOrchestra::Signal(OverseerSignal::BlockFinalized(_hash, number)) => { + gum::trace!(target: LOG_TARGET, number = %number, "finalized signal"); + state.handle_block_finalized(network_sender, &self.metrics, number).await; + }, + FromOrchestra::Signal(OverseerSignal::Conclude) => return true, + } + false + } + + async fn handle_incoming< + N: overseer::SubsystemSender, + A: overseer::SubsystemSender, + >( + approval_voting_sender: &mut A, + network_sender: &mut N, state: &mut State, msg: ApprovalDistributionMessage, metrics: &Metrics, @@ -2470,10 +2577,14 @@ impl ApprovalDistribution { ) { match msg { ApprovalDistributionMessage::NetworkBridgeUpdate(event) => { - state.handle_network_msg(ctx, metrics, event, rng).await; + state + .handle_network_msg(approval_voting_sender, network_sender, metrics, event, rng) + .await; }, ApprovalDistributionMessage::NewBlocks(metas) => { - state.handle_new_blocks(ctx, metrics, metas, rng).await; + state + .handle_new_blocks(approval_voting_sender, network_sender, metrics, metas, rng) + .await; }, ApprovalDistributionMessage::DistributeAssignment(cert, candidate_indices) => { let _span = state @@ -2494,7 +2605,8 @@ impl ApprovalDistribution { state .import_and_circulate_assignment( - ctx, + approval_voting_sender, + network_sender, &metrics, MessageSource::Local, cert, @@ -2512,7 +2624,13 @@ impl ApprovalDistribution { ); state - .import_and_circulate_approval(ctx, metrics, MessageSource::Local, vote) + .import_and_circulate_approval( + approval_voting_sender, + network_sender, + metrics, + MessageSource::Local, + vote, + ) .await; }, ApprovalDistributionMessage::GetApprovalSignatures(indices, tx) => { @@ -2567,7 +2685,7 @@ pub const MAX_APPROVAL_BATCH_SIZE: usize = ensure_size_not_zero( // Low level helper for sending assignments. async fn send_assignments_batched_inner( - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, batch: impl IntoIterator, peers: Vec, peer_version: ValidationVersion, @@ -2622,7 +2740,7 @@ async fn send_assignments_batched_inner( /// destination, such that the subsystem doesn't get stuck for long processing a batch /// of assignments and can `select!` other tasks. pub(crate) async fn send_assignments_batched( - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + network_sender: &mut impl overseer::SubsystemSender, v2_assignments: impl IntoIterator + Clone, peers: &[(PeerId, ProtocolVersion)], ) { @@ -2646,7 +2764,7 @@ pub(crate) async fn send_assignments_batched( let batch: Vec<_> = v1_batches.by_ref().take(MAX_ASSIGNMENT_BATCH_SIZE).collect(); if !v1_peers.is_empty() { send_assignments_batched_inner( - sender, + network_sender, batch.clone(), v1_peers.clone(), ValidationVersion::V1, @@ -2656,7 +2774,7 @@ pub(crate) async fn send_assignments_batched( if !v2_peers.is_empty() { send_assignments_batched_inner( - sender, + network_sender, batch, v2_peers.clone(), ValidationVersion::V2, @@ -2671,15 +2789,20 @@ pub(crate) async fn send_assignments_batched( while v3.peek().is_some() { let batch = v3.by_ref().take(MAX_ASSIGNMENT_BATCH_SIZE).collect::>(); - send_assignments_batched_inner(sender, batch, v3_peers.clone(), ValidationVersion::V3) - .await; + send_assignments_batched_inner( + network_sender, + batch, + v3_peers.clone(), + ValidationVersion::V3, + ) + .await; } } } /// Send approvals while honoring the `max_notification_size` of the protocol and peer version. pub(crate) async fn send_approvals_batched( - sender: &mut impl overseer::ApprovalDistributionSenderTrait, + sender: &mut impl overseer::SubsystemSender, approvals: impl IntoIterator + Clone, peers: &[(PeerId, ProtocolVersion)], ) { diff --git a/polkadot/node/network/approval-distribution/src/tests.rs b/polkadot/node/network/approval-distribution/src/tests.rs index 3159fe2ae5e8d4e4df0ba7bf2f4c42b44d658686..1ca571721ea9063c9794eaa2c9017fcecdad2e7c 100644 --- a/polkadot/node/network/approval-distribution/src/tests.rs +++ b/polkadot/node/network/approval-distribution/src/tests.rs @@ -36,7 +36,6 @@ use polkadot_node_primitives::approval::{ use polkadot_node_subsystem::messages::{ network_bridge_event, AllMessages, ApprovalCheckError, ReportPeerMessage, }; -use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_node_subsystem_util::{reputation::add_reputation, TimeoutExt as _}; use polkadot_primitives::{AuthorityDiscoveryId, BlakeTwo256, CoreIndex, HashT}; use polkadot_primitives_test_helpers::dummy_signature; @@ -44,26 +43,29 @@ use rand::SeedableRng; use sp_authority_discovery::AuthorityPair as AuthorityDiscoveryPair; use sp_core::crypto::Pair as PairT; use std::time::Duration; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; fn test_harness>( mut state: State, test_fn: impl FnOnce(VirtualOverseer) -> T, ) -> State { - let _ = env_logger::builder() - .is_test(true) - .filter(Some(LOG_TARGET), log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = ApprovalDistribution::new(Default::default()); { let mut rng = rand_chacha::ChaCha12Rng::seed_from_u64(12345); - - let subsystem = - subsystem.run_inner(context, &mut state, REPUTATION_CHANGE_TEST_INTERVAL, &mut rng); + let (tx, rx) = oneshot::channel(); + let subsystem = async { + subsystem + .run_inner(context, &mut state, REPUTATION_CHANGE_TEST_INTERVAL, &mut rng) + .await; + tx.send(()).expect("Fail to notify subystem is done"); + }; let test_fut = test_fn(virtual_overseer); @@ -78,6 +80,8 @@ fn test_harness>( .timeout(TIMEOUT) .await .expect("Conclude send timeout"); + let _ = + rx.timeout(Duration::from_secs(2)).await.expect("Subsystem did not conclude"); }, subsystem, )); @@ -2403,7 +2407,7 @@ fn propagates_locally_generated_assignment_to_both_dimensions() { let assignments = vec![(cert.clone(), candidate_index)]; let approvals = vec![approval.clone()]; - let assignment_sent_peers = assert_matches!( + let mut assignment_sent_peers = assert_matches!( overseer_recv(overseer).await, AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage( sent_peers, @@ -2427,12 +2431,14 @@ fn propagates_locally_generated_assignment_to_both_dimensions() { assert_matches!( overseer_recv(overseer).await, AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage( - sent_peers, + mut sent_peers, Versioned::V1(protocol_v1::ValidationProtocol::ApprovalDistribution( protocol_v1::ApprovalDistributionMessage::Approvals(sent_approvals) )) )) => { // Random sampling is reused from the assignment. + sent_peers.sort(); + assignment_sent_peers.sort(); assert_eq!(sent_peers, assignment_sent_peers); assert_eq!(sent_approvals, approvals); } @@ -2677,7 +2683,7 @@ fn propagates_to_required_after_connect() { let assignments = vec![(cert.clone(), candidate_index)]; let approvals = vec![approval.clone()]; - let assignment_sent_peers = assert_matches!( + let mut assignment_sent_peers = assert_matches!( overseer_recv(overseer).await, AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage( sent_peers, @@ -2701,12 +2707,14 @@ fn propagates_to_required_after_connect() { assert_matches!( overseer_recv(overseer).await, AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage( - sent_peers, + mut sent_peers, Versioned::V1(protocol_v1::ValidationProtocol::ApprovalDistribution( protocol_v1::ApprovalDistributionMessage::Approvals(sent_approvals) )) )) => { // Random sampling is reused from the assignment. + sent_peers.sort(); + assignment_sent_peers.sort(); assert_eq!(sent_peers, assignment_sent_peers); assert_eq!(sent_approvals, approvals); } @@ -3657,7 +3665,8 @@ fn batch_test_round(message_count: usize) { let pool = sp_core::testing::TaskExecutor::new(); let mut state = State::default(); - let (mut context, mut virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (mut context, mut virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = ApprovalDistribution::new(Default::default()); let mut rng = rand_chacha::ChaCha12Rng::seed_from_u64(12345); let mut sender = context.sender().clone(); diff --git a/polkadot/node/network/availability-distribution/Cargo.toml b/polkadot/node/network/availability-distribution/Cargo.toml index b5636203f166efdbc2d871df778d148c0f9ce3e4..8c5574f244e4a0671e807cc46dcb1286bafaf3a2 100644 --- a/polkadot/node/network/availability-distribution/Cargo.toml +++ b/polkadot/node/network/availability-distribution/Cargo.toml @@ -10,33 +10,35 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -parity-scale-codec = { version = "3.6.1", features = ["std"] } -polkadot-primitives = { path = "../../../primitives" } -polkadot-erasure-coding = { path = "../../../erasure-coding" } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-primitives = { path = "../../primitives" } -sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } +futures = { workspace = true } +gum = { workspace = true, default-features = true } +codec = { features = ["std"], workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sp-core = { features = ["std"], workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } thiserror = { workspace = true } -rand = "0.8.5" -derive_more = "0.99.17" -schnellru = "0.2.1" -fatality = "0.0.6" +rand = { workspace = true, default-features = true } +derive_more = { workspace = true, default-features = true } +schnellru = { workspace = true } +fatality = { workspace = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -sc-network = { path = "../../../../substrate/client/network" } -futures-timer = "3.0.2" -assert_matches = "1.4.0" -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } -polkadot-subsystem-bench = { path = "../../subsystem-bench" } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-core = { features = ["std"], workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +futures-timer = { workspace = true } +assert_matches = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +rstest = { workspace = true } +polkadot-subsystem-bench = { workspace = true } [[bench]] diff --git a/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs b/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs index 5e3072be3a8c13d08bfec7fc5840320fcc33c6c5..4467941c849ccf36328d211745a3e858bea105fe 100644 --- a/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs +++ b/polkadot/node/network/availability-distribution/benches/availability-distribution-regression-bench.rs @@ -53,11 +53,7 @@ fn main() -> Result<(), String> { polkadot_subsystem_bench::availability::TestDataAvailability::Write, false, ); - env.runtime().block_on(benchmark_availability_write( - "data_availability_write", - &mut env, - &state, - )) + env.runtime().block_on(benchmark_availability_write(&mut env, &state)) }) .collect(); println!("\rDone!{}", " ".repeat(BENCH_COUNT)); @@ -77,8 +73,8 @@ fn main() -> Result<(), String> { ("Sent to peers", 18479.9000, 0.001), ])); messages.extend(average_usage.check_cpu_usage(&[ - ("availability-distribution", 0.0123, 0.1), - ("availability-store", 0.1597, 0.1), + ("availability-distribution", 0.0128, 0.1), + ("availability-store", 0.1733, 0.1), ("bitfield-distribution", 0.0223, 0.1), ])); diff --git a/polkadot/node/network/availability-distribution/src/error.rs b/polkadot/node/network/availability-distribution/src/error.rs index c547a1abbc27604862cebef2790223a0b54fac37..72a809dd114080f185c8aee45f87ff8655c236a4 100644 --- a/polkadot/node/network/availability-distribution/src/error.rs +++ b/polkadot/node/network/availability-distribution/src/error.rs @@ -49,7 +49,7 @@ pub enum Error { #[fatal] #[error("Oneshot for receiving response from Chain API got cancelled")] - ChainApiSenderDropped(#[source] oneshot::Canceled), + ChainApiSenderDropped(#[from] oneshot::Canceled), #[fatal] #[error("Retrieving response from Chain API unexpectedly failed with error: {0}")] @@ -82,6 +82,9 @@ pub enum Error { #[error("Given validator index could not be found in current session")] InvalidValidatorIndex, + + #[error("Erasure coding error: {0}")] + ErasureCoding(#[from] polkadot_erasure_coding::Error), } /// General result abbreviation type alias. @@ -104,7 +107,8 @@ pub fn log_error( JfyiError::InvalidValidatorIndex | JfyiError::NoSuchCachedSession { .. } | JfyiError::QueryAvailableDataResponseChannel(_) | - JfyiError::QueryChunkResponseChannel(_) => gum::warn!(target: LOG_TARGET, error = %jfyi, ctx), + JfyiError::QueryChunkResponseChannel(_) | + JfyiError::ErasureCoding(_) => gum::warn!(target: LOG_TARGET, error = %jfyi, ctx), JfyiError::FetchPoV(_) | JfyiError::SendResponse | JfyiError::NoSuchPoV | diff --git a/polkadot/node/network/availability-distribution/src/lib.rs b/polkadot/node/network/availability-distribution/src/lib.rs index c62ce1dd981a9ce8c4fe6e2b7c451a401e609b25..d3185e0af809c3b92df929d265f1962884d3f096 100644 --- a/polkadot/node/network/availability-distribution/src/lib.rs +++ b/polkadot/node/network/availability-distribution/src/lib.rs @@ -18,12 +18,14 @@ use futures::{future::Either, FutureExt, StreamExt, TryFutureExt}; use sp_keystore::KeystorePtr; -use polkadot_node_network_protocol::request_response::{v1, IncomingRequestReceiver}; +use polkadot_node_network_protocol::request_response::{ + v1, v2, IncomingRequestReceiver, ReqProtocolNames, +}; use polkadot_node_subsystem::{ jaeger, messages::AvailabilityDistributionMessage, overseer, FromOrchestra, OverseerSignal, SpawnedSubsystem, SubsystemError, }; -use polkadot_primitives::Hash; +use polkadot_primitives::{BlockNumber, Hash}; use std::collections::HashMap; /// Error and [`Result`] type for this subsystem. @@ -41,7 +43,7 @@ mod pov_requester; /// Responding to erasure chunk requests: mod responder; -use responder::{run_chunk_receiver, run_pov_receiver}; +use responder::{run_chunk_receivers, run_pov_receiver}; mod metrics; /// Prometheus `Metrics` for availability distribution. @@ -58,6 +60,8 @@ pub struct AvailabilityDistributionSubsystem { runtime: RuntimeInfo, /// Receivers to receive messages from. recvs: IncomingRequestReceivers, + /// Mapping of the req-response protocols to the full protocol names. + req_protocol_names: ReqProtocolNames, /// Prometheus metrics. metrics: Metrics, } @@ -66,8 +70,10 @@ pub struct AvailabilityDistributionSubsystem { pub struct IncomingRequestReceivers { /// Receiver for incoming PoV requests. pub pov_req_receiver: IncomingRequestReceiver, - /// Receiver for incoming availability chunk requests. - pub chunk_req_receiver: IncomingRequestReceiver, + /// Receiver for incoming v1 availability chunk requests. + pub chunk_req_v1_receiver: IncomingRequestReceiver, + /// Receiver for incoming v2 availability chunk requests. + pub chunk_req_v2_receiver: IncomingRequestReceiver, } #[overseer::subsystem(AvailabilityDistribution, error=SubsystemError, prefix=self::overseer)] @@ -85,18 +91,27 @@ impl AvailabilityDistributionSubsystem { #[overseer::contextbounds(AvailabilityDistribution, prefix = self::overseer)] impl AvailabilityDistributionSubsystem { /// Create a new instance of the availability distribution. - pub fn new(keystore: KeystorePtr, recvs: IncomingRequestReceivers, metrics: Metrics) -> Self { + pub fn new( + keystore: KeystorePtr, + recvs: IncomingRequestReceivers, + req_protocol_names: ReqProtocolNames, + metrics: Metrics, + ) -> Self { let runtime = RuntimeInfo::new(Some(keystore)); - Self { runtime, recvs, metrics } + Self { runtime, recvs, req_protocol_names, metrics } } /// Start processing work as passed on from the Overseer. async fn run(self, mut ctx: Context) -> std::result::Result<(), FatalError> { - let Self { mut runtime, recvs, metrics } = self; - let mut spans: HashMap = HashMap::new(); - - let IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver } = recvs; - let mut requester = Requester::new(metrics.clone()).fuse(); + let Self { mut runtime, recvs, metrics, req_protocol_names } = self; + let mut spans: HashMap = HashMap::new(); + + let IncomingRequestReceivers { + pov_req_receiver, + chunk_req_v1_receiver, + chunk_req_v2_receiver, + } = recvs; + let mut requester = Requester::new(req_protocol_names, metrics.clone()).fuse(); let mut warn_freq = gum::Freq::new(); { @@ -109,7 +124,13 @@ impl AvailabilityDistributionSubsystem { ctx.spawn( "chunk-receiver", - run_chunk_receiver(sender, chunk_req_receiver, metrics.clone()).boxed(), + run_chunk_receivers( + sender, + chunk_req_v1_receiver, + chunk_req_v2_receiver, + metrics.clone(), + ) + .boxed(), ) .map_err(FatalError::SpawnTask)?; } @@ -141,7 +162,7 @@ impl AvailabilityDistributionSubsystem { }; let span = jaeger::PerLeafSpan::new(cloned_leaf.span, "availability-distribution"); - spans.insert(cloned_leaf.hash, span); + spans.insert(cloned_leaf.hash, (cloned_leaf.number, span)); log_error( requester .get_mut() @@ -151,8 +172,8 @@ impl AvailabilityDistributionSubsystem { &mut warn_freq, )?; }, - FromOrchestra::Signal(OverseerSignal::BlockFinalized(hash, _)) => { - spans.remove(&hash); + FromOrchestra::Signal(OverseerSignal::BlockFinalized(_hash, finalized_number)) => { + spans.retain(|_hash, (block_number, _span)| *block_number > finalized_number); }, FromOrchestra::Signal(OverseerSignal::Conclude) => return Ok(()), FromOrchestra::Communication { @@ -168,7 +189,7 @@ impl AvailabilityDistributionSubsystem { } => { let span = spans .get(&relay_parent) - .map(|span| span.child("fetch-pov")) + .map(|(_, span)| span.child("fetch-pov")) .unwrap_or_else(|| jaeger::Span::new(&relay_parent, "fetch-pov")) .with_trace_id(candidate_hash) .with_candidate(candidate_hash) diff --git a/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs b/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs index f99002d4188bf584b927510d86ec0ef3eb272baa..6c632fa7efee6ecec2d11f7bb9f42cd8164587f1 100644 --- a/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs +++ b/polkadot/node/network/availability-distribution/src/pov_requester/mod.rs @@ -138,7 +138,7 @@ mod tests { use assert_matches::assert_matches; use futures::{executor, future}; - use parity_scale_codec::Encode; + use codec::Encode; use sc_network::ProtocolName; use sp_core::testing::TaskExecutor; @@ -169,10 +169,11 @@ mod tests { fn test_run(pov_hash: Hash, pov: PoV) { let pool = TaskExecutor::new(); - let (mut context, mut virtual_overseer) = test_helpers::make_subsystem_context::< - AvailabilityDistributionMessage, - TaskExecutor, - >(pool.clone()); + let (mut context, mut virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context::< + AvailabilityDistributionMessage, + TaskExecutor, + >(pool.clone()); let keystore = make_ferdie_keystore(); let mut runtime = polkadot_node_subsystem_util::runtime::RuntimeInfo::new(Some(keystore)); diff --git a/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs b/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs index f478defcaa96530d695eace0acad11057609d8e9..278608cc858df5e6f586606c5b66d37147d67e15 100644 --- a/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs +++ b/polkadot/node/network/availability-distribution/src/requester/fetch_task/mod.rs @@ -22,10 +22,12 @@ use futures::{ FutureExt, SinkExt, }; +use codec::Decode; use polkadot_erasure_coding::branch_hash; use polkadot_node_network_protocol::request_response::{ outgoing::{OutgoingRequest, Recipient, RequestError, Requests}, - v1::{ChunkFetchingRequest, ChunkFetchingResponse}, + v1::{self, ChunkResponse}, + v2, }; use polkadot_node_primitives::ErasureChunk; use polkadot_node_subsystem::{ @@ -34,9 +36,10 @@ use polkadot_node_subsystem::{ overseer, }; use polkadot_primitives::{ - AuthorityDiscoveryId, BlakeTwo256, CandidateHash, GroupIndex, Hash, HashT, OccupiedCore, - SessionIndex, + AuthorityDiscoveryId, BlakeTwo256, CandidateHash, ChunkIndex, GroupIndex, Hash, HashT, + OccupiedCore, SessionIndex, }; +use sc_network::ProtocolName; use crate::{ error::{FatalError, Result}, @@ -111,8 +114,8 @@ struct RunningTask { /// This vector gets drained during execution of the task (it will be empty afterwards). group: Vec, - /// The request to send. - request: ChunkFetchingRequest, + /// The request to send. We can store it as either v1 or v2, they have the same payload. + request: v2::ChunkFetchingRequest, /// Root hash, for verifying the chunks validity. erasure_root: Hash, @@ -128,6 +131,16 @@ struct RunningTask { /// Span tracking the fetching of this chunk. span: jaeger::Span, + + /// Expected chunk index. We'll validate that the remote did send us the correct chunk (only + /// important for v2 requests). + chunk_index: ChunkIndex, + + /// Full protocol name for ChunkFetchingV1. + req_v1_protocol_name: ProtocolName, + + /// Full protocol name for ChunkFetchingV2. + req_v2_protocol_name: ProtocolName, } impl FetchTaskConfig { @@ -140,13 +153,17 @@ impl FetchTaskConfig { sender: mpsc::Sender, metrics: Metrics, session_info: &SessionInfo, + chunk_index: ChunkIndex, span: jaeger::Span, + req_v1_protocol_name: ProtocolName, + req_v2_protocol_name: ProtocolName, ) -> Self { let span = span .child("fetch-task-config") .with_trace_id(core.candidate_hash) .with_string_tag("leaf", format!("{:?}", leaf)) .with_validator_index(session_info.our_index) + .with_chunk_index(chunk_index) .with_uint_tag("group-index", core.group_responsible.0 as u64) .with_relay_parent(core.candidate_descriptor.relay_parent) .with_string_tag("pov-hash", format!("{:?}", core.candidate_descriptor.pov_hash)) @@ -165,7 +182,7 @@ impl FetchTaskConfig { group: session_info.validator_groups.get(core.group_responsible.0 as usize) .expect("The responsible group of a candidate should be available in the corresponding session. qed.") .clone(), - request: ChunkFetchingRequest { + request: v2::ChunkFetchingRequest { candidate_hash: core.candidate_hash, index: session_info.our_index, }, @@ -174,6 +191,9 @@ impl FetchTaskConfig { metrics, sender, span, + chunk_index, + req_v1_protocol_name, + req_v2_protocol_name }; FetchTaskConfig { live_in, prepared_running: Some(prepared_running) } } @@ -271,7 +291,8 @@ impl RunningTask { count += 1; let _chunk_fetch_span = span .child("fetch-chunk-request") - .with_chunk_index(self.request.index.0) + .with_validator_index(self.request.index) + .with_chunk_index(self.chunk_index) .with_stage(jaeger::Stage::AvailabilityDistribution); // Send request: let resp = match self @@ -296,11 +317,12 @@ impl RunningTask { drop(_chunk_fetch_span); let _chunk_recombine_span = span .child("recombine-chunk") - .with_chunk_index(self.request.index.0) + .with_validator_index(self.request.index) + .with_chunk_index(self.chunk_index) .with_stage(jaeger::Stage::AvailabilityDistribution); let chunk = match resp { - ChunkFetchingResponse::Chunk(resp) => resp.recombine_into_chunk(&self.request), - ChunkFetchingResponse::NoSuchChunk => { + Some(chunk) => chunk, + None => { gum::debug!( target: LOG_TARGET, validator = ?validator, @@ -320,11 +342,12 @@ impl RunningTask { drop(_chunk_recombine_span); let _chunk_validate_and_store_span = span .child("validate-and-store-chunk") - .with_chunk_index(self.request.index.0) + .with_validator_index(self.request.index) + .with_chunk_index(self.chunk_index) .with_stage(jaeger::Stage::AvailabilityDistribution); // Data genuine? - if !self.validate_chunk(&validator, &chunk) { + if !self.validate_chunk(&validator, &chunk, self.chunk_index) { bad_validators.push(validator); continue } @@ -350,7 +373,7 @@ impl RunningTask { validator: &AuthorityDiscoveryId, network_error_freq: &mut gum::Freq, canceled_freq: &mut gum::Freq, - ) -> std::result::Result { + ) -> std::result::Result, TaskError> { gum::trace!( target: LOG_TARGET, origin = ?validator, @@ -362,9 +385,13 @@ impl RunningTask { "Starting chunk request", ); - let (full_request, response_recv) = - OutgoingRequest::new(Recipient::Authority(validator.clone()), self.request); - let requests = Requests::ChunkFetchingV1(full_request); + let (full_request, response_recv) = OutgoingRequest::new_with_fallback( + Recipient::Authority(validator.clone()), + self.request, + // Fallback to v1, for backwards compatibility. + v1::ChunkFetchingRequest::from(self.request), + ); + let requests = Requests::ChunkFetching(full_request); self.sender .send(FromFetchTask::Message( @@ -378,7 +405,58 @@ impl RunningTask { .map_err(|_| TaskError::ShuttingDown)?; match response_recv.await { - Ok(resp) => Ok(resp), + Ok((bytes, protocol)) => match protocol { + _ if protocol == self.req_v2_protocol_name => + match v2::ChunkFetchingResponse::decode(&mut &bytes[..]) { + Ok(chunk_response) => Ok(Option::::from(chunk_response)), + Err(e) => { + gum::warn!( + target: LOG_TARGET, + origin = ?validator, + relay_parent = ?self.relay_parent, + group_index = ?self.group_index, + session_index = ?self.session_index, + chunk_index = ?self.request.index, + candidate_hash = ?self.request.candidate_hash, + err = ?e, + "Peer sent us invalid erasure chunk data (v2)" + ); + Err(TaskError::PeerError) + }, + }, + _ if protocol == self.req_v1_protocol_name => + match v1::ChunkFetchingResponse::decode(&mut &bytes[..]) { + Ok(chunk_response) => Ok(Option::::from(chunk_response) + .map(|c| c.recombine_into_chunk(&self.request.into()))), + Err(e) => { + gum::warn!( + target: LOG_TARGET, + origin = ?validator, + relay_parent = ?self.relay_parent, + group_index = ?self.group_index, + session_index = ?self.session_index, + chunk_index = ?self.request.index, + candidate_hash = ?self.request.candidate_hash, + err = ?e, + "Peer sent us invalid erasure chunk data" + ); + Err(TaskError::PeerError) + }, + }, + _ => { + gum::warn!( + target: LOG_TARGET, + origin = ?validator, + relay_parent = ?self.relay_parent, + group_index = ?self.group_index, + session_index = ?self.session_index, + chunk_index = ?self.request.index, + candidate_hash = ?self.request.candidate_hash, + "Peer sent us invalid erasure chunk data - unknown protocol" + ); + Err(TaskError::PeerError) + }, + }, Err(RequestError::InvalidResponse(err)) => { gum::warn!( target: LOG_TARGET, @@ -427,7 +505,23 @@ impl RunningTask { } } - fn validate_chunk(&self, validator: &AuthorityDiscoveryId, chunk: &ErasureChunk) -> bool { + fn validate_chunk( + &self, + validator: &AuthorityDiscoveryId, + chunk: &ErasureChunk, + expected_chunk_index: ChunkIndex, + ) -> bool { + if chunk.index != expected_chunk_index { + gum::warn!( + target: LOG_TARGET, + candidate_hash = ?self.request.candidate_hash, + origin = ?validator, + chunk_index = ?chunk.index, + expected_chunk_index = ?expected_chunk_index, + "Validator sent the wrong chunk", + ); + return false + } let anticipated_hash = match branch_hash(&self.erasure_root, chunk.proof(), chunk.index.0 as usize) { Ok(hash) => hash, @@ -459,6 +553,7 @@ impl RunningTask { AvailabilityStoreMessage::StoreChunk { candidate_hash: self.request.candidate_hash, chunk, + validator_index: self.request.index, tx, } .into(), diff --git a/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs b/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs index a5a81082e39ad8897845363960120956b1599a95..2cd4bf29a56356dc56dd2538467da0f2078fccaf 100644 --- a/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs +++ b/polkadot/node/network/availability-distribution/src/requester/fetch_task/tests.rs @@ -16,7 +16,7 @@ use std::collections::HashMap; -use parity_scale_codec::Encode; +use codec::Encode; use futures::{ channel::{mpsc, oneshot}, @@ -24,21 +24,26 @@ use futures::{ task::{noop_waker, Context, Poll}, Future, FutureExt, StreamExt, }; +use rstest::rstest; use sc_network::{self as network, ProtocolName}; use sp_keyring::Sr25519Keyring; -use polkadot_node_network_protocol::request_response::{v1, Recipient}; +use polkadot_node_network_protocol::request_response::{ + v1::{self, ChunkResponse}, + Protocol, Recipient, ReqProtocolNames, +}; use polkadot_node_primitives::{BlockData, PoV, Proof}; use polkadot_node_subsystem::messages::AllMessages; -use polkadot_primitives::{CandidateHash, ValidatorIndex}; +use polkadot_primitives::{CandidateHash, ChunkIndex, ValidatorIndex}; use super::*; use crate::{metrics::Metrics, tests::mock::get_valid_chunk_data}; #[test] fn task_can_be_canceled() { - let (task, _rx) = get_test_running_task(); + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + let (task, _rx) = get_test_running_task(&req_protocol_names, 0.into(), 0.into()); let (handle, kill) = oneshot::channel(); std::mem::drop(handle); let running_task = task.run(kill); @@ -49,96 +54,130 @@ fn task_can_be_canceled() { } /// Make sure task won't accept a chunk that has is invalid. -#[test] -fn task_does_not_accept_invalid_chunk() { - let (mut task, rx) = get_test_running_task(); +#[rstest] +#[case(Protocol::ChunkFetchingV1)] +#[case(Protocol::ChunkFetchingV2)] +fn task_does_not_accept_invalid_chunk(#[case] protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + let chunk_index = ChunkIndex(1); + let validator_index = ValidatorIndex(0); + let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index); let validators = vec![Sr25519Keyring::Alice.public().into()]; task.group = validators; + let protocol_name = req_protocol_names.get_name(protocol); let test = TestRun { chunk_responses: { - let mut m = HashMap::new(); - m.insert( + [( Recipient::Authority(Sr25519Keyring::Alice.public().into()), - ChunkFetchingResponse::Chunk(v1::ChunkResponse { - chunk: vec![1, 2, 3], - proof: Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(), - }), - ); - m + get_response( + protocol, + protocol_name.clone(), + Some(( + vec![1, 2, 3], + Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(), + chunk_index, + )), + ), + )] + .into_iter() + .collect() }, valid_chunks: HashSet::new(), + req_protocol_names, }; test.run(task, rx); } -#[test] -fn task_stores_valid_chunk() { - let (mut task, rx) = get_test_running_task(); +#[rstest] +#[case(Protocol::ChunkFetchingV1)] +#[case(Protocol::ChunkFetchingV2)] +fn task_stores_valid_chunk(#[case] protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + // In order for protocol version 1 to work, the chunk index needs to be equal to the validator + // index. + let chunk_index = ChunkIndex(0); + let validator_index = + if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(0) } else { ValidatorIndex(1) }; + let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index); + let validators = vec![Sr25519Keyring::Alice.public().into()]; let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; - let (root_hash, chunk) = get_valid_chunk_data(pov); + let (root_hash, chunk) = get_valid_chunk_data(pov, 10, chunk_index); task.erasure_root = root_hash; - task.request.index = chunk.index; - - let validators = vec![Sr25519Keyring::Alice.public().into()]; task.group = validators; + let protocol_name = req_protocol_names.get_name(protocol); let test = TestRun { chunk_responses: { - let mut m = HashMap::new(); - m.insert( + [( Recipient::Authority(Sr25519Keyring::Alice.public().into()), - ChunkFetchingResponse::Chunk(v1::ChunkResponse { - chunk: chunk.chunk.clone(), - proof: chunk.proof, - }), - ); - m - }, - valid_chunks: { - let mut s = HashSet::new(); - s.insert(chunk.chunk); - s + get_response( + protocol, + protocol_name.clone(), + Some((chunk.chunk.clone(), chunk.proof, chunk_index)), + ), + )] + .into_iter() + .collect() }, + valid_chunks: [(chunk.chunk)].into_iter().collect(), + req_protocol_names, }; test.run(task, rx); } -#[test] -fn task_does_not_accept_wrongly_indexed_chunk() { - let (mut task, rx) = get_test_running_task(); - let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; - let (root_hash, chunk) = get_valid_chunk_data(pov); - task.erasure_root = root_hash; - task.request.index = ValidatorIndex(chunk.index.0 + 1); +#[rstest] +#[case(Protocol::ChunkFetchingV1)] +#[case(Protocol::ChunkFetchingV2)] +fn task_does_not_accept_wrongly_indexed_chunk(#[case] protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + // In order for protocol version 1 to work, the chunk index needs to be equal to the validator + // index. + let chunk_index = ChunkIndex(0); + let validator_index = + if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(0) } else { ValidatorIndex(1) }; + let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index); let validators = vec![Sr25519Keyring::Alice.public().into()]; + let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; + let (_, other_chunk) = get_valid_chunk_data(pov.clone(), 10, ChunkIndex(3)); + let (root_hash, chunk) = get_valid_chunk_data(pov, 10, ChunkIndex(0)); + task.erasure_root = root_hash; + task.request.index = chunk.index.into(); task.group = validators; + let protocol_name = req_protocol_names.get_name(protocol); let test = TestRun { chunk_responses: { - let mut m = HashMap::new(); - m.insert( + [( Recipient::Authority(Sr25519Keyring::Alice.public().into()), - ChunkFetchingResponse::Chunk(v1::ChunkResponse { - chunk: chunk.chunk.clone(), - proof: chunk.proof, - }), - ); - m + get_response( + protocol, + protocol_name.clone(), + Some((other_chunk.chunk.clone(), chunk.proof, other_chunk.index)), + ), + )] + .into_iter() + .collect() }, valid_chunks: HashSet::new(), + req_protocol_names, }; test.run(task, rx); } /// Task stores chunk, if there is at least one validator having a valid chunk. -#[test] -fn task_stores_valid_chunk_if_there_is_one() { - let (mut task, rx) = get_test_running_task(); +#[rstest] +#[case(Protocol::ChunkFetchingV1)] +#[case(Protocol::ChunkFetchingV2)] +fn task_stores_valid_chunk_if_there_is_one(#[case] protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + // In order for protocol version 1 to work, the chunk index needs to be equal to the validator + // index. + let chunk_index = ChunkIndex(1); + let validator_index = + if protocol == Protocol::ChunkFetchingV1 { ValidatorIndex(1) } else { ValidatorIndex(2) }; + let (mut task, rx) = get_test_running_task(&req_protocol_names, validator_index, chunk_index); let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; - let (root_hash, chunk) = get_valid_chunk_data(pov); - task.erasure_root = root_hash; - task.request.index = chunk.index; let validators = [ // Only Alice has valid chunk - should succeed, even though she is tried last. @@ -151,37 +190,45 @@ fn task_stores_valid_chunk_if_there_is_one() { .iter() .map(|v| v.public().into()) .collect::>(); + + let (root_hash, chunk) = get_valid_chunk_data(pov, 10, chunk_index); + task.erasure_root = root_hash; task.group = validators; + let protocol_name = req_protocol_names.get_name(protocol); let test = TestRun { chunk_responses: { - let mut m = HashMap::new(); - m.insert( - Recipient::Authority(Sr25519Keyring::Alice.public().into()), - ChunkFetchingResponse::Chunk(v1::ChunkResponse { - chunk: chunk.chunk.clone(), - proof: chunk.proof, - }), - ); - m.insert( - Recipient::Authority(Sr25519Keyring::Bob.public().into()), - ChunkFetchingResponse::NoSuchChunk, - ); - m.insert( - Recipient::Authority(Sr25519Keyring::Charlie.public().into()), - ChunkFetchingResponse::Chunk(v1::ChunkResponse { - chunk: vec![1, 2, 3], - proof: Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(), - }), - ); - - m - }, - valid_chunks: { - let mut s = HashSet::new(); - s.insert(chunk.chunk); - s + [ + ( + Recipient::Authority(Sr25519Keyring::Alice.public().into()), + get_response( + protocol, + protocol_name.clone(), + Some((chunk.chunk.clone(), chunk.proof, chunk_index)), + ), + ), + ( + Recipient::Authority(Sr25519Keyring::Bob.public().into()), + get_response(protocol, protocol_name.clone(), None), + ), + ( + Recipient::Authority(Sr25519Keyring::Charlie.public().into()), + get_response( + protocol, + protocol_name.clone(), + Some(( + vec![1, 2, 3], + Proof::try_from(vec![vec![9, 8, 2], vec![2, 3, 4]]).unwrap(), + chunk_index, + )), + ), + ), + ] + .into_iter() + .collect() }, + valid_chunks: [(chunk.chunk)].into_iter().collect(), + req_protocol_names, }; test.run(task, rx); } @@ -189,14 +236,16 @@ fn task_stores_valid_chunk_if_there_is_one() { struct TestRun { /// Response to deliver for a given validator index. /// None means, answer with `NetworkError`. - chunk_responses: HashMap, + chunk_responses: HashMap, ProtocolName)>, /// Set of chunks that should be considered valid: valid_chunks: HashSet>, + /// Request protocol names + req_protocol_names: ReqProtocolNames, } impl TestRun { fn run(self, task: RunningTask, rx: mpsc::Receiver) { - sp_tracing::try_init_simple(); + sp_tracing::init_for_tests(); let mut rx = rx.fuse(); let task = task.run_inner().fuse(); futures::pin_mut!(task); @@ -240,20 +289,41 @@ impl TestRun { let mut valid_responses = 0; for req in reqs { let req = match req { - Requests::ChunkFetchingV1(req) => req, + Requests::ChunkFetching(req) => req, _ => panic!("Unexpected request"), }; let response = self.chunk_responses.get(&req.peer).ok_or(network::RequestFailure::Refused); - if let Ok(ChunkFetchingResponse::Chunk(resp)) = &response { - if self.valid_chunks.contains(&resp.chunk) { - valid_responses += 1; + if let Ok((resp, protocol)) = response { + let chunk = if protocol == + &self.req_protocol_names.get_name(Protocol::ChunkFetchingV1) + { + Into::>::into( + v1::ChunkFetchingResponse::decode(&mut &resp[..]).unwrap(), + ) + .map(|c| c.chunk) + } else if protocol == + &self.req_protocol_names.get_name(Protocol::ChunkFetchingV2) + { + Into::>::into( + v2::ChunkFetchingResponse::decode(&mut &resp[..]).unwrap(), + ) + .map(|c| c.chunk) + } else { + unreachable!() + }; + + if let Some(chunk) = chunk { + if self.valid_chunks.contains(&chunk) { + valid_responses += 1; + } } + + req.pending_response + .send(response.cloned()) + .expect("Sending response should succeed"); } - req.pending_response - .send(response.map(|r| (r.encode(), ProtocolName::from("")))) - .expect("Sending response should succeed"); } return (valid_responses == 0) && self.valid_chunks.is_empty() }, @@ -274,8 +344,12 @@ impl TestRun { } } -/// Get a `RunningTask` filled with dummy values. -fn get_test_running_task() -> (RunningTask, mpsc::Receiver) { +/// Get a `RunningTask` filled with (mostly) dummy values. +fn get_test_running_task( + req_protocol_names: &ReqProtocolNames, + validator_index: ValidatorIndex, + chunk_index: ChunkIndex, +) -> (RunningTask, mpsc::Receiver) { let (tx, rx) = mpsc::channel(0); ( @@ -283,16 +357,45 @@ fn get_test_running_task() -> (RunningTask, mpsc::Receiver) { session_index: 0, group_index: GroupIndex(0), group: Vec::new(), - request: ChunkFetchingRequest { + request: v2::ChunkFetchingRequest { candidate_hash: CandidateHash([43u8; 32].into()), - index: ValidatorIndex(0), + index: validator_index, }, erasure_root: Hash::repeat_byte(99), relay_parent: Hash::repeat_byte(71), sender: tx, metrics: Metrics::new_dummy(), span: jaeger::Span::Disabled, + req_v1_protocol_name: req_protocol_names.get_name(Protocol::ChunkFetchingV1), + req_v2_protocol_name: req_protocol_names.get_name(Protocol::ChunkFetchingV2), + chunk_index, }, rx, ) } + +/// Make a versioned ChunkFetchingResponse. +fn get_response( + protocol: Protocol, + protocol_name: ProtocolName, + chunk: Option<(Vec, Proof, ChunkIndex)>, +) -> (Vec, ProtocolName) { + ( + match protocol { + Protocol::ChunkFetchingV1 => if let Some((chunk, proof, _)) = chunk { + v1::ChunkFetchingResponse::Chunk(ChunkResponse { chunk, proof }) + } else { + v1::ChunkFetchingResponse::NoSuchChunk + } + .encode(), + Protocol::ChunkFetchingV2 => if let Some((chunk, proof, index)) = chunk { + v2::ChunkFetchingResponse::Chunk(ErasureChunk { chunk, index, proof }) + } else { + v2::ChunkFetchingResponse::NoSuchChunk + } + .encode(), + _ => unreachable!(), + }, + protocol_name, + ) +} diff --git a/polkadot/node/network/availability-distribution/src/requester/mod.rs b/polkadot/node/network/availability-distribution/src/requester/mod.rs index 97e80d696e7ef2adabdbc24dda76172603e462f0..0175161af70dfa706e02bad07ca9fabd4bb1109e 100644 --- a/polkadot/node/network/availability-distribution/src/requester/mod.rs +++ b/polkadot/node/network/availability-distribution/src/requester/mod.rs @@ -18,10 +18,7 @@ //! availability. use std::{ - collections::{ - hash_map::{Entry, HashMap}, - hash_set::HashSet, - }, + collections::{hash_map::HashMap, hash_set::HashSet}, iter::IntoIterator, pin::Pin, }; @@ -32,13 +29,19 @@ use futures::{ Stream, }; +use polkadot_node_network_protocol::request_response::{v1, v2, IsRequest, ReqProtocolNames}; use polkadot_node_subsystem::{ jaeger, messages::{ChainApiMessage, RuntimeApiMessage}, overseer, ActivatedLeaf, ActiveLeavesUpdate, }; -use polkadot_node_subsystem_util::runtime::{get_occupied_cores, RuntimeInfo}; -use polkadot_primitives::{CandidateHash, Hash, OccupiedCore, SessionIndex}; +use polkadot_node_subsystem_util::{ + availability_chunks::availability_chunk_index, + runtime::{get_occupied_cores, RuntimeInfo}, +}; +use polkadot_primitives::{ + BlockNumber, CandidateHash, CoreIndex, Hash, OccupiedCore, SessionIndex, +}; use super::{FatalError, Metrics, Result, LOG_TARGET}; @@ -77,6 +80,9 @@ pub struct Requester { /// Prometheus Metrics metrics: Metrics, + + /// Mapping of the req-response protocols to the full protocol names. + req_protocol_names: ReqProtocolNames, } #[overseer::contextbounds(AvailabilityDistribution, prefix = self::overseer)] @@ -88,9 +94,16 @@ impl Requester { /// /// You must feed it with `ActiveLeavesUpdate` via `update_fetching_heads` and make it progress /// by advancing the stream. - pub fn new(metrics: Metrics) -> Self { + pub fn new(req_protocol_names: ReqProtocolNames, metrics: Metrics) -> Self { let (tx, rx) = mpsc::channel(1); - Requester { fetches: HashMap::new(), session_cache: SessionCache::new(), tx, rx, metrics } + Requester { + fetches: HashMap::new(), + session_cache: SessionCache::new(), + tx, + rx, + metrics, + req_protocol_names, + } } /// Update heads that need availability distribution. @@ -101,14 +114,14 @@ impl Requester { ctx: &mut Context, runtime: &mut RuntimeInfo, update: ActiveLeavesUpdate, - spans: &HashMap, + spans: &HashMap, ) -> Result<()> { gum::trace!(target: LOG_TARGET, ?update, "Update fetching heads"); let ActiveLeavesUpdate { activated, deactivated } = update; if let Some(leaf) = activated { let span = spans .get(&leaf.hash) - .map(|span| span.child("update-fetching-heads")) + .map(|(_, span)| span.child("update-fetching-heads")) .unwrap_or_else(|| jaeger::Span::new(&leaf.hash, "update-fetching-heads")) .with_string_tag("leaf", format!("{:?}", leaf.hash)) .with_stage(jaeger::Stage::AvailabilityDistribution); @@ -197,56 +210,76 @@ impl Requester { runtime: &mut RuntimeInfo, leaf: Hash, leaf_session_index: SessionIndex, - cores: impl IntoIterator, + cores: impl IntoIterator, span: jaeger::Span, ) -> Result<()> { - for core in cores { + for (core_index, core) in cores { let mut span = span .child("check-fetch-candidate") .with_trace_id(core.candidate_hash) .with_string_tag("leaf", format!("{:?}", leaf)) .with_candidate(core.candidate_hash) .with_stage(jaeger::Stage::AvailabilityDistribution); - match self.fetches.entry(core.candidate_hash) { - Entry::Occupied(mut e) => + + if let Some(e) = self.fetches.get_mut(&core.candidate_hash) { // Just book keeping - we are already requesting that chunk: - { - span.add_string_tag("already-requested-chunk", "true"); - e.get_mut().add_leaf(leaf); - }, - Entry::Vacant(e) => { - span.add_string_tag("already-requested-chunk", "false"); - let tx = self.tx.clone(); - let metrics = self.metrics.clone(); - - let task_cfg = self - .session_cache - .with_session_info( - context, - runtime, - // We use leaf here, the relay_parent must be in the same session as - // the leaf. This is guaranteed by runtime which ensures that cores are - // cleared at session boundaries. At the same time, only leaves are - // guaranteed to be fetchable by the state trie. - leaf, - leaf_session_index, - |info| FetchTaskConfig::new(leaf, &core, tx, metrics, info, span), - ) - .await - .map_err(|err| { - gum::warn!( - target: LOG_TARGET, - error = ?err, - "Failed to spawn a fetch task" - ); - err + span.add_string_tag("already-requested-chunk", "true"); + e.add_leaf(leaf); + } else { + span.add_string_tag("already-requested-chunk", "false"); + let tx = self.tx.clone(); + let metrics = self.metrics.clone(); + + let session_info = self + .session_cache + .get_session_info( + context, + runtime, + // We use leaf here, the relay_parent must be in the same session as + // the leaf. This is guaranteed by runtime which ensures that cores are + // cleared at session boundaries. At the same time, only leaves are + // guaranteed to be fetchable by the state trie. + leaf, + leaf_session_index, + ) + .await + .map_err(|err| { + gum::warn!( + target: LOG_TARGET, + error = ?err, + "Failed to spawn a fetch task" + ); + err + })?; + + if let Some(session_info) = session_info { + let n_validators = + session_info.validator_groups.iter().fold(0usize, |mut acc, group| { + acc = acc.saturating_add(group.len()); + acc }); - - if let Ok(Some(task_cfg)) = task_cfg { - e.insert(FetchTask::start(task_cfg, context).await?); - } - // Not a validator, nothing to do. - }, + let chunk_index = availability_chunk_index( + session_info.node_features.as_ref(), + n_validators, + core_index, + session_info.our_index, + )?; + + let task_cfg = FetchTaskConfig::new( + leaf, + &core, + tx, + metrics, + session_info, + chunk_index, + span, + self.req_protocol_names.get_name(v1::ChunkFetchingRequest::PROTOCOL), + self.req_protocol_names.get_name(v2::ChunkFetchingRequest::PROTOCOL), + ); + + self.fetches + .insert(core.candidate_hash, FetchTask::start(task_cfg, context).await?); + } } } Ok(()) diff --git a/polkadot/node/network/availability-distribution/src/requester/session_cache.rs b/polkadot/node/network/availability-distribution/src/requester/session_cache.rs index 8a48e19c2827d13fe2d15ea4cc5ded50f058ca03..a762c262dba3ec1df0c7609017b704d867f11141 100644 --- a/polkadot/node/network/availability-distribution/src/requester/session_cache.rs +++ b/polkadot/node/network/availability-distribution/src/requester/session_cache.rs @@ -20,8 +20,10 @@ use rand::{seq::SliceRandom, thread_rng}; use schnellru::{ByLength, LruMap}; use polkadot_node_subsystem::overseer; -use polkadot_node_subsystem_util::runtime::RuntimeInfo; -use polkadot_primitives::{AuthorityDiscoveryId, GroupIndex, Hash, SessionIndex, ValidatorIndex}; +use polkadot_node_subsystem_util::runtime::{request_node_features, RuntimeInfo}; +use polkadot_primitives::{ + AuthorityDiscoveryId, GroupIndex, Hash, NodeFeatures, SessionIndex, ValidatorIndex, +}; use crate::{ error::{Error, Result}, @@ -62,6 +64,9 @@ pub struct SessionInfo { /// /// `None`, if we are not in fact part of any group. pub our_group: Option, + + /// Node features. + pub node_features: Option, } /// Report of bad validators. @@ -87,39 +92,29 @@ impl SessionCache { } } - /// Tries to retrieve `SessionInfo` and calls `with_info` if successful. - /// + /// Tries to retrieve `SessionInfo`. /// If this node is not a validator, the function will return `None`. - /// - /// Use this function over any `fetch_session_info` if all you need is a reference to - /// `SessionInfo`, as it avoids an expensive clone. - pub async fn with_session_info( - &mut self, + pub async fn get_session_info<'a, Context>( + &'a mut self, ctx: &mut Context, runtime: &mut RuntimeInfo, parent: Hash, session_index: SessionIndex, - with_info: F, - ) -> Result> - where - F: FnOnce(&SessionInfo) -> R, - { - if let Some(o_info) = self.session_info_cache.get(&session_index) { - gum::trace!(target: LOG_TARGET, session_index, "Got session from lru"); - return Ok(Some(with_info(o_info))) + ) -> Result> { + gum::trace!(target: LOG_TARGET, session_index, "Calling `get_session_info`"); + + if self.session_info_cache.get(&session_index).is_none() { + if let Some(info) = + Self::query_info_from_runtime(ctx, runtime, parent, session_index).await? + { + gum::trace!(target: LOG_TARGET, session_index, "Storing session info in lru!"); + self.session_info_cache.insert(session_index, info); + } else { + return Ok(None) + } } - if let Some(info) = - self.query_info_from_runtime(ctx, runtime, parent, session_index).await? - { - gum::trace!(target: LOG_TARGET, session_index, "Calling `with_info`"); - let r = with_info(&info); - gum::trace!(target: LOG_TARGET, session_index, "Storing session info in lru!"); - self.session_info_cache.insert(session_index, info); - Ok(Some(r)) - } else { - Ok(None) - } + Ok(self.session_info_cache.get(&session_index).map(|i| &*i)) } /// Variant of `report_bad` that never fails, but just logs errors. @@ -171,7 +166,6 @@ impl SessionCache { /// /// Returns: `None` if not a validator. async fn query_info_from_runtime( - &self, ctx: &mut Context, runtime: &mut RuntimeInfo, relay_parent: Hash, @@ -181,6 +175,9 @@ impl SessionCache { .get_session_info_by_index(ctx.sender(), relay_parent, session_index) .await?; + let node_features = + request_node_features(relay_parent, session_index, ctx.sender()).await?; + let discovery_keys = info.session_info.discovery_keys.clone(); let mut validator_groups = info.session_info.validator_groups.clone(); @@ -208,7 +205,13 @@ impl SessionCache { }) .collect(); - let info = SessionInfo { validator_groups, our_index, session_index, our_group }; + let info = SessionInfo { + validator_groups, + our_index, + session_index, + our_group, + node_features, + }; return Ok(Some(info)) } return Ok(None) diff --git a/polkadot/node/network/availability-distribution/src/requester/tests.rs b/polkadot/node/network/availability-distribution/src/requester/tests.rs index 0dedd4f091acd692c5b319f5669c1356bf335e2b..decb3156004ef6dc52332ef6a4998a3e33ed8ed0 100644 --- a/polkadot/node/network/availability-distribution/src/requester/tests.rs +++ b/polkadot/node/network/availability-distribution/src/requester/tests.rs @@ -14,21 +14,17 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use std::collections::HashMap; - -use std::future::Future; - use futures::FutureExt; +use std::{collections::HashMap, future::Future}; -use polkadot_node_network_protocol::jaeger; +use polkadot_node_network_protocol::{jaeger, request_response::ReqProtocolNames}; use polkadot_node_primitives::{BlockData, ErasureChunk, PoV}; -use polkadot_node_subsystem_test_helpers::mock::new_leaf; use polkadot_node_subsystem_util::runtime::RuntimeInfo; use polkadot_primitives::{ - BlockNumber, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId, NodeFeatures, + BlockNumber, ChunkIndex, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId, ScheduledCore, SessionIndex, SessionInfo, }; -use sp_core::traits::SpawnNamed; +use sp_core::{testing::TaskExecutor, traits::SpawnNamed}; use polkadot_node_subsystem::{ messages::{ @@ -38,19 +34,21 @@ use polkadot_node_subsystem::{ ActiveLeavesUpdate, SpawnGlue, }; use polkadot_node_subsystem_test_helpers::{ - make_subsystem_context, mock::make_ferdie_keystore, TestSubsystemContext, - TestSubsystemContextHandle, + make_subsystem_context, + mock::{make_ferdie_keystore, new_leaf}, + TestSubsystemContext, TestSubsystemContextHandle, }; -use sp_core::testing::TaskExecutor; - -use crate::tests::mock::{get_valid_chunk_data, make_session_info, OccupiedCoreBuilder}; +use crate::tests::{ + mock::{get_valid_chunk_data, make_session_info, OccupiedCoreBuilder}, + node_features_with_mapping_enabled, +}; use super::Requester; fn get_erasure_chunk() -> ErasureChunk { let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; - get_valid_chunk_data(pov).1 + get_valid_chunk_data(pov, 10, ChunkIndex(0)).1 } #[derive(Clone)] @@ -126,7 +124,7 @@ fn spawn_virtual_overseer( .expect("Receiver should be alive."); }, RuntimeApiRequest::NodeFeatures(_, tx) => { - tx.send(Ok(NodeFeatures::EMPTY)) + tx.send(Ok(node_features_with_mapping_enabled())) .expect("Receiver should be alive."); }, RuntimeApiRequest::AvailabilityCores(tx) => { @@ -146,6 +144,8 @@ fn spawn_virtual_overseer( group_responsible: GroupIndex(1), para_id, relay_parent: hash, + n_validators: 10, + chunk_index: ChunkIndex(0), } .build() .0, @@ -201,13 +201,14 @@ fn test_harness>( #[test] fn check_ancestry_lookup_in_same_session() { let test_state = TestState::new(); - let mut requester = Requester::new(Default::default()); + let mut requester = + Requester::new(ReqProtocolNames::new(&Hash::repeat_byte(0xff), None), Default::default()); let keystore = make_ferdie_keystore(); let mut runtime = RuntimeInfo::new(Some(keystore)); test_harness(test_state.clone(), |mut ctx| async move { let chain = &test_state.relay_chain; - let spans: HashMap = HashMap::new(); + let spans: HashMap = HashMap::new(); let block_number = 1; let update = ActiveLeavesUpdate { activated: Some(new_leaf(chain[block_number], block_number as u32)), @@ -268,7 +269,8 @@ fn check_ancestry_lookup_in_same_session() { #[test] fn check_ancestry_lookup_in_different_sessions() { let mut test_state = TestState::new(); - let mut requester = Requester::new(Default::default()); + let mut requester = + Requester::new(ReqProtocolNames::new(&Hash::repeat_byte(0xff), None), Default::default()); let keystore = make_ferdie_keystore(); let mut runtime = RuntimeInfo::new(Some(keystore)); @@ -279,7 +281,7 @@ fn check_ancestry_lookup_in_different_sessions() { test_harness(test_state.clone(), |mut ctx| async move { let chain = &test_state.relay_chain; - let spans: HashMap = HashMap::new(); + let spans: HashMap = HashMap::new(); let block_number = 3; let update = ActiveLeavesUpdate { activated: Some(new_leaf(chain[block_number], block_number as u32)), diff --git a/polkadot/node/network/availability-distribution/src/responder.rs b/polkadot/node/network/availability-distribution/src/responder.rs index 54b188f7f01fc7e22b4ea7679be0a67f8d9d0d37..fb08c47125038edffff6e5d7cd57d986ed5fe138 100644 --- a/polkadot/node/network/availability-distribution/src/responder.rs +++ b/polkadot/node/network/availability-distribution/src/responder.rs @@ -18,11 +18,12 @@ use std::sync::Arc; -use futures::channel::oneshot; +use futures::{channel::oneshot, select, FutureExt}; +use codec::{Decode, Encode}; use fatality::Nested; use polkadot_node_network_protocol::{ - request_response::{v1, IncomingRequest, IncomingRequestReceiver}, + request_response::{v1, v2, IncomingRequest, IncomingRequestReceiver, IsRequest}, UnifiedReputationChange as Rep, }; use polkadot_node_primitives::{AvailableData, ErasureChunk}; @@ -66,33 +67,66 @@ pub async fn run_pov_receiver( } /// Receiver task to be forked as a separate task to handle chunk requests. -pub async fn run_chunk_receiver( +pub async fn run_chunk_receivers( mut sender: Sender, - mut receiver: IncomingRequestReceiver, + mut receiver_v1: IncomingRequestReceiver, + mut receiver_v2: IncomingRequestReceiver, metrics: Metrics, ) where Sender: SubsystemSender, { + let make_resp_v1 = |chunk: Option| match chunk { + None => v1::ChunkFetchingResponse::NoSuchChunk, + Some(chunk) => v1::ChunkFetchingResponse::Chunk(chunk.into()), + }; + + let make_resp_v2 = |chunk: Option| match chunk { + None => v2::ChunkFetchingResponse::NoSuchChunk, + Some(chunk) => v2::ChunkFetchingResponse::Chunk(chunk.into()), + }; + loop { - match receiver.recv(|| vec![COST_INVALID_REQUEST]).await.into_nested() { - Ok(Ok(msg)) => { - answer_chunk_request_log(&mut sender, msg, &metrics).await; - }, - Err(fatal) => { - gum::debug!( - target: LOG_TARGET, - error = ?fatal, - "Shutting down chunk receiver." - ); - return - }, - Ok(Err(jfyi)) => { - gum::debug!( - target: LOG_TARGET, - error = ?jfyi, - "Error decoding incoming chunk request." - ); + select! { + res = receiver_v1.recv(|| vec![COST_INVALID_REQUEST]).fuse() => match res.into_nested() { + Ok(Ok(msg)) => { + answer_chunk_request_log(&mut sender, msg, make_resp_v1, &metrics).await; + }, + Err(fatal) => { + gum::debug!( + target: LOG_TARGET, + error = ?fatal, + "Shutting down chunk receiver." + ); + return + }, + Ok(Err(jfyi)) => { + gum::debug!( + target: LOG_TARGET, + error = ?jfyi, + "Error decoding incoming chunk request." + ); + } }, + res = receiver_v2.recv(|| vec![COST_INVALID_REQUEST]).fuse() => match res.into_nested() { + Ok(Ok(msg)) => { + answer_chunk_request_log(&mut sender, msg.into(), make_resp_v2, &metrics).await; + }, + Err(fatal) => { + gum::debug!( + target: LOG_TARGET, + error = ?fatal, + "Shutting down chunk receiver." + ); + return + }, + Ok(Err(jfyi)) => { + gum::debug!( + target: LOG_TARGET, + error = ?jfyi, + "Error decoding incoming chunk request." + ); + } + } } } } @@ -124,15 +158,18 @@ pub async fn answer_pov_request_log( /// Variant of `answer_chunk_request` that does Prometheus metric and logging on errors. /// /// Any errors of `answer_request` will simply be logged. -pub async fn answer_chunk_request_log( +pub async fn answer_chunk_request_log( sender: &mut Sender, - req: IncomingRequest, + req: IncomingRequest, + make_response: MakeResp, metrics: &Metrics, -) -> () -where +) where + Req: IsRequest + Decode + Encode + Into, + Req::Response: Encode, Sender: SubsystemSender, + MakeResp: Fn(Option) -> Req::Response, { - let res = answer_chunk_request(sender, req).await; + let res = answer_chunk_request(sender, req, make_response).await; match res { Ok(result) => metrics.on_served_chunk(if result { SUCCEEDED } else { NOT_FOUND }), Err(err) => { @@ -177,39 +214,46 @@ where /// Answer an incoming chunk request by querying the av store. /// /// Returns: `Ok(true)` if chunk was found and served. -pub async fn answer_chunk_request( +pub async fn answer_chunk_request( sender: &mut Sender, - req: IncomingRequest, + req: IncomingRequest, + make_response: MakeResp, ) -> Result where Sender: SubsystemSender, + Req: IsRequest + Decode + Encode + Into, + Req::Response: Encode, + MakeResp: Fn(Option) -> Req::Response, { - let span = jaeger::Span::new(req.payload.candidate_hash, "answer-chunk-request"); + // V1 and V2 requests have the same payload, so decoding into either one will work. It's the + // responses that differ, hence the `MakeResp` generic. + let payload: v1::ChunkFetchingRequest = req.payload.into(); + let span = jaeger::Span::new(payload.candidate_hash, "answer-chunk-request"); let _child_span = span .child("answer-chunk-request") - .with_trace_id(req.payload.candidate_hash) - .with_chunk_index(req.payload.index.0); + .with_trace_id(payload.candidate_hash) + .with_validator_index(payload.index); - let chunk = query_chunk(sender, req.payload.candidate_hash, req.payload.index).await?; + let chunk = query_chunk(sender, payload.candidate_hash, payload.index).await?; let result = chunk.is_some(); gum::trace!( target: LOG_TARGET, - hash = ?req.payload.candidate_hash, - index = ?req.payload.index, + hash = ?payload.candidate_hash, + index = ?payload.index, peer = ?req.peer, has_data = ?chunk.is_some(), "Serving chunk", ); - let response = match chunk { - None => v1::ChunkFetchingResponse::NoSuchChunk, - Some(chunk) => v1::ChunkFetchingResponse::Chunk(chunk.into()), - }; + let response = make_response(chunk); + + req.pending_response + .send_response(response) + .map_err(|_| JfyiError::SendResponse)?; - req.send_response(response).map_err(|_| JfyiError::SendResponse)?; Ok(result) } diff --git a/polkadot/node/network/availability-distribution/src/tests/mock.rs b/polkadot/node/network/availability-distribution/src/tests/mock.rs index 3df662fe546c07f7a7f58d02d0ceafd98a7e1b6c..b41c493a10721bbdd988125d1c355ad9e4cc4824 100644 --- a/polkadot/node/network/availability-distribution/src/tests/mock.rs +++ b/polkadot/node/network/availability-distribution/src/tests/mock.rs @@ -23,9 +23,9 @@ use sp_keyring::Sr25519Keyring; use polkadot_erasure_coding::{branches, obtain_chunks_v1 as obtain_chunks}; use polkadot_node_primitives::{AvailableData, BlockData, ErasureChunk, PoV, Proof}; use polkadot_primitives::{ - CandidateCommitments, CandidateDescriptor, CandidateHash, CommittedCandidateReceipt, - GroupIndex, Hash, HeadData, Id as ParaId, IndexedVec, OccupiedCore, PersistedValidationData, - SessionInfo, ValidatorIndex, + CandidateCommitments, CandidateDescriptor, CandidateHash, ChunkIndex, + CommittedCandidateReceipt, GroupIndex, Hash, HeadData, Id as ParaId, IndexedVec, OccupiedCore, + PersistedValidationData, SessionInfo, ValidatorIndex, }; use polkadot_primitives_test_helpers::{ dummy_collator, dummy_collator_signature, dummy_hash, dummy_validation_code, @@ -75,13 +75,16 @@ pub struct OccupiedCoreBuilder { pub group_responsible: GroupIndex, pub para_id: ParaId, pub relay_parent: Hash, + pub n_validators: usize, + pub chunk_index: ChunkIndex, } impl OccupiedCoreBuilder { pub fn build(self) -> (OccupiedCore, (CandidateHash, ErasureChunk)) { let pov = PoV { block_data: BlockData(vec![45, 46, 47]) }; let pov_hash = pov.hash(); - let (erasure_root, chunk) = get_valid_chunk_data(pov.clone()); + let (erasure_root, chunk) = + get_valid_chunk_data(pov.clone(), self.n_validators, self.chunk_index); let candidate_receipt = TestCandidateBuilder { para_id: self.para_id, pov_hash, @@ -133,8 +136,11 @@ impl TestCandidateBuilder { } // Get chunk for index 0 -pub fn get_valid_chunk_data(pov: PoV) -> (Hash, ErasureChunk) { - let fake_validator_count = 10; +pub fn get_valid_chunk_data( + pov: PoV, + n_validators: usize, + chunk_index: ChunkIndex, +) -> (Hash, ErasureChunk) { let persisted = PersistedValidationData { parent_head: HeadData(vec![7, 8, 9]), relay_parent_number: Default::default(), @@ -142,17 +148,17 @@ pub fn get_valid_chunk_data(pov: PoV) -> (Hash, ErasureChunk) { relay_parent_storage_root: Default::default(), }; let available_data = AvailableData { validation_data: persisted, pov: Arc::new(pov) }; - let chunks = obtain_chunks(fake_validator_count, &available_data).unwrap(); + let chunks = obtain_chunks(n_validators, &available_data).unwrap(); let branches = branches(chunks.as_ref()); let root = branches.root(); let chunk = branches .enumerate() .map(|(index, (proof, chunk))| ErasureChunk { chunk: chunk.to_vec(), - index: ValidatorIndex(index as _), + index: ChunkIndex(index as _), proof: Proof::try_from(proof).unwrap(), }) - .next() - .expect("There really should be 10 chunks."); + .nth(chunk_index.0 as usize) + .expect("There really should be enough chunks."); (root, chunk) } diff --git a/polkadot/node/network/availability-distribution/src/tests/mod.rs b/polkadot/node/network/availability-distribution/src/tests/mod.rs index 214498979fb68307ce45705e396a7e306d53da87..3320871bceb5ad152c3dbd3483a86babbcf8994d 100644 --- a/polkadot/node/network/availability-distribution/src/tests/mod.rs +++ b/polkadot/node/network/availability-distribution/src/tests/mod.rs @@ -17,13 +17,14 @@ use std::collections::HashSet; use futures::{executor, future, Future}; +use rstest::rstest; -use polkadot_node_network_protocol::request_response::{IncomingRequest, ReqProtocolNames}; -use polkadot_primitives::{Block, CoreState, Hash}; +use polkadot_node_network_protocol::request_response::{ + IncomingRequest, Protocol, ReqProtocolNames, +}; +use polkadot_primitives::{node_features, Block, CoreState, Hash, NodeFeatures}; use sp_keystore::KeystorePtr; -use polkadot_node_subsystem_test_helpers as test_helpers; - use super::*; mod state; @@ -35,67 +36,130 @@ pub(crate) mod mock; fn test_harness>( keystore: KeystorePtr, + req_protocol_names: ReqProtocolNames, test_fx: impl FnOnce(TestHarness) -> T, -) { - sp_tracing::try_init_simple(); +) -> std::result::Result<(), FatalError> { + sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); - let genesis_hash = Hash::repeat_byte(0xff); - let req_protocol_names = ReqProtocolNames::new(&genesis_hash, None); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let (pov_req_receiver, pov_req_cfg) = IncomingRequest::get_config_receiver::< Block, sc_network::NetworkWorker, >(&req_protocol_names); - let (chunk_req_receiver, chunk_req_cfg) = IncomingRequest::get_config_receiver::< + let (chunk_req_v1_receiver, chunk_req_v1_cfg) = IncomingRequest::get_config_receiver::< + Block, + sc_network::NetworkWorker, + >(&req_protocol_names); + let (chunk_req_v2_receiver, chunk_req_v2_cfg) = IncomingRequest::get_config_receiver::< Block, sc_network::NetworkWorker, >(&req_protocol_names); let subsystem = AvailabilityDistributionSubsystem::new( keystore, - IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver }, + IncomingRequestReceivers { pov_req_receiver, chunk_req_v1_receiver, chunk_req_v2_receiver }, + req_protocol_names, Default::default(), ); let subsystem = subsystem.run(context); - let test_fut = test_fx(TestHarness { virtual_overseer, pov_req_cfg, chunk_req_cfg, pool }); + let test_fut = test_fx(TestHarness { + virtual_overseer, + pov_req_cfg, + chunk_req_v1_cfg, + chunk_req_v2_cfg, + pool, + }); futures::pin_mut!(test_fut); futures::pin_mut!(subsystem); - executor::block_on(future::join(test_fut, subsystem)).1.unwrap(); + executor::block_on(future::join(test_fut, subsystem)).1 +} + +pub fn node_features_with_mapping_enabled() -> NodeFeatures { + let mut node_features = NodeFeatures::new(); + node_features.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false); + node_features.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true); + node_features } /// Simple basic check, whether the subsystem works as expected. /// /// Exceptional cases are tested as unit tests in `fetch_task`. -#[test] -fn check_basic() { - let state = TestState::default(); - test_harness(state.keystore.clone(), move |harness| state.run(harness)); +#[rstest] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)] +fn check_basic(#[case] node_features: NodeFeatures, #[case] chunk_resp_protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + let state = + TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol); + + if node_features == node_features_with_mapping_enabled() && + chunk_resp_protocol == Protocol::ChunkFetchingV1 + { + // For this specific case, chunk fetching is not possible, because the ValidatorIndex is not + // equal to the ChunkIndex and the peer does not send back the actual ChunkIndex. + let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| { + state.run_assert_timeout(harness) + }); + } else { + test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness)) + .unwrap(); + } } /// Check whether requester tries all validators in group. -#[test] -fn check_fetch_tries_all() { - let mut state = TestState::default(); +#[rstest] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)] +fn check_fetch_tries_all( + #[case] node_features: NodeFeatures, + #[case] chunk_resp_protocol: Protocol, +) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + let mut state = + TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol); for (_, v) in state.chunks.iter_mut() { // 4 validators in group, so this should still succeed: v.push(None); v.push(None); v.push(None); } - test_harness(state.keystore.clone(), move |harness| state.run(harness)); + + if node_features == node_features_with_mapping_enabled() && + chunk_resp_protocol == Protocol::ChunkFetchingV1 + { + // For this specific case, chunk fetching is not possible, because the ValidatorIndex is not + // equal to the ChunkIndex and the peer does not send back the actual ChunkIndex. + let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| { + state.run_assert_timeout(harness) + }); + } else { + test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness)) + .unwrap(); + } } /// Check whether requester tries all validators in group /// /// Check that requester will retry the fetch on error on the next block still pending /// availability. -#[test] -fn check_fetch_retry() { - let mut state = TestState::default(); +#[rstest] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV1)] +#[case(NodeFeatures::EMPTY, Protocol::ChunkFetchingV2)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV1)] +#[case(node_features_with_mapping_enabled(), Protocol::ChunkFetchingV2)] +fn check_fetch_retry(#[case] node_features: NodeFeatures, #[case] chunk_resp_protocol: Protocol) { + let req_protocol_names = ReqProtocolNames::new(&Hash::repeat_byte(0xff), None); + let mut state = + TestState::new(node_features.clone(), req_protocol_names.clone(), chunk_resp_protocol); state .cores .insert(state.relay_chain[2], state.cores.get(&state.relay_chain[1]).unwrap().clone()); @@ -126,5 +190,17 @@ fn check_fetch_retry() { v.push(None); v.push(None); } - test_harness(state.keystore.clone(), move |harness| state.run(harness)); + + if node_features == node_features_with_mapping_enabled() && + chunk_resp_protocol == Protocol::ChunkFetchingV1 + { + // For this specific case, chunk fetching is not possible, because the ValidatorIndex is not + // equal to the ChunkIndex and the peer does not send back the actual ChunkIndex. + let _ = test_harness(state.keystore.clone(), req_protocol_names, move |harness| { + state.run_assert_timeout(harness) + }); + } else { + test_harness(state.keystore.clone(), req_protocol_names, move |harness| state.run(harness)) + .unwrap(); + } } diff --git a/polkadot/node/network/availability-distribution/src/tests/state.rs b/polkadot/node/network/availability-distribution/src/tests/state.rs index 93411511e763af437d7813c9e5d83bac4609959e..97e616f79fb759c0800946b762aca03acba9c4bc 100644 --- a/polkadot/node/network/availability-distribution/src/tests/state.rs +++ b/polkadot/node/network/availability-distribution/src/tests/state.rs @@ -19,9 +19,9 @@ use std::{ time::Duration, }; -use network::ProtocolName; +use network::{request_responses::OutgoingResponse, ProtocolName, RequestFailure}; use polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; -use polkadot_node_subsystem_util::TimeoutExt; +use polkadot_node_subsystem_util::{availability_chunks::availability_chunk_index, TimeoutExt}; use futures::{ channel::{mpsc, oneshot}, @@ -35,7 +35,7 @@ use sp_core::{testing::TaskExecutor, traits::SpawnNamed}; use sp_keystore::KeystorePtr; use polkadot_node_network_protocol::request_response::{ - v1, IncomingRequest, OutgoingRequest, Requests, + v1, v2, IncomingRequest, OutgoingRequest, Protocol, ReqProtocolNames, Requests, }; use polkadot_node_primitives::ErasureChunk; use polkadot_node_subsystem::{ @@ -47,19 +47,22 @@ use polkadot_node_subsystem::{ }; use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_primitives::{ - CandidateHash, CoreState, ExecutorParams, GroupIndex, Hash, Id as ParaId, NodeFeatures, - ScheduledCore, SessionInfo, ValidatorIndex, + CandidateHash, ChunkIndex, CoreIndex, CoreState, ExecutorParams, GroupIndex, Hash, + Id as ParaId, NodeFeatures, ScheduledCore, SessionInfo, ValidatorIndex, }; use test_helpers::mock::{make_ferdie_keystore, new_leaf}; use super::mock::{make_session_info, OccupiedCoreBuilder}; use crate::LOG_TARGET; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle< + AvailabilityDistributionMessage, +>; pub struct TestHarness { pub virtual_overseer: VirtualOverseer, pub pov_req_cfg: RequestResponseConfig, - pub chunk_req_cfg: RequestResponseConfig, + pub chunk_req_v1_cfg: RequestResponseConfig, + pub chunk_req_v2_cfg: RequestResponseConfig, pub pool: TaskExecutor, } @@ -83,10 +86,19 @@ pub struct TestState { /// Cores per relay chain block. pub cores: HashMap>, pub keystore: KeystorePtr, + pub node_features: NodeFeatures, + pub chunk_response_protocol: Protocol, + pub req_protocol_names: ReqProtocolNames, + pub our_chunk_index: ChunkIndex, } -impl Default for TestState { - fn default() -> Self { +impl TestState { + /// Initialize a default test state. + pub fn new( + node_features: NodeFeatures, + req_protocol_names: ReqProtocolNames, + chunk_response_protocol: Protocol, + ) -> Self { let relay_chain: Vec<_> = (1u8..10).map(Hash::repeat_byte).collect(); let chain_a = ParaId::from(1); let chain_b = ParaId::from(2); @@ -97,6 +109,14 @@ impl Default for TestState { let session_info = make_session_info(); + let our_chunk_index = availability_chunk_index( + Some(&node_features), + session_info.validators.len(), + CoreIndex(1), + ValidatorIndex(0), + ) + .unwrap(); + let (cores, chunks) = { let mut cores = HashMap::new(); let mut chunks = HashMap::new(); @@ -123,6 +143,8 @@ impl Default for TestState { group_responsible: GroupIndex(i as _), para_id: *para_id, relay_parent: *relay_parent, + n_validators: session_info.validators.len(), + chunk_index: our_chunk_index, } .build(); (CoreState::Occupied(core), chunk) @@ -132,8 +154,8 @@ impl Default for TestState { // Skip chunks for our own group (won't get fetched): let mut chunks_other_groups = p_chunks.into_iter(); chunks_other_groups.next(); - for (validator_index, chunk) in chunks_other_groups { - chunks.insert((validator_index, chunk.index), vec![Some(chunk)]); + for (candidate, chunk) in chunks_other_groups { + chunks.insert((candidate, ValidatorIndex(0)), vec![Some(chunk)]); } } (cores, chunks) @@ -145,18 +167,27 @@ impl Default for TestState { session_info, cores, keystore, + node_features, + chunk_response_protocol, + req_protocol_names, + our_chunk_index, } } -} -impl TestState { /// Run, but fail after some timeout. pub async fn run(self, harness: TestHarness) { // Make sure test won't run forever. - let f = self.run_inner(harness).timeout(Duration::from_secs(10)); + let f = self.run_inner(harness).timeout(Duration::from_secs(5)); assert!(f.await.is_some(), "Test ran into timeout"); } + /// Run, and assert an expected timeout. + pub async fn run_assert_timeout(self, harness: TestHarness) { + // Make sure test won't run forever. + let f = self.run_inner(harness).timeout(Duration::from_secs(5)); + assert!(f.await.is_none(), "Test should have run into timeout"); + } + /// Run tests with the given mock values in `TestState`. /// /// This will simply advance through the simulated chain and examines whether the subsystem @@ -185,7 +216,7 @@ impl TestState { // Test will fail if this does not happen until timeout. let mut remaining_stores = self.valid_chunks.len(); - let TestSubsystemContextHandle { tx, mut rx } = harness.virtual_overseer; + let TestSubsystemContextHandle { tx, mut rx, .. } = harness.virtual_overseer; // Spawning necessary as incoming queue can only hold a single item, we don't want to dead // lock ;-) @@ -214,15 +245,41 @@ impl TestState { )) => { for req in reqs { // Forward requests: - let in_req = to_incoming_req(&harness.pool, req); - harness - .chunk_req_cfg - .inbound_queue - .as_mut() - .unwrap() - .send(in_req.into_raw()) - .await - .unwrap(); + match self.chunk_response_protocol { + Protocol::ChunkFetchingV1 => { + let in_req = to_incoming_req_v1( + &harness.pool, + req, + self.req_protocol_names.get_name(Protocol::ChunkFetchingV1), + ); + + harness + .chunk_req_v1_cfg + .inbound_queue + .as_mut() + .unwrap() + .send(in_req.into_raw()) + .await + .unwrap(); + }, + Protocol::ChunkFetchingV2 => { + let in_req = to_incoming_req_v2( + &harness.pool, + req, + self.req_protocol_names.get_name(Protocol::ChunkFetchingV2), + ); + + harness + .chunk_req_v2_cfg + .inbound_queue + .as_mut() + .unwrap() + .send(in_req.into_raw()) + .await + .unwrap(); + }, + _ => panic!("Unexpected protocol"), + } } }, AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryChunk( @@ -240,13 +297,16 @@ impl TestState { AllMessages::AvailabilityStore(AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk, + validator_index, tx, .. }) => { assert!( - self.valid_chunks.contains(&(candidate_hash, chunk.index)), + self.valid_chunks.contains(&(candidate_hash, validator_index)), "Only valid chunks should ever get stored." ); + assert_eq!(self.our_chunk_index, chunk.index); + tx.send(Ok(())).expect("Receiver is expected to be alive"); gum::trace!(target: LOG_TARGET, "'Stored' fetched chunk."); remaining_stores -= 1; @@ -265,14 +325,15 @@ impl TestState { tx.send(Ok(Some(ExecutorParams::default()))) .expect("Receiver should be alive."); }, - RuntimeApiRequest::NodeFeatures(_, si_tx) => { - si_tx.send(Ok(NodeFeatures::EMPTY)).expect("Receiver should be alive."); - }, RuntimeApiRequest::AvailabilityCores(tx) => { gum::trace!(target: LOG_TARGET, cores= ?self.cores[&hash], hash = ?hash, "Sending out cores for hash"); tx.send(Ok(self.cores[&hash].clone())) .expect("Receiver should still be alive"); }, + RuntimeApiRequest::NodeFeatures(_, tx) => { + tx.send(Ok(self.node_features.clone())) + .expect("Receiver should still be alive"); + }, _ => { panic!("Unexpected runtime request: {:?}", req); }, @@ -286,7 +347,10 @@ impl TestState { .unwrap_or_default(); response_channel.send(Ok(ancestors)).expect("Receiver is expected to be alive"); }, - _ => {}, + + _ => { + panic!("Received unexpected message") + }, } } @@ -310,30 +374,47 @@ async fn overseer_recv(rx: &mut mpsc::UnboundedReceiver) -> AllMess rx.next().await.expect("Test subsystem no longer live") } -fn to_incoming_req( +fn to_incoming_req_v1( executor: &TaskExecutor, outgoing: Requests, + protocol_name: ProtocolName, ) -> IncomingRequest { match outgoing { - Requests::ChunkFetchingV1(OutgoingRequest { payload, pending_response, .. }) => { - let (tx, rx): (oneshot::Sender, oneshot::Receiver<_>) = - oneshot::channel(); - executor.spawn( - "message-forwarding", - None, - async { - let response = rx.await; - let payload = response.expect("Unexpected canceled request").result; - pending_response - .send( - payload - .map_err(|_| network::RequestFailure::Refused) - .map(|r| (r, ProtocolName::from(""))), - ) - .expect("Sending response is expected to work"); - } - .boxed(), - ); + Requests::ChunkFetching(OutgoingRequest { + pending_response, + fallback_request: Some((fallback_request, fallback_protocol)), + .. + }) => { + assert_eq!(fallback_protocol, Protocol::ChunkFetchingV1); + + let tx = spawn_message_forwarding(executor, protocol_name, pending_response); + + IncomingRequest::new( + // We don't really care: + network::PeerId::random().into(), + fallback_request, + tx, + ) + }, + _ => panic!("Unexpected request!"), + } +} + +fn to_incoming_req_v2( + executor: &TaskExecutor, + outgoing: Requests, + protocol_name: ProtocolName, +) -> IncomingRequest { + match outgoing { + Requests::ChunkFetching(OutgoingRequest { + payload, + pending_response, + fallback_request: Some((_, fallback_protocol)), + .. + }) => { + assert_eq!(fallback_protocol, Protocol::ChunkFetchingV1); + + let tx = spawn_message_forwarding(executor, protocol_name, pending_response); IncomingRequest::new( // We don't really care: @@ -345,3 +426,26 @@ fn to_incoming_req( _ => panic!("Unexpected request!"), } } + +fn spawn_message_forwarding( + executor: &TaskExecutor, + protocol_name: ProtocolName, + pending_response: oneshot::Sender, ProtocolName), RequestFailure>>, +) -> oneshot::Sender { + let (tx, rx): (oneshot::Sender, oneshot::Receiver<_>) = + oneshot::channel(); + executor.spawn( + "message-forwarding", + None, + async { + let response = rx.await; + let payload = response.expect("Unexpected canceled request").result; + pending_response + .send(payload.map_err(|_| RequestFailure::Refused).map(|r| (r, protocol_name))) + .expect("Sending response is expected to work"); + } + .boxed(), + ); + + tx +} diff --git a/polkadot/node/network/availability-recovery/Cargo.toml b/polkadot/node/network/availability-recovery/Cargo.toml index dd0e0c432345ed7006fa4a18fbb05bc9efca8538..41f09b1f7044358697fe923ab56f745bfdce22e7 100644 --- a/polkadot/node/network/availability-recovery/Cargo.toml +++ b/polkadot/node/network/availability-recovery/Cargo.toml @@ -10,38 +10,39 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -tokio = "1.37" -schnellru = "0.2.1" -rand = "0.8.5" -fatality = "0.0.6" +futures = { workspace = true } +tokio = { workspace = true, default-features = true } +schnellru = { workspace = true } +rand = { workspace = true, default-features = true } +fatality = { workspace = true } thiserror = { workspace = true } -async-trait = "0.1.79" -gum = { package = "tracing-gum", path = "../../gum" } - -polkadot-erasure-coding = { path = "../../../erasure-coding" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-network-protocol = { path = "../protocol" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sc-network = { path = "../../../../substrate/client/network" } +async-trait = { workspace = true } +gum = { workspace = true, default-features = true } + +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +codec = { features = ["derive"], workspace = true } +sc-network = { workspace = true, default-features = true } [dev-dependencies] -assert_matches = "1.4.0" -env_logger = "0.11" -futures-timer = "3.0.2" +assert_matches = { workspace = true } +futures-timer = { workspace = true } +rstest = { workspace = true } log = { workspace = true, default-features = true } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sc-network = { path = "../../../../substrate/client/network" } +sp-tracing = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } -polkadot-subsystem-bench = { path = "../../subsystem-bench" } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +polkadot-subsystem-bench = { workspace = true } [[bench]] name = "availability-recovery-regression-bench" diff --git a/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs b/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs index d9bdc1a2d944d71231d0679fd5e5ef79a52cc782..c734ac99e870df128c5443e9cb3b83371bc1156f 100644 --- a/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs +++ b/polkadot/node/network/availability-recovery/benches/availability-recovery-regression-bench.rs @@ -23,7 +23,7 @@ use polkadot_subsystem_bench::{ availability::{ - benchmark_availability_read, prepare_test, DataAvailabilityReadOptions, + benchmark_availability_read, prepare_test, DataAvailabilityReadOptions, Strategy, TestDataAvailability, TestState, }, configuration::TestConfiguration, @@ -37,7 +37,7 @@ const BENCH_COUNT: usize = 10; fn main() -> Result<(), String> { let mut messages = vec![]; - let options = DataAvailabilityReadOptions { fetch_from_backers: true }; + let options = DataAvailabilityReadOptions { strategy: Strategy::FullFromBackers }; let mut config = TestConfiguration::default(); config.num_blocks = 3; config.generate_pov_sizes(); @@ -51,11 +51,7 @@ fn main() -> Result<(), String> { std::io::stdout().flush().unwrap(); let (mut env, _cfgs) = prepare_test(&state, TestDataAvailability::Read(options.clone()), false); - env.runtime().block_on(benchmark_availability_read( - "data_availability_read", - &mut env, - &state, - )) + env.runtime().block_on(benchmark_availability_read(&mut env, &state)) }) .collect(); println!("\rDone!{}", " ".repeat(BENCH_COUNT)); @@ -74,7 +70,7 @@ fn main() -> Result<(), String> { ("Received from peers", 307203.0000, 0.001), ("Sent to peers", 1.6667, 0.001), ])); - messages.extend(average_usage.check_cpu_usage(&[("availability-recovery", 12.8338, 0.1)])); + messages.extend(average_usage.check_cpu_usage(&[("availability-recovery", 12.8412, 0.1)])); if messages.is_empty() { Ok(()) diff --git a/polkadot/node/network/availability-recovery/src/error.rs b/polkadot/node/network/availability-recovery/src/error.rs index 47277a521b81ee72261ab8d71ff9f0cf97bf56ad..eaec4cbc9d9426fce260a4fdc2744506bf34c830 100644 --- a/polkadot/node/network/availability-recovery/src/error.rs +++ b/polkadot/node/network/availability-recovery/src/error.rs @@ -16,20 +16,34 @@ //! The `Error` and `Result` types used by the subsystem. +use crate::LOG_TARGET; +use fatality::{fatality, Nested}; use futures::channel::oneshot; -use thiserror::Error; +use polkadot_node_network_protocol::request_response::incoming; +use polkadot_node_subsystem::{RecoveryError, SubsystemError}; +use polkadot_primitives::Hash; /// Error type used by the Availability Recovery subsystem. -#[derive(Debug, Error)] +#[fatality(splitable)] pub enum Error { - #[error(transparent)] - Subsystem(#[from] polkadot_node_subsystem::SubsystemError), + #[fatal] + #[error("Spawning subsystem task failed: {0}")] + SpawnTask(#[source] SubsystemError), + + /// Receiving subsystem message from overseer failed. + #[fatal] + #[error("Receiving message from overseer failed: {0}")] + SubsystemReceive(#[source] SubsystemError), + #[fatal] #[error("failed to query full data from store")] CanceledQueryFullData(#[source] oneshot::Canceled), - #[error("failed to query session info")] - CanceledSessionInfo(#[source] oneshot::Canceled), + #[error("`SessionInfo` is `None` at {0}")] + SessionInfoUnavailable(Hash), + + #[error("failed to query node features from runtime")] + RequestNodeFeatures(#[source] polkadot_node_subsystem_util::runtime::Error), #[error("failed to send response")] CanceledResponseSender, @@ -40,8 +54,38 @@ pub enum Error { #[error(transparent)] Erasure(#[from] polkadot_erasure_coding::Error), + #[fatal] #[error(transparent)] - Util(#[from] polkadot_node_subsystem_util::Error), + Oneshot(#[from] oneshot::Canceled), + + #[fatal(forward)] + #[error("Error during recovery: {0}")] + Recovery(#[from] RecoveryError), + + #[fatal(forward)] + #[error("Retrieving next incoming request failed: {0}")] + IncomingRequest(#[from] incoming::Error), } pub type Result = std::result::Result; + +/// Utility for eating top level errors and log them. +/// +/// We basically always want to try and continue on error, unless the error is fatal for the entire +/// subsystem. +pub fn log_error(result: Result<()>) -> std::result::Result<(), FatalError> { + match result.into_nested()? { + Ok(()) => Ok(()), + Err(jfyi) => { + jfyi.log(); + Ok(()) + }, + } +} + +impl JfyiError { + /// Log a `JfyiError`. + pub fn log(self) { + gum::warn!(target: LOG_TARGET, "{}", self); + } +} diff --git a/polkadot/node/network/availability-recovery/src/lib.rs b/polkadot/node/network/availability-recovery/src/lib.rs index 94b9d9546cdecd4a244bc3de9e10c1db4c3c066d..167125f987ab8f9af4f1d8b91ebd33d80bd05039 100644 --- a/polkadot/node/network/availability-recovery/src/lib.rs +++ b/polkadot/node/network/availability-recovery/src/lib.rs @@ -19,7 +19,7 @@ #![warn(missing_docs)] use std::{ - collections::{HashMap, VecDeque}, + collections::{BTreeMap, VecDeque}, iter::Iterator, num::NonZeroUsize, pin::Pin, @@ -34,31 +34,41 @@ use futures::{ stream::{FuturesUnordered, StreamExt}, task::{Context, Poll}, }; +use sc_network::ProtocolName; use schnellru::{ByLength, LruMap}; -use task::{FetchChunks, FetchChunksParams, FetchFull, FetchFullParams}; +use task::{ + FetchChunks, FetchChunksParams, FetchFull, FetchFullParams, FetchSystematicChunks, + FetchSystematicChunksParams, +}; -use fatality::Nested; use polkadot_erasure_coding::{ - branch_hash, branches, obtain_chunks_v1, recovery_threshold, Error as ErasureEncodingError, + branches, obtain_chunks_v1, recovery_threshold, systematic_recovery_threshold, + Error as ErasureEncodingError, }; use task::{RecoveryParams, RecoveryStrategy, RecoveryTask}; +use error::{log_error, Error, FatalError, Result}; use polkadot_node_network_protocol::{ - request_response::{v1 as request_v1, IncomingRequestReceiver}, + request_response::{ + v1 as request_v1, v2 as request_v2, IncomingRequestReceiver, IsRequest, ReqProtocolNames, + }, UnifiedReputationChange as Rep, }; -use polkadot_node_primitives::{AvailableData, ErasureChunk}; +use polkadot_node_primitives::AvailableData; use polkadot_node_subsystem::{ errors::RecoveryError, jaeger, messages::{AvailabilityRecoveryMessage, AvailabilityStoreMessage}, overseer, ActiveLeavesUpdate, FromOrchestra, OverseerSignal, SpawnedSubsystem, - SubsystemContext, SubsystemError, SubsystemResult, + SubsystemContext, SubsystemError, +}; +use polkadot_node_subsystem_util::{ + availability_chunks::availability_chunk_indices, + runtime::{ExtendedSessionInfo, RuntimeInfo}, }; -use polkadot_node_subsystem_util::request_session_info; use polkadot_primitives::{ - BlakeTwo256, BlockNumber, CandidateHash, CandidateReceipt, GroupIndex, Hash, HashT, - SessionIndex, SessionInfo, ValidatorIndex, + node_features, BlockNumber, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex, GroupIndex, + Hash, SessionIndex, ValidatorIndex, }; mod error; @@ -70,6 +80,8 @@ pub use metrics::Metrics; #[cfg(test)] mod tests; +type RecoveryResult = std::result::Result; + const LOG_TARGET: &str = "parachain::availability-recovery"; // Size of the LRU cache where we keep recovered data. @@ -77,19 +89,35 @@ const LRU_SIZE: u32 = 16; const COST_INVALID_REQUEST: Rep = Rep::CostMajor("Peer sent unparsable request"); -/// PoV size limit in bytes for which prefer fetching from backers. -const SMALL_POV_LIMIT: usize = 128 * 1024; +/// PoV size limit in bytes for which prefer fetching from backers. (conservative, Polkadot for now) +pub(crate) const CONSERVATIVE_FETCH_CHUNKS_THRESHOLD: usize = 1 * 1024 * 1024; +/// PoV size limit in bytes for which prefer fetching from backers. (Kusama and all testnets) +pub const FETCH_CHUNKS_THRESHOLD: usize = 4 * 1024 * 1024; #[derive(Clone, PartialEq)] /// The strategy we use to recover the PoV. pub enum RecoveryStrategyKind { - /// We always try the backing group first, then fallback to validator chunks. - BackersFirstAlways, /// We try the backing group first if PoV size is lower than specified, then fallback to /// validator chunks. BackersFirstIfSizeLower(usize), + /// We try the backing group first if PoV size is lower than specified, then fallback to + /// systematic chunks. Regular chunk recovery as a last resort. + BackersFirstIfSizeLowerThenSystematicChunks(usize), + + /// The following variants are only helpful for integration tests. + /// + /// We always try the backing group first, then fallback to validator chunks. + #[allow(dead_code)] + BackersFirstAlways, /// We always recover using validator chunks. + #[allow(dead_code)] ChunksAlways, + /// First try the backing group. Then systematic chunks. + #[allow(dead_code)] + BackersThenSystematicChunks, + /// Always recover using systematic chunks, fall back to regular chunks. + #[allow(dead_code)] + SystematicChunks, } /// The Availability Recovery Subsystem. @@ -107,11 +135,15 @@ pub struct AvailabilityRecoverySubsystem { metrics: Metrics, /// The type of check to perform after available data was recovered. post_recovery_check: PostRecoveryCheck, + /// Full protocol name for ChunkFetchingV1. + req_v1_protocol_name: ProtocolName, + /// Full protocol name for ChunkFetchingV2. + req_v2_protocol_name: ProtocolName, } #[derive(Clone, PartialEq, Debug)] /// The type of check to perform after available data was recovered. -pub enum PostRecoveryCheck { +enum PostRecoveryCheck { /// Reencode the data and check erasure root. For validators. Reencode, /// Only check the pov hash. For collators only. @@ -119,56 +151,18 @@ pub enum PostRecoveryCheck { } /// Expensive erasure coding computations that we want to run on a blocking thread. -pub enum ErasureTask { +enum ErasureTask { /// Reconstructs `AvailableData` from chunks given `n_validators`. Reconstruct( usize, - HashMap, - oneshot::Sender>, + BTreeMap>, + oneshot::Sender>, ), /// Re-encode `AvailableData` into erasure chunks in order to verify the provided root hash of /// the Merkle tree. Reencode(usize, Hash, AvailableData, oneshot::Sender>), } -const fn is_unavailable( - received_chunks: usize, - requesting_chunks: usize, - unrequested_validators: usize, - threshold: usize, -) -> bool { - received_chunks + requesting_chunks + unrequested_validators < threshold -} - -/// Check validity of a chunk. -fn is_chunk_valid(params: &RecoveryParams, chunk: &ErasureChunk) -> bool { - let anticipated_hash = - match branch_hash(¶ms.erasure_root, chunk.proof(), chunk.index.0 as usize) { - Ok(hash) => hash, - Err(e) => { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - validator_index = ?chunk.index, - error = ?e, - "Invalid Merkle proof", - ); - return false - }, - }; - let erasure_chunk_hash = BlakeTwo256::hash(&chunk.chunk); - if anticipated_hash != erasure_chunk_hash { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - validator_index = ?chunk.index, - "Merkle proof mismatch" - ); - return false - } - true -} - /// Re-encode the data into erasure chunks in order to verify /// the root hash of the provided Merkle tree, which is built /// on-top of the encoded chunks. @@ -212,12 +206,12 @@ fn reconstructed_data_matches_root( /// Accumulate all awaiting sides for some particular `AvailableData`. struct RecoveryHandle { candidate_hash: CandidateHash, - remote: RemoteHandle>, - awaiting: Vec>>, + remote: RemoteHandle, + awaiting: Vec>, } impl Future for RecoveryHandle { - type Output = Option<(CandidateHash, Result)>; + type Output = Option<(CandidateHash, RecoveryResult)>; fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { let mut indices_to_remove = Vec::new(); @@ -271,7 +265,7 @@ enum CachedRecovery { impl CachedRecovery { /// Convert back to `Result` to deliver responses. - fn into_result(self) -> Result { + fn into_result(self) -> RecoveryResult { match self { Self::Valid(d) => Ok(d), Self::Invalid => Err(RecoveryError::Invalid), @@ -279,9 +273,9 @@ impl CachedRecovery { } } -impl TryFrom> for CachedRecovery { +impl TryFrom for CachedRecovery { type Error = (); - fn try_from(o: Result) -> Result { + fn try_from(o: RecoveryResult) -> std::result::Result { match o { Ok(d) => Ok(Self::Valid(d)), Err(RecoveryError::Invalid) => Ok(Self::Invalid), @@ -303,6 +297,9 @@ struct State { /// An LRU cache of recently recovered data. availability_lru: LruMap, + + /// Cached runtime info. + runtime_info: RuntimeInfo, } impl Default for State { @@ -311,6 +308,7 @@ impl Default for State { ongoing_recoveries: FuturesUnordered::new(), live_block: (0, Hash::default()), availability_lru: LruMap::new(ByLength::new(LRU_SIZE)), + runtime_info: RuntimeInfo::new(None), } } } @@ -327,9 +325,10 @@ impl AvailabilityRecoverySubsystem { } /// Handles a signal from the overseer. -async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemResult { +/// Returns true if subsystem receives a deadly signal. +async fn handle_signal(state: &mut State, signal: OverseerSignal) -> bool { match signal { - OverseerSignal::Conclude => Ok(true), + OverseerSignal::Conclude => true, OverseerSignal::ActiveLeaves(ActiveLeavesUpdate { activated, .. }) => { // if activated is non-empty, set state.live_block to the highest block in `activated` if let Some(activated) = activated { @@ -338,9 +337,9 @@ async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemRe } } - Ok(false) + false }, - OverseerSignal::BlockFinalized(_, _) => Ok(false), + OverseerSignal::BlockFinalized(_, _) => false, } } @@ -349,27 +348,11 @@ async fn handle_signal(state: &mut State, signal: OverseerSignal) -> SubsystemRe async fn launch_recovery_task( state: &mut State, ctx: &mut Context, - session_info: SessionInfo, - receipt: CandidateReceipt, - response_sender: oneshot::Sender>, - metrics: &Metrics, + response_sender: oneshot::Sender, recovery_strategies: VecDeque::Sender>>>, - bypass_availability_store: bool, - post_recovery_check: PostRecoveryCheck, -) -> error::Result<()> { - let candidate_hash = receipt.hash(); - let params = RecoveryParams { - validator_authority_keys: session_info.discovery_keys.clone(), - n_validators: session_info.validators.len(), - threshold: recovery_threshold(session_info.validators.len())?, - candidate_hash, - erasure_root: receipt.descriptor.erasure_root, - metrics: metrics.clone(), - bypass_availability_store, - post_recovery_check, - pov_hash: receipt.descriptor.pov_hash, - }; - + params: RecoveryParams, +) -> Result<()> { + let candidate_hash = params.candidate_hash; let recovery_task = RecoveryTask::new(ctx.sender().clone(), params, recovery_strategies); let (remote, remote_handle) = recovery_task.run().remote_handle(); @@ -380,15 +363,8 @@ async fn launch_recovery_task( awaiting: vec![response_sender], }); - if let Err(e) = ctx.spawn("recovery-task", Box::pin(remote)) { - gum::warn!( - target: LOG_TARGET, - err = ?e, - "Failed to spawn a recovery task", - ); - } - - Ok(()) + ctx.spawn("recovery-task", Box::pin(remote)) + .map_err(|err| Error::SpawnTask(err)) } /// Handles an availability recovery request. @@ -399,13 +375,16 @@ async fn handle_recover( receipt: CandidateReceipt, session_index: SessionIndex, backing_group: Option, - response_sender: oneshot::Sender>, + response_sender: oneshot::Sender, metrics: &Metrics, erasure_task_tx: futures::channel::mpsc::Sender, recovery_strategy_kind: RecoveryStrategyKind, bypass_availability_store: bool, post_recovery_check: PostRecoveryCheck, -) -> error::Result<()> { + maybe_core_index: Option, + req_v1_protocol_name: ProtocolName, + req_v2_protocol_name: ProtocolName, +) -> Result<()> { let candidate_hash = receipt.hash(); let span = jaeger::Span::new(candidate_hash, "availability-recovery") @@ -414,14 +393,7 @@ async fn handle_recover( if let Some(result) = state.availability_lru.get(&candidate_hash).cloned().map(|v| v.into_result()) { - if let Err(e) = response_sender.send(result) { - gum::warn!( - target: LOG_TARGET, - err = ?e, - "Error responding with an availability recovery result", - ); - } - return Ok(()) + return response_sender.send(result).map_err(|_| Error::CanceledResponseSender) } if let Some(i) = @@ -432,100 +404,182 @@ async fn handle_recover( } let _span = span.child("not-cached"); - let session_info = request_session_info(state.live_block.1, session_index, ctx.sender()) - .await - .await - .map_err(error::Error::CanceledSessionInfo)??; + let session_info_res = state + .runtime_info + .get_session_info_by_index(ctx.sender(), state.live_block.1, session_index) + .await; let _span = span.child("session-info-ctx-received"); - match session_info { - Some(session_info) => { + match session_info_res { + Ok(ExtendedSessionInfo { session_info, node_features, .. }) => { + let mut backer_group = None; + let n_validators = session_info.validators.len(); + let systematic_threshold = systematic_recovery_threshold(n_validators)?; let mut recovery_strategies: VecDeque< Box::Sender>>, - > = VecDeque::with_capacity(2); + > = VecDeque::with_capacity(3); if let Some(backing_group) = backing_group { if let Some(backing_validators) = session_info.validator_groups.get(backing_group) { let mut small_pov_size = true; - if let RecoveryStrategyKind::BackersFirstIfSizeLower(small_pov_limit) = - recovery_strategy_kind - { - // Get our own chunk size to get an estimate of the PoV size. - let chunk_size: Result, error::Error> = - query_chunk_size(ctx, candidate_hash).await; - if let Ok(Some(chunk_size)) = chunk_size { - let pov_size_estimate = - chunk_size.saturating_mul(session_info.validators.len()) / 3; - small_pov_size = pov_size_estimate < small_pov_limit; - - gum::trace!( - target: LOG_TARGET, - ?candidate_hash, - pov_size_estimate, - small_pov_limit, - enabled = small_pov_size, - "Prefer fetch from backing group", - ); - } else { - // we have a POV limit but were not able to query the chunk size, so - // don't use the backing group. - small_pov_size = false; - } + match recovery_strategy_kind { + RecoveryStrategyKind::BackersFirstIfSizeLower(fetch_chunks_threshold) | + RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks( + fetch_chunks_threshold, + ) => { + // Get our own chunk size to get an estimate of the PoV size. + let chunk_size: Result> = + query_chunk_size(ctx, candidate_hash).await; + if let Ok(Some(chunk_size)) = chunk_size { + let pov_size_estimate = chunk_size * systematic_threshold; + small_pov_size = pov_size_estimate < fetch_chunks_threshold; + + if small_pov_size { + gum::trace!( + target: LOG_TARGET, + ?candidate_hash, + pov_size_estimate, + fetch_chunks_threshold, + "Prefer fetch from backing group", + ); + } + } else { + // we have a POV limit but were not able to query the chunk size, so + // don't use the backing group. + small_pov_size = false; + } + }, + _ => {}, }; match (&recovery_strategy_kind, small_pov_size) { (RecoveryStrategyKind::BackersFirstAlways, _) | - (RecoveryStrategyKind::BackersFirstIfSizeLower(_), true) => recovery_strategies.push_back( - Box::new(FetchFull::new(FetchFullParams { - validators: backing_validators.to_vec(), - erasure_task_tx: erasure_task_tx.clone(), - })), - ), + (RecoveryStrategyKind::BackersFirstIfSizeLower(_), true) | + ( + RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(_), + true, + ) | + (RecoveryStrategyKind::BackersThenSystematicChunks, _) => + recovery_strategies.push_back(Box::new(FetchFull::new( + FetchFullParams { validators: backing_validators.to_vec() }, + ))), _ => {}, }; + + backer_group = Some(backing_validators); + } + } + + let chunk_mapping_enabled = if let Some(&true) = node_features + .get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8)) + .as_deref() + { + true + } else { + false + }; + + // We can only attempt systematic recovery if we received the core index of the + // candidate and chunk mapping is enabled. + if let Some(core_index) = maybe_core_index { + if matches!( + recovery_strategy_kind, + RecoveryStrategyKind::BackersThenSystematicChunks | + RecoveryStrategyKind::SystematicChunks | + RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks(_) + ) && chunk_mapping_enabled + { + let chunk_indices = + availability_chunk_indices(Some(node_features), n_validators, core_index)?; + + let chunk_indices: VecDeque<_> = chunk_indices + .iter() + .enumerate() + .map(|(v_index, c_index)| { + ( + *c_index, + ValidatorIndex( + u32::try_from(v_index) + .expect("validator count should not exceed u32"), + ), + ) + }) + .collect(); + + // Only get the validators according to the threshold. + let validators = chunk_indices + .clone() + .into_iter() + .filter(|(c_index, _)| { + usize::try_from(c_index.0) + .expect("usize is at least u32 bytes on all modern targets.") < + systematic_threshold + }) + .collect(); + + recovery_strategies.push_back(Box::new(FetchSystematicChunks::new( + FetchSystematicChunksParams { + validators, + backers: backer_group.map(|v| v.to_vec()).unwrap_or_else(|| vec![]), + }, + ))); } } recovery_strategies.push_back(Box::new(FetchChunks::new(FetchChunksParams { n_validators: session_info.validators.len(), - erasure_task_tx, }))); + let session_info = session_info.clone(); + + let n_validators = session_info.validators.len(); + launch_recovery_task( state, ctx, - session_info, - receipt, response_sender, - metrics, recovery_strategies, - bypass_availability_store, - post_recovery_check, + RecoveryParams { + validator_authority_keys: session_info.discovery_keys.clone(), + n_validators, + threshold: recovery_threshold(n_validators)?, + systematic_threshold, + candidate_hash, + erasure_root: receipt.descriptor.erasure_root, + metrics: metrics.clone(), + bypass_availability_store, + post_recovery_check, + pov_hash: receipt.descriptor.pov_hash, + req_v1_protocol_name, + req_v2_protocol_name, + chunk_mapping_enabled, + erasure_task_tx, + }, ) .await }, - None => { - gum::warn!(target: LOG_TARGET, "SessionInfo is `None` at {:?}", state.live_block); + Err(_) => { response_sender .send(Err(RecoveryError::Unavailable)) - .map_err(|_| error::Error::CanceledResponseSender)?; - Ok(()) + .map_err(|_| Error::CanceledResponseSender)?; + + Err(Error::SessionInfoUnavailable(state.live_block.1)) }, } } -/// Queries a chunk from av-store. +/// Queries the full `AvailableData` from av-store. #[overseer::contextbounds(AvailabilityRecovery, prefix = self::overseer)] async fn query_full_data( ctx: &mut Context, candidate_hash: CandidateHash, -) -> error::Result> { +) -> Result> { let (tx, rx) = oneshot::channel(); ctx.send_message(AvailabilityStoreMessage::QueryAvailableData(candidate_hash, tx)) .await; - rx.await.map_err(error::Error::CanceledQueryFullData) + rx.await.map_err(Error::CanceledQueryFullData) } /// Queries a chunk from av-store. @@ -533,12 +587,12 @@ async fn query_full_data( async fn query_chunk_size( ctx: &mut Context, candidate_hash: CandidateHash, -) -> error::Result> { +) -> Result> { let (tx, rx) = oneshot::channel(); ctx.send_message(AvailabilityStoreMessage::QueryChunkSize(candidate_hash, tx)) .await; - rx.await.map_err(error::Error::CanceledQueryFullData) + rx.await.map_err(Error::CanceledQueryFullData) } #[overseer::contextbounds(AvailabilityRecovery, prefix = self::overseer)] @@ -547,64 +601,80 @@ impl AvailabilityRecoverySubsystem { /// which never requests the `AvailabilityStoreSubsystem` subsystem and only checks the POV hash /// instead of reencoding the available data. pub fn for_collator( + fetch_chunks_threshold: Option, req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, metrics: Metrics, ) -> Self { Self { - recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower(SMALL_POV_LIMIT), + recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower( + fetch_chunks_threshold.unwrap_or(CONSERVATIVE_FETCH_CHUNKS_THRESHOLD), + ), bypass_availability_store: true, post_recovery_check: PostRecoveryCheck::PovHash, req_receiver, metrics, + req_v1_protocol_name: req_protocol_names + .get_name(request_v1::ChunkFetchingRequest::PROTOCOL), + req_v2_protocol_name: req_protocol_names + .get_name(request_v2::ChunkFetchingRequest::PROTOCOL), } } - /// Create a new instance of `AvailabilityRecoverySubsystem` which starts with a fast path to - /// request data from backers. - pub fn with_fast_path( + /// Create an optimised new instance of `AvailabilityRecoverySubsystem` suitable for validator + /// nodes, which: + /// - for small POVs (over the `fetch_chunks_threshold` or the + /// `CONSERVATIVE_FETCH_CHUNKS_THRESHOLD`), it attempts full recovery from backers, if backing + /// group supplied. + /// - for large POVs, attempts systematic recovery, if core_index supplied and + /// AvailabilityChunkMapping node feature is enabled. + /// - as a last resort, attempt regular chunk recovery from all validators. + pub fn for_validator( + fetch_chunks_threshold: Option, req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, metrics: Metrics, ) -> Self { Self { - recovery_strategy_kind: RecoveryStrategyKind::BackersFirstAlways, + recovery_strategy_kind: + RecoveryStrategyKind::BackersFirstIfSizeLowerThenSystematicChunks( + fetch_chunks_threshold.unwrap_or(CONSERVATIVE_FETCH_CHUNKS_THRESHOLD), + ), bypass_availability_store: false, post_recovery_check: PostRecoveryCheck::Reencode, req_receiver, metrics, + req_v1_protocol_name: req_protocol_names + .get_name(request_v1::ChunkFetchingRequest::PROTOCOL), + req_v2_protocol_name: req_protocol_names + .get_name(request_v2::ChunkFetchingRequest::PROTOCOL), } } - /// Create a new instance of `AvailabilityRecoverySubsystem` which requests only chunks - pub fn with_chunks_only( + /// Customise the recovery strategy kind + /// Currently only useful for tests. + #[cfg(any(test, feature = "subsystem-benchmarks"))] + pub fn with_recovery_strategy_kind( req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, metrics: Metrics, + recovery_strategy_kind: RecoveryStrategyKind, ) -> Self { Self { - recovery_strategy_kind: RecoveryStrategyKind::ChunksAlways, - bypass_availability_store: false, - post_recovery_check: PostRecoveryCheck::Reencode, - req_receiver, - metrics, - } - } - - /// Create a new instance of `AvailabilityRecoverySubsystem` which requests chunks if PoV is - /// above a threshold. - pub fn with_chunks_if_pov_large( - req_receiver: IncomingRequestReceiver, - metrics: Metrics, - ) -> Self { - Self { - recovery_strategy_kind: RecoveryStrategyKind::BackersFirstIfSizeLower(SMALL_POV_LIMIT), + recovery_strategy_kind, bypass_availability_store: false, post_recovery_check: PostRecoveryCheck::Reencode, req_receiver, metrics, + req_v1_protocol_name: req_protocol_names + .get_name(request_v1::ChunkFetchingRequest::PROTOCOL), + req_v2_protocol_name: req_protocol_names + .get_name(request_v2::ChunkFetchingRequest::PROTOCOL), } } /// Starts the inner subsystem loop. - pub async fn run(self, mut ctx: Context) -> SubsystemResult<()> { + pub async fn run(self, mut ctx: Context) -> std::result::Result<(), FatalError> { let mut state = State::default(); let Self { mut req_receiver, @@ -612,6 +682,8 @@ impl AvailabilityRecoverySubsystem { recovery_strategy_kind, bypass_availability_store, post_recovery_check, + req_v1_protocol_name, + req_v2_protocol_name, } = self; let (erasure_task_tx, erasure_task_rx) = futures::channel::mpsc::channel(16); @@ -647,53 +719,44 @@ impl AvailabilityRecoverySubsystem { loop { let recv_req = req_receiver.recv(|| vec![COST_INVALID_REQUEST]).fuse(); pin_mut!(recv_req); - futures::select! { + let res = futures::select! { erasure_task = erasure_task_rx.next() => { match erasure_task { Some(task) => { - let send_result = to_pool + to_pool .next() .expect("Pool size is `NonZeroUsize`; qed") .send(task) .await - .map_err(|_| RecoveryError::ChannelClosed); - - if let Err(err) = send_result { - gum::warn!( - target: LOG_TARGET, - ?err, - "Failed to send erasure coding task", - ); - } + .map_err(|_| RecoveryError::ChannelClosed) }, None => { - gum::debug!( - target: LOG_TARGET, - "Erasure task channel closed", - ); - - return Err(SubsystemError::with_origin("availability-recovery", RecoveryError::ChannelClosed)) + Err(RecoveryError::ChannelClosed) } - } + }.map_err(Into::into) } - v = ctx.recv().fuse() => { - match v? { - FromOrchestra::Signal(signal) => if handle_signal( - &mut state, - signal, - ).await? { - gum::debug!(target: LOG_TARGET, "subsystem concluded"); - return Ok(()); - } - FromOrchestra::Communication { msg } => { - match msg { - AvailabilityRecoveryMessage::RecoverAvailableData( - receipt, - session_index, - maybe_backing_group, - response_sender, - ) => { - if let Err(e) = handle_recover( + signal = ctx.recv().fuse() => { + match signal { + Ok(signal) => { + match signal { + FromOrchestra::Signal(signal) => if handle_signal( + &mut state, + signal, + ).await { + gum::debug!(target: LOG_TARGET, "subsystem concluded"); + return Ok(()); + } else { + Ok(()) + }, + FromOrchestra::Communication { + msg: AvailabilityRecoveryMessage::RecoverAvailableData( + receipt, + session_index, + maybe_backing_group, + maybe_core_index, + response_sender, + ) + } => handle_recover( &mut state, &mut ctx, receipt, @@ -704,21 +767,18 @@ impl AvailabilityRecoverySubsystem { erasure_task_tx.clone(), recovery_strategy_kind.clone(), bypass_availability_store, - post_recovery_check.clone() - ).await { - gum::warn!( - target: LOG_TARGET, - err = ?e, - "Error handling a recovery request", - ); - } - } + post_recovery_check.clone(), + maybe_core_index, + req_v1_protocol_name.clone(), + req_v2_protocol_name.clone(), + ).await } - } + }, + Err(e) => Err(Error::SubsystemReceive(e)) } } in_req = recv_req => { - match in_req.into_nested().map_err(|fatal| SubsystemError::with_origin("availability-recovery", fatal))? { + match in_req { Ok(req) => { if bypass_availability_store { gum::debug!( @@ -726,40 +786,42 @@ impl AvailabilityRecoverySubsystem { "Skipping request to availability-store.", ); let _ = req.send_response(None.into()); - continue - } - match query_full_data(&mut ctx, req.payload.candidate_hash).await { - Ok(res) => { - let _ = req.send_response(res.into()); - } - Err(e) => { - gum::debug!( - target: LOG_TARGET, - err = ?e, - "Failed to query available data.", - ); - - let _ = req.send_response(None.into()); + Ok(()) + } else { + match query_full_data(&mut ctx, req.payload.candidate_hash).await { + Ok(res) => { + let _ = req.send_response(res.into()); + Ok(()) + } + Err(e) => { + let _ = req.send_response(None.into()); + Err(e) + } } } } - Err(jfyi) => { - gum::debug!( - target: LOG_TARGET, - error = ?jfyi, - "Decoding incoming request failed" - ); - continue - } + Err(e) => Err(Error::IncomingRequest(e)) } } output = state.ongoing_recoveries.select_next_some() => { + let mut res = Ok(()); if let Some((candidate_hash, result)) = output { + if let Err(ref e) = result { + res = Err(Error::Recovery(e.clone())); + } + if let Ok(recovery) = CachedRecovery::try_from(result) { state.availability_lru.insert(candidate_hash, recovery); } } + + res } + }; + + // Only bubble up fatal errors, but log all of them. + if let Err(e) = res { + log_error(Err(e))?; } } } @@ -827,7 +889,13 @@ async fn erasure_task_thread( Some(ErasureTask::Reconstruct(n_validators, chunks, sender)) => { let _ = sender.send(polkadot_erasure_coding::reconstruct_v1( n_validators, - chunks.values().map(|c| (&c.chunk[..], c.index.0 as usize)), + chunks.iter().map(|(c_index, chunk)| { + ( + &chunk[..], + usize::try_from(c_index.0) + .expect("usize is at least u32 bytes on all modern targets."), + ) + }), )); }, Some(ErasureTask::Reencode(n_validators, root, available_data, sender)) => { diff --git a/polkadot/node/network/availability-recovery/src/metrics.rs b/polkadot/node/network/availability-recovery/src/metrics.rs index 9f4cddc57e43a93089fbb08ec4a18dfd77ffea8d..4e269df55027b69fbff7604ac85d980f4fd36c6f 100644 --- a/polkadot/node/network/availability-recovery/src/metrics.rs +++ b/polkadot/node/network/availability-recovery/src/metrics.rs @@ -14,9 +14,13 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use polkadot_node_subsystem::prometheus::HistogramVec; use polkadot_node_subsystem_util::metrics::{ self, - prometheus::{self, Counter, CounterVec, Histogram, Opts, PrometheusError, Registry, U64}, + prometheus::{ + self, prometheus::HistogramTimer, Counter, CounterVec, Histogram, Opts, PrometheusError, + Registry, U64, + }, }; /// Availability Distribution metrics. @@ -28,26 +32,61 @@ struct MetricsInner { /// Number of sent chunk requests. /// /// Gets incremented on each sent chunk requests. - chunk_requests_issued: Counter, + /// + /// Split by chunk type: + /// - `regular_chunks` + /// - `systematic_chunks` + chunk_requests_issued: CounterVec, + /// Total number of bytes recovered /// /// Gets incremented on each successful recovery recovered_bytes_total: Counter, + /// A counter for finished chunk requests. /// - /// Split by result: + /// Split by the chunk type (`regular_chunks` or `systematic_chunks`) + /// + /// Also split by result: /// - `no_such_chunk` ... peer did not have the requested chunk /// - `timeout` ... request timed out. - /// - `network_error` ... Some networking issue except timeout + /// - `error` ... Some networking issue except timeout /// - `invalid` ... Chunk was received, but not valid. /// - `success` chunk_requests_finished: CounterVec, + /// A counter for successful chunk requests, split by the network protocol version. + chunk_request_protocols: CounterVec, + + /// Number of sent available data requests. + full_data_requests_issued: Counter, + + /// Counter for finished available data requests. + /// + /// Split by the result type: + /// + /// - `no_such_data` ... peer did not have the requested data + /// - `timeout` ... request timed out. + /// - `error` ... Some networking issue except timeout + /// - `invalid` ... data was received, but not valid. + /// - `success` + full_data_requests_finished: CounterVec, + /// The duration of request to response. - time_chunk_request: Histogram, + /// + /// Split by chunk type (`regular_chunks` or `systematic_chunks`). + time_chunk_request: HistogramVec, /// The duration between the pure recovery and verification. - time_erasure_recovery: Histogram, + /// + /// Split by recovery type (`regular_chunks`, `systematic_chunks` or `full_from_backers`). + time_erasure_recovery: HistogramVec, + + /// How much time it takes to reconstruct the available data from chunks. + /// + /// Split by chunk type (`regular_chunks` or `systematic_chunks`), as the algorithms are + /// different. + time_erasure_reconstruct: HistogramVec, /// How much time it takes to re-encode the data into erasure chunks in order to verify /// the root hash of the provided Merkle tree. See `reconstructed_data_matches_root`. @@ -58,6 +97,10 @@ struct MetricsInner { time_full_recovery: Histogram, /// Number of full recoveries that have been finished one way or the other. + /// + /// Split by recovery `strategy_type` (`full_from_backers, systematic_chunks, regular_chunks, + /// all`). `all` is used for failed recoveries that tried all available strategies. + /// Also split by `result` type. full_recoveries_finished: CounterVec, /// Number of full recoveries that have been started on this subsystem. @@ -73,87 +116,175 @@ impl Metrics { Metrics(None) } - /// Increment counter on fetched labels. - pub fn on_chunk_request_issued(&self) { + /// Increment counter for chunk requests. + pub fn on_chunk_request_issued(&self, chunk_type: &str) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_issued.inc() + metrics.chunk_requests_issued.with_label_values(&[chunk_type]).inc() + } + } + + /// Increment counter for full data requests. + pub fn on_full_request_issued(&self) { + if let Some(metrics) = &self.0 { + metrics.full_data_requests_issued.inc() } } /// A chunk request timed out. - pub fn on_chunk_request_timeout(&self) { + pub fn on_chunk_request_timeout(&self, chunk_type: &str) { + if let Some(metrics) = &self.0 { + metrics + .chunk_requests_finished + .with_label_values(&[chunk_type, "timeout"]) + .inc() + } + } + + /// A full data request timed out. + pub fn on_full_request_timeout(&self) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_finished.with_label_values(&["timeout"]).inc() + metrics.full_data_requests_finished.with_label_values(&["timeout"]).inc() } } /// A chunk request failed because validator did not have its chunk. - pub fn on_chunk_request_no_such_chunk(&self) { + pub fn on_chunk_request_no_such_chunk(&self, chunk_type: &str) { + if let Some(metrics) = &self.0 { + metrics + .chunk_requests_finished + .with_label_values(&[chunk_type, "no_such_chunk"]) + .inc() + } + } + + /// A full data request failed because the validator did not have it. + pub fn on_full_request_no_such_data(&self) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_finished.with_label_values(&["no_such_chunk"]).inc() + metrics.full_data_requests_finished.with_label_values(&["no_such_data"]).inc() } } /// A chunk request failed for some non timeout related network error. - pub fn on_chunk_request_error(&self) { + pub fn on_chunk_request_error(&self, chunk_type: &str) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_finished.with_label_values(&["error"]).inc() + metrics.chunk_requests_finished.with_label_values(&[chunk_type, "error"]).inc() + } + } + + /// A full data request failed for some non timeout related network error. + pub fn on_full_request_error(&self) { + if let Some(metrics) = &self.0 { + metrics.full_data_requests_finished.with_label_values(&["error"]).inc() } } /// A chunk request succeeded, but was not valid. - pub fn on_chunk_request_invalid(&self) { + pub fn on_chunk_request_invalid(&self, chunk_type: &str) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_finished.with_label_values(&["invalid"]).inc() + metrics + .chunk_requests_finished + .with_label_values(&[chunk_type, "invalid"]) + .inc() + } + } + + /// A full data request succeeded, but was not valid. + pub fn on_full_request_invalid(&self) { + if let Some(metrics) = &self.0 { + metrics.full_data_requests_finished.with_label_values(&["invalid"]).inc() } } /// A chunk request succeeded. - pub fn on_chunk_request_succeeded(&self) { + pub fn on_chunk_request_succeeded(&self, chunk_type: &str) { if let Some(metrics) = &self.0 { - metrics.chunk_requests_finished.with_label_values(&["success"]).inc() + metrics + .chunk_requests_finished + .with_label_values(&[chunk_type, "success"]) + .inc() + } + } + + /// A chunk response was received on the v1 protocol. + pub fn on_chunk_response_v1(&self) { + if let Some(metrics) = &self.0 { + metrics.chunk_request_protocols.with_label_values(&["v1"]).inc() + } + } + + /// A chunk response was received on the v2 protocol. + pub fn on_chunk_response_v2(&self) { + if let Some(metrics) = &self.0 { + metrics.chunk_request_protocols.with_label_values(&["v2"]).inc() + } + } + + /// A full data request succeeded. + pub fn on_full_request_succeeded(&self) { + if let Some(metrics) = &self.0 { + metrics.full_data_requests_finished.with_label_values(&["success"]).inc() } } /// Get a timer to time request/response duration. - pub fn time_chunk_request(&self) -> Option { - self.0.as_ref().map(|metrics| metrics.time_chunk_request.start_timer()) + pub fn time_chunk_request(&self, chunk_type: &str) -> Option { + self.0.as_ref().map(|metrics| { + metrics.time_chunk_request.with_label_values(&[chunk_type]).start_timer() + }) } /// Get a timer to time erasure code recover. - pub fn time_erasure_recovery(&self) -> Option { - self.0.as_ref().map(|metrics| metrics.time_erasure_recovery.start_timer()) + pub fn time_erasure_recovery(&self, chunk_type: &str) -> Option { + self.0.as_ref().map(|metrics| { + metrics.time_erasure_recovery.with_label_values(&[chunk_type]).start_timer() + }) + } + + /// Get a timer for available data reconstruction. + pub fn time_erasure_reconstruct(&self, chunk_type: &str) -> Option { + self.0.as_ref().map(|metrics| { + metrics.time_erasure_reconstruct.with_label_values(&[chunk_type]).start_timer() + }) } /// Get a timer to time chunk encoding. - pub fn time_reencode_chunks(&self) -> Option { + pub fn time_reencode_chunks(&self) -> Option { self.0.as_ref().map(|metrics| metrics.time_reencode_chunks.start_timer()) } /// Get a timer to measure the time of the complete recovery process. - pub fn time_full_recovery(&self) -> Option { + pub fn time_full_recovery(&self) -> Option { self.0.as_ref().map(|metrics| metrics.time_full_recovery.start_timer()) } /// A full recovery succeeded. - pub fn on_recovery_succeeded(&self, bytes: usize) { + pub fn on_recovery_succeeded(&self, strategy_type: &str, bytes: usize) { if let Some(metrics) = &self.0 { - metrics.full_recoveries_finished.with_label_values(&["success"]).inc(); + metrics + .full_recoveries_finished + .with_label_values(&["success", strategy_type]) + .inc(); metrics.recovered_bytes_total.inc_by(bytes as u64) } } /// A full recovery failed (data not available). - pub fn on_recovery_failed(&self) { + pub fn on_recovery_failed(&self, strategy_type: &str) { if let Some(metrics) = &self.0 { - metrics.full_recoveries_finished.with_label_values(&["failure"]).inc() + metrics + .full_recoveries_finished + .with_label_values(&["failure", strategy_type]) + .inc() } } /// A full recovery failed (data was recovered, but invalid). - pub fn on_recovery_invalid(&self) { + pub fn on_recovery_invalid(&self, strategy_type: &str) { if let Some(metrics) = &self.0 { - metrics.full_recoveries_finished.with_label_values(&["invalid"]).inc() + metrics + .full_recoveries_finished + .with_label_values(&["invalid", strategy_type]) + .inc() } } @@ -169,9 +300,17 @@ impl metrics::Metrics for Metrics { fn try_register(registry: &Registry) -> Result { let metrics = MetricsInner { chunk_requests_issued: prometheus::register( + CounterVec::new( + Opts::new("polkadot_parachain_availability_recovery_chunk_requests_issued", + "Total number of issued chunk requests."), + &["type"] + )?, + registry, + )?, + full_data_requests_issued: prometheus::register( Counter::new( - "polkadot_parachain_availability_recovery_chunk_requests_issued", - "Total number of issued chunk requests.", + "polkadot_parachain_availability_recovery_full_data_requests_issued", + "Total number of issued full data requests.", )?, registry, )?, @@ -188,22 +327,49 @@ impl metrics::Metrics for Metrics { "polkadot_parachain_availability_recovery_chunk_requests_finished", "Total number of chunk requests finished.", ), + &["result", "type"], + )?, + registry, + )?, + chunk_request_protocols: prometheus::register( + CounterVec::new( + Opts::new( + "polkadot_parachain_availability_recovery_chunk_request_protocols", + "Total number of successful chunk requests, mapped by the protocol version (v1 or v2).", + ), + &["protocol"], + )?, + registry, + )?, + full_data_requests_finished: prometheus::register( + CounterVec::new( + Opts::new( + "polkadot_parachain_availability_recovery_full_data_requests_finished", + "Total number of full data requests finished.", + ), &["result"], )?, registry, )?, time_chunk_request: prometheus::register( - prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( + prometheus::HistogramVec::new(prometheus::HistogramOpts::new( "polkadot_parachain_availability_recovery_time_chunk_request", "Time spent waiting for a response to a chunk request", - ))?, + ), &["type"])?, registry, )?, time_erasure_recovery: prometheus::register( - prometheus::Histogram::with_opts(prometheus::HistogramOpts::new( + prometheus::HistogramVec::new(prometheus::HistogramOpts::new( "polkadot_parachain_availability_recovery_time_erasure_recovery", "Time spent to recover the erasure code and verify the merkle root by re-encoding as erasure chunks", - ))?, + ), &["type"])?, + registry, + )?, + time_erasure_reconstruct: prometheus::register( + prometheus::HistogramVec::new(prometheus::HistogramOpts::new( + "polkadot_parachain_availability_recovery_time_erasure_reconstruct", + "Time spent to reconstruct the data from chunks", + ), &["type"])?, registry, )?, time_reencode_chunks: prometheus::register( @@ -226,7 +392,7 @@ impl metrics::Metrics for Metrics { "polkadot_parachain_availability_recovery_recoveries_finished", "Total number of recoveries that finished.", ), - &["result"], + &["result", "strategy_type"], )?, registry, )?, diff --git a/polkadot/node/network/availability-recovery/src/task.rs b/polkadot/node/network/availability-recovery/src/task.rs deleted file mode 100644 index c300c221da5c6da8f40e8a6db3dede59ba207a58..0000000000000000000000000000000000000000 --- a/polkadot/node/network/availability-recovery/src/task.rs +++ /dev/null @@ -1,861 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Polkadot. - -// Polkadot 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. - -// Polkadot 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 Polkadot. If not, see . - -//! Recovery task and associated strategies. - -#![warn(missing_docs)] - -use crate::{ - futures_undead::FuturesUndead, is_chunk_valid, is_unavailable, metrics::Metrics, ErasureTask, - PostRecoveryCheck, LOG_TARGET, -}; -use futures::{channel::oneshot, SinkExt}; -use parity_scale_codec::Encode; -#[cfg(not(test))] -use polkadot_node_network_protocol::request_response::CHUNK_REQUEST_TIMEOUT; -use polkadot_node_network_protocol::request_response::{ - self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests, -}; -use polkadot_node_primitives::{AvailableData, ErasureChunk}; -use polkadot_node_subsystem::{ - messages::{AvailabilityStoreMessage, NetworkBridgeTxMessage}, - overseer, RecoveryError, -}; -use polkadot_primitives::{AuthorityDiscoveryId, CandidateHash, Hash, ValidatorIndex}; -use rand::seq::SliceRandom; -use sc_network::{IfDisconnected, OutboundFailure, RequestFailure}; -use std::{ - collections::{HashMap, VecDeque}, - time::Duration, -}; - -// How many parallel recovery tasks should be running at once. -const N_PARALLEL: usize = 50; - -/// Time after which we consider a request to have failed -/// -/// and we should try more peers. Note in theory the request times out at the network level, -/// measurements have shown, that in practice requests might actually take longer to fail in -/// certain occasions. (The very least, authority discovery is not part of the timeout.) -/// -/// For the time being this value is the same as the timeout on the networking layer, but as this -/// timeout is more soft than the networking one, it might make sense to pick different values as -/// well. -#[cfg(not(test))] -const TIMEOUT_START_NEW_REQUESTS: Duration = CHUNK_REQUEST_TIMEOUT; -#[cfg(test)] -const TIMEOUT_START_NEW_REQUESTS: Duration = Duration::from_millis(100); - -#[async_trait::async_trait] -/// Common trait for runnable recovery strategies. -pub trait RecoveryStrategy: Send { - /// Main entry point of the strategy. - async fn run( - &mut self, - state: &mut State, - sender: &mut Sender, - common_params: &RecoveryParams, - ) -> Result; - - /// Return the name of the strategy for logging purposes. - fn display_name(&self) -> &'static str; -} - -/// Recovery parameters common to all strategies in a `RecoveryTask`. -pub struct RecoveryParams { - /// Discovery ids of `validators`. - pub validator_authority_keys: Vec, - - /// Number of validators. - pub n_validators: usize, - - /// The number of chunks needed. - pub threshold: usize, - - /// A hash of the relevant candidate. - pub candidate_hash: CandidateHash, - - /// The root of the erasure encoding of the candidate. - pub erasure_root: Hash, - - /// Metrics to report. - pub metrics: Metrics, - - /// Do not request data from availability-store. Useful for collators. - pub bypass_availability_store: bool, - - /// The type of check to perform after available data was recovered. - pub post_recovery_check: PostRecoveryCheck, - - /// The blake2-256 hash of the PoV. - pub pov_hash: Hash, -} - -/// Intermediate/common data that must be passed between `RecoveryStrategy`s belonging to the -/// same `RecoveryTask`. -pub struct State { - /// Chunks received so far. - received_chunks: HashMap, -} - -impl State { - fn new() -> Self { - Self { received_chunks: HashMap::new() } - } - - fn insert_chunk(&mut self, validator: ValidatorIndex, chunk: ErasureChunk) { - self.received_chunks.insert(validator, chunk); - } - - fn chunk_count(&self) -> usize { - self.received_chunks.len() - } - - /// Retrieve the local chunks held in the av-store (either 0 or 1). - async fn populate_from_av_store( - &mut self, - params: &RecoveryParams, - sender: &mut Sender, - ) -> Vec { - let (tx, rx) = oneshot::channel(); - sender - .send_message(AvailabilityStoreMessage::QueryAllChunks(params.candidate_hash, tx)) - .await; - - match rx.await { - Ok(chunks) => { - // This should either be length 1 or 0. If we had the whole data, - // we wouldn't have reached this stage. - let chunk_indices: Vec<_> = chunks.iter().map(|c| c.index).collect(); - - for chunk in chunks { - if is_chunk_valid(params, &chunk) { - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - validator_index = ?chunk.index, - "Found valid chunk on disk" - ); - self.insert_chunk(chunk.index, chunk); - } else { - gum::error!( - target: LOG_TARGET, - "Loaded invalid chunk from disk! Disk/Db corruption _very_ likely - please fix ASAP!" - ); - }; - } - - chunk_indices - }, - Err(oneshot::Canceled) => { - gum::warn!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - "Failed to reach the availability store" - ); - - vec![] - }, - } - } - - /// Launch chunk requests in parallel, according to the parameters. - async fn launch_parallel_chunk_requests( - &mut self, - params: &RecoveryParams, - sender: &mut Sender, - desired_requests_count: usize, - validators: &mut VecDeque, - requesting_chunks: &mut FuturesUndead< - Result, (ValidatorIndex, RequestError)>, - >, - ) where - Sender: overseer::AvailabilityRecoverySenderTrait, - { - let candidate_hash = ¶ms.candidate_hash; - let already_requesting_count = requesting_chunks.len(); - - let mut requests = Vec::with_capacity(desired_requests_count - already_requesting_count); - - while requesting_chunks.len() < desired_requests_count { - if let Some(validator_index) = validators.pop_back() { - let validator = params.validator_authority_keys[validator_index.0 as usize].clone(); - gum::trace!( - target: LOG_TARGET, - ?validator, - ?validator_index, - ?candidate_hash, - "Requesting chunk", - ); - - // Request data. - let raw_request = req_res::v1::ChunkFetchingRequest { - candidate_hash: params.candidate_hash, - index: validator_index, - }; - - let (req, res) = OutgoingRequest::new(Recipient::Authority(validator), raw_request); - requests.push(Requests::ChunkFetchingV1(req)); - - params.metrics.on_chunk_request_issued(); - let timer = params.metrics.time_chunk_request(); - - requesting_chunks.push(Box::pin(async move { - let _timer = timer; - match res.await { - Ok(req_res::v1::ChunkFetchingResponse::Chunk(chunk)) => - Ok(Some(chunk.recombine_into_chunk(&raw_request))), - Ok(req_res::v1::ChunkFetchingResponse::NoSuchChunk) => Ok(None), - Err(e) => Err((validator_index, e)), - } - })); - } else { - break - } - } - - sender - .send_message(NetworkBridgeTxMessage::SendRequests( - requests, - IfDisconnected::TryConnect, - )) - .await; - } - - /// Wait for a sufficient amount of chunks to reconstruct according to the provided `params`. - async fn wait_for_chunks( - &mut self, - params: &RecoveryParams, - validators: &mut VecDeque, - requesting_chunks: &mut FuturesUndead< - Result, (ValidatorIndex, RequestError)>, - >, - can_conclude: impl Fn(usize, usize, usize, &RecoveryParams, usize) -> bool, - ) -> (usize, usize) { - let metrics = ¶ms.metrics; - - let mut total_received_responses = 0; - let mut error_count = 0; - - // Wait for all current requests to conclude or time-out, or until we reach enough chunks. - // We also declare requests undead, once `TIMEOUT_START_NEW_REQUESTS` is reached and will - // return in that case for `launch_parallel_requests` to fill up slots again. - while let Some(request_result) = - requesting_chunks.next_with_timeout(TIMEOUT_START_NEW_REQUESTS).await - { - total_received_responses += 1; - - match request_result { - Ok(Some(chunk)) => - if is_chunk_valid(params, &chunk) { - metrics.on_chunk_request_succeeded(); - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - validator_index = ?chunk.index, - "Received valid chunk", - ); - self.insert_chunk(chunk.index, chunk); - } else { - metrics.on_chunk_request_invalid(); - error_count += 1; - }, - Ok(None) => { - metrics.on_chunk_request_no_such_chunk(); - error_count += 1; - }, - Err((validator_index, e)) => { - error_count += 1; - - gum::trace!( - target: LOG_TARGET, - candidate_hash= ?params.candidate_hash, - err = ?e, - ?validator_index, - "Failure requesting chunk", - ); - - match e { - RequestError::InvalidResponse(_) => { - metrics.on_chunk_request_invalid(); - - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - err = ?e, - ?validator_index, - "Chunk fetching response was invalid", - ); - }, - RequestError::NetworkError(err) => { - // No debug logs on general network errors - that became very spammy - // occasionally. - if let RequestFailure::Network(OutboundFailure::Timeout) = err { - metrics.on_chunk_request_timeout(); - } else { - metrics.on_chunk_request_error(); - } - - validators.push_front(validator_index); - }, - RequestError::Canceled(_) => { - metrics.on_chunk_request_error(); - - validators.push_front(validator_index); - }, - } - }, - } - - // Stop waiting for requests when we either can already recover the data - // or have gotten firm 'No' responses from enough validators. - if can_conclude( - validators.len(), - requesting_chunks.total_len(), - self.chunk_count(), - params, - error_count, - ) { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?params.candidate_hash, - received_chunks_count = ?self.chunk_count(), - requested_chunks_count = ?requesting_chunks.len(), - threshold = ?params.threshold, - "Can conclude availability for a candidate", - ); - break - } - } - - (total_received_responses, error_count) - } -} - -/// A stateful reconstruction of availability data in reference to -/// a candidate hash. -pub struct RecoveryTask { - sender: Sender, - params: RecoveryParams, - strategies: VecDeque>>, - state: State, -} - -impl RecoveryTask -where - Sender: overseer::AvailabilityRecoverySenderTrait, -{ - /// Instantiate a new recovery task. - pub fn new( - sender: Sender, - params: RecoveryParams, - strategies: VecDeque>>, - ) -> Self { - Self { sender, params, strategies, state: State::new() } - } - - async fn in_availability_store(&mut self) -> Option { - if !self.params.bypass_availability_store { - let (tx, rx) = oneshot::channel(); - self.sender - .send_message(AvailabilityStoreMessage::QueryAvailableData( - self.params.candidate_hash, - tx, - )) - .await; - - match rx.await { - Ok(Some(data)) => return Some(data), - Ok(None) => {}, - Err(oneshot::Canceled) => { - gum::warn!( - target: LOG_TARGET, - candidate_hash = ?self.params.candidate_hash, - "Failed to reach the availability store", - ) - }, - } - } - - None - } - - /// Run this recovery task to completion. It will loop through the configured strategies - /// in-order and return whenever the first one recovers the full `AvailableData`. - pub async fn run(mut self) -> Result { - if let Some(data) = self.in_availability_store().await { - return Ok(data) - } - - self.params.metrics.on_recovery_started(); - - let _timer = self.params.metrics.time_full_recovery(); - - while let Some(mut current_strategy) = self.strategies.pop_front() { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?self.params.candidate_hash, - "Starting `{}` strategy", - current_strategy.display_name(), - ); - - let res = current_strategy.run(&mut self.state, &mut self.sender, &self.params).await; - - match res { - Err(RecoveryError::Unavailable) => - if self.strategies.front().is_some() { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?self.params.candidate_hash, - "Recovery strategy `{}` did not conclude. Trying the next one.", - current_strategy.display_name(), - ); - continue - }, - Err(err) => { - match &err { - RecoveryError::Invalid => self.params.metrics.on_recovery_invalid(), - _ => self.params.metrics.on_recovery_failed(), - } - return Err(err) - }, - Ok(data) => { - self.params.metrics.on_recovery_succeeded(data.encoded_size()); - return Ok(data) - }, - } - } - - // We have no other strategies to try. - gum::warn!( - target: LOG_TARGET, - candidate_hash = ?self.params.candidate_hash, - "Recovery of available data failed.", - ); - self.params.metrics.on_recovery_failed(); - - Err(RecoveryError::Unavailable) - } -} - -/// `RecoveryStrategy` that sequentially tries to fetch the full `AvailableData` from -/// already-connected validators in the configured validator set. -pub struct FetchFull { - params: FetchFullParams, -} - -pub struct FetchFullParams { - /// Validators that will be used for fetching the data. - pub validators: Vec, - /// Channel to the erasure task handler. - pub erasure_task_tx: futures::channel::mpsc::Sender, -} - -impl FetchFull { - /// Create a new `FetchFull` recovery strategy. - pub fn new(mut params: FetchFullParams) -> Self { - params.validators.shuffle(&mut rand::thread_rng()); - Self { params } - } -} - -#[async_trait::async_trait] -impl RecoveryStrategy for FetchFull { - fn display_name(&self) -> &'static str { - "Full recovery from backers" - } - - async fn run( - &mut self, - _: &mut State, - sender: &mut Sender, - common_params: &RecoveryParams, - ) -> Result { - loop { - // Pop the next validator, and proceed to next fetch_chunks_task if we're out. - let validator_index = - self.params.validators.pop().ok_or_else(|| RecoveryError::Unavailable)?; - - // Request data. - let (req, response) = OutgoingRequest::new( - Recipient::Authority( - common_params.validator_authority_keys[validator_index.0 as usize].clone(), - ), - req_res::v1::AvailableDataFetchingRequest { - candidate_hash: common_params.candidate_hash, - }, - ); - - sender - .send_message(NetworkBridgeTxMessage::SendRequests( - vec![Requests::AvailableDataFetchingV1(req)], - IfDisconnected::ImmediateError, - )) - .await; - - match response.await { - Ok(req_res::v1::AvailableDataFetchingResponse::AvailableData(data)) => { - let maybe_data = match common_params.post_recovery_check { - PostRecoveryCheck::Reencode => { - let (reencode_tx, reencode_rx) = oneshot::channel(); - self.params - .erasure_task_tx - .send(ErasureTask::Reencode( - common_params.n_validators, - common_params.erasure_root, - data, - reencode_tx, - )) - .await - .map_err(|_| RecoveryError::ChannelClosed)?; - - reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)? - }, - PostRecoveryCheck::PovHash => - (data.pov.hash() == common_params.pov_hash).then_some(data), - }; - - match maybe_data { - Some(data) => { - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - "Received full data", - ); - - return Ok(data) - }, - None => { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - ?validator_index, - "Invalid data response", - ); - - // it doesn't help to report the peer with req/res. - // we'll try the next backer. - }, - }; - }, - Ok(req_res::v1::AvailableDataFetchingResponse::NoSuchData) => {}, - Err(e) => gum::debug!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - ?validator_index, - err = ?e, - "Error fetching full available data." - ), - } - } - } -} - -/// `RecoveryStrategy` that requests chunks from validators, in parallel. -pub struct FetchChunks { - /// How many requests have been unsuccessful so far. - error_count: usize, - /// Total number of responses that have been received, including failed ones. - total_received_responses: usize, - /// Collection of in-flight requests. - requesting_chunks: FuturesUndead, (ValidatorIndex, RequestError)>>, - /// A random shuffling of the validators which indicates the order in which we connect to the - /// validators and request the chunk from them. - validators: VecDeque, - /// Channel to the erasure task handler. - erasure_task_tx: futures::channel::mpsc::Sender, -} - -/// Parameters specific to the `FetchChunks` strategy. -pub struct FetchChunksParams { - /// Total number of validators. - pub n_validators: usize, - /// Channel to the erasure task handler. - pub erasure_task_tx: futures::channel::mpsc::Sender, -} - -impl FetchChunks { - /// Instantiate a new strategy. - pub fn new(params: FetchChunksParams) -> Self { - let mut shuffling: Vec<_> = (0..params.n_validators) - .map(|i| ValidatorIndex(i.try_into().expect("number of validators must fit in a u32"))) - .collect(); - shuffling.shuffle(&mut rand::thread_rng()); - - Self { - error_count: 0, - total_received_responses: 0, - requesting_chunks: FuturesUndead::new(), - validators: shuffling.into(), - erasure_task_tx: params.erasure_task_tx, - } - } - - fn is_unavailable( - unrequested_validators: usize, - in_flight_requests: usize, - chunk_count: usize, - threshold: usize, - ) -> bool { - is_unavailable(chunk_count, in_flight_requests, unrequested_validators, threshold) - } - - /// Desired number of parallel requests. - /// - /// For the given threshold (total required number of chunks) get the desired number of - /// requests we want to have running in parallel at this time. - fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize { - // Upper bound for parallel requests. - // We want to limit this, so requests can be processed within the timeout and we limit the - // following feedback loop: - // 1. Requests fail due to timeout - // 2. We request more chunks to make up for it - // 3. Bandwidth is spread out even more, so we get even more timeouts - // 4. We request more chunks to make up for it ... - let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold); - // How many chunks are still needed? - let remaining_chunks = threshold.saturating_sub(chunk_count); - // What is the current error rate, so we can make up for it? - let inv_error_rate = - self.total_received_responses.checked_div(self.error_count).unwrap_or(0); - // Actual number of requests we want to have in flight in parallel: - std::cmp::min( - max_requests_boundary, - remaining_chunks + remaining_chunks.checked_div(inv_error_rate).unwrap_or(0), - ) - } - - async fn attempt_recovery( - &mut self, - state: &mut State, - common_params: &RecoveryParams, - ) -> Result { - let recovery_duration = common_params.metrics.time_erasure_recovery(); - - // Send request to reconstruct available data from chunks. - let (avilable_data_tx, available_data_rx) = oneshot::channel(); - self.erasure_task_tx - .send(ErasureTask::Reconstruct( - common_params.n_validators, - // Safe to leave an empty vec in place, as we're stopping the recovery process if - // this reconstruct fails. - std::mem::take(&mut state.received_chunks), - avilable_data_tx, - )) - .await - .map_err(|_| RecoveryError::ChannelClosed)?; - - let available_data_response = - available_data_rx.await.map_err(|_| RecoveryError::ChannelClosed)?; - - match available_data_response { - Ok(data) => { - let maybe_data = match common_params.post_recovery_check { - PostRecoveryCheck::Reencode => { - // Send request to re-encode the chunks and check merkle root. - let (reencode_tx, reencode_rx) = oneshot::channel(); - self.erasure_task_tx - .send(ErasureTask::Reencode( - common_params.n_validators, - common_params.erasure_root, - data, - reencode_tx, - )) - .await - .map_err(|_| RecoveryError::ChannelClosed)?; - - reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?.or_else(|| { - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - erasure_root = ?common_params.erasure_root, - "Data recovery error - root mismatch", - ); - None - }) - }, - PostRecoveryCheck::PovHash => - (data.pov.hash() == common_params.pov_hash).then_some(data).or_else(|| { - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - pov_hash = ?common_params.pov_hash, - "Data recovery error - PoV hash mismatch", - ); - None - }), - }; - - if let Some(data) = maybe_data { - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - erasure_root = ?common_params.erasure_root, - "Data recovery from chunks complete", - ); - - Ok(data) - } else { - recovery_duration.map(|rd| rd.stop_and_discard()); - - Err(RecoveryError::Invalid) - } - }, - Err(err) => { - recovery_duration.map(|rd| rd.stop_and_discard()); - gum::trace!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - erasure_root = ?common_params.erasure_root, - ?err, - "Data recovery error ", - ); - - Err(RecoveryError::Invalid) - }, - } - } -} - -#[async_trait::async_trait] -impl RecoveryStrategy for FetchChunks { - fn display_name(&self) -> &'static str { - "Fetch chunks" - } - - async fn run( - &mut self, - state: &mut State, - sender: &mut Sender, - common_params: &RecoveryParams, - ) -> Result { - // First query the store for any chunks we've got. - if !common_params.bypass_availability_store { - let local_chunk_indices = state.populate_from_av_store(common_params, sender).await; - self.validators.retain(|i| !local_chunk_indices.contains(i)); - } - - // No need to query the validators that have the chunks we already received. - self.validators.retain(|i| !state.received_chunks.contains_key(i)); - - loop { - // If received_chunks has more than threshold entries, attempt to recover the data. - // If that fails, or a re-encoding of it doesn't match the expected erasure root, - // return Err(RecoveryError::Invalid). - // Do this before requesting any chunks because we may have enough of them coming from - // past RecoveryStrategies. - if state.chunk_count() >= common_params.threshold { - return self.attempt_recovery(state, common_params).await - } - - if Self::is_unavailable( - self.validators.len(), - self.requesting_chunks.total_len(), - state.chunk_count(), - common_params.threshold, - ) { - gum::debug!( - target: LOG_TARGET, - candidate_hash = ?common_params.candidate_hash, - erasure_root = ?common_params.erasure_root, - received = %state.chunk_count(), - requesting = %self.requesting_chunks.len(), - total_requesting = %self.requesting_chunks.total_len(), - n_validators = %common_params.n_validators, - "Data recovery from chunks is not possible", - ); - - return Err(RecoveryError::Unavailable) - } - - let desired_requests_count = - self.get_desired_request_count(state.chunk_count(), common_params.threshold); - let already_requesting_count = self.requesting_chunks.len(); - gum::debug!( - target: LOG_TARGET, - ?common_params.candidate_hash, - ?desired_requests_count, - error_count= ?self.error_count, - total_received = ?self.total_received_responses, - threshold = ?common_params.threshold, - ?already_requesting_count, - "Requesting availability chunks for a candidate", - ); - state - .launch_parallel_chunk_requests( - common_params, - sender, - desired_requests_count, - &mut self.validators, - &mut self.requesting_chunks, - ) - .await; - - let (total_responses, error_count) = state - .wait_for_chunks( - common_params, - &mut self.validators, - &mut self.requesting_chunks, - |unrequested_validators, reqs, chunk_count, params, _error_count| { - chunk_count >= params.threshold || - Self::is_unavailable( - unrequested_validators, - reqs, - chunk_count, - params.threshold, - ) - }, - ) - .await; - - self.total_received_responses += total_responses; - self.error_count += error_count; - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use polkadot_erasure_coding::recovery_threshold; - - #[test] - fn parallel_request_calculation_works_as_expected() { - let num_validators = 100; - let threshold = recovery_threshold(num_validators).unwrap(); - let (erasure_task_tx, _erasure_task_rx) = futures::channel::mpsc::channel(16); - - let mut fetch_chunks_task = - FetchChunks::new(FetchChunksParams { n_validators: 100, erasure_task_tx }); - assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold); - fetch_chunks_task.error_count = 1; - fetch_chunks_task.total_received_responses = 1; - // We saturate at threshold (34): - assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold); - - fetch_chunks_task.total_received_responses = 2; - // With given error rate - still saturating: - assert_eq!(fetch_chunks_task.get_desired_request_count(1, threshold), threshold); - fetch_chunks_task.total_received_responses += 8; - // error rate: 1/10 - // remaining chunks needed: threshold (34) - 9 - // expected: 24 * (1+ 1/10) = (next greater integer) = 27 - assert_eq!(fetch_chunks_task.get_desired_request_count(9, threshold), 27); - fetch_chunks_task.error_count = 0; - // With error count zero - we should fetch exactly as needed: - assert_eq!(fetch_chunks_task.get_desired_request_count(10, threshold), threshold - 10); - } -} diff --git a/polkadot/node/network/availability-recovery/src/task/mod.rs b/polkadot/node/network/availability-recovery/src/task/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0a8b52411afee5cd5f63d0f3ec90497af34601e2 --- /dev/null +++ b/polkadot/node/network/availability-recovery/src/task/mod.rs @@ -0,0 +1,197 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Main recovery task logic. Runs recovery strategies. + +#![warn(missing_docs)] + +mod strategy; + +pub use self::strategy::{ + FetchChunks, FetchChunksParams, FetchFull, FetchFullParams, FetchSystematicChunks, + FetchSystematicChunksParams, RecoveryStrategy, State, +}; + +#[cfg(test)] +pub use self::strategy::{REGULAR_CHUNKS_REQ_RETRY_LIMIT, SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT}; + +use crate::{metrics::Metrics, ErasureTask, PostRecoveryCheck, LOG_TARGET}; + +use codec::Encode; +use polkadot_node_primitives::AvailableData; +use polkadot_node_subsystem::{messages::AvailabilityStoreMessage, overseer, RecoveryError}; +use polkadot_primitives::{AuthorityDiscoveryId, CandidateHash, Hash}; +use sc_network::ProtocolName; + +use futures::channel::{mpsc, oneshot}; +use std::collections::VecDeque; + +/// Recovery parameters common to all strategies in a `RecoveryTask`. +#[derive(Clone)] +pub struct RecoveryParams { + /// Discovery ids of `validators`. + pub validator_authority_keys: Vec, + + /// Number of validators. + pub n_validators: usize, + + /// The number of regular chunks needed. + pub threshold: usize, + + /// The number of systematic chunks needed. + pub systematic_threshold: usize, + + /// A hash of the relevant candidate. + pub candidate_hash: CandidateHash, + + /// The root of the erasure encoding of the candidate. + pub erasure_root: Hash, + + /// Metrics to report. + pub metrics: Metrics, + + /// Do not request data from availability-store. Useful for collators. + pub bypass_availability_store: bool, + + /// The type of check to perform after available data was recovered. + pub post_recovery_check: PostRecoveryCheck, + + /// The blake2-256 hash of the PoV. + pub pov_hash: Hash, + + /// Protocol name for ChunkFetchingV1. + pub req_v1_protocol_name: ProtocolName, + + /// Protocol name for ChunkFetchingV2. + pub req_v2_protocol_name: ProtocolName, + + /// Whether or not chunk mapping is enabled. + pub chunk_mapping_enabled: bool, + + /// Channel to the erasure task handler. + pub erasure_task_tx: mpsc::Sender, +} + +/// A stateful reconstruction of availability data in reference to +/// a candidate hash. +pub struct RecoveryTask { + sender: Sender, + params: RecoveryParams, + strategies: VecDeque>>, + state: State, +} + +impl RecoveryTask +where + Sender: overseer::AvailabilityRecoverySenderTrait, +{ + /// Instantiate a new recovery task. + pub fn new( + sender: Sender, + params: RecoveryParams, + strategies: VecDeque>>, + ) -> Self { + Self { sender, params, strategies, state: State::new() } + } + + async fn in_availability_store(&mut self) -> Option { + if !self.params.bypass_availability_store { + let (tx, rx) = oneshot::channel(); + self.sender + .send_message(AvailabilityStoreMessage::QueryAvailableData( + self.params.candidate_hash, + tx, + )) + .await; + + match rx.await { + Ok(Some(data)) => return Some(data), + Ok(None) => {}, + Err(oneshot::Canceled) => { + gum::warn!( + target: LOG_TARGET, + candidate_hash = ?self.params.candidate_hash, + "Failed to reach the availability store", + ) + }, + } + } + + None + } + + /// Run this recovery task to completion. It will loop through the configured strategies + /// in-order and return whenever the first one recovers the full `AvailableData`. + pub async fn run(mut self) -> Result { + if let Some(data) = self.in_availability_store().await { + return Ok(data) + } + + self.params.metrics.on_recovery_started(); + + let _timer = self.params.metrics.time_full_recovery(); + + while let Some(current_strategy) = self.strategies.pop_front() { + let display_name = current_strategy.display_name(); + let strategy_type = current_strategy.strategy_type(); + + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?self.params.candidate_hash, + "Starting `{}` strategy", + display_name + ); + + let res = current_strategy.run(&mut self.state, &mut self.sender, &self.params).await; + + match res { + Err(RecoveryError::Unavailable) => + if self.strategies.front().is_some() { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?self.params.candidate_hash, + "Recovery strategy `{}` did not conclude. Trying the next one.", + display_name + ); + continue + }, + Err(err) => { + match &err { + RecoveryError::Invalid => + self.params.metrics.on_recovery_invalid(strategy_type), + _ => self.params.metrics.on_recovery_failed(strategy_type), + } + return Err(err) + }, + Ok(data) => { + self.params.metrics.on_recovery_succeeded(strategy_type, data.encoded_size()); + return Ok(data) + }, + } + } + + // We have no other strategies to try. + gum::warn!( + target: LOG_TARGET, + candidate_hash = ?self.params.candidate_hash, + "Recovery of available data failed.", + ); + + self.params.metrics.on_recovery_failed("all"); + + Err(RecoveryError::Unavailable) + } +} diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs b/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6376a5b543ed75d511571ec48d2fee8cac6a7d4 --- /dev/null +++ b/polkadot/node/network/availability-recovery/src/task/strategy/chunks.rs @@ -0,0 +1,335 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use crate::{ + futures_undead::FuturesUndead, + task::{ + strategy::{ + do_post_recovery_check, is_unavailable, OngoingRequests, N_PARALLEL, + REGULAR_CHUNKS_REQ_RETRY_LIMIT, + }, + RecoveryParams, State, + }, + ErasureTask, RecoveryStrategy, LOG_TARGET, +}; + +use polkadot_node_primitives::AvailableData; +use polkadot_node_subsystem::{overseer, RecoveryError}; +use polkadot_primitives::ValidatorIndex; + +use futures::{channel::oneshot, SinkExt}; +use rand::seq::SliceRandom; +use std::collections::VecDeque; + +/// Parameters specific to the `FetchChunks` strategy. +pub struct FetchChunksParams { + pub n_validators: usize, +} + +/// `RecoveryStrategy` that requests chunks from validators, in parallel. +pub struct FetchChunks { + /// How many requests have been unsuccessful so far. + error_count: usize, + /// Total number of responses that have been received, including failed ones. + total_received_responses: usize, + /// A shuffled array of validator indices. + validators: VecDeque, + /// Collection of in-flight requests. + requesting_chunks: OngoingRequests, +} + +impl FetchChunks { + /// Instantiate a new strategy. + pub fn new(params: FetchChunksParams) -> Self { + // Shuffle the validators to make sure that we don't request chunks from the same + // validators over and over. + let mut validators: VecDeque = + (0..params.n_validators).map(|i| ValidatorIndex(i as u32)).collect(); + validators.make_contiguous().shuffle(&mut rand::thread_rng()); + + Self { + error_count: 0, + total_received_responses: 0, + validators, + requesting_chunks: FuturesUndead::new(), + } + } + + fn is_unavailable( + unrequested_validators: usize, + in_flight_requests: usize, + chunk_count: usize, + threshold: usize, + ) -> bool { + is_unavailable(chunk_count, in_flight_requests, unrequested_validators, threshold) + } + + /// Desired number of parallel requests. + /// + /// For the given threshold (total required number of chunks) get the desired number of + /// requests we want to have running in parallel at this time. + fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize { + // Upper bound for parallel requests. + // We want to limit this, so requests can be processed within the timeout and we limit the + // following feedback loop: + // 1. Requests fail due to timeout + // 2. We request more chunks to make up for it + // 3. Bandwidth is spread out even more, so we get even more timeouts + // 4. We request more chunks to make up for it ... + let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold); + // How many chunks are still needed? + let remaining_chunks = threshold.saturating_sub(chunk_count); + // What is the current error rate, so we can make up for it? + let inv_error_rate = + self.total_received_responses.checked_div(self.error_count).unwrap_or(0); + // Actual number of requests we want to have in flight in parallel: + std::cmp::min( + max_requests_boundary, + remaining_chunks + remaining_chunks.checked_div(inv_error_rate).unwrap_or(0), + ) + } + + async fn attempt_recovery( + &mut self, + state: &mut State, + common_params: &RecoveryParams, + ) -> Result { + let recovery_duration = common_params + .metrics + .time_erasure_recovery(RecoveryStrategy::::strategy_type(self)); + + // Send request to reconstruct available data from chunks. + let (avilable_data_tx, available_data_rx) = oneshot::channel(); + + let mut erasure_task_tx = common_params.erasure_task_tx.clone(); + erasure_task_tx + .send(ErasureTask::Reconstruct( + common_params.n_validators, + // Safe to leave an empty vec in place, as we're stopping the recovery process if + // this reconstruct fails. + std::mem::take(&mut state.received_chunks) + .into_iter() + .map(|(c_index, chunk)| (c_index, chunk.chunk)) + .collect(), + avilable_data_tx, + )) + .await + .map_err(|_| RecoveryError::ChannelClosed)?; + + let available_data_response = + available_data_rx.await.map_err(|_| RecoveryError::ChannelClosed)?; + + match available_data_response { + // Attempt post-recovery check. + Ok(data) => do_post_recovery_check(common_params, data) + .await + .map_err(|e| { + recovery_duration.map(|rd| rd.stop_and_discard()); + e + }) + .map(|data| { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + "Data recovery from chunks complete", + ); + data + }), + Err(err) => { + recovery_duration.map(|rd| rd.stop_and_discard()); + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + ?err, + "Data recovery error", + ); + + Err(RecoveryError::Invalid) + }, + } + } +} + +#[async_trait::async_trait] +impl RecoveryStrategy for FetchChunks { + fn display_name(&self) -> &'static str { + "Fetch chunks" + } + + fn strategy_type(&self) -> &'static str { + "regular_chunks" + } + + async fn run( + mut self: Box, + state: &mut State, + sender: &mut Sender, + common_params: &RecoveryParams, + ) -> Result { + // First query the store for any chunks we've got. + if !common_params.bypass_availability_store { + let local_chunk_indices = state.populate_from_av_store(common_params, sender).await; + self.validators.retain(|validator_index| { + !local_chunk_indices.iter().any(|(v_index, _)| v_index == validator_index) + }); + } + + // No need to query the validators that have the chunks we already received or that we know + // don't have the data from previous strategies. + self.validators.retain(|v_index| { + !state.received_chunks.values().any(|c| v_index == &c.validator_index) && + state.can_retry_request( + &(common_params.validator_authority_keys[v_index.0 as usize].clone(), *v_index), + REGULAR_CHUNKS_REQ_RETRY_LIMIT, + ) + }); + + // Safe to `take` here, as we're consuming `self` anyway and we're not using the + // `validators` field in other methods. + let mut validators_queue: VecDeque<_> = std::mem::take(&mut self.validators) + .into_iter() + .map(|validator_index| { + ( + common_params.validator_authority_keys[validator_index.0 as usize].clone(), + validator_index, + ) + }) + .collect(); + + loop { + // If received_chunks has more than threshold entries, attempt to recover the data. + // If that fails, or a re-encoding of it doesn't match the expected erasure root, + // return Err(RecoveryError::Invalid). + // Do this before requesting any chunks because we may have enough of them coming from + // past RecoveryStrategies. + if state.chunk_count() >= common_params.threshold { + return self.attempt_recovery::(state, common_params).await + } + + if Self::is_unavailable( + validators_queue.len(), + self.requesting_chunks.total_len(), + state.chunk_count(), + common_params.threshold, + ) { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + received = %state.chunk_count(), + requesting = %self.requesting_chunks.len(), + total_requesting = %self.requesting_chunks.total_len(), + n_validators = %common_params.n_validators, + "Data recovery from chunks is not possible", + ); + + return Err(RecoveryError::Unavailable) + } + + let desired_requests_count = + self.get_desired_request_count(state.chunk_count(), common_params.threshold); + let already_requesting_count = self.requesting_chunks.len(); + gum::debug!( + target: LOG_TARGET, + ?common_params.candidate_hash, + ?desired_requests_count, + error_count= ?self.error_count, + total_received = ?self.total_received_responses, + threshold = ?common_params.threshold, + ?already_requesting_count, + "Requesting availability chunks for a candidate", + ); + + let strategy_type = RecoveryStrategy::::strategy_type(&*self); + + state + .launch_parallel_chunk_requests( + strategy_type, + common_params, + sender, + desired_requests_count, + &mut validators_queue, + &mut self.requesting_chunks, + ) + .await; + + let (total_responses, error_count) = state + .wait_for_chunks( + strategy_type, + common_params, + REGULAR_CHUNKS_REQ_RETRY_LIMIT, + &mut validators_queue, + &mut self.requesting_chunks, + &mut vec![], + |unrequested_validators, + in_flight_reqs, + chunk_count, + _systematic_chunk_count| { + chunk_count >= common_params.threshold || + Self::is_unavailable( + unrequested_validators, + in_flight_reqs, + chunk_count, + common_params.threshold, + ) + }, + ) + .await; + + self.total_received_responses += total_responses; + self.error_count += error_count; + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use polkadot_erasure_coding::recovery_threshold; + + #[test] + fn test_get_desired_request_count() { + let n_validators = 100; + let threshold = recovery_threshold(n_validators).unwrap(); + + let mut fetch_chunks_task = FetchChunks::new(FetchChunksParams { n_validators }); + assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold); + fetch_chunks_task.error_count = 1; + fetch_chunks_task.total_received_responses = 1; + // We saturate at threshold (34): + assert_eq!(fetch_chunks_task.get_desired_request_count(0, threshold), threshold); + + // We saturate at the parallel limit. + assert_eq!(fetch_chunks_task.get_desired_request_count(0, N_PARALLEL + 2), N_PARALLEL); + + fetch_chunks_task.total_received_responses = 2; + // With given error rate - still saturating: + assert_eq!(fetch_chunks_task.get_desired_request_count(1, threshold), threshold); + fetch_chunks_task.total_received_responses = 10; + // error rate: 1/10 + // remaining chunks needed: threshold (34) - 9 + // expected: 24 * (1+ 1/10) = (next greater integer) = 27 + assert_eq!(fetch_chunks_task.get_desired_request_count(9, threshold), 27); + // We saturate at the parallel limit. + assert_eq!(fetch_chunks_task.get_desired_request_count(9, N_PARALLEL + 9), N_PARALLEL); + + fetch_chunks_task.error_count = 0; + // With error count zero - we should fetch exactly as needed: + assert_eq!(fetch_chunks_task.get_desired_request_count(10, threshold), threshold - 10); + } +} diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/full.rs b/polkadot/node/network/availability-recovery/src/task/strategy/full.rs new file mode 100644 index 0000000000000000000000000000000000000000..1d7fbe8ea3c8da42ab3227750852c02d328b6dd8 --- /dev/null +++ b/polkadot/node/network/availability-recovery/src/task/strategy/full.rs @@ -0,0 +1,174 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use crate::{ + task::{RecoveryParams, RecoveryStrategy, State}, + ErasureTask, PostRecoveryCheck, LOG_TARGET, +}; + +use polkadot_node_network_protocol::request_response::{ + self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests, +}; +use polkadot_node_primitives::AvailableData; +use polkadot_node_subsystem::{messages::NetworkBridgeTxMessage, overseer, RecoveryError}; +use polkadot_primitives::ValidatorIndex; +use sc_network::{IfDisconnected, OutboundFailure, RequestFailure}; + +use futures::{channel::oneshot, SinkExt}; +use rand::seq::SliceRandom; + +/// Parameters specific to the `FetchFull` strategy. +pub struct FetchFullParams { + /// Validators that will be used for fetching the data. + pub validators: Vec, +} + +/// `RecoveryStrategy` that sequentially tries to fetch the full `AvailableData` from +/// already-connected validators in the configured validator set. +pub struct FetchFull { + params: FetchFullParams, +} + +impl FetchFull { + /// Create a new `FetchFull` recovery strategy. + pub fn new(mut params: FetchFullParams) -> Self { + params.validators.shuffle(&mut rand::thread_rng()); + Self { params } + } +} + +#[async_trait::async_trait] +impl RecoveryStrategy for FetchFull { + fn display_name(&self) -> &'static str { + "Full recovery from backers" + } + + fn strategy_type(&self) -> &'static str { + "full_from_backers" + } + + async fn run( + mut self: Box, + _: &mut State, + sender: &mut Sender, + common_params: &RecoveryParams, + ) -> Result { + let strategy_type = RecoveryStrategy::::strategy_type(&*self); + + loop { + // Pop the next validator. + let validator_index = + self.params.validators.pop().ok_or_else(|| RecoveryError::Unavailable)?; + + // Request data. + let (req, response) = OutgoingRequest::new( + Recipient::Authority( + common_params.validator_authority_keys[validator_index.0 as usize].clone(), + ), + req_res::v1::AvailableDataFetchingRequest { + candidate_hash: common_params.candidate_hash, + }, + ); + + sender + .send_message(NetworkBridgeTxMessage::SendRequests( + vec![Requests::AvailableDataFetchingV1(req)], + IfDisconnected::ImmediateError, + )) + .await; + + common_params.metrics.on_full_request_issued(); + + match response.await { + Ok(req_res::v1::AvailableDataFetchingResponse::AvailableData(data)) => { + let recovery_duration = + common_params.metrics.time_erasure_recovery(strategy_type); + let maybe_data = match common_params.post_recovery_check { + PostRecoveryCheck::Reencode => { + let (reencode_tx, reencode_rx) = oneshot::channel(); + let mut erasure_task_tx = common_params.erasure_task_tx.clone(); + + erasure_task_tx + .send(ErasureTask::Reencode( + common_params.n_validators, + common_params.erasure_root, + data, + reencode_tx, + )) + .await + .map_err(|_| RecoveryError::ChannelClosed)?; + + reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)? + }, + PostRecoveryCheck::PovHash => + (data.pov.hash() == common_params.pov_hash).then_some(data), + }; + + match maybe_data { + Some(data) => { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + "Received full data", + ); + + common_params.metrics.on_full_request_succeeded(); + return Ok(data) + }, + None => { + common_params.metrics.on_full_request_invalid(); + recovery_duration.map(|rd| rd.stop_and_discard()); + + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + ?validator_index, + "Invalid data response", + ); + + // it doesn't help to report the peer with req/res. + // we'll try the next backer. + }, + } + }, + Ok(req_res::v1::AvailableDataFetchingResponse::NoSuchData) => { + common_params.metrics.on_full_request_no_such_data(); + }, + Err(e) => { + match &e { + RequestError::Canceled(_) => common_params.metrics.on_full_request_error(), + RequestError::InvalidResponse(_) => + common_params.metrics.on_full_request_invalid(), + RequestError::NetworkError(req_failure) => { + if let RequestFailure::Network(OutboundFailure::Timeout) = req_failure { + common_params.metrics.on_full_request_timeout(); + } else { + common_params.metrics.on_full_request_error(); + } + }, + }; + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + ?validator_index, + err = ?e, + "Error fetching full available data." + ); + }, + } + } + } +} diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs b/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1403277c8a95bff3c98115f58197fd0373047c71 --- /dev/null +++ b/polkadot/node/network/availability-recovery/src/task/strategy/mod.rs @@ -0,0 +1,1558 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Recovery strategies. + +mod chunks; +mod full; +mod systematic; + +pub use self::{ + chunks::{FetchChunks, FetchChunksParams}, + full::{FetchFull, FetchFullParams}, + systematic::{FetchSystematicChunks, FetchSystematicChunksParams}, +}; +use crate::{ + futures_undead::FuturesUndead, ErasureTask, PostRecoveryCheck, RecoveryParams, LOG_TARGET, +}; + +use codec::Decode; +use futures::{channel::oneshot, SinkExt}; +use polkadot_erasure_coding::branch_hash; +#[cfg(not(test))] +use polkadot_node_network_protocol::request_response::CHUNK_REQUEST_TIMEOUT; +use polkadot_node_network_protocol::request_response::{ + self as req_res, outgoing::RequestError, OutgoingRequest, Recipient, Requests, +}; +use polkadot_node_primitives::{AvailableData, ErasureChunk}; +use polkadot_node_subsystem::{ + messages::{AvailabilityStoreMessage, NetworkBridgeTxMessage}, + overseer, RecoveryError, +}; +use polkadot_primitives::{AuthorityDiscoveryId, BlakeTwo256, ChunkIndex, HashT, ValidatorIndex}; +use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure}; +use std::{ + collections::{BTreeMap, HashMap, VecDeque}, + time::Duration, +}; + +// How many parallel chunk fetching requests should be running at once. +const N_PARALLEL: usize = 50; + +/// Time after which we consider a request to have failed +/// +/// and we should try more peers. Note in theory the request times out at the network level, +/// measurements have shown, that in practice requests might actually take longer to fail in +/// certain occasions. (The very least, authority discovery is not part of the timeout.) +/// +/// For the time being this value is the same as the timeout on the networking layer, but as this +/// timeout is more soft than the networking one, it might make sense to pick different values as +/// well. +#[cfg(not(test))] +const TIMEOUT_START_NEW_REQUESTS: Duration = CHUNK_REQUEST_TIMEOUT; +#[cfg(test)] +const TIMEOUT_START_NEW_REQUESTS: Duration = Duration::from_millis(100); + +/// The maximum number of times systematic chunk recovery will try making a request for a given +/// (validator,chunk) pair, if the error was not fatal. Added so that we don't get stuck in an +/// infinite retry loop. +pub const SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT: u32 = 2; +/// The maximum number of times regular chunk recovery will try making a request for a given +/// (validator,chunk) pair, if the error was not fatal. Added so that we don't get stuck in an +/// infinite retry loop. +pub const REGULAR_CHUNKS_REQ_RETRY_LIMIT: u32 = 5; + +// Helpful type alias for tracking ongoing chunk requests. +type OngoingRequests = FuturesUndead<( + AuthorityDiscoveryId, + ValidatorIndex, + Result<(Option, ProtocolName), RequestError>, +)>; + +const fn is_unavailable( + received_chunks: usize, + requesting_chunks: usize, + unrequested_validators: usize, + threshold: usize, +) -> bool { + received_chunks + requesting_chunks + unrequested_validators < threshold +} + +/// Check validity of a chunk. +fn is_chunk_valid(params: &RecoveryParams, chunk: &ErasureChunk) -> bool { + let anticipated_hash = + match branch_hash(¶ms.erasure_root, chunk.proof(), chunk.index.0 as usize) { + Ok(hash) => hash, + Err(e) => { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + chunk_index = ?chunk.index, + error = ?e, + "Invalid Merkle proof", + ); + return false + }, + }; + let erasure_chunk_hash = BlakeTwo256::hash(&chunk.chunk); + if anticipated_hash != erasure_chunk_hash { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + chunk_index = ?chunk.index, + "Merkle proof mismatch" + ); + return false + } + true +} + +/// Perform the validity checks after recovery. +async fn do_post_recovery_check( + params: &RecoveryParams, + data: AvailableData, +) -> Result { + let mut erasure_task_tx = params.erasure_task_tx.clone(); + match params.post_recovery_check { + PostRecoveryCheck::Reencode => { + // Send request to re-encode the chunks and check merkle root. + let (reencode_tx, reencode_rx) = oneshot::channel(); + erasure_task_tx + .send(ErasureTask::Reencode( + params.n_validators, + params.erasure_root, + data, + reencode_tx, + )) + .await + .map_err(|_| RecoveryError::ChannelClosed)?; + + reencode_rx.await.map_err(|_| RecoveryError::ChannelClosed)?.ok_or_else(|| { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + erasure_root = ?params.erasure_root, + "Data recovery error - root mismatch", + ); + RecoveryError::Invalid + }) + }, + PostRecoveryCheck::PovHash => { + let pov = data.pov.clone(); + (pov.hash() == params.pov_hash).then_some(data).ok_or_else(|| { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + expected_pov_hash = ?params.pov_hash, + actual_pov_hash = ?pov.hash(), + "Data recovery error - PoV hash mismatch", + ); + RecoveryError::Invalid + }) + }, + } +} + +#[async_trait::async_trait] +/// Common trait for runnable recovery strategies. +pub trait RecoveryStrategy: Send { + /// Main entry point of the strategy. + async fn run( + mut self: Box, + state: &mut State, + sender: &mut Sender, + common_params: &RecoveryParams, + ) -> Result; + + /// Return the name of the strategy for logging purposes. + fn display_name(&self) -> &'static str; + + /// Return the strategy type for use as a metric label. + fn strategy_type(&self) -> &'static str; +} + +/// Utility type used for recording the result of requesting a chunk from a validator. +enum ErrorRecord { + NonFatal(u32), + Fatal, +} + +/// Helper struct used for the `received_chunks` mapping. +/// Compared to `ErasureChunk`, it doesn't need to hold the `ChunkIndex` (because it's the key used +/// for the map) and proof, but needs to hold the `ValidatorIndex` instead. +struct Chunk { + /// The erasure-encoded chunk of data belonging to the candidate block. + chunk: Vec, + /// The validator index that corresponds to this chunk. Not always the same as the chunk index. + validator_index: ValidatorIndex, +} + +/// Intermediate/common data that must be passed between `RecoveryStrategy`s belonging to the +/// same `RecoveryTask`. +pub struct State { + /// Chunks received so far. + /// This MUST be a `BTreeMap` in order for systematic recovery to work (the algorithm assumes + /// that chunks are ordered by their index). If we ever switch this to some non-ordered + /// collection, we need to add a sort step to the systematic recovery. + received_chunks: BTreeMap, + + /// A record of errors returned when requesting a chunk from a validator. + recorded_errors: HashMap<(AuthorityDiscoveryId, ValidatorIndex), ErrorRecord>, +} + +impl State { + pub fn new() -> Self { + Self { received_chunks: BTreeMap::new(), recorded_errors: HashMap::new() } + } + + fn insert_chunk(&mut self, chunk_index: ChunkIndex, chunk: Chunk) { + self.received_chunks.insert(chunk_index, chunk); + } + + fn chunk_count(&self) -> usize { + self.received_chunks.len() + } + + fn systematic_chunk_count(&self, systematic_threshold: usize) -> usize { + self.received_chunks + .range(ChunkIndex(0)..ChunkIndex(systematic_threshold as u32)) + .count() + } + + fn record_error_fatal( + &mut self, + authority_id: AuthorityDiscoveryId, + validator_index: ValidatorIndex, + ) { + self.recorded_errors.insert((authority_id, validator_index), ErrorRecord::Fatal); + } + + fn record_error_non_fatal( + &mut self, + authority_id: AuthorityDiscoveryId, + validator_index: ValidatorIndex, + ) { + self.recorded_errors + .entry((authority_id, validator_index)) + .and_modify(|record| { + if let ErrorRecord::NonFatal(ref mut count) = record { + *count = count.saturating_add(1); + } + }) + .or_insert(ErrorRecord::NonFatal(1)); + } + + fn can_retry_request( + &self, + key: &(AuthorityDiscoveryId, ValidatorIndex), + retry_threshold: u32, + ) -> bool { + match self.recorded_errors.get(key) { + None => true, + Some(entry) => match entry { + ErrorRecord::Fatal => false, + ErrorRecord::NonFatal(count) if *count < retry_threshold => true, + ErrorRecord::NonFatal(_) => false, + }, + } + } + + /// Retrieve the local chunks held in the av-store (should be either 0 or 1). + async fn populate_from_av_store( + &mut self, + params: &RecoveryParams, + sender: &mut Sender, + ) -> Vec<(ValidatorIndex, ChunkIndex)> { + let (tx, rx) = oneshot::channel(); + sender + .send_message(AvailabilityStoreMessage::QueryAllChunks(params.candidate_hash, tx)) + .await; + + match rx.await { + Ok(chunks) => { + // This should either be length 1 or 0. If we had the whole data, + // we wouldn't have reached this stage. + let chunk_indices: Vec<_> = chunks + .iter() + .map(|(validator_index, chunk)| (*validator_index, chunk.index)) + .collect(); + + for (validator_index, chunk) in chunks { + if is_chunk_valid(params, &chunk) { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + chunk_index = ?chunk.index, + "Found valid chunk on disk" + ); + self.insert_chunk( + chunk.index, + Chunk { chunk: chunk.chunk, validator_index }, + ); + } else { + gum::error!( + target: LOG_TARGET, + "Loaded invalid chunk from disk! Disk/Db corruption _very_ likely - please fix ASAP!" + ); + }; + } + + chunk_indices + }, + Err(oneshot::Canceled) => { + gum::warn!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + "Failed to reach the availability store" + ); + + vec![] + }, + } + } + + /// Launch chunk requests in parallel, according to the parameters. + async fn launch_parallel_chunk_requests( + &mut self, + strategy_type: &str, + params: &RecoveryParams, + sender: &mut Sender, + desired_requests_count: usize, + validators: &mut VecDeque<(AuthorityDiscoveryId, ValidatorIndex)>, + requesting_chunks: &mut OngoingRequests, + ) where + Sender: overseer::AvailabilityRecoverySenderTrait, + { + let candidate_hash = params.candidate_hash; + let already_requesting_count = requesting_chunks.len(); + + let to_launch = desired_requests_count - already_requesting_count; + let mut requests = Vec::with_capacity(to_launch); + + gum::trace!( + target: LOG_TARGET, + ?candidate_hash, + "Attempting to launch {} requests", + to_launch + ); + + while requesting_chunks.len() < desired_requests_count { + if let Some((authority_id, validator_index)) = validators.pop_back() { + gum::trace!( + target: LOG_TARGET, + ?authority_id, + ?validator_index, + ?candidate_hash, + "Requesting chunk", + ); + + // Request data. + let raw_request_v2 = + req_res::v2::ChunkFetchingRequest { candidate_hash, index: validator_index }; + let raw_request_v1 = req_res::v1::ChunkFetchingRequest::from(raw_request_v2); + + let (req, res) = OutgoingRequest::new_with_fallback( + Recipient::Authority(authority_id.clone()), + raw_request_v2, + raw_request_v1, + ); + requests.push(Requests::ChunkFetching(req)); + + params.metrics.on_chunk_request_issued(strategy_type); + let timer = params.metrics.time_chunk_request(strategy_type); + let v1_protocol_name = params.req_v1_protocol_name.clone(); + let v2_protocol_name = params.req_v2_protocol_name.clone(); + + let chunk_mapping_enabled = params.chunk_mapping_enabled; + let authority_id_clone = authority_id.clone(); + + requesting_chunks.push(Box::pin(async move { + let _timer = timer; + let res = match res.await { + Ok((bytes, protocol)) => + if v2_protocol_name == protocol { + match req_res::v2::ChunkFetchingResponse::decode(&mut &bytes[..]) { + Ok(req_res::v2::ChunkFetchingResponse::Chunk(chunk)) => + Ok((Some(chunk.into()), protocol)), + Ok(req_res::v2::ChunkFetchingResponse::NoSuchChunk) => + Ok((None, protocol)), + Err(e) => Err(RequestError::InvalidResponse(e)), + } + } else if v1_protocol_name == protocol { + // V1 protocol version must not be used when chunk mapping node + // feature is enabled, because we can't know the real index of the + // returned chunk. + // This case should never be reached as long as the + // `AvailabilityChunkMapping` feature is only enabled after the + // v1 version is removed. Still, log this. + if chunk_mapping_enabled { + gum::info!( + target: LOG_TARGET, + ?candidate_hash, + authority_id = ?authority_id_clone, + "Another validator is responding on /req_chunk/1 protocol while the availability chunk \ + mapping feature is enabled in the runtime. All validators must switch to /req_chunk/2." + ); + } + + match req_res::v1::ChunkFetchingResponse::decode(&mut &bytes[..]) { + Ok(req_res::v1::ChunkFetchingResponse::Chunk(chunk)) => Ok(( + Some(chunk.recombine_into_chunk(&raw_request_v1)), + protocol, + )), + Ok(req_res::v1::ChunkFetchingResponse::NoSuchChunk) => + Ok((None, protocol)), + Err(e) => Err(RequestError::InvalidResponse(e)), + } + } else { + Err(RequestError::NetworkError(RequestFailure::UnknownProtocol)) + }, + + Err(e) => Err(e), + }; + + (authority_id, validator_index, res) + })); + } else { + break + } + } + + if requests.len() != 0 { + sender + .send_message(NetworkBridgeTxMessage::SendRequests( + requests, + IfDisconnected::TryConnect, + )) + .await; + } + } + + /// Wait for a sufficient amount of chunks to reconstruct according to the provided `params`. + async fn wait_for_chunks( + &mut self, + strategy_type: &str, + params: &RecoveryParams, + retry_threshold: u32, + validators: &mut VecDeque<(AuthorityDiscoveryId, ValidatorIndex)>, + requesting_chunks: &mut OngoingRequests, + // If supplied, these validators will be used as a backup for requesting chunks. They + // should hold all chunks. Each of them will only be used to query one chunk. + backup_validators: &mut Vec, + // Function that returns `true` when this strategy can conclude. Either if we got enough + // chunks or if it's impossible. + mut can_conclude: impl FnMut( + // Number of validators left in the queue + usize, + // Number of in flight requests + usize, + // Number of valid chunks received so far + usize, + // Number of valid systematic chunks received so far + usize, + ) -> bool, + ) -> (usize, usize) { + let metrics = ¶ms.metrics; + + let mut total_received_responses = 0; + let mut error_count = 0; + + // Wait for all current requests to conclude or time-out, or until we reach enough chunks. + // We also declare requests undead, once `TIMEOUT_START_NEW_REQUESTS` is reached and will + // return in that case for `launch_parallel_requests` to fill up slots again. + while let Some(res) = requesting_chunks.next_with_timeout(TIMEOUT_START_NEW_REQUESTS).await + { + total_received_responses += 1; + + let (authority_id, validator_index, request_result) = res; + + let mut is_error = false; + + match request_result { + Ok((maybe_chunk, protocol)) => { + match protocol { + name if name == params.req_v1_protocol_name => + params.metrics.on_chunk_response_v1(), + name if name == params.req_v2_protocol_name => + params.metrics.on_chunk_response_v2(), + _ => {}, + } + + match maybe_chunk { + Some(chunk) => + if is_chunk_valid(params, &chunk) { + metrics.on_chunk_request_succeeded(strategy_type); + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + ?authority_id, + ?validator_index, + "Received valid chunk", + ); + self.insert_chunk( + chunk.index, + Chunk { chunk: chunk.chunk, validator_index }, + ); + } else { + metrics.on_chunk_request_invalid(strategy_type); + error_count += 1; + // Record that we got an invalid chunk so that subsequent strategies + // don't try requesting this again. + self.record_error_fatal(authority_id.clone(), validator_index); + is_error = true; + }, + None => { + metrics.on_chunk_request_no_such_chunk(strategy_type); + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + ?authority_id, + ?validator_index, + "Validator did not have the chunk", + ); + error_count += 1; + // Record that the validator did not have this chunk so that subsequent + // strategies don't try requesting this again. + self.record_error_fatal(authority_id.clone(), validator_index); + is_error = true; + }, + } + }, + Err(err) => { + error_count += 1; + + gum::trace!( + target: LOG_TARGET, + candidate_hash= ?params.candidate_hash, + ?err, + ?authority_id, + ?validator_index, + "Failure requesting chunk", + ); + + is_error = true; + + match err { + RequestError::InvalidResponse(_) => { + metrics.on_chunk_request_invalid(strategy_type); + + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?params.candidate_hash, + ?err, + ?authority_id, + ?validator_index, + "Chunk fetching response was invalid", + ); + + // Record that we got an invalid chunk so that this or + // subsequent strategies don't try requesting this again. + self.record_error_fatal(authority_id.clone(), validator_index); + }, + RequestError::NetworkError(err) => { + // No debug logs on general network errors - that became very + // spammy occasionally. + if let RequestFailure::Network(OutboundFailure::Timeout) = err { + metrics.on_chunk_request_timeout(strategy_type); + } else { + metrics.on_chunk_request_error(strategy_type); + } + + // Record that we got a non-fatal error so that this or + // subsequent strategies will retry requesting this only a + // limited number of times. + self.record_error_non_fatal(authority_id.clone(), validator_index); + }, + RequestError::Canceled(_) => { + metrics.on_chunk_request_error(strategy_type); + + // Record that we got a non-fatal error so that this or + // subsequent strategies will retry requesting this only a + // limited number of times. + self.record_error_non_fatal(authority_id.clone(), validator_index); + }, + } + }, + } + + if is_error { + // First, see if we can retry the request. + if self.can_retry_request(&(authority_id.clone(), validator_index), retry_threshold) + { + validators.push_front((authority_id, validator_index)); + } else { + // Otherwise, try requesting from a backer as a backup, if we've not already + // requested the same chunk from it. + + let position = backup_validators.iter().position(|v| { + !self.recorded_errors.contains_key(&(v.clone(), validator_index)) + }); + if let Some(position) = position { + // Use swap_remove because it's faster and we don't care about order here. + let backer = backup_validators.swap_remove(position); + validators.push_front((backer, validator_index)); + } + } + } + + if can_conclude( + validators.len(), + requesting_chunks.total_len(), + self.chunk_count(), + self.systematic_chunk_count(params.systematic_threshold), + ) { + gum::debug!( + target: LOG_TARGET, + validators_len = validators.len(), + candidate_hash = ?params.candidate_hash, + received_chunks_count = ?self.chunk_count(), + requested_chunks_count = ?requesting_chunks.len(), + threshold = ?params.threshold, + "Can conclude availability recovery strategy", + ); + break + } + } + + (total_received_responses, error_count) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{tests::*, Metrics, RecoveryStrategy, RecoveryTask}; + use assert_matches::assert_matches; + use codec::Error as DecodingError; + use futures::{ + channel::mpsc::{self, UnboundedReceiver}, + executor, future, Future, FutureExt, StreamExt, + }; + use polkadot_erasure_coding::{recovery_threshold, systematic_recovery_threshold}; + use polkadot_node_network_protocol::request_response::Protocol; + use polkadot_node_primitives::{BlockData, PoV}; + use polkadot_node_subsystem::{AllMessages, TimeoutExt}; + use polkadot_node_subsystem_test_helpers::{ + derive_erasure_chunks_with_proofs_and_root, sender_receiver, TestSubsystemSender, + }; + use polkadot_primitives::{CandidateHash, HeadData, PersistedValidationData}; + use polkadot_primitives_test_helpers::dummy_hash; + use sp_keyring::Sr25519Keyring; + use std::sync::Arc; + + const TIMEOUT: Duration = Duration::from_secs(1); + + impl Default for RecoveryParams { + fn default() -> Self { + let validators = vec![ + Sr25519Keyring::Ferdie, + Sr25519Keyring::Alice.into(), + Sr25519Keyring::Bob.into(), + Sr25519Keyring::Charlie, + Sr25519Keyring::Dave, + Sr25519Keyring::One, + Sr25519Keyring::Two, + ]; + let (erasure_task_tx, _erasure_task_rx) = mpsc::channel(10); + + Self { + validator_authority_keys: validator_authority_id(&validators), + n_validators: validators.len(), + threshold: recovery_threshold(validators.len()).unwrap(), + systematic_threshold: systematic_recovery_threshold(validators.len()).unwrap(), + candidate_hash: CandidateHash(dummy_hash()), + erasure_root: dummy_hash(), + metrics: Metrics::new_dummy(), + bypass_availability_store: false, + post_recovery_check: PostRecoveryCheck::Reencode, + pov_hash: dummy_hash(), + req_v1_protocol_name: "/req_chunk/1".into(), + req_v2_protocol_name: "/req_chunk/2".into(), + chunk_mapping_enabled: true, + erasure_task_tx, + } + } + } + + impl RecoveryParams { + fn create_chunks(&mut self) -> Vec { + let available_data = dummy_available_data(); + let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root( + self.n_validators, + &available_data, + |_, _| {}, + ); + + self.erasure_root = erasure_root; + self.pov_hash = available_data.pov.hash(); + + chunks + } + } + + fn dummy_available_data() -> AvailableData { + let validation_data = PersistedValidationData { + parent_head: HeadData(vec![7, 8, 9]), + relay_parent_number: Default::default(), + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }; + + AvailableData { + validation_data, + pov: Arc::new(PoV { block_data: BlockData(vec![42; 64]) }), + } + } + + fn test_harness, TestFut: Future>( + receiver_future: impl FnOnce(UnboundedReceiver) -> RecvFut, + test: impl FnOnce(TestSubsystemSender) -> TestFut, + ) { + let (sender, receiver) = sender_receiver(); + + let test_fut = test(sender); + let receiver_future = receiver_future(receiver); + + futures::pin_mut!(test_fut); + futures::pin_mut!(receiver_future); + + executor::block_on(future::join(test_fut, receiver_future)).1 + } + + #[test] + fn test_recorded_errors() { + let retry_threshold = 2; + let mut state = State::new(); + + let alice = Sr25519Keyring::Alice.public(); + let bob = Sr25519Keyring::Bob.public(); + let eve = Sr25519Keyring::Eve.public(); + + assert!(state.can_retry_request(&(alice.into(), 0.into()), retry_threshold)); + assert!(state.can_retry_request(&(alice.into(), 0.into()), 0)); + state.record_error_non_fatal(alice.into(), 0.into()); + assert!(state.can_retry_request(&(alice.into(), 0.into()), retry_threshold)); + state.record_error_non_fatal(alice.into(), 0.into()); + assert!(!state.can_retry_request(&(alice.into(), 0.into()), retry_threshold)); + state.record_error_non_fatal(alice.into(), 0.into()); + assert!(!state.can_retry_request(&(alice.into(), 0.into()), retry_threshold)); + + assert!(state.can_retry_request(&(alice.into(), 0.into()), 5)); + + state.record_error_fatal(bob.into(), 1.into()); + assert!(!state.can_retry_request(&(bob.into(), 1.into()), retry_threshold)); + state.record_error_non_fatal(bob.into(), 1.into()); + assert!(!state.can_retry_request(&(bob.into(), 1.into()), retry_threshold)); + + assert!(state.can_retry_request(&(eve.into(), 4.into()), 0)); + assert!(state.can_retry_request(&(eve.into(), 4.into()), retry_threshold)); + } + + #[test] + fn test_populate_from_av_store() { + let params = RecoveryParams::default(); + + // Failed to reach the av store + { + let params = params.clone(); + let candidate_hash = params.candidate_hash; + let mut state = State::new(); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => { + assert_eq!(hash, candidate_hash); + drop(tx); + }); + }, + |mut sender| async move { + let local_chunk_indices = + state.populate_from_av_store(¶ms, &mut sender).await; + + assert_eq!(state.chunk_count(), 0); + assert_eq!(local_chunk_indices.len(), 0); + }, + ); + } + + // Found invalid chunk + { + let mut params = params.clone(); + let candidate_hash = params.candidate_hash; + let mut state = State::new(); + let chunks = params.create_chunks(); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => { + assert_eq!(hash, candidate_hash); + let mut chunk = chunks[0].clone(); + chunk.index = 3.into(); + tx.send(vec![(2.into(), chunk)]).unwrap(); + }); + }, + |mut sender| async move { + let local_chunk_indices = + state.populate_from_av_store(¶ms, &mut sender).await; + + assert_eq!(state.chunk_count(), 0); + assert_eq!(local_chunk_indices.len(), 1); + }, + ); + } + + // Found valid chunk + { + let mut params = params.clone(); + let candidate_hash = params.candidate_hash; + let mut state = State::new(); + let chunks = params.create_chunks(); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAllChunks(hash, tx)) => { + assert_eq!(hash, candidate_hash); + tx.send(vec![(4.into(), chunks[1].clone())]).unwrap(); + }); + }, + |mut sender| async move { + let local_chunk_indices = + state.populate_from_av_store(¶ms, &mut sender).await; + + assert_eq!(state.chunk_count(), 1); + assert_eq!(local_chunk_indices.len(), 1); + }, + ); + } + } + + #[test] + fn test_launch_parallel_chunk_requests() { + let params = RecoveryParams::default(); + let alice: AuthorityDiscoveryId = Sr25519Keyring::Alice.public().into(); + let bob: AuthorityDiscoveryId = Sr25519Keyring::Bob.public().into(); + let eve: AuthorityDiscoveryId = Sr25519Keyring::Eve.public().into(); + + // No validators to request from. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + let mut validators = VecDeque::new(); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |mut sender| async move { + state + .launch_parallel_chunk_requests( + "regular", + ¶ms, + &mut sender, + 3, + &mut validators, + &mut ongoing_reqs, + ) + .await; + + assert_eq!(ongoing_reqs.total_len(), 0); + }, + ); + } + + // Has validators but no need to request more. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + let mut validators = VecDeque::new(); + validators.push_back((alice.clone(), ValidatorIndex(1))); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |mut sender| async move { + state + .launch_parallel_chunk_requests( + "regular", + ¶ms, + &mut sender, + 0, + &mut validators, + &mut ongoing_reqs, + ) + .await; + + assert_eq!(ongoing_reqs.total_len(), 0); + }, + ); + } + + // Has validators but no need to request more. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + ongoing_reqs.push(async { todo!() }.boxed()); + ongoing_reqs.soft_cancel(); + let mut validators = VecDeque::new(); + validators.push_back((alice.clone(), ValidatorIndex(1))); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |mut sender| async move { + state + .launch_parallel_chunk_requests( + "regular", + ¶ms, + &mut sender, + 0, + &mut validators, + &mut ongoing_reqs, + ) + .await; + + assert_eq!(ongoing_reqs.total_len(), 1); + assert_eq!(ongoing_reqs.len(), 0); + }, + ); + } + + // Needs to request more. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + ongoing_reqs.push(async { todo!() }.boxed()); + ongoing_reqs.soft_cancel(); + ongoing_reqs.push(async { todo!() }.boxed()); + let mut validators = VecDeque::new(); + validators.push_back((alice.clone(), 0.into())); + validators.push_back((bob, 1.into())); + validators.push_back((eve, 2.into())); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests(requests, _)) if requests.len() +== 3 ); + }, + |mut sender| async move { + state + .launch_parallel_chunk_requests( + "regular", + ¶ms, + &mut sender, + 10, + &mut validators, + &mut ongoing_reqs, + ) + .await; + + assert_eq!(ongoing_reqs.total_len(), 5); + assert_eq!(ongoing_reqs.len(), 4); + }, + ); + } + + // Check network protocol versioning. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + let mut validators = VecDeque::new(); + validators.push_back((alice, 0.into())); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + match receiver.next().timeout(TIMEOUT).await.unwrap().unwrap() { + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests( + mut requests, + _, + )) => { + assert_eq!(requests.len(), 1); + // By default, we should use the new protocol version with a fallback on + // the older one. + let (protocol, request) = requests.remove(0).encode_request(); + assert_eq!(protocol, Protocol::ChunkFetchingV2); + assert_eq!( + request.fallback_request.unwrap().1, + Protocol::ChunkFetchingV1 + ); + }, + _ => unreachable!(), + } + }, + |mut sender| async move { + state + .launch_parallel_chunk_requests( + "regular", + ¶ms, + &mut sender, + 10, + &mut validators, + &mut ongoing_reqs, + ) + .await; + + assert_eq!(ongoing_reqs.total_len(), 1); + assert_eq!(ongoing_reqs.len(), 1); + }, + ); + } + } + + #[test] + fn test_wait_for_chunks() { + let params = RecoveryParams::default(); + let retry_threshold = 2; + + // No ongoing requests. + { + let params = params.clone(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + let mut validators = VecDeque::new(); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |_| async move { + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut vec![], + |_, _, _, _| false, + ) + .await; + assert_eq!(total_responses, 0); + assert_eq!(error_count, 0); + assert_eq!(state.chunk_count(), 0); + }, + ); + } + + // Complex scenario. + { + let mut params = params.clone(); + let chunks = params.create_chunks(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[0].clone(), + 0.into(), + Ok((Some(chunks[0].clone()), "".into())), + )) + .boxed(), + ); + ongoing_reqs.soft_cancel(); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[1].clone(), + 1.into(), + Ok((Some(chunks[1].clone()), "".into())), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[2].clone(), + 2.into(), + Ok((None, "".into())), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[3].clone(), + 3.into(), + Err(RequestError::from(DecodingError::from("err"))), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[4].clone(), + 4.into(), + Err(RequestError::NetworkError(RequestFailure::NotConnected)), + )) + .boxed(), + ); + + let mut validators: VecDeque<_> = (5..params.n_validators as u32) + .map(|i| (params.validator_authority_keys[i as usize].clone(), i.into())) + .collect(); + validators.push_back(( + Sr25519Keyring::AliceStash.public().into(), + ValidatorIndex(params.n_validators as u32), + )); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |_| async move { + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut vec![], + |_, _, _, _| false, + ) + .await; + assert_eq!(total_responses, 5); + assert_eq!(error_count, 3); + assert_eq!(state.chunk_count(), 2); + + let mut expected_validators: VecDeque<_> = (4..params.n_validators as u32) + .map(|i| (params.validator_authority_keys[i as usize].clone(), i.into())) + .collect(); + expected_validators.push_back(( + Sr25519Keyring::AliceStash.public().into(), + ValidatorIndex(params.n_validators as u32), + )); + + assert_eq!(validators, expected_validators); + + // This time we'll go over the recoverable error threshold. + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[4].clone(), + 4.into(), + Err(RequestError::NetworkError(RequestFailure::NotConnected)), + )) + .boxed(), + ); + + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut vec![], + |_, _, _, _| false, + ) + .await; + assert_eq!(total_responses, 1); + assert_eq!(error_count, 1); + assert_eq!(state.chunk_count(), 2); + + validators.pop_front(); + let mut expected_validators: VecDeque<_> = (5..params.n_validators as u32) + .map(|i| (params.validator_authority_keys[i as usize].clone(), i.into())) + .collect(); + expected_validators.push_back(( + Sr25519Keyring::AliceStash.public().into(), + ValidatorIndex(params.n_validators as u32), + )); + + assert_eq!(validators, expected_validators); + + // Check that can_conclude returning true terminates the loop. + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut vec![], + |_, _, _, _| true, + ) + .await; + assert_eq!(total_responses, 0); + assert_eq!(error_count, 0); + assert_eq!(state.chunk_count(), 2); + + assert_eq!(validators, expected_validators); + }, + ); + } + + // Complex scenario with backups in the backing group. + { + let mut params = params.clone(); + let chunks = params.create_chunks(); + let mut state = State::new(); + let mut ongoing_reqs = OngoingRequests::new(); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[0].clone(), + 0.into(), + Ok((Some(chunks[0].clone()), "".into())), + )) + .boxed(), + ); + ongoing_reqs.soft_cancel(); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[1].clone(), + 1.into(), + Ok((Some(chunks[1].clone()), "".into())), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[2].clone(), + 2.into(), + Ok((None, "".into())), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[3].clone(), + 3.into(), + Err(RequestError::from(DecodingError::from("err"))), + )) + .boxed(), + ); + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[4].clone(), + 4.into(), + Err(RequestError::NetworkError(RequestFailure::NotConnected)), + )) + .boxed(), + ); + + let mut validators: VecDeque<_> = (5..params.n_validators as u32) + .map(|i| (params.validator_authority_keys[i as usize].clone(), i.into())) + .collect(); + validators.push_back(( + Sr25519Keyring::Eve.public().into(), + ValidatorIndex(params.n_validators as u32), + )); + + let mut backup_backers = vec![ + params.validator_authority_keys[2].clone(), + params.validator_authority_keys[0].clone(), + params.validator_authority_keys[4].clone(), + params.validator_authority_keys[3].clone(), + Sr25519Keyring::AliceStash.public().into(), + Sr25519Keyring::BobStash.public().into(), + ]; + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |_| async move { + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut backup_backers, + |_, _, _, _| false, + ) + .await; + assert_eq!(total_responses, 5); + assert_eq!(error_count, 3); + assert_eq!(state.chunk_count(), 2); + + let mut expected_validators: VecDeque<_> = (5..params.n_validators as u32) + .map(|i| (params.validator_authority_keys[i as usize].clone(), i.into())) + .collect(); + expected_validators.push_back(( + Sr25519Keyring::Eve.public().into(), + ValidatorIndex(params.n_validators as u32), + )); + // We picked a backer as a backup for chunks 2 and 3. + expected_validators + .push_front((params.validator_authority_keys[0].clone(), 2.into())); + expected_validators + .push_front((params.validator_authority_keys[2].clone(), 3.into())); + expected_validators + .push_front((params.validator_authority_keys[4].clone(), 4.into())); + + assert_eq!(validators, expected_validators); + + // This time we'll go over the recoverable error threshold for chunk 4. + ongoing_reqs.push( + future::ready(( + params.validator_authority_keys[4].clone(), + 4.into(), + Err(RequestError::NetworkError(RequestFailure::NotConnected)), + )) + .boxed(), + ); + + validators.pop_front(); + + let (total_responses, error_count) = state + .wait_for_chunks( + "regular", + ¶ms, + retry_threshold, + &mut validators, + &mut ongoing_reqs, + &mut backup_backers, + |_, _, _, _| false, + ) + .await; + assert_eq!(total_responses, 1); + assert_eq!(error_count, 1); + assert_eq!(state.chunk_count(), 2); + + expected_validators.pop_front(); + expected_validators + .push_front((Sr25519Keyring::AliceStash.public().into(), 4.into())); + + assert_eq!(validators, expected_validators); + }, + ); + } + } + + #[test] + fn test_recovery_strategy_run() { + let params = RecoveryParams::default(); + + struct GoodStrategy; + #[async_trait::async_trait] + impl RecoveryStrategy for GoodStrategy { + fn display_name(&self) -> &'static str { + "GoodStrategy" + } + + fn strategy_type(&self) -> &'static str { + "good_strategy" + } + + async fn run( + mut self: Box, + _state: &mut State, + _sender: &mut Sender, + _common_params: &RecoveryParams, + ) -> Result { + Ok(dummy_available_data()) + } + } + + struct UnavailableStrategy; + #[async_trait::async_trait] + impl RecoveryStrategy + for UnavailableStrategy + { + fn display_name(&self) -> &'static str { + "UnavailableStrategy" + } + + fn strategy_type(&self) -> &'static str { + "unavailable_strategy" + } + + async fn run( + mut self: Box, + _state: &mut State, + _sender: &mut Sender, + _common_params: &RecoveryParams, + ) -> Result { + Err(RecoveryError::Unavailable) + } + } + + struct InvalidStrategy; + #[async_trait::async_trait] + impl RecoveryStrategy + for InvalidStrategy + { + fn display_name(&self) -> &'static str { + "InvalidStrategy" + } + + fn strategy_type(&self) -> &'static str { + "invalid_strategy" + } + + async fn run( + mut self: Box, + _state: &mut State, + _sender: &mut Sender, + _common_params: &RecoveryParams, + ) -> Result { + Err(RecoveryError::Invalid) + } + } + + // No recovery strategies. + { + let mut params = params.clone(); + let strategies = VecDeque::new(); + params.bypass_availability_store = true; + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |sender| async move { + let task = RecoveryTask::new(sender, params, strategies); + + assert_eq!(task.run().await.unwrap_err(), RecoveryError::Unavailable); + }, + ); + } + + // If we have the data in av-store, returns early. + { + let params = params.clone(); + let strategies = VecDeque::new(); + let candidate_hash = params.candidate_hash; + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => { + assert_eq!(hash, candidate_hash); + tx.send(Some(dummy_available_data())).unwrap(); + }); + }, + |sender| async move { + let task = RecoveryTask::new(sender, params, strategies); + + assert_eq!(task.run().await.unwrap(), dummy_available_data()); + }, + ); + } + + // Strategy returning `RecoveryError::Invalid`` will short-circuit the entire task. + { + let mut params = params.clone(); + params.bypass_availability_store = true; + let mut strategies: VecDeque>> = + VecDeque::new(); + strategies.push_back(Box::new(InvalidStrategy)); + strategies.push_back(Box::new(GoodStrategy)); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + // Shouldn't send any requests. + assert!(receiver.next().timeout(TIMEOUT).await.unwrap().is_none()); + }, + |sender| async move { + let task = RecoveryTask::new(sender, params, strategies); + + assert_eq!(task.run().await.unwrap_err(), RecoveryError::Invalid); + }, + ); + } + + // Strategy returning `Unavailable` will fall back to the next one. + { + let params = params.clone(); + let candidate_hash = params.candidate_hash; + let mut strategies: VecDeque>> = + VecDeque::new(); + strategies.push_back(Box::new(UnavailableStrategy)); + strategies.push_back(Box::new(GoodStrategy)); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => { + assert_eq!(hash, candidate_hash); + tx.send(Some(dummy_available_data())).unwrap(); + }); + }, + |sender| async move { + let task = RecoveryTask::new(sender, params, strategies); + + assert_eq!(task.run().await.unwrap(), dummy_available_data()); + }, + ); + } + + // More complex scenario. + { + let params = params.clone(); + let candidate_hash = params.candidate_hash; + let mut strategies: VecDeque>> = + VecDeque::new(); + strategies.push_back(Box::new(UnavailableStrategy)); + strategies.push_back(Box::new(UnavailableStrategy)); + strategies.push_back(Box::new(GoodStrategy)); + strategies.push_back(Box::new(InvalidStrategy)); + + test_harness( + |mut receiver: UnboundedReceiver| async move { + assert_matches!( + receiver.next().timeout(TIMEOUT).await.unwrap().unwrap(), + AllMessages::AvailabilityStore(AvailabilityStoreMessage::QueryAvailableData(hash, tx)) => { + assert_eq!(hash, candidate_hash); + tx.send(Some(dummy_available_data())).unwrap(); + }); + }, + |sender| async move { + let task = RecoveryTask::new(sender, params, strategies); + + assert_eq!(task.run().await.unwrap(), dummy_available_data()); + }, + ); + } + } + + #[test] + fn test_is_unavailable() { + assert_eq!(is_unavailable(0, 0, 0, 0), false); + assert_eq!(is_unavailable(2, 2, 2, 0), false); + // Already reached the threshold. + assert_eq!(is_unavailable(3, 0, 10, 3), false); + assert_eq!(is_unavailable(3, 2, 0, 3), false); + assert_eq!(is_unavailable(3, 2, 10, 3), false); + // It's still possible to reach the threshold + assert_eq!(is_unavailable(0, 0, 10, 3), false); + assert_eq!(is_unavailable(0, 0, 3, 3), false); + assert_eq!(is_unavailable(1, 1, 1, 3), false); + // Not possible to reach the threshold + assert_eq!(is_unavailable(0, 0, 0, 3), true); + assert_eq!(is_unavailable(2, 3, 2, 10), true); + } +} diff --git a/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs b/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs new file mode 100644 index 0000000000000000000000000000000000000000..677bc2d1375aa75900123c39f1fbe59c8902ea69 --- /dev/null +++ b/polkadot/node/network/availability-recovery/src/task/strategy/systematic.rs @@ -0,0 +1,343 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use crate::{ + futures_undead::FuturesUndead, + task::{ + strategy::{ + do_post_recovery_check, is_unavailable, OngoingRequests, N_PARALLEL, + SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT, + }, + RecoveryParams, RecoveryStrategy, State, + }, + LOG_TARGET, +}; + +use polkadot_node_primitives::AvailableData; +use polkadot_node_subsystem::{overseer, RecoveryError}; +use polkadot_primitives::{ChunkIndex, ValidatorIndex}; + +use std::collections::VecDeque; + +/// Parameters needed for fetching systematic chunks. +pub struct FetchSystematicChunksParams { + /// Validators that hold the systematic chunks. + pub validators: Vec<(ChunkIndex, ValidatorIndex)>, + /// Validators in the backing group, to be used as a backup for requesting systematic chunks. + pub backers: Vec, +} + +/// `RecoveryStrategy` that attempts to recover the systematic chunks from the validators that +/// hold them, in order to bypass the erasure code reconstruction step, which is costly. +pub struct FetchSystematicChunks { + /// Systematic recovery threshold. + threshold: usize, + /// Validators that hold the systematic chunks. + validators: Vec<(ChunkIndex, ValidatorIndex)>, + /// Backers to be used as a backup. + backers: Vec, + /// Collection of in-flight requests. + requesting_chunks: OngoingRequests, +} + +impl FetchSystematicChunks { + /// Instantiate a new systematic chunks strategy. + pub fn new(params: FetchSystematicChunksParams) -> Self { + Self { + threshold: params.validators.len(), + validators: params.validators, + backers: params.backers, + requesting_chunks: FuturesUndead::new(), + } + } + + fn is_unavailable( + unrequested_validators: usize, + in_flight_requests: usize, + systematic_chunk_count: usize, + threshold: usize, + ) -> bool { + is_unavailable( + systematic_chunk_count, + in_flight_requests, + unrequested_validators, + threshold, + ) + } + + /// Desired number of parallel requests. + /// + /// For the given threshold (total required number of chunks) get the desired number of + /// requests we want to have running in parallel at this time. + fn get_desired_request_count(&self, chunk_count: usize, threshold: usize) -> usize { + // Upper bound for parallel requests. + let max_requests_boundary = std::cmp::min(N_PARALLEL, threshold); + // How many chunks are still needed? + let remaining_chunks = threshold.saturating_sub(chunk_count); + // Actual number of requests we want to have in flight in parallel: + // We don't have to make up for any error rate, as an error fetching a systematic chunk + // results in failure of the entire strategy. + std::cmp::min(max_requests_boundary, remaining_chunks) + } + + async fn attempt_systematic_recovery( + &mut self, + state: &mut State, + common_params: &RecoveryParams, + ) -> Result { + let strategy_type = RecoveryStrategy::::strategy_type(self); + let recovery_duration = common_params.metrics.time_erasure_recovery(strategy_type); + let reconstruct_duration = common_params.metrics.time_erasure_reconstruct(strategy_type); + let chunks = state + .received_chunks + .range( + ChunkIndex(0).. + ChunkIndex( + u32::try_from(self.threshold) + .expect("validator count should not exceed u32"), + ), + ) + .map(|(_, chunk)| chunk.chunk.clone()) + .collect::>(); + + let available_data = polkadot_erasure_coding::reconstruct_from_systematic_v1( + common_params.n_validators, + chunks, + ); + + match available_data { + Ok(data) => { + drop(reconstruct_duration); + + // Attempt post-recovery check. + do_post_recovery_check(common_params, data) + .await + .map_err(|e| { + recovery_duration.map(|rd| rd.stop_and_discard()); + e + }) + .map(|data| { + gum::trace!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + "Data recovery from systematic chunks complete", + ); + data + }) + }, + Err(err) => { + reconstruct_duration.map(|rd| rd.stop_and_discard()); + recovery_duration.map(|rd| rd.stop_and_discard()); + + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + ?err, + "Systematic data recovery error", + ); + + Err(RecoveryError::Invalid) + }, + } + } +} + +#[async_trait::async_trait] +impl RecoveryStrategy + for FetchSystematicChunks +{ + fn display_name(&self) -> &'static str { + "Fetch systematic chunks" + } + + fn strategy_type(&self) -> &'static str { + "systematic_chunks" + } + + async fn run( + mut self: Box, + state: &mut State, + sender: &mut Sender, + common_params: &RecoveryParams, + ) -> Result { + // First query the store for any chunks we've got. + if !common_params.bypass_availability_store { + let local_chunk_indices = state.populate_from_av_store(common_params, sender).await; + + for (_, our_c_index) in &local_chunk_indices { + // If we are among the systematic validators but hold an invalid chunk, we cannot + // perform the systematic recovery. Fall through to the next strategy. + if self.validators.iter().any(|(c_index, _)| c_index == our_c_index) && + !state.received_chunks.contains_key(our_c_index) + { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + requesting = %self.requesting_chunks.len(), + total_requesting = %self.requesting_chunks.total_len(), + n_validators = %common_params.n_validators, + chunk_index = ?our_c_index, + "Systematic chunk recovery is not possible. We are among the systematic validators but hold an invalid chunk", + ); + return Err(RecoveryError::Unavailable) + } + } + } + + // No need to query the validators that have the chunks we already received or that we know + // don't have the data from previous strategies. + self.validators.retain(|(c_index, v_index)| { + !state.received_chunks.contains_key(c_index) && + state.can_retry_request( + &(common_params.validator_authority_keys[v_index.0 as usize].clone(), *v_index), + SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT, + ) + }); + + let mut systematic_chunk_count = state + .received_chunks + .range(ChunkIndex(0)..ChunkIndex(self.threshold as u32)) + .count(); + + // Safe to `take` here, as we're consuming `self` anyway and we're not using the + // `validators` or `backers` fields in other methods. + let mut validators_queue: VecDeque<_> = std::mem::take(&mut self.validators) + .into_iter() + .map(|(_, validator_index)| { + ( + common_params.validator_authority_keys[validator_index.0 as usize].clone(), + validator_index, + ) + }) + .collect(); + let mut backers: Vec<_> = std::mem::take(&mut self.backers) + .into_iter() + .map(|validator_index| { + common_params.validator_authority_keys[validator_index.0 as usize].clone() + }) + .collect(); + + loop { + // If received_chunks has `systematic_chunk_threshold` entries, attempt to recover the + // data. + if systematic_chunk_count >= self.threshold { + return self.attempt_systematic_recovery::(state, common_params).await + } + + if Self::is_unavailable( + validators_queue.len(), + self.requesting_chunks.total_len(), + systematic_chunk_count, + self.threshold, + ) { + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?common_params.candidate_hash, + erasure_root = ?common_params.erasure_root, + %systematic_chunk_count, + requesting = %self.requesting_chunks.len(), + total_requesting = %self.requesting_chunks.total_len(), + n_validators = %common_params.n_validators, + systematic_threshold = ?self.threshold, + "Data recovery from systematic chunks is not possible", + ); + + return Err(RecoveryError::Unavailable) + } + + let desired_requests_count = + self.get_desired_request_count(systematic_chunk_count, self.threshold); + let already_requesting_count = self.requesting_chunks.len(); + gum::debug!( + target: LOG_TARGET, + ?common_params.candidate_hash, + ?desired_requests_count, + total_received = ?systematic_chunk_count, + systematic_threshold = ?self.threshold, + ?already_requesting_count, + "Requesting systematic availability chunks for a candidate", + ); + + let strategy_type = RecoveryStrategy::::strategy_type(&*self); + + state + .launch_parallel_chunk_requests( + strategy_type, + common_params, + sender, + desired_requests_count, + &mut validators_queue, + &mut self.requesting_chunks, + ) + .await; + + let _ = state + .wait_for_chunks( + strategy_type, + common_params, + SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT, + &mut validators_queue, + &mut self.requesting_chunks, + &mut backers, + |unrequested_validators, + in_flight_reqs, + // Don't use this chunk count, as it may contain non-systematic chunks. + _chunk_count, + new_systematic_chunk_count| { + systematic_chunk_count = new_systematic_chunk_count; + + let is_unavailable = Self::is_unavailable( + unrequested_validators, + in_flight_reqs, + systematic_chunk_count, + self.threshold, + ); + + systematic_chunk_count >= self.threshold || is_unavailable + }, + ) + .await; + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use polkadot_erasure_coding::systematic_recovery_threshold; + + #[test] + fn test_get_desired_request_count() { + let num_validators = 100; + let threshold = systematic_recovery_threshold(num_validators).unwrap(); + + let systematic_chunks_task = FetchSystematicChunks::new(FetchSystematicChunksParams { + validators: vec![(1.into(), 1.into()); num_validators], + backers: vec![], + }); + assert_eq!(systematic_chunks_task.get_desired_request_count(0, threshold), threshold); + assert_eq!(systematic_chunks_task.get_desired_request_count(5, threshold), threshold - 5); + assert_eq!( + systematic_chunks_task.get_desired_request_count(num_validators * 2, threshold), + 0 + ); + assert_eq!(systematic_chunks_task.get_desired_request_count(0, N_PARALLEL * 2), N_PARALLEL); + assert_eq!(systematic_chunks_task.get_desired_request_count(N_PARALLEL, N_PARALLEL + 2), 2); + } +} diff --git a/polkadot/node/network/availability-recovery/src/tests.rs b/polkadot/node/network/availability-recovery/src/tests.rs index 909f6a25f46b1eca3074095b6f54f0415d62c562..4fd9ede40ff658631142df4829aab43e55c9f105 100644 --- a/polkadot/node/network/availability-recovery/src/tests.rs +++ b/polkadot/node/network/availability-recovery/src/tests.rs @@ -14,38 +14,133 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use std::{sync::Arc, time::Duration}; +use crate::task::{REGULAR_CHUNKS_REQ_RETRY_LIMIT, SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT}; + +use super::*; +use std::{result::Result, sync::Arc, time::Duration}; use assert_matches::assert_matches; use futures::{executor, future}; use futures_timer::Delay; +use rstest::rstest; -use parity_scale_codec::Encode; +use codec::Encode; use polkadot_node_network_protocol::request_response::{ - self as req_res, v1::AvailableDataFetchingRequest, IncomingRequest, Protocol, Recipient, - ReqProtocolNames, Requests, + self as req_res, + v1::{AvailableDataFetchingRequest, ChunkResponse}, + IncomingRequest, Protocol, Recipient, ReqProtocolNames, Requests, }; -use polkadot_node_subsystem_test_helpers::derive_erasure_chunks_with_proofs_and_root; - -use super::*; -use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure}; - -use polkadot_node_primitives::{BlockData, PoV, Proof}; +use polkadot_node_primitives::{BlockData, ErasureChunk, PoV, Proof}; use polkadot_node_subsystem::messages::{ AllMessages, NetworkBridgeTxMessage, RuntimeApiMessage, RuntimeApiRequest, }; use polkadot_node_subsystem_test_helpers::{ - make_subsystem_context, mock::new_leaf, TestSubsystemContextHandle, + derive_erasure_chunks_with_proofs_and_root, make_subsystem_context, mock::new_leaf, + TestSubsystemContextHandle, }; use polkadot_node_subsystem_util::TimeoutExt; use polkadot_primitives::{ - AuthorityDiscoveryId, Block, Hash, HeadData, IndexedVec, PersistedValidationData, ValidatorId, + node_features, AuthorityDiscoveryId, Block, ExecutorParams, Hash, HeadData, IndexedVec, + NodeFeatures, PersistedValidationData, SessionInfo, ValidatorId, }; use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; +use sc_network::{IfDisconnected, OutboundFailure, ProtocolName, RequestFailure}; +use sp_keyring::Sr25519Keyring; type VirtualOverseer = TestSubsystemContextHandle; +// Implement some helper constructors for the AvailabilityRecoverySubsystem + +/// Create a new instance of `AvailabilityRecoverySubsystem` which starts with a fast path to +/// request data from backers. +fn with_fast_path( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + req_receiver, + req_protocol_names, + metrics, + RecoveryStrategyKind::BackersFirstAlways, + ) +} + +/// Create a new instance of `AvailabilityRecoverySubsystem` which requests only chunks +fn with_chunks_only( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + req_receiver, + req_protocol_names, + metrics, + RecoveryStrategyKind::ChunksAlways, + ) +} + +/// Create a new instance of `AvailabilityRecoverySubsystem` which requests chunks if PoV is +/// above a threshold. +fn with_chunks_if_pov_large( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + req_receiver, + req_protocol_names, + metrics, + RecoveryStrategyKind::BackersFirstIfSizeLower(FETCH_CHUNKS_THRESHOLD), + ) +} + +/// Create a new instance of `AvailabilityRecoverySubsystem` which requests systematic chunks if +/// PoV is above a threshold. +fn with_systematic_chunks_if_pov_large( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::for_validator( + Some(FETCH_CHUNKS_THRESHOLD), + req_receiver, + req_protocol_names, + metrics, + ) +} + +/// Create a new instance of `AvailabilityRecoverySubsystem` which first requests full data +/// from backers, with a fallback to recover from systematic chunks. +fn with_fast_path_then_systematic_chunks( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + req_receiver, + req_protocol_names, + metrics, + RecoveryStrategyKind::BackersThenSystematicChunks, + ) +} + +/// Create a new instance of `AvailabilityRecoverySubsystem` which first attempts to request +/// systematic chunks, with a fallback to requesting regular chunks. +fn with_systematic_chunks( + req_receiver: IncomingRequestReceiver, + req_protocol_names: &ReqProtocolNames, + metrics: Metrics, +) -> AvailabilityRecoverySubsystem { + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + req_receiver, + req_protocol_names, + metrics, + RecoveryStrategyKind::SystematicChunks, + ) +} + // Deterministic genesis hash for protocol names const GENESIS_HASH: Hash = Hash::repeat_byte(0xff); @@ -61,14 +156,11 @@ fn request_receiver( receiver.0 } -fn test_harness>( +fn test_harness>( subsystem: AvailabilityRecoverySubsystem, - test: impl FnOnce(VirtualOverseer) -> T, + test: impl FnOnce(VirtualOverseer) -> Fut, ) { - let _ = env_logger::builder() - .is_test(true) - .filter(Some("polkadot_availability_recovery"), log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); @@ -138,8 +230,6 @@ async fn overseer_recv( msg } -use sp_keyring::Sr25519Keyring; - #[derive(Debug)] enum Has { No, @@ -163,27 +253,127 @@ struct TestState { validators: Vec, validator_public: IndexedVec, validator_authority_id: Vec, + validator_groups: IndexedVec>, current: Hash, candidate: CandidateReceipt, session_index: SessionIndex, + core_index: CoreIndex, + node_features: NodeFeatures, persisted_validation_data: PersistedValidationData, available_data: AvailableData, - chunks: Vec, - invalid_chunks: Vec, + chunks: IndexedVec, + invalid_chunks: IndexedVec, } impl TestState { + fn new(node_features: NodeFeatures) -> Self { + let validators = vec![ + Sr25519Keyring::Ferdie, // <- this node, role: validator + Sr25519Keyring::Alice, + Sr25519Keyring::Bob, + Sr25519Keyring::Charlie, + Sr25519Keyring::Dave, + Sr25519Keyring::One, + Sr25519Keyring::Two, + ]; + + let validator_public = validator_pubkeys(&validators); + let validator_authority_id = validator_authority_id(&validators); + let validator_groups = vec![ + vec![1.into(), 0.into(), 3.into(), 4.into()], + vec![5.into(), 6.into()], + vec![2.into()], + ]; + + let current = Hash::repeat_byte(1); + + let mut candidate = dummy_candidate_receipt(dummy_hash()); + + let session_index = 10; + + let persisted_validation_data = PersistedValidationData { + parent_head: HeadData(vec![7, 8, 9]), + relay_parent_number: Default::default(), + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }; + + let pov = PoV { block_data: BlockData(vec![42; 64]) }; + + let available_data = AvailableData { + validation_data: persisted_validation_data.clone(), + pov: Arc::new(pov), + }; + + let core_index = CoreIndex(2); + + let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root( + validators.len(), + &available_data, + |_, _| {}, + ); + let chunks = map_chunks(chunks, &node_features, validators.len(), core_index); + + // Mess around: + let invalid_chunks = chunks + .iter() + .cloned() + .map(|mut chunk| { + if chunk.chunk.len() >= 2 && chunk.chunk[0] != chunk.chunk[1] { + chunk.chunk[0] = chunk.chunk[1]; + } else if chunk.chunk.len() >= 1 { + chunk.chunk[0] = !chunk.chunk[0]; + } else { + chunk.proof = Proof::dummy_proof(); + } + chunk + }) + .collect(); + debug_assert_ne!(chunks, invalid_chunks); + + candidate.descriptor.erasure_root = erasure_root; + candidate.descriptor.relay_parent = Hash::repeat_byte(10); + candidate.descriptor.pov_hash = Hash::repeat_byte(3); + + Self { + validators, + validator_public, + validator_authority_id, + validator_groups: IndexedVec::>::try_from( + validator_groups, + ) + .unwrap(), + current, + candidate, + session_index, + core_index, + node_features, + persisted_validation_data, + available_data, + chunks, + invalid_chunks, + } + } + + fn with_empty_node_features() -> Self { + Self::new(NodeFeatures::EMPTY) + } + fn threshold(&self) -> usize { recovery_threshold(self.validators.len()).unwrap() } + fn systematic_threshold(&self) -> usize { + systematic_recovery_threshold(self.validators.len()).unwrap() + } + fn impossibility_threshold(&self) -> usize { self.validators.len() - self.threshold() + 1 } - async fn test_runtime_api(&self, virtual_overseer: &mut VirtualOverseer) { + async fn test_runtime_api_session_info(&self, virtual_overseer: &mut VirtualOverseer) { assert_matches!( overseer_recv(virtual_overseer).await, AllMessages::RuntimeApi(RuntimeApiMessage::Request( @@ -199,8 +389,7 @@ impl TestState { tx.send(Ok(Some(SessionInfo { validators: self.validator_public.clone(), discovery_keys: self.validator_authority_id.clone(), - // all validators in the same group. - validator_groups: IndexedVec::>::from(vec![(0..self.validators.len()).map(|i| ValidatorIndex(i as _)).collect()]), + validator_groups: self.validator_groups.clone(), assignment_keys: vec![], n_cores: 0, zeroth_delay_tranche_width: 0, @@ -214,6 +403,38 @@ impl TestState { }))).unwrap(); } ); + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionExecutorParams( + session_index, + tx, + ) + )) => { + assert_eq!(relay_parent, self.current); + assert_eq!(session_index, self.session_index); + + tx.send(Ok(Some(ExecutorParams::new()))).unwrap(); + } + ); + } + + async fn test_runtime_api_node_features(&self, virtual_overseer: &mut VirtualOverseer) { + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _relay_parent, + RuntimeApiRequest::NodeFeatures( + _, + tx, + ) + )) => { + tx.send(Ok( + self.node_features.clone() + )).unwrap(); + } + ); } async fn respond_to_available_data_query( @@ -239,16 +460,19 @@ impl TestState { async fn respond_to_query_all_request( &self, virtual_overseer: &mut VirtualOverseer, - send_chunk: impl Fn(usize) -> bool, + send_chunk: impl Fn(ValidatorIndex) -> bool, ) { assert_matches!( overseer_recv(virtual_overseer).await, AllMessages::AvailabilityStore( AvailabilityStoreMessage::QueryAllChunks(_, tx) ) => { - let v = self.chunks.iter() - .filter(|c| send_chunk(c.index.0 as usize)) - .cloned() + let v = self.chunks.iter().enumerate() + .filter_map(|(val_idx, c)| if send_chunk(ValidatorIndex(val_idx as u32)) { + Some((ValidatorIndex(val_idx as u32), c.clone())) + } else { + None + }) .collect(); let _ = tx.send(v); @@ -259,16 +483,19 @@ impl TestState { async fn respond_to_query_all_request_invalid( &self, virtual_overseer: &mut VirtualOverseer, - send_chunk: impl Fn(usize) -> bool, + send_chunk: impl Fn(ValidatorIndex) -> bool, ) { assert_matches!( overseer_recv(virtual_overseer).await, AllMessages::AvailabilityStore( AvailabilityStoreMessage::QueryAllChunks(_, tx) ) => { - let v = self.invalid_chunks.iter() - .filter(|c| send_chunk(c.index.0 as usize)) - .cloned() + let v = self.invalid_chunks.iter().enumerate() + .filter_map(|(val_idx, c)| if send_chunk(ValidatorIndex(val_idx as u32)) { + Some((ValidatorIndex(val_idx as u32), c.clone())) + } else { + None + }) .collect(); let _ = tx.send(v); @@ -276,14 +503,16 @@ impl TestState { ) } - async fn test_chunk_requests( + async fn test_chunk_requests_inner( &self, req_protocol_names: &ReqProtocolNames, candidate_hash: CandidateHash, virtual_overseer: &mut VirtualOverseer, n: usize, - who_has: impl Fn(usize) -> Has, - ) -> Vec, ProtocolName), RequestFailure>>> { + mut who_has: impl FnMut(ValidatorIndex) -> Has, + systematic_recovery: bool, + protocol: Protocol, + ) -> Vec, ProtocolName), RequestFailure>>> { // arbitrary order. let mut i = 0; let mut senders = Vec::new(); @@ -301,13 +530,19 @@ impl TestState { i += 1; assert_matches!( req, - Requests::ChunkFetchingV1(req) => { + Requests::ChunkFetching(req) => { assert_eq!(req.payload.candidate_hash, candidate_hash); - let validator_index = req.payload.index.0 as usize; + let validator_index = req.payload.index; + let chunk = self.chunks.get(validator_index).unwrap().clone(); + + if systematic_recovery { + assert!(chunk.index.0 as usize <= self.systematic_threshold(), "requested non-systematic chunk"); + } + let available_data = match who_has(validator_index) { Has::No => Ok(None), - Has::Yes => Ok(Some(self.chunks[validator_index].clone().into())), + Has::Yes => Ok(Some(chunk)), Has::NetworkError(e) => Err(e), Has::DoesNotReturn => { senders.push(req.pending_response); @@ -315,11 +550,29 @@ impl TestState { } }; - let _ = req.pending_response.send( + req.pending_response.send( available_data.map(|r| - (req_res::v1::ChunkFetchingResponse::from(r).encode(), req_protocol_names.get_name(Protocol::ChunkFetchingV1)) + ( + match protocol { + Protocol::ChunkFetchingV1 => + match r { + None => req_res::v1::ChunkFetchingResponse::NoSuchChunk, + Some(c) => req_res::v1::ChunkFetchingResponse::Chunk( + ChunkResponse { + chunk: c.chunk, + proof: c.proof + } + ) + }.encode(), + Protocol::ChunkFetchingV2 => + req_res::v2::ChunkFetchingResponse::from(r).encode(), + + _ => unreachable!() + }, + req_protocol_names.get_name(protocol) + ) ) - ); + ).unwrap(); } ) } @@ -329,16 +582,61 @@ impl TestState { senders } + async fn test_chunk_requests( + &self, + req_protocol_names: &ReqProtocolNames, + candidate_hash: CandidateHash, + virtual_overseer: &mut VirtualOverseer, + n: usize, + who_has: impl FnMut(ValidatorIndex) -> Has, + systematic_recovery: bool, + ) -> Vec, ProtocolName), RequestFailure>>> { + self.test_chunk_requests_inner( + req_protocol_names, + candidate_hash, + virtual_overseer, + n, + who_has, + systematic_recovery, + Protocol::ChunkFetchingV2, + ) + .await + } + + // Use legacy network protocol version. + async fn test_chunk_requests_v1( + &self, + req_protocol_names: &ReqProtocolNames, + candidate_hash: CandidateHash, + virtual_overseer: &mut VirtualOverseer, + n: usize, + who_has: impl FnMut(ValidatorIndex) -> Has, + systematic_recovery: bool, + ) -> Vec, ProtocolName), RequestFailure>>> { + self.test_chunk_requests_inner( + req_protocol_names, + candidate_hash, + virtual_overseer, + n, + who_has, + systematic_recovery, + Protocol::ChunkFetchingV1, + ) + .await + } + async fn test_full_data_requests( &self, req_protocol_names: &ReqProtocolNames, candidate_hash: CandidateHash, virtual_overseer: &mut VirtualOverseer, who_has: impl Fn(usize) -> Has, - ) -> Vec, ProtocolName), RequestFailure>>> { + group_index: GroupIndex, + ) -> Vec, ProtocolName), RequestFailure>>> { let mut senders = Vec::new(); - for _ in 0..self.validators.len() { - // Receive a request for a chunk. + let expected_validators = self.validator_groups.get(group_index).unwrap(); + for _ in 0..expected_validators.len() { + // Receive a request for the full `AvailableData`. assert_matches!( overseer_recv(virtual_overseer).await, AllMessages::NetworkBridgeTx( @@ -357,6 +655,7 @@ impl TestState { .iter() .position(|a| Recipient::Authority(a.clone()) == req.peer) .unwrap(); + assert!(expected_validators.contains(&ValidatorIndex(validator_index as u32))); let available_data = match who_has(validator_index) { Has::No => Ok(None), @@ -387,95 +686,67 @@ impl TestState { } } +impl Default for TestState { + fn default() -> Self { + // Enable the chunk mapping node feature. + let mut node_features = NodeFeatures::new(); + node_features + .resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false); + node_features + .set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true); + + Self::new(node_features) + } +} + fn validator_pubkeys(val_ids: &[Sr25519Keyring]) -> IndexedVec { val_ids.iter().map(|v| v.public().into()).collect() } -fn validator_authority_id(val_ids: &[Sr25519Keyring]) -> Vec { +pub fn validator_authority_id(val_ids: &[Sr25519Keyring]) -> Vec { val_ids.iter().map(|v| v.public().into()).collect() } -impl Default for TestState { - fn default() -> Self { - let validators = vec![ - Sr25519Keyring::Ferdie, // <- this node, role: validator - Sr25519Keyring::Alice, - Sr25519Keyring::Bob, - Sr25519Keyring::Charlie, - Sr25519Keyring::Dave, - ]; - - let validator_public = validator_pubkeys(&validators); - let validator_authority_id = validator_authority_id(&validators); - - let current = Hash::repeat_byte(1); - - let mut candidate = dummy_candidate_receipt(dummy_hash()); - - let session_index = 10; - - let persisted_validation_data = PersistedValidationData { - parent_head: HeadData(vec![7, 8, 9]), - relay_parent_number: Default::default(), - max_pov_size: 1024, - relay_parent_storage_root: Default::default(), - }; - - let pov = PoV { block_data: BlockData(vec![42; 64]) }; - - let available_data = AvailableData { - validation_data: persisted_validation_data.clone(), - pov: Arc::new(pov), - }; - - let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root( - validators.len(), - &available_data, - |_, _| {}, - ); - // Mess around: - let invalid_chunks = chunks - .iter() - .cloned() - .map(|mut chunk| { - if chunk.chunk.len() >= 2 && chunk.chunk[0] != chunk.chunk[1] { - chunk.chunk[0] = chunk.chunk[1]; - } else if chunk.chunk.len() >= 1 { - chunk.chunk[0] = !chunk.chunk[0]; - } else { - chunk.proof = Proof::dummy_proof(); - } - chunk - }) - .collect(); - debug_assert_ne!(chunks, invalid_chunks); - - candidate.descriptor.erasure_root = erasure_root; - candidate.descriptor.relay_parent = Hash::repeat_byte(10); - - Self { - validators, - validator_public, - validator_authority_id, - current, - candidate, - session_index, - persisted_validation_data, - available_data, - chunks, - invalid_chunks, - } - } +/// Map the chunks to the validators according to the availability chunk mapping algorithm. +fn map_chunks( + chunks: Vec, + node_features: &NodeFeatures, + n_validators: usize, + core_index: CoreIndex, +) -> IndexedVec { + let chunk_indices = + availability_chunk_indices(Some(node_features), n_validators, core_index).unwrap(); + + (0..n_validators) + .map(|val_idx| chunks[chunk_indices[val_idx].0 as usize].clone()) + .collect::>() + .into() } -#[test] -fn availability_is_recovered_from_chunks_if_no_group_provided() { +#[rstest] +#[case(true)] +#[case(false)] +fn availability_is_recovered_from_chunks_if_no_group_provided(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_fast_path_then_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_fast_path( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -495,12 +766,15 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -512,8 +786,9 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() { &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold(), + threshold, |_| Has::Yes, + systematic_recovery, ) .await; @@ -533,16 +808,31 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() { new_candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + if systematic_recovery { + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + threshold, + |_| Has::No, + systematic_recovery, + ) + .await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + + // Even if the recovery is systematic, we'll always fall back to regular recovery, so keep + // this around. test_state .test_chunk_requests( &req_protocol_names, @@ -550,6 +840,7 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() { &mut virtual_overseer, test_state.impossibility_threshold(), |_| Has::No, + false, ) .await; @@ -559,16 +850,34 @@ fn availability_is_recovered_from_chunks_if_no_group_provided() { }); } -#[test] -fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunks_only() { - let test_state = TestState::default(); +#[rstest] +#[case(true)] +#[case(false)] +fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunks_only( + #[case] systematic_recovery: bool, +) { let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); - - test_harness(subsystem, |mut virtual_overseer| async move { + let test_state = TestState::default(); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( &mut virtual_overseer, OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( @@ -586,12 +895,15 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -603,8 +915,9 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold(), + threshold, |_| Has::Yes, + systematic_recovery, ) .await; @@ -623,41 +936,80 @@ fn availability_is_recovered_from_chunks_even_if_backing_group_supplied_if_chunk AvailabilityRecoveryMessage::RecoverAvailableData( new_candidate.clone(), test_state.session_index, - None, + Some(GroupIndex(1)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; - test_state - .test_chunk_requests( - &req_protocol_names, - new_candidate.hash(), - &mut virtual_overseer, - test_state.impossibility_threshold(), - |_| Has::No, - ) - .await; + if systematic_recovery { + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + threshold * SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT as usize, + |_| Has::No, + systematic_recovery, + ) + .await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + // Even if the recovery is systematic, we'll always fall back to regular recovery, so + // keep this around. + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + test_state.impossibility_threshold() - threshold, + |_| Has::No, + false, + ) + .await; + + // A request times out with `Unavailable` error. + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + } else { + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + test_state.impossibility_threshold(), + |_| Has::No, + false, + ) + .await; - // A request times out with `Unavailable` error. - assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + // A request times out with `Unavailable` error. + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + } virtual_overseer }); } -#[test] -fn bad_merkle_path_leads_to_recovery_error() { - let mut test_state = TestState::default(); +#[rstest] +#[case(true)] +#[case(false)] +fn bad_merkle_path_leads_to_recovery_error(#[case] systematic_recovery: bool) { let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let mut test_state = TestState::default(); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -677,25 +1029,40 @@ fn bad_merkle_path_leads_to_recovery_error() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); // Create some faulty chunks. - test_state.chunks[0].chunk = vec![0; 32]; - test_state.chunks[1].chunk = vec![1; 32]; - test_state.chunks[2].chunk = vec![2; 32]; - test_state.chunks[3].chunk = vec![3; 32]; - test_state.chunks[4].chunk = vec![4; 32]; + for chunk in test_state.chunks.iter_mut() { + chunk.chunk = vec![0; 32]; + } test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + if systematic_recovery { + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.systematic_threshold(), + |_| Has::No, + systematic_recovery, + ) + .await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + test_state .test_chunk_requests( &req_protocol_names, @@ -703,6 +1070,7 @@ fn bad_merkle_path_leads_to_recovery_error() { &mut virtual_overseer, test_state.impossibility_threshold(), |_| Has::Yes, + false, ) .await; @@ -712,14 +1080,24 @@ fn bad_merkle_path_leads_to_recovery_error() { }); } -#[test] -fn wrong_chunk_index_leads_to_recovery_error() { +#[rstest] +#[case(true)] +#[case(false)] +fn wrong_chunk_index_leads_to_recovery_error(#[case] systematic_recovery: bool) { let mut test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -739,32 +1117,55 @@ fn wrong_chunk_index_leads_to_recovery_error() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; - let candidate_hash = test_state.candidate.hash(); + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; - // These chunks should fail the index check as they don't have the correct index for - // validator. - test_state.chunks[1] = test_state.chunks[0].clone(); - test_state.chunks[2] = test_state.chunks[0].clone(); - test_state.chunks[3] = test_state.chunks[0].clone(); - test_state.chunks[4] = test_state.chunks[0].clone(); + let candidate_hash = test_state.candidate.hash(); test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + // Chunks should fail the index check as they don't have the correct index. + + // *(test_state.chunks.get_mut(0.into()).unwrap()) = + // test_state.chunks.get(1.into()).unwrap().clone(); + let first_chunk = test_state.chunks.get(0.into()).unwrap().clone(); + for c_index in 1..test_state.chunks.len() { + *(test_state.chunks.get_mut(ValidatorIndex(c_index as u32)).unwrap()) = + first_chunk.clone(); + } + + if systematic_recovery { + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.systematic_threshold(), + |_| Has::Yes, + // We set this to false, as we know we will be requesting the wrong indices. + false, + ) + .await; + + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + test_state .test_chunk_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.impossibility_threshold(), - |_| Has::No, + test_state.chunks.len() - 1, + |_| Has::Yes, + false, ) .await; @@ -774,14 +1175,30 @@ fn wrong_chunk_index_leads_to_recovery_error() { }); } -#[test] -fn invalid_erasure_coding_leads_to_invalid_error() { +#[rstest] +#[case(true)] +#[case(false)] +fn invalid_erasure_coding_leads_to_invalid_error(#[case] systematic_recovery: bool) { let mut test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_fast_path_then_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_fast_path( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { let pov = PoV { block_data: BlockData(vec![69; 64]) }; @@ -795,7 +1212,12 @@ fn invalid_erasure_coding_leads_to_invalid_error() { |i, chunk| *chunk = vec![i as u8; 32], ); - test_state.chunks = bad_chunks; + test_state.chunks = map_chunks( + bad_chunks, + &test_state.node_features, + test_state.validators.len(), + test_state.core_index, + ); test_state.candidate.descriptor.erasure_root = bad_erasure_root; let candidate_hash = test_state.candidate.hash(); @@ -817,12 +1239,15 @@ fn invalid_erasure_coding_leads_to_invalid_error() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; @@ -832,8 +1257,9 @@ fn invalid_erasure_coding_leads_to_invalid_error() { &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold(), + threshold, |_| Has::Yes, + systematic_recovery, ) .await; @@ -843,12 +1269,74 @@ fn invalid_erasure_coding_leads_to_invalid_error() { }); } +#[test] +fn invalid_pov_hash_leads_to_invalid_error() { + let mut test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let subsystem = AvailabilityRecoverySubsystem::for_collator( + None, + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ); + + test_harness(subsystem, |mut virtual_overseer| async move { + let pov = PoV { block_data: BlockData(vec![69; 64]) }; + + test_state.candidate.descriptor.pov_hash = pov.hash(); + + let candidate_hash = test_state.candidate.hash(); + + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.threshold(), + |_| Has::Yes, + false, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Invalid); + virtual_overseer + }); +} + #[test] fn fast_path_backing_group_recovers() { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( + let subsystem = with_fast_path( request_receiver(&req_protocol_names), + &req_protocol_names, Metrics::new_dummy(), ); @@ -870,12 +1358,14 @@ fn fast_path_backing_group_recovers() { test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -892,6 +1382,7 @@ fn fast_path_backing_group_recovers() { candidate_hash, &mut virtual_overseer, who_has, + GroupIndex(0), ) .await; @@ -901,14 +1392,47 @@ fn fast_path_backing_group_recovers() { }); } -#[test] -fn recovers_from_only_chunks_if_pov_large() { - let test_state = TestState::default(); +#[rstest] +#[case(true, false)] +#[case(false, true)] +#[case(false, false)] +fn recovers_from_only_chunks_if_pov_large( + #[case] systematic_recovery: bool, + #[case] for_collator: bool, +) { + let mut test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_if_pov_large( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let (subsystem, threshold) = match (systematic_recovery, for_collator) { + (true, false) => ( + with_systematic_chunks_if_pov_large( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + (false, false) => ( + with_chunks_if_pov_large( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + (false, true) => { + test_state.candidate.descriptor.pov_hash = test_state.available_data.pov.hash(); + ( + AvailabilityRecoverySubsystem::for_collator( + None, + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ) + }, + (_, _) => unreachable!(), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -928,12 +1452,15 @@ fn recovers_from_only_chunks_if_pov_large() { test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -942,20 +1469,23 @@ fn recovers_from_only_chunks_if_pov_large() { AllMessages::AvailabilityStore( AvailabilityStoreMessage::QueryChunkSize(_, tx) ) => { - let _ = tx.send(Some(1000000)); + let _ = tx.send(Some(crate::FETCH_CHUNKS_THRESHOLD + 1)); } ); - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; - test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + if !for_collator { + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } test_state .test_chunk_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold(), + threshold, |_| Has::Yes, + systematic_recovery, ) .await; @@ -974,35 +1504,64 @@ fn recovers_from_only_chunks_if_pov_large() { AvailabilityRecoveryMessage::RecoverAvailableData( new_candidate.clone(), test_state.session_index, - Some(GroupIndex(0)), + Some(GroupIndex(1)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; - assert_matches!( overseer_recv(&mut virtual_overseer).await, AllMessages::AvailabilityStore( AvailabilityStoreMessage::QueryChunkSize(_, tx) ) => { - let _ = tx.send(Some(1000000)); + let _ = tx.send(Some(crate::FETCH_CHUNKS_THRESHOLD + 1)); } ); - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; - test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + if !for_collator { + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } - test_state - .test_chunk_requests( - &req_protocol_names, - new_candidate.hash(), - &mut virtual_overseer, - test_state.impossibility_threshold(), - |_| Has::No, - ) - .await; + if systematic_recovery { + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + test_state.systematic_threshold() * SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT as usize, + |_| Has::No, + systematic_recovery, + ) + .await; + if !for_collator { + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + // Even if the recovery is systematic, we'll always fall back to regular recovery. + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + test_state.impossibility_threshold() - threshold, + |_| Has::No, + false, + ) + .await; + } else { + test_state + .test_chunk_requests( + &req_protocol_names, + new_candidate.hash(), + &mut virtual_overseer, + test_state.impossibility_threshold(), + |_| Has::No, + false, + ) + .await; + } // A request times out with `Unavailable` error. assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); @@ -1010,14 +1569,40 @@ fn recovers_from_only_chunks_if_pov_large() { }); } -#[test] -fn fast_path_backing_group_recovers_if_pov_small() { - let test_state = TestState::default(); +#[rstest] +#[case(true, false)] +#[case(false, true)] +#[case(false, false)] +fn fast_path_backing_group_recovers_if_pov_small( + #[case] systematic_recovery: bool, + #[case] for_collator: bool, +) { + let mut test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_if_pov_large( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + + let subsystem = match (systematic_recovery, for_collator) { + (true, false) => with_systematic_chunks_if_pov_large( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + + (false, false) => with_chunks_if_pov_large( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + (false, true) => { + test_state.candidate.descriptor.pov_hash = test_state.available_data.pov.hash(); + AvailabilityRecoverySubsystem::for_collator( + None, + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ) + }, + (_, _) => unreachable!(), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1037,12 +1622,15 @@ fn fast_path_backing_group_recovers_if_pov_small() { test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -1060,7 +1648,9 @@ fn fast_path_backing_group_recovers_if_pov_small() { } ); - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + if !for_collator { + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + } test_state .test_full_data_requests( @@ -1068,6 +1658,7 @@ fn fast_path_backing_group_recovers_if_pov_small() { candidate_hash, &mut virtual_overseer, who_has, + GroupIndex(0), ) .await; @@ -1077,14 +1668,31 @@ fn fast_path_backing_group_recovers_if_pov_small() { }); } -#[test] -fn no_answers_in_fast_path_causes_chunk_requests() { +#[rstest] +#[case(true)] +#[case(false)] +fn no_answers_in_fast_path_causes_chunk_requests(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_fast_path( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_fast_path_then_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_fast_path( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1104,12 +1712,15 @@ fn no_answers_in_fast_path_causes_chunk_requests() { test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -1127,6 +1738,7 @@ fn no_answers_in_fast_path_causes_chunk_requests() { candidate_hash, &mut virtual_overseer, who_has, + GroupIndex(0), ) .await; @@ -1137,8 +1749,9 @@ fn no_answers_in_fast_path_causes_chunk_requests() { &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold(), + threshold, |_| Has::Yes, + systematic_recovery, ) .await; @@ -1148,14 +1761,25 @@ fn no_answers_in_fast_path_causes_chunk_requests() { }); } -#[test] -fn task_canceled_when_receivers_dropped() { +#[rstest] +#[case(true)] +#[case(false)] +fn task_canceled_when_receivers_dropped(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1175,12 +1799,15 @@ fn task_canceled_when_receivers_dropped() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; for _ in 0..test_state.validators.len() { match virtual_overseer.recv().timeout(TIMEOUT).await { @@ -1193,14 +1820,24 @@ fn task_canceled_when_receivers_dropped() { }); } -#[test] -fn chunks_retry_until_all_nodes_respond() { +#[rstest] +#[case(true)] +#[case(false)] +fn chunks_retry_until_all_nodes_respond(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1219,30 +1856,51 @@ fn chunks_retry_until_all_nodes_respond() { AvailabilityRecoveryMessage::RecoverAvailableData( test_state.candidate.clone(), test_state.session_index, - Some(GroupIndex(0)), + None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + if systematic_recovery { + for _ in 0..SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT { + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.systematic_threshold(), + |_| Has::timeout(), + true, + ) + .await; + } + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + test_state .test_chunk_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.validators.len() - test_state.threshold(), + test_state.impossibility_threshold(), |_| Has::timeout(), + false, ) .await; - // we get to go another round! + // We get to go another round! Actually, we get to go `REGULAR_CHUNKS_REQ_RETRY_LIMIT` + // number of times. test_state .test_chunk_requests( &req_protocol_names, @@ -1250,21 +1908,23 @@ fn chunks_retry_until_all_nodes_respond() { &mut virtual_overseer, test_state.impossibility_threshold(), |_| Has::No, + false, ) .await; - // Recovered data should match the original one. + // Recovery is impossible. assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); virtual_overseer }); } #[test] -fn not_returning_requests_wont_stall_retrieval() { +fn network_bridge_not_returning_responses_wont_stall_retrieval() { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( + let subsystem = with_chunks_only( request_receiver(&req_protocol_names), + &req_protocol_names, Metrics::new_dummy(), ); @@ -1286,12 +1946,15 @@ fn not_returning_requests_wont_stall_retrieval() { test_state.candidate.clone(), test_state.session_index, Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); @@ -1309,6 +1972,7 @@ fn not_returning_requests_wont_stall_retrieval() { &mut virtual_overseer, not_returning_count, |_| Has::DoesNotReturn, + false, ) .await; @@ -1320,6 +1984,7 @@ fn not_returning_requests_wont_stall_retrieval() { // Should start over: test_state.validators.len() + 3, |_| Has::timeout(), + false, ) .await; @@ -1331,6 +1996,7 @@ fn not_returning_requests_wont_stall_retrieval() { &mut virtual_overseer, test_state.threshold(), |_| Has::Yes, + false, ) .await; @@ -1340,14 +2006,24 @@ fn not_returning_requests_wont_stall_retrieval() { }); } -#[test] -fn all_not_returning_requests_still_recovers_on_return() { +#[rstest] +#[case(true)] +#[case(false)] +fn all_not_returning_requests_still_recovers_on_return(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1366,46 +2042,64 @@ fn all_not_returning_requests_still_recovers_on_return() { AvailabilityRecoveryMessage::RecoverAvailableData( test_state.candidate.clone(), test_state.session_index, - Some(GroupIndex(0)), + None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + let n = if systematic_recovery { + test_state.systematic_threshold() + } else { + test_state.validators.len() + }; let senders = test_state .test_chunk_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.validators.len(), + n, |_| Has::DoesNotReturn, + systematic_recovery, ) .await; future::join( async { Delay::new(Duration::from_millis(10)).await; - // Now retrieval should be able to recover. + // Now retrieval should be able progress. std::mem::drop(senders); }, - test_state.test_chunk_requests( - &req_protocol_names, - candidate_hash, - &mut virtual_overseer, - // Should start over: - test_state.validators.len() + 3, - |_| Has::timeout(), - ), + async { + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + // Should start over: + n, + |_| Has::timeout(), + systematic_recovery, + ) + .await + }, ) .await; + if systematic_recovery { + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + // we get to go another round! test_state .test_chunk_requests( @@ -1414,6 +2108,7 @@ fn all_not_returning_requests_still_recovers_on_return() { &mut virtual_overseer, test_state.threshold(), |_| Has::Yes, + false, ) .await; @@ -1423,14 +2118,24 @@ fn all_not_returning_requests_still_recovers_on_return() { }); } -#[test] -fn returns_early_if_we_have_the_data() { +#[rstest] +#[case(true)] +#[case(false)] +fn returns_early_if_we_have_the_data(#[case] systematic_recovery: bool) { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( - request_receiver(&req_protocol_names), - Metrics::new_dummy(), - ); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; test_harness(subsystem, |mut virtual_overseer| async move { overseer_signal( @@ -1450,12 +2155,15 @@ fn returns_early_if_we_have_the_data() { test_state.candidate.clone(), test_state.session_index, None, + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; test_state.respond_to_available_data_query(&mut virtual_overseer, true).await; assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); @@ -1464,11 +2172,12 @@ fn returns_early_if_we_have_the_data() { } #[test] -fn does_not_query_local_validator() { +fn returns_early_if_present_in_the_subsystem_cache() { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( + let subsystem = with_fast_path( request_receiver(&req_protocol_names), + &req_protocol_names, Metrics::new_dummy(), ); @@ -1489,50 +2198,812 @@ fn does_not_query_local_validator() { AvailabilityRecoveryMessage::RecoverAvailableData( test_state.candidate.clone(), test_state.session_index, - None, + Some(GroupIndex(0)), + Some(test_state.core_index), tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; - test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; - test_state.respond_to_query_all_request(&mut virtual_overseer, |i| i == 0).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; let candidate_hash = test_state.candidate.hash(); + let who_has = |i| match i { + 3 => Has::Yes, + _ => Has::No, + }; + + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state - .test_chunk_requests( + .test_full_data_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.validators.len(), - |i| if i == 0 { panic!("requested from local validator") } else { Has::timeout() }, + who_has, + GroupIndex(0), ) .await; - // second round, make sure it uses the local chunk. - test_state - .test_chunk_requests( - &req_protocol_names, + // Recovered data should match the original one. + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + + // A second recovery for the same candidate will return early as it'll be present in the + // cache. + let (tx, rx) = oneshot::channel(); + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + Some(GroupIndex(0)), + Some(test_state.core_index), + tx, + ), + ) + .await; + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + + virtual_overseer + }); +} + +#[rstest] +#[case(true)] +#[case(false)] +fn does_not_query_local_validator(#[case] systematic_recovery: bool) { + let test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state + .respond_to_query_all_request(&mut virtual_overseer, |i| i.0 == 0) + .await; + + let candidate_hash = test_state.candidate.hash(); + + // second round, make sure it uses the local chunk. + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + threshold - 1, + |i| if i.0 == 0 { panic!("requested from local validator") } else { Has::Yes }, + systematic_recovery, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + virtual_overseer + }); +} + +#[rstest] +#[case(true)] +#[case(false)] +fn invalid_local_chunk(#[case] systematic_recovery: bool) { + let test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + + let validator_index_for_first_chunk = test_state + .chunks + .iter() + .enumerate() + .find_map(|(val_idx, chunk)| if chunk.index.0 == 0 { Some(val_idx) } else { None }) + .unwrap() as u32; + + test_state + .respond_to_query_all_request_invalid(&mut virtual_overseer, |i| { + i.0 == validator_index_for_first_chunk + }) + .await; + + let candidate_hash = test_state.candidate.hash(); + + // If systematic recovery detects invalid local chunk, it'll directly go to regular + // recovery, if we were the one holding an invalid chunk. + if systematic_recovery { + test_state + .respond_to_query_all_request_invalid(&mut virtual_overseer, |i| { + i.0 == validator_index_for_first_chunk + }) + .await; + } + + test_state + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.threshold(), + |i| { + if i.0 == validator_index_for_first_chunk { + panic!("requested from local validator") + } else { + Has::Yes + } + }, + false, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + virtual_overseer + }); +} + +#[test] +fn systematic_chunks_are_not_requested_again_in_regular_recovery() { + // Run this test multiple times, as the order in which requests are made is random and we want + // to make sure that we catch regressions. + for _ in 0..TestState::default().chunks.len() { + let test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let subsystem = with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ); + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + let validator_index_for_first_chunk = test_state + .chunks + .iter() + .enumerate() + .find_map(|(val_idx, chunk)| if chunk.index.0 == 0 { Some(val_idx) } else { None }) + .unwrap() as u32; + + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + test_state.systematic_threshold(), + |i| if i.0 == validator_index_for_first_chunk { Has::No } else { Has::Yes }, + true, + ) + .await; + + // Falls back to regular recovery, since one validator returned a fatal error. + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + 1, + |i| { + if (test_state.chunks.get(i).unwrap().index.0 as usize) < + test_state.systematic_threshold() + { + panic!("Already requested") + } else { + Has::Yes + } + }, + false, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + virtual_overseer + }); + } +} + +#[rstest] +#[case(true, true)] +#[case(true, false)] +#[case(false, true)] +#[case(false, false)] +fn chunk_indices_are_mapped_to_different_validators( + #[case] systematic_recovery: bool, + #[case] mapping_enabled: bool, +) { + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let test_state = match mapping_enabled { + true => TestState::default(), + false => TestState::with_empty_node_features(), + }; + let subsystem = match systematic_recovery { + true => with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + false => with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, _rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + let mut chunk_indices: Vec<(u32, u32)> = vec![]; + + assert_matches!( + overseer_recv(&mut virtual_overseer).await, + AllMessages::NetworkBridgeTx( + NetworkBridgeTxMessage::SendRequests( + requests, + _if_disconnected, + ) + ) => { + for req in requests { + assert_matches!( + req, + Requests::ChunkFetching(req) => { + assert_eq!(req.payload.candidate_hash, test_state.candidate.hash()); + + let validator_index = req.payload.index; + let chunk_index = test_state.chunks.get(validator_index).unwrap().index; + + if systematic_recovery && mapping_enabled { + assert!((chunk_index.0 as usize) <= test_state.systematic_threshold(), "requested non-systematic chunk"); + } + + chunk_indices.push((chunk_index.0, validator_index.0)); + } + ) + } + } + ); + + if mapping_enabled { + assert!(!chunk_indices.iter().any(|(c_index, v_index)| c_index == v_index)); + } else { + assert!(chunk_indices.iter().all(|(c_index, v_index)| c_index == v_index)); + } + + virtual_overseer + }); +} + +#[rstest] +#[case(true, false)] +#[case(false, true)] +#[case(false, false)] +fn number_of_request_retries_is_bounded( + #[case] systematic_recovery: bool, + #[case] should_fail: bool, +) { + let mut test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + // We need the number of validators to be evenly divisible by the threshold for this test to be + // easier to write. + let n_validators = 6; + test_state.validators.truncate(n_validators); + test_state.validator_authority_id.truncate(n_validators); + let mut temp = test_state.validator_public.to_vec(); + temp.truncate(n_validators); + test_state.validator_public = temp.into(); + + let (chunks, erasure_root) = derive_erasure_chunks_with_proofs_and_root( + n_validators, + &test_state.available_data, + |_, _| {}, + ); + test_state.chunks = + map_chunks(chunks, &test_state.node_features, n_validators, test_state.core_index); + test_state.candidate.descriptor.erasure_root = erasure_root; + + let (subsystem, retry_limit) = match systematic_recovery { + false => ( + with_chunks_only( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + REGULAR_CHUNKS_REQ_RETRY_LIMIT, + ), + true => ( + with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT, + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + let validator_count_per_iteration = if systematic_recovery { + test_state.systematic_threshold() + } else { + test_state.chunks.len() + }; + + // Network errors are considered non-fatal but should be retried a limited number of times. + for _ in 1..retry_limit { + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + validator_count_per_iteration, + |_| Has::timeout(), + systematic_recovery, + ) + .await; + } + + if should_fail { + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + validator_count_per_iteration, + |_| Has::timeout(), + systematic_recovery, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + } else { + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + test_state.threshold(), + |_| Has::Yes, + systematic_recovery, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + } + + virtual_overseer + }); +} + +#[test] +fn systematic_recovery_retries_from_backers() { + let test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let subsystem = with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ); + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + let group_index = GroupIndex(2); + let group_size = test_state.validator_groups.get(group_index).unwrap().len(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + Some(group_index), + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + let mut cnt = 0; + + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + test_state.systematic_threshold(), + |_| { + let res = if cnt < group_size { Has::timeout() } else { Has::Yes }; + cnt += 1; + res + }, + true, + ) + .await; + + // Exhaust retries. + for _ in 0..(SYSTEMATIC_CHUNKS_REQ_RETRY_LIMIT - 1) { + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + group_size, + |_| Has::No, + true, + ) + .await; + } + + // Now, final chance is to try from a backer. + test_state + .test_chunk_requests( + &req_protocol_names, + test_state.candidate.hash(), + &mut virtual_overseer, + group_size, + |_| Has::Yes, + true, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + virtual_overseer + }); +} + +#[rstest] +#[case(true)] +#[case(false)] +fn test_legacy_network_protocol_with_mapping_disabled(#[case] systematic_recovery: bool) { + // In this case, when the mapping is disabled, recovery will work with both v2 and v1 requests, + // under the assumption that ValidatorIndex is always equal to ChunkIndex. However, systematic + // recovery will not be possible, it will fall back to regular recovery. + let test_state = TestState::with_empty_node_features(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_fast_path( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + + let candidate_hash = test_state.candidate.hash(); + + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + test_state + .test_chunk_requests_v1( + &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold() - 1, - |i| if i == 0 { panic!("requested from local validator") } else { Has::Yes }, + threshold, + |_| Has::Yes, + false, ) .await; + // Recovered data should match the original one. assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); virtual_overseer }); } +#[rstest] +#[case(true)] +#[case(false)] +fn test_legacy_network_protocol_with_mapping_enabled(#[case] systematic_recovery: bool) { + // In this case, when the mapping is enabled, we MUST only use v2. Recovery should fail for v1. + let test_state = TestState::default(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let (subsystem, threshold) = match systematic_recovery { + true => ( + with_systematic_chunks( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.systematic_threshold(), + ), + false => ( + with_fast_path( + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ), + test_state.threshold(), + ), + }; + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + + let candidate_hash = test_state.candidate.hash(); + + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + if systematic_recovery { + test_state + .test_chunk_requests_v1( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + threshold, + |_| Has::Yes, + systematic_recovery, + ) + .await; + + // Systematic recovery failed, trying regular recovery. + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + } + + test_state + .test_chunk_requests_v1( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.validators.len() - test_state.threshold(), + |_| Has::Yes, + false, + ) + .await; + + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + virtual_overseer + }); +} + #[test] -fn invalid_local_chunk_is_ignored() { +fn test_systematic_recovery_skipped_if_no_core_index() { let test_state = TestState::default(); let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); - let subsystem = AvailabilityRecoverySubsystem::with_chunks_only( + let subsystem = with_systematic_chunks( request_receiver(&req_protocol_names), + &req_protocol_names, Metrics::new_dummy(), ); @@ -1554,30 +3025,99 @@ fn invalid_local_chunk_is_ignored() { test_state.candidate.clone(), test_state.session_index, None, + None, tx, ), ) .await; - test_state.test_runtime_api(&mut virtual_overseer).await; + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + + let candidate_hash = test_state.candidate.hash(); + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + // Systematic recovery not possible without core index, falling back to regular recovery. test_state - .respond_to_query_all_request_invalid(&mut virtual_overseer, |i| i == 0) + .test_chunk_requests( + &req_protocol_names, + candidate_hash, + &mut virtual_overseer, + test_state.validators.len() - test_state.threshold(), + |_| Has::No, + false, + ) .await; + // Make it fail, in order to assert that indeed regular recovery was attempted. If it were + // systematic recovery, we would have had one more attempt for regular reconstruction. + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); + virtual_overseer + }); +} + +#[test] +fn test_systematic_recovery_skipped_if_mapping_disabled() { + let test_state = TestState::with_empty_node_features(); + let req_protocol_names = ReqProtocolNames::new(&GENESIS_HASH, None); + let subsystem = AvailabilityRecoverySubsystem::for_validator( + None, + request_receiver(&req_protocol_names), + &req_protocol_names, + Metrics::new_dummy(), + ); + + test_harness(subsystem, |mut virtual_overseer| async move { + overseer_signal( + &mut virtual_overseer, + OverseerSignal::ActiveLeaves(ActiveLeavesUpdate::start_work(new_leaf( + test_state.current, + 1, + ))), + ) + .await; + + let (tx, rx) = oneshot::channel(); + + overseer_send( + &mut virtual_overseer, + AvailabilityRecoveryMessage::RecoverAvailableData( + test_state.candidate.clone(), + test_state.session_index, + None, + Some(test_state.core_index), + tx, + ), + ) + .await; + + test_state.test_runtime_api_session_info(&mut virtual_overseer).await; + + test_state.test_runtime_api_node_features(&mut virtual_overseer).await; + let candidate_hash = test_state.candidate.hash(); + test_state.respond_to_available_data_query(&mut virtual_overseer, false).await; + test_state.respond_to_query_all_request(&mut virtual_overseer, |_| false).await; + + // Systematic recovery not possible without core index, falling back to regular recovery. test_state .test_chunk_requests( &req_protocol_names, candidate_hash, &mut virtual_overseer, - test_state.threshold() - 1, - |i| if i == 0 { panic!("requested from local validator") } else { Has::Yes }, + test_state.validators.len() - test_state.threshold(), + |_| Has::No, + false, ) .await; - assert_eq!(rx.await.unwrap().unwrap(), test_state.available_data); + // Make it fail, in order to assert that indeed regular recovery was attempted. If it were + // systematic recovery, we would have had one more attempt for regular reconstruction. + assert_eq!(rx.await.unwrap().unwrap_err(), RecoveryError::Unavailable); virtual_overseer }); } diff --git a/polkadot/node/network/bitfield-distribution/Cargo.toml b/polkadot/node/network/bitfield-distribution/Cargo.toml index 6b5b784b7fd899713c4ccbce2f9dec649a50f933..6d007255c574fc35aff7142e244113dd8022e56d 100644 --- a/polkadot/node/network/bitfield-distribution/Cargo.toml +++ b/polkadot/node/network/bitfield-distribution/Cargo.toml @@ -10,26 +10,25 @@ license.workspace = true workspace = true [dependencies] -always-assert = "0.1" -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-network-protocol = { path = "../protocol" } -rand = "0.8" +always-assert = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } [dev-dependencies] -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -maplit = "1.0.2" -log = { workspace = true, default-features = true } -env_logger = "0.11" -assert_matches = "1.4.0" -rand_chacha = "0.3.1" +polkadot-node-subsystem-test-helpers = { workspace = true } +bitvec = { features = ["alloc"], workspace = true } +sp-core = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +maplit = { workspace = true } +sp-tracing = { workspace = true } +assert_matches = { workspace = true } +rand_chacha = { workspace = true, default-features = true } diff --git a/polkadot/node/network/bitfield-distribution/src/tests.rs b/polkadot/node/network/bitfield-distribution/src/tests.rs index dc37f73ec8a12fdf2ae3a44b41fef6902e0e9998..4ed4bf6b38c50ca837456db70881f32cf4b43f5f 100644 --- a/polkadot/node/network/bitfield-distribution/src/tests.rs +++ b/polkadot/node/network/bitfield-distribution/src/tests.rs @@ -137,10 +137,7 @@ fn state_with_view( #[test] fn receive_invalid_signature() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash_a: Hash = [0; 32].into(); @@ -254,10 +251,7 @@ fn receive_invalid_signature() { #[test] fn receive_invalid_validator_index() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash_a: Hash = [0; 32].into(); let hash_b: Hash = [1; 32].into(); // other @@ -317,10 +311,7 @@ fn receive_invalid_validator_index() { #[test] fn receive_duplicate_messages() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash_a: Hash = [0; 32].into(); let hash_b: Hash = [1; 32].into(); @@ -442,10 +433,7 @@ fn receive_duplicate_messages() { fn delay_reputation_change() { use polkadot_node_subsystem_util::reputation::add_reputation; - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash_a: Hash = [0; 32].into(); let hash_b: Hash = [1; 32].into(); @@ -550,10 +538,7 @@ fn delay_reputation_change() { #[test] fn do_not_relay_message_twice() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash = Hash::random(); @@ -658,10 +643,7 @@ fn do_not_relay_message_twice() { #[test] fn changing_view() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash_a: Hash = [0; 32].into(); let hash_b: Hash = [1; 32].into(); @@ -833,10 +815,7 @@ fn changing_view() { #[test] fn do_not_send_message_back_to_origin() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash: Hash = [0; 32].into(); @@ -920,10 +899,7 @@ fn do_not_send_message_back_to_origin() { #[test] fn topology_test() { - let _ = env_logger::builder() - .filter(None, log::LevelFilter::Trace) - .is_test(true) - .try_init(); + sp_tracing::init_for_tests(); let hash: Hash = [0; 32].into(); diff --git a/polkadot/node/network/bridge/Cargo.toml b/polkadot/node/network/bridge/Cargo.toml index 9c2423e7e5810c3406ab4f40c219dbd8001245bb..b4b5743853cd6dc2b43cce5d6b8c4d63bb893c8b 100644 --- a/polkadot/node/network/bridge/Cargo.toml +++ b/polkadot/node/network/bridge/Cargo.toml @@ -10,28 +10,28 @@ license.workspace = true workspace = true [dependencies] -always-assert = "0.1" -async-trait = "0.1.79" -futures = "0.3.30" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-primitives = { path = "../../../primitives" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sc-network = { path = "../../../../substrate/client/network" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -polkadot-node-metrics = { path = "../../metrics" } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-overseer = { path = "../../overseer" } -parking_lot = "0.12.1" -bytes = "1" -fatality = "0.0.6" +always-assert = { workspace = true } +async-trait = { workspace = true } +futures = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +codec = { features = ["derive"], workspace = true } +sc-network = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } +bytes = { workspace = true, default-features = true } +fatality = { workspace = true } thiserror = { workspace = true } [dev-dependencies] -assert_matches = "1.4.0" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -futures-timer = "3" -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } +assert_matches = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +futures-timer = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/network/bridge/src/lib.rs b/polkadot/node/network/bridge/src/lib.rs index 0305aaa067ccd5dbeb571ee3c9531417ac32818b..0db18bc219a9f00bbb57662e2d051c8405d4cf3a 100644 --- a/polkadot/node/network/bridge/src/lib.rs +++ b/polkadot/node/network/bridge/src/lib.rs @@ -21,8 +21,8 @@ #![deny(unused_crate_dependencies)] #![warn(missing_docs)] +use codec::{Decode, Encode}; use futures::prelude::*; -use parity_scale_codec::{Decode, Encode}; use parking_lot::Mutex; use sp_consensus::SyncOracle; diff --git a/polkadot/node/network/bridge/src/network.rs b/polkadot/node/network/bridge/src/network.rs index 5691c8413ad997daf80fcd551b4265031d563d88..1f438df2d148cc8ebaffba08d98d2220c8745685 100644 --- a/polkadot/node/network/bridge/src/network.rs +++ b/polkadot/node/network/bridge/src/network.rs @@ -22,7 +22,7 @@ use std::{ use async_trait::async_trait; use parking_lot::Mutex; -use parity_scale_codec::Encode; +use codec::Encode; use sc_network::{ config::parse_addr, multiaddr::Multiaddr, service::traits::NetworkService, types::ProtocolName, @@ -177,7 +177,7 @@ fn send_message( // network used `Bytes` this would not be necessary. // // peer may have gotten disconnect by the time `send_message()` is called - // at which point the the sink is not available. + // at which point the sink is not available. let last_peer = peers.pop(); peers.into_iter().for_each(|peer| { if let Some(sink) = notification_sinks.get(&(peer_set, peer)) { @@ -204,6 +204,13 @@ pub trait Network: Clone + Send + 'static { multiaddresses: HashSet, ) -> Result<(), String>; + /// Ask the network to extend the reserved set with these nodes. + async fn add_peers_to_reserved_set( + &mut self, + protocol: ProtocolName, + multiaddresses: HashSet, + ) -> Result<(), String>; + /// Removes the peers for the protocol's peer set (both reserved and non-reserved). async fn remove_from_peers_set( &mut self, @@ -240,6 +247,14 @@ impl Network for Arc { ::set_reserved_peers(&**self, protocol, multiaddresses) } + async fn add_peers_to_reserved_set( + &mut self, + protocol: ProtocolName, + multiaddresses: HashSet, + ) -> Result<(), String> { + ::add_peers_to_reserved_set(&**self, protocol, multiaddresses) + } + async fn remove_from_peers_set( &mut self, protocol: ProtocolName, diff --git a/polkadot/node/network/bridge/src/rx/mod.rs b/polkadot/node/network/bridge/src/rx/mod.rs index 0a4497fc4b5a22639e516598a15557f08227c969..7745c42f78a173b2c835f4b575171bd25146341e 100644 --- a/polkadot/node/network/bridge/src/rx/mod.rs +++ b/polkadot/node/network/bridge/src/rx/mod.rs @@ -20,8 +20,8 @@ use super::*; use always_assert::never; use bytes::Bytes; +use codec::{Decode, DecodeAll}; use net_protocol::filter_by_peer_version; -use parity_scale_codec::{Decode, DecodeAll}; use parking_lot::Mutex; use sc_network::{ @@ -962,6 +962,21 @@ fn update_our_view( ) }; + let our_view = OurView::new( + live_heads.iter().take(MAX_VIEW_HEADS).cloned().map(|a| (a.hash, a.span)), + finalized_number, + ); + + dispatch_validation_event_to_all_unbounded( + NetworkBridgeEvent::OurViewChange(our_view.clone()), + ctx.sender(), + ); + + dispatch_collation_event_to_all_unbounded( + NetworkBridgeEvent::OurViewChange(our_view), + ctx.sender(), + ); + let v1_validation_peers = filter_by_peer_version(&validation_peers, ValidationVersion::V1.into()); let v1_collation_peers = filter_by_peer_version(&collation_peers, CollationVersion::V1.into()); @@ -1007,21 +1022,6 @@ fn update_our_view( metrics, notification_sinks, ); - - let our_view = OurView::new( - live_heads.iter().take(MAX_VIEW_HEADS).cloned().map(|a| (a.hash, a.span)), - finalized_number, - ); - - dispatch_validation_event_to_all_unbounded( - NetworkBridgeEvent::OurViewChange(our_view.clone()), - ctx.sender(), - ); - - dispatch_collation_event_to_all_unbounded( - NetworkBridgeEvent::OurViewChange(our_view), - ctx.sender(), - ); } // Handle messages on a specific v1 peer-set. The peer is expected to be connected on that @@ -1135,13 +1135,33 @@ async fn dispatch_validation_events_to_all( I: IntoIterator>, I::IntoIter: Send, { + macro_rules! send_message { + ($event:expr, $message:ident) => { + if let Ok(event) = $event.focus() { + let has_high_priority = matches!( + event, + // NetworkBridgeEvent::OurViewChange(..) must also be here, + // but it is sent via an unbounded channel. + // See https://github.com/paritytech/polkadot-sdk/issues/824 + NetworkBridgeEvent::PeerConnected(..) | + NetworkBridgeEvent::PeerDisconnected(..) | + NetworkBridgeEvent::PeerViewChange(..) + ); + let message = $message::from(event); + if has_high_priority { + sender.send_message_with_priority::(message).await; + } else { + sender.send_message(message).await; + } + } + }; + } + for event in events { - sender - .send_messages(event.focus().map(StatementDistributionMessage::from)) - .await; - sender.send_messages(event.focus().map(BitfieldDistributionMessage::from)).await; - sender.send_messages(event.focus().map(ApprovalDistributionMessage::from)).await; - sender.send_messages(event.focus().map(GossipSupportMessage::from)).await; + send_message!(event, StatementDistributionMessage); + send_message!(event, BitfieldDistributionMessage); + send_message!(event, ApprovalDistributionMessage); + send_message!(event, GossipSupportMessage); } } diff --git a/polkadot/node/network/bridge/src/rx/tests.rs b/polkadot/node/network/bridge/src/rx/tests.rs index 6182bf3d883b5be19231d534babf1c70973da00d..601dca5cb8a3c4db817d2c4681058392b9f7686f 100644 --- a/polkadot/node/network/bridge/src/rx/tests.rs +++ b/polkadot/node/network/bridge/src/rx/tests.rs @@ -124,6 +124,14 @@ impl Network for TestNetwork { Ok(()) } + async fn add_peers_to_reserved_set( + &mut self, + _protocol: ProtocolName, + _: HashSet, + ) -> Result<(), String> { + Ok(()) + } + async fn remove_from_peers_set( &mut self, _protocol: ProtocolName, @@ -880,6 +888,8 @@ fn peer_view_updates_sent_via_overseer() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } network_handle @@ -895,6 +905,7 @@ fn peer_view_updates_sent_via_overseer() { &mut virtual_overseer, ) .await; + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 12); virtual_overseer }); } @@ -930,6 +941,8 @@ fn peer_messages_sent_via_overseer() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } let approval_distribution_message = @@ -970,6 +983,7 @@ fn peer_messages_sent_via_overseer() { &mut virtual_overseer, ) .await; + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 12); virtual_overseer }); } @@ -1008,6 +1022,8 @@ fn peer_disconnect_from_just_one_peerset() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } { @@ -1036,6 +1052,7 @@ fn peer_disconnect_from_just_one_peerset() { &mut virtual_overseer, ) .await; + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 12); // to show that we're still connected on the collation protocol, send a view update. @@ -1094,6 +1111,8 @@ fn relays_collation_protocol_messages() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } { @@ -1201,6 +1220,8 @@ fn different_views_on_different_peer_sets() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } { @@ -1247,6 +1268,8 @@ fn different_views_on_different_peer_sets() { ) .await; + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 12); + assert_sends_collation_event_to_all( NetworkBridgeEvent::PeerViewChange(peer, view_b.clone()), &mut virtual_overseer, @@ -1481,6 +1504,8 @@ fn network_protocol_versioning_subsystem_msg() { &mut virtual_overseer, ) .await; + + assert_eq!(virtual_overseer.message_counter.with_high_priority(), 8); } let approval_distribution_message = diff --git a/polkadot/node/network/bridge/src/tx/mod.rs b/polkadot/node/network/bridge/src/tx/mod.rs index d5be6f01c33737a2b09bd39f40640d29c99ca94c..6c353195d41ada27a579fba83f8d86979b3ca407 100644 --- a/polkadot/node/network/bridge/src/tx/mod.rs +++ b/polkadot/node/network/bridge/src/tx/mod.rs @@ -301,7 +301,15 @@ where for req in reqs { match req { - Requests::ChunkFetchingV1(_) => metrics.on_message("chunk_fetching_v1"), + Requests::ChunkFetching(ref req) => { + // This is not the actual request that will succeed, as we don't know yet + // what that will be. It's only the primary request we tried. + if req.fallback_request.is_some() { + metrics.on_message("chunk_fetching_v2") + } else { + metrics.on_message("chunk_fetching_v1") + } + }, Requests::AvailableDataFetchingV1(_) => metrics.on_message("available_data_fetching_v1"), Requests::CollationFetchingV1(_) => metrics.on_message("collation_fetching_v1"), @@ -362,6 +370,22 @@ where .await; return (network_service, authority_discovery_service) }, + + NetworkBridgeTxMessage::AddToResolvedValidators { validator_addrs, peer_set } => { + gum::trace!( + target: LOG_TARGET, + action = "AddToResolvedValidators", + peer_set = ?peer_set, + ?validator_addrs, + "Received a resolved validator connection request", + ); + + let all_addrs = validator_addrs.into_iter().flatten().collect(); + let network_service = validator_discovery + .on_add_to_resolved_request(all_addrs, peer_set, network_service) + .await; + return (network_service, authority_discovery_service) + }, } (network_service, authority_discovery_service) } diff --git a/polkadot/node/network/bridge/src/tx/tests.rs b/polkadot/node/network/bridge/src/tx/tests.rs index c3cf0f322f681b5cf2bca5c7a8bbadd53553a90d..30b2c3421372a44d7e2c3716fdb280ab5ecbf887 100644 --- a/polkadot/node/network/bridge/src/tx/tests.rs +++ b/polkadot/node/network/bridge/src/tx/tests.rs @@ -26,7 +26,7 @@ use sc_network::{ IfDisconnected, ObservedRole as SubstrateObservedRole, ProtocolName, ReputationChange, Roles, }; -use parity_scale_codec::DecodeAll; +use codec::DecodeAll; use polkadot_node_network_protocol::{ peer_set::{PeerSetProtocolNames, ValidationVersion}, request_response::{outgoing::Requests, ReqProtocolNames}, @@ -148,6 +148,14 @@ impl Network for TestNetwork { Ok(()) } + async fn add_peers_to_reserved_set( + &mut self, + _protocol: ProtocolName, + _: HashSet, + ) -> Result<(), String> { + Ok(()) + } + async fn remove_from_peers_set( &mut self, _protocol: ProtocolName, diff --git a/polkadot/node/network/bridge/src/validator_discovery.rs b/polkadot/node/network/bridge/src/validator_discovery.rs index b11af8a8a089c4aa64b26312562636b039068a78..9accd56d86ae603e5c5f37fbe18b550e55d47d47 100644 --- a/polkadot/node/network/bridge/src/validator_discovery.rs +++ b/polkadot/node/network/bridge/src/validator_discovery.rs @@ -88,16 +88,44 @@ impl Service { { gum::warn!(target: LOG_TARGET, err = ?e, "AuthorityDiscoveryService returned an invalid multiaddress"); } - // the addresses are known to be valid + + network_service + } + + /// Connect to already resolved addresses. + pub async fn on_add_to_resolved_request( + &mut self, + newly_requested: HashSet, + peer_set: PeerSet, + mut network_service: N, + ) -> N { + let state = &mut self.state[peer_set]; + let new_peer_ids: HashSet = extract_peer_ids(newly_requested.iter().cloned()); + let num_peers = new_peer_ids.len(); + + state.previously_requested.extend(new_peer_ids); + + gum::debug!( + target: LOG_TARGET, + ?peer_set, + ?num_peers, + "New add to resolved validators request", + ); + + // ask the network to connect to these nodes and not disconnect + // from them until they are removed from the set. // // for peer-set management, the main protocol name should be used regardless of // the negotiated version. - let _ = network_service - .remove_from_peers_set( + if let Err(e) = network_service + .add_peers_to_reserved_set( self.peerset_protocol_names.get_main_name(peer_set), - peers_to_remove, + newly_requested, ) - .await; + .await + { + gum::warn!(target: LOG_TARGET, err = ?e, "AuthorityDiscoveryService returned an invalid multiaddress"); + } network_service } @@ -232,6 +260,15 @@ mod tests { Ok(()) } + async fn add_peers_to_reserved_set( + &mut self, + _protocol: ProtocolName, + multiaddresses: HashSet, + ) -> Result<(), String> { + self.peers_set.extend(extract_peer_ids(multiaddresses.into_iter())); + Ok(()) + } + async fn remove_from_peers_set( &mut self, _protocol: ProtocolName, diff --git a/polkadot/node/network/collator-protocol/Cargo.toml b/polkadot/node/network/collator-protocol/Cargo.toml index 2c7135742f56890a7ad147e95c545cbebde04c9b..8a7c384dcbe8b72acb895a253d0b4022b66fc147 100644 --- a/polkadot/node/network/collator-protocol/Cargo.toml +++ b/polkadot/node/network/collator-protocol/Cargo.toml @@ -10,38 +10,37 @@ license.workspace = true workspace = true [dependencies] -bitvec = { version = "1.0.1", default-features = false, features = ["alloc"] } -futures = "0.3.30" -futures-timer = "3" -gum = { package = "tracing-gum", path = "../../gum" } - -sp-core = { path = "../../../../substrate/primitives/core" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } - -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-subsystem = { path = "../../subsystem" } -fatality = "0.0.6" +bitvec = { features = ["alloc"], workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } + +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } + +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +fatality = { workspace = true } thiserror = { workspace = true } -tokio-util = "0.7.1" +tokio-util = { workspace = true } [dev-dependencies] -log = { workspace = true, default-features = true } -env_logger = "0.11" -assert_matches = "1.4.0" +sp-tracing = { workspace = true } +assert_matches = { workspace = true } +rstest = { workspace = true } -sp-core = { path = "../../../../substrate/primitives/core", features = ["std"] } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -sc-network = { path = "../../../../substrate/client/network" } -parity-scale-codec = { version = "3.6.1", features = ["std"] } +sp-core = { features = ["std"], workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +codec = { features = ["std"], workspace = true, default-features = true } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } [features] default = [] -elastic-scaling-experimental = [] diff --git a/polkadot/node/network/collator-protocol/src/collator_side/mod.rs b/polkadot/node/network/collator-protocol/src/collator_side/mod.rs index 879caf923285b3341a0bc28bc52371fb9c81ff69..401525d02f1150382d85e98c7e0996ef1d7ce235 100644 --- a/polkadot/node/network/collator-protocol/src/collator_side/mod.rs +++ b/polkadot/node/network/collator-protocol/src/collator_side/mod.rs @@ -48,8 +48,8 @@ use polkadot_node_subsystem_util::{ backing_implicit_view::View as ImplicitView, reputation::{ReputationAggregator, REPUTATION_CHANGE_INTERVAL}, runtime::{ - get_availability_cores, get_group_rotation_info, prospective_parachains_mode, - ProspectiveParachainsMode, RuntimeInfo, + fetch_claim_queue, get_availability_cores, get_group_rotation_info, + prospective_parachains_mode, ProspectiveParachainsMode, RuntimeInfo, }, TimeoutExt, }; @@ -261,10 +261,12 @@ struct State { /// `active_leaves`, the opposite doesn't hold true. /// /// Relay-chain blocks which don't support prospective parachains are - /// never included in the fragment trees of active leaves which do. In + /// never included in the fragment chains of active leaves which do. In /// particular, this means that if a given relay parent belongs to implicit /// ancestry of some active leaf, then it does support prospective parachains. - implicit_view: ImplicitView, + /// + /// It's `None` if the collator is not yet collating for a paraid. + implicit_view: Option, /// All active leaves observed by us, including both that do and do not /// support prospective parachains. This mapping works as a replacement for @@ -334,7 +336,7 @@ impl State { metrics, collating_on: Default::default(), peer_data: Default::default(), - implicit_view: Default::default(), + implicit_view: None, active_leaves: Default::default(), per_relay_parent: Default::default(), span_per_relay_parent: Default::default(), @@ -531,7 +533,7 @@ async fn distribute_collation( // Otherwise, it should be present in allowed ancestry of some leaf. // // It's collation-producer responsibility to verify that there exists - // a hypothetical membership in a fragment tree for candidate. + // a hypothetical membership in a fragment chain for the candidate. let interested = state .peer_data @@ -539,11 +541,12 @@ async fn distribute_collation( .filter(|(_, PeerData { view: v, .. })| match relay_parent_mode { ProspectiveParachainsMode::Disabled => v.contains(&candidate_relay_parent), ProspectiveParachainsMode::Enabled { .. } => v.iter().any(|block_hash| { - state - .implicit_view - .known_allowed_relay_parents_under(block_hash, Some(id)) - .unwrap_or_default() - .contains(&candidate_relay_parent) + state.implicit_view.as_ref().map(|implicit_view| { + implicit_view + .known_allowed_relay_parents_under(block_hash, Some(id)) + .unwrap_or_default() + .contains(&candidate_relay_parent) + }) == Some(true) }), }); @@ -576,22 +579,27 @@ async fn determine_cores( let cores = get_availability_cores(sender, relay_parent).await?; let n_cores = cores.len(); let mut assigned_cores = Vec::new(); + let maybe_claim_queue = fetch_claim_queue(sender, relay_parent).await?; for (idx, core) in cores.iter().enumerate() { - let core_para_id = match core { - CoreState::Scheduled(scheduled) => Some(scheduled.para_id), - CoreState::Occupied(occupied) => - if relay_parent_mode.is_enabled() { - // With async backing we don't care about the core state, - // it is only needed for figuring our validators group. - Some(occupied.candidate_descriptor.para_id) - } else { - None - }, - CoreState::Free => None, + let core_is_scheduled = match maybe_claim_queue { + Some(ref claim_queue) => { + // Runtime supports claim queue - use it. + claim_queue + .iter_claims_for_core(&CoreIndex(idx as u32)) + .any(|para| para == ¶_id) + }, + None => match core { + CoreState::Scheduled(scheduled) if scheduled.para_id == para_id => true, + CoreState::Occupied(occupied) if relay_parent_mode.is_enabled() => + // With async backing we don't care about the core state, + // it is only needed for figuring our validators group. + occupied.next_up_on_available.as_ref().map(|c| c.para_id) == Some(para_id), + _ => false, + }, }; - if core_para_id == Some(para_id) { + if core_is_scheduled { assigned_cores.push(CoreIndex::from(idx as u32)); } } @@ -830,6 +838,7 @@ async fn process_msg( match msg { CollateOn(id) => { state.collating_on = Some(id); + state.implicit_view = Some(ImplicitView::new(Some(id))); }, DistributeCollation { candidate_receipt, @@ -894,7 +903,7 @@ async fn process_msg( ); } }, - msg @ (ReportCollator(..) | Invalid(..) | Seconded(..) | Backed { .. }) => { + msg @ (ReportCollator(..) | Invalid(..) | Seconded(..)) => { gum::warn!( target: LOG_TARGET, "{:?} message is not expected on the collator side of the protocol", @@ -920,7 +929,6 @@ async fn send_collation( let peer_id = request.peer_id(); let candidate_hash = receipt.hash(); - #[cfg(feature = "elastic-scaling-experimental")] let result = match parent_head_data { ParentHeadData::WithData { head_data, .. } => Ok(request_v2::CollationFetchingResponse::CollationWithParentHeadData { @@ -931,13 +939,6 @@ async fn send_collation( ParentHeadData::OnlyHash(_) => Ok(request_v1::CollationFetchingResponse::Collation(receipt, pov)), }; - #[cfg(not(feature = "elastic-scaling-experimental"))] - let result = { - // suppress unused warning - let _parent_head_data = parent_head_data; - - Ok(request_v1::CollationFetchingResponse::Collation(receipt, pov)) - }; let response = OutgoingResponse { result, reputation_changes: Vec::new(), sent_feedback: Some(tx) }; @@ -1215,7 +1216,10 @@ async fn handle_peer_view_change( Some(ProspectiveParachainsMode::Disabled) => std::slice::from_ref(&added), Some(ProspectiveParachainsMode::Enabled { .. }) => state .implicit_view - .known_allowed_relay_parents_under(&added, state.collating_on) + .as_ref() + .and_then(|implicit_view| { + implicit_view.known_allowed_relay_parents_under(&added, state.collating_on) + }) .unwrap_or_default(), None => { gum::trace!( @@ -1353,21 +1357,22 @@ where state.per_relay_parent.insert(*leaf, PerRelayParent::new(mode)); if mode.is_enabled() { - state - .implicit_view - .activate_leaf(sender, *leaf) - .await - .map_err(Error::ImplicitViewFetchError)?; + if let Some(ref mut implicit_view) = state.implicit_view { + implicit_view + .activate_leaf(sender, *leaf) + .await + .map_err(Error::ImplicitViewFetchError)?; - let allowed_ancestry = state - .implicit_view - .known_allowed_relay_parents_under(leaf, state.collating_on) - .unwrap_or_default(); - for block_hash in allowed_ancestry { - state - .per_relay_parent - .entry(*block_hash) - .or_insert_with(|| PerRelayParent::new(mode)); + let allowed_ancestry = implicit_view + .known_allowed_relay_parents_under(leaf, state.collating_on) + .unwrap_or_default(); + + for block_hash in allowed_ancestry { + state + .per_relay_parent + .entry(*block_hash) + .or_insert_with(|| PerRelayParent::new(mode)); + } } } } @@ -1378,7 +1383,11 @@ where // of implicit ancestry. Only update the state after the hash is actually // pruned from the block info storage. let pruned = if mode.is_enabled() { - state.implicit_view.deactivate_leaf(*leaf) + state + .implicit_view + .as_mut() + .map(|view| view.deactivate_leaf(*leaf)) + .unwrap_or_default() } else { vec![*leaf] }; diff --git a/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs b/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs index 689e03ce4737bcdd39d0651009f212e3cb364eea..74a151c168dcab581d66e4f7be3530d703e0fdd9 100644 --- a/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs +++ b/polkadot/node/network/collator-protocol/src/collator_side/tests/mod.rs @@ -16,13 +16,17 @@ use super::*; -use std::{collections::HashSet, sync::Arc, time::Duration}; +use std::{ + collections::{BTreeMap, HashSet, VecDeque}, + sync::Arc, + time::Duration, +}; use assert_matches::assert_matches; use futures::{executor, future, Future}; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use sc_network::config::IncomingRequest as RawIncomingRequest; use sp_core::crypto::Pair; @@ -66,7 +70,7 @@ struct TestState { group_rotation_info: GroupRotationInfo, validator_peer_id: Vec, relay_parent: Hash, - availability_cores: Vec, + claim_queue: BTreeMap>, local_peer_id: PeerId, collator_pair: CollatorPair, session_index: SessionIndex, @@ -105,8 +109,9 @@ impl Default for TestState { let group_rotation_info = GroupRotationInfo { session_start_block: 0, group_rotation_frequency: 100, now: 1 }; - let availability_cores = - vec![CoreState::Scheduled(ScheduledCore { para_id, collator: None }), CoreState::Free]; + let mut claim_queue = BTreeMap::new(); + claim_queue.insert(CoreIndex(0), [para_id].into_iter().collect()); + claim_queue.insert(CoreIndex(1), VecDeque::new()); let relay_parent = Hash::random(); @@ -133,7 +138,7 @@ impl Default for TestState { group_rotation_info, validator_peer_id, relay_parent, - availability_cores, + claim_queue, local_peer_id, collator_pair, session_index: 1, @@ -144,21 +149,17 @@ impl Default for TestState { impl TestState { /// Adds a few more scheduled cores to the state for the same para id /// compared to the default. - #[cfg(feature = "elastic-scaling-experimental")] pub fn with_elastic_scaling() -> Self { let mut state = Self::default(); let para_id = state.para_id; - state - .availability_cores - .push(CoreState::Scheduled(ScheduledCore { para_id, collator: None })); - state - .availability_cores - .push(CoreState::Scheduled(ScheduledCore { para_id, collator: None })); + + state.claim_queue.insert(CoreIndex(2), [para_id].into_iter().collect()); + state.claim_queue.insert(CoreIndex(3), [para_id].into_iter().collect()); state } fn current_group_validator_indices(&self) -> &[ValidatorIndex] { - let core_num = self.availability_cores.len(); + let core_num = self.claim_queue.len(); let GroupIndex(group_idx) = self.group_rotation_info.group_for_core(CoreIndex(0), core_num); &self.session_info.validator_groups.get(GroupIndex::from(group_idx)).unwrap() } @@ -223,7 +224,8 @@ impl TestState { } } -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; struct TestHarness { virtual_overseer: VirtualOverseer, @@ -237,15 +239,12 @@ fn test_harness>( reputation: ReputationAggregator, test: impl FnOnce(TestHarness) -> T, ) { - let _ = env_logger::builder() - .is_test(true) - .filter(Some("polkadot_collator_protocol"), log::LevelFilter::Trace) - .filter(Some(LOG_TARGET), log::LevelFilter::Trace) - .try_init(); + let _ = sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let genesis_hash = Hash::repeat_byte(0xff); let req_protocol_names = ReqProtocolNames::new(&genesis_hash, None); @@ -394,7 +393,36 @@ async fn distribute_collation_with_receipt( RuntimeApiRequest::AvailabilityCores(tx) )) => { assert_eq!(relay_parent, _relay_parent); - tx.send(Ok(test_state.availability_cores.clone())).unwrap(); + tx.send(Ok(test_state.claim_queue.values().map(|paras| + if let Some(para) = paras.front() { + CoreState::Scheduled(ScheduledCore { para_id: *para, collator: None }) + } else { + CoreState::Free + } + ).collect())).unwrap(); + } + ); + + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _relay_parent, + RuntimeApiRequest::Version(tx) + )) => { + assert_eq!(relay_parent, _relay_parent); + tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)).unwrap(); + } + ); + + // obtain the claim queue schedule. + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _relay_parent, + RuntimeApiRequest::ClaimQueue(tx) + )) => { + assert_eq!(relay_parent, _relay_parent); + tx.send(Ok(test_state.claim_queue.clone())).unwrap(); } ); diff --git a/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs b/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs index 707053545630a0a11603ccda030200eed7b5cfe2..ea8fdb0e04fbe0ba29303b62ae1d45c63d43cdf4 100644 --- a/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs +++ b/polkadot/node/network/collator-protocol/src/collator_side/tests/prospective_parachains.rs @@ -18,8 +18,8 @@ use super::*; -use polkadot_node_subsystem::messages::{ChainApiMessage, ProspectiveParachainsMessage}; -use polkadot_primitives::{AsyncBackingParams, Header, OccupiedCore}; +use polkadot_node_subsystem::messages::ChainApiMessage; +use polkadot_primitives::{AsyncBackingParams, Header}; const ASYNC_BACKING_PARAMETERS: AsyncBackingParams = AsyncBackingParams { max_candidate_depth: 4, allowed_ancestry_len: 3 }; @@ -31,7 +31,6 @@ fn get_parent_hash(hash: Hash) -> Hash { /// Handle a view update. async fn update_view( virtual_overseer: &mut VirtualOverseer, - test_state: &TestState, new_view: Vec<(Hash, u32)>, // Hash and block number. activated: u8, // How many new heads does this update contain? ) { @@ -61,21 +60,88 @@ async fn update_view( let min_number = leaf_number.saturating_sub(ASYNC_BACKING_PARAMETERS.allowed_ancestry_len); - assert_matches!( - overseer_recv(virtual_overseer).await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx), - ) if parent == leaf_hash => { - tx.send(vec![(test_state.para_id, min_number)]).unwrap(); - } - ); - let ancestry_len = leaf_number + 1 - min_number; let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h))) .take(ancestry_len as usize); let ancestry_numbers = (min_number..=leaf_number).rev(); let mut ancestry_iter = ancestry_hashes.clone().zip(ancestry_numbers).peekable(); + if let Some((hash, number)) = ancestry_iter.next() { + assert_matches!( + overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(), + AllMessages::ChainApi(ChainApiMessage::BlockHeader(.., tx)) => { + let header = Header { + parent_hash: get_parent_hash(hash), + number, + state_root: Hash::zero(), + extrinsics_root: Hash::zero(), + digest: Default::default(), + }; + + tx.send(Ok(Some(header))).unwrap(); + } + ); + + assert_matches!( + overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(), + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + .., + RuntimeApiRequest::AsyncBackingParams( + tx + ) + ) + ) => { + tx.send(Ok(ASYNC_BACKING_PARAMETERS)).unwrap(); + } + ); + + assert_matches!( + overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(), + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + .., + RuntimeApiRequest::SessionIndexForChild( + tx + ) + ) + ) => { + tx.send(Ok(1)).unwrap(); + } + ); + + assert_matches!( + overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(), + AllMessages::ChainApi( + ChainApiMessage::Ancestors { + k, + response_channel: tx, + .. + } + ) => { + assert_eq!(k, ASYNC_BACKING_PARAMETERS.allowed_ancestry_len as usize); + + tx.send(Ok(ancestry_hashes.clone().skip(1).into_iter().collect())).unwrap(); + } + ); + } + + for _ in ancestry_iter.clone() { + assert_matches!( + overseer_recv_with_timeout(virtual_overseer, Duration::from_millis(50)).await.unwrap(), + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + .., + RuntimeApiRequest::SessionIndexForChild( + tx + ) + ) + ) => { + tx.send(Ok(1)).unwrap(); + } + ); + } + while let Some((hash, number)) = ancestry_iter.next() { // May be `None` for the last element. let parent_hash = @@ -195,7 +261,7 @@ fn distribute_collation_from_implicit_view() { overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id)) .await; // Activated leaf is `b`, but the collation will be based on `c`. - update_view(virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await; + update_view(virtual_overseer, vec![(head_b, head_b_num)], 1).await; let validator_peer_ids = test_state.current_group_validator_peer_ids(); for (val, peer) in test_state @@ -258,7 +324,7 @@ fn distribute_collation_from_implicit_view() { // Head `c` goes out of view. // Build a different candidate for this relay parent and attempt to distribute it. - update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await; + update_view(virtual_overseer, vec![(head_a, head_a_num)], 1).await; let pov = PoV { block_data: BlockData(vec![4, 5, 6]) }; let parent_head_data_hash = Hash::repeat_byte(0xBB); @@ -318,7 +384,7 @@ fn distribute_collation_up_to_limit() { overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id)) .await; // Activated leaf is `a`, but the collation will be based on `b`. - update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await; + update_view(virtual_overseer, vec![(head_a, head_a_num)], 1).await; for i in 0..(ASYNC_BACKING_PARAMETERS.max_candidate_depth + 1) { let pov = PoV { block_data: BlockData(vec![i as u8]) }; @@ -377,7 +443,6 @@ fn distribute_collation_up_to_limit() { /// Tests that collator send the parent head data in /// case the para is assigned to multiple cores (elastic scaling). #[test] -#[cfg(feature = "elastic-scaling-experimental")] fn send_parent_head_data_for_elastic_scaling() { let test_state = TestState::with_elastic_scaling(); @@ -402,7 +467,7 @@ fn send_parent_head_data_for_elastic_scaling() { CollatorProtocolMessage::CollateOn(test_state.para_id), ) .await; - update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await; + update_view(&mut virtual_overseer, vec![(head_b, head_b_num)], 1).await; let pov_data = PoV { block_data: BlockData(vec![1 as u8]) }; let candidate = TestCandidateBuilder { @@ -517,8 +582,8 @@ fn advertise_and_send_collation_by_hash() { CollatorProtocolMessage::CollateOn(test_state.para_id), ) .await; - update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await; - update_view(&mut virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await; + update_view(&mut virtual_overseer, vec![(head_b, head_b_num)], 1).await; + update_view(&mut virtual_overseer, vec![(head_a, head_a_num)], 1).await; let candidates: Vec<_> = (0..2) .map(|i| { @@ -600,90 +665,3 @@ fn advertise_and_send_collation_by_hash() { }, ) } - -/// Tests that collator distributes collation built on top of occupied core. -#[test] -fn advertise_core_occupied() { - let mut test_state = TestState::default(); - let candidate = - TestCandidateBuilder { para_id: test_state.para_id, ..Default::default() }.build(); - test_state.availability_cores[0] = CoreState::Occupied(OccupiedCore { - next_up_on_available: None, - occupied_since: 0, - time_out_at: 0, - next_up_on_time_out: None, - availability: BitVec::default(), - group_responsible: GroupIndex(0), - candidate_hash: candidate.hash(), - candidate_descriptor: candidate.descriptor, - }); - - let local_peer_id = test_state.local_peer_id; - let collator_pair = test_state.collator_pair.clone(); - - test_harness( - local_peer_id, - collator_pair, - ReputationAggregator::new(|_| true), - |mut test_harness| async move { - let virtual_overseer = &mut test_harness.virtual_overseer; - - let head_a = Hash::from_low_u64_be(128); - let head_a_num: u32 = 64; - - // Grandparent of head `a`. - let head_b = Hash::from_low_u64_be(130); - - // Set collating para id. - overseer_send(virtual_overseer, CollatorProtocolMessage::CollateOn(test_state.para_id)) - .await; - // Activated leaf is `a`, but the collation will be based on `b`. - update_view(virtual_overseer, &test_state, vec![(head_a, head_a_num)], 1).await; - - let pov = PoV { block_data: BlockData(vec![1, 2, 3]) }; - let candidate = TestCandidateBuilder { - para_id: test_state.para_id, - relay_parent: head_b, - pov_hash: pov.hash(), - ..Default::default() - } - .build(); - let candidate_hash = candidate.hash(); - distribute_collation_with_receipt( - virtual_overseer, - &test_state, - head_b, - true, - candidate, - pov, - Hash::zero(), - ) - .await; - - let validators = test_state.current_group_validator_authority_ids(); - let peer_ids = test_state.current_group_validator_peer_ids(); - - connect_peer( - virtual_overseer, - peer_ids[0], - CollationVersion::V2, - Some(validators[0].clone()), - ) - .await; - expect_declare_msg_v2(virtual_overseer, &test_state, &peer_ids[0]).await; - // Peer is aware of the leaf. - send_peer_view_change(virtual_overseer, &peer_ids[0], vec![head_a]).await; - - // Collation is advertised. - expect_advertise_collation_msg( - virtual_overseer, - &peer_ids[0], - head_b, - Some(vec![candidate_hash]), - ) - .await; - - test_harness - }, - ) -} diff --git a/polkadot/node/network/collator-protocol/src/validator_side/collation.rs b/polkadot/node/network/collator-protocol/src/validator_side/collation.rs index 8c3889a3554865c919f2eb33a8f86cce15317ff3..96ffe9f13db3562429eb68cdfdc05da801c33863 100644 --- a/polkadot/node/network/collator-protocol/src/validator_side/collation.rs +++ b/polkadot/node/network/collator-protocol/src/validator_side/collation.rs @@ -121,19 +121,15 @@ impl PendingCollation { } } -/// v2 or v3 advertisement that was rejected by the backing -/// subsystem. Validator may fetch it later if its fragment -/// membership gets recognized before relay parent goes out of view. -#[derive(Debug, Clone)] -pub struct BlockedAdvertisement { - /// Peer that advertised the collation. - pub peer_id: PeerId, - /// Collator id. - pub collator_id: CollatorId, - /// The relay-parent of the candidate. - pub candidate_relay_parent: Hash, - /// Hash of the candidate. - pub candidate_hash: CandidateHash, +/// An identifier for a fetched collation that was blocked from being seconded because we don't have +/// access to the parent's HeadData. Can be retried once the candidate outputting this head data is +/// seconded. +#[derive(Debug, Clone, Eq, PartialEq, Hash)] +pub struct BlockedCollationId { + /// Para id. + pub para_id: ParaId, + /// Hash of the parent head data. + pub parent_head_data_hash: Hash, } /// Performs a sanity check between advertised and fetched collations. @@ -274,7 +270,7 @@ impl Collations { // We don't need to fetch any other collation when we already have seconded one. CollationStatus::Seconded => None, CollationStatus::Waiting => - if !self.is_seconded_limit_reached(relay_parent_mode) { + if self.is_seconded_limit_reached(relay_parent_mode) { None } else { self.waiting_queue.pop_front() @@ -284,7 +280,7 @@ impl Collations { } } - /// Checks the limit of seconded candidates for a given para. + /// Checks the limit of seconded candidates. pub(super) fn is_seconded_limit_reached( &self, relay_parent_mode: ProspectiveParachainsMode, @@ -297,7 +293,7 @@ impl Collations { } else { 1 }; - self.seconded_count < seconded_limit + self.seconded_count >= seconded_limit } } diff --git a/polkadot/node/network/collator-protocol/src/validator_side/mod.rs b/polkadot/node/network/collator-protocol/src/validator_side/mod.rs index ac8c060827f5a4519cd8e4930d1447a8bf4cbe47..cbf00a9e119d95af0c254df31babf67652d9da25 100644 --- a/polkadot/node/network/collator-protocol/src/validator_side/mod.rs +++ b/polkadot/node/network/collator-protocol/src/validator_side/mod.rs @@ -19,7 +19,7 @@ use futures::{ }; use futures_timer::Delay; use std::{ - collections::{hash_map::Entry, HashMap, HashSet}, + collections::{hash_map::Entry, HashMap, HashSet, VecDeque}, future::Future, time::{Duration, Instant}, }; @@ -50,7 +50,7 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_util::{ backing_implicit_view::View as ImplicitView, reputation::{ReputationAggregator, REPUTATION_CHANGE_INTERVAL}, - runtime::{prospective_parachains_mode, ProspectiveParachainsMode}, + runtime::{fetch_claim_queue, prospective_parachains_mode, ProspectiveParachainsMode}, }; use polkadot_primitives::{ CandidateHash, CollatorId, CoreState, Hash, HeadData, Id as ParaId, OccupiedCoreAssumption, @@ -59,15 +59,17 @@ use polkadot_primitives::{ use crate::error::{Error, FetchError, Result, SecondingError}; +use self::collation::BlockedCollationId; + use super::{modify_reputation, tick_stream, LOG_TARGET}; mod collation; mod metrics; use collation::{ - fetched_collation_sanity_check, BlockedAdvertisement, CollationEvent, CollationFetchError, - CollationFetchRequest, CollationStatus, Collations, FetchedCollation, PendingCollation, - PendingCollationFetch, ProspectiveCandidate, + fetched_collation_sanity_check, CollationEvent, CollationFetchError, CollationFetchRequest, + CollationStatus, Collations, FetchedCollation, PendingCollation, PendingCollationFetch, + ProspectiveCandidate, }; #[cfg(test)] @@ -360,8 +362,8 @@ impl PeerData { #[derive(Debug)] struct GroupAssignments { - /// Current assignment. - current: Option, + /// Current assignments. + current: Vec, } struct PerRelayParent { @@ -374,7 +376,7 @@ impl PerRelayParent { fn new(mode: ProspectiveParachainsMode) -> Self { Self { prospective_parachains_mode: mode, - assignment: GroupAssignments { current: None }, + assignment: GroupAssignments { current: vec![] }, collations: Collations::default(), } } @@ -388,7 +390,7 @@ struct State { /// `active_leaves`, the opposite doesn't hold true. /// /// Relay-chain blocks which don't support prospective parachains are - /// never included in the fragment trees of active leaves which do. In + /// never included in the fragment chains of active leaves which do. In /// particular, this means that if a given relay parent belongs to implicit /// ancestry of some active leaf, then it does support prospective parachains. implicit_view: ImplicitView, @@ -421,14 +423,6 @@ struct State { /// Span per relay parent. span_per_relay_parent: HashMap, - /// Advertisements that were accepted as valid by collator protocol but rejected by backing. - /// - /// It's only legal to fetch collations that are either built on top of the root - /// of some fragment tree or have a parent node which represents backed candidate. - /// Otherwise, a validator will keep such advertisement in the memory and re-trigger - /// requests to backing on new backed candidates and activations. - blocked_advertisements: HashMap<(ParaId, Hash), Vec>, - /// When a timer in this `FuturesUnordered` triggers, we should dequeue the next request /// attempt in the corresponding `collations_per_relay_parent`. /// @@ -441,6 +435,12 @@ struct State { /// on validation. fetched_candidates: HashMap, + /// Collations which we haven't been able to second due to their parent not being known by + /// prospective-parachains. Mapped from the paraid and parent_head_hash to the fetched + /// collation data. Only needed for async backing. For elastic scaling, the fetched collation + /// must contain the full parent head data. + blocked_from_seconding: HashMap>, + /// Aggregated reputation change reputation: ReputationAggregator, } @@ -491,34 +491,34 @@ where .await .map_err(Error::CancelledAvailabilityCores)??; - let para_now = match polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore) - .and_then(|(_, index)| polkadot_node_subsystem_util::find_validator_group(&groups, index)) - { - Some(group) => { - let core_now = rotation_info.core_for_group(group, cores.len()); - - cores.get(core_now.0 as usize).and_then(|c| match c { - CoreState::Occupied(core) if relay_parent_mode.is_enabled() => Some(core.para_id()), - CoreState::Scheduled(core) => Some(core.para_id), - CoreState::Occupied(_) | CoreState::Free => None, - }) - }, - None => { - gum::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator"); - - return Ok(()) - }, + let core_now = if let Some(group) = + polkadot_node_subsystem_util::signing_key_and_index(&validators, keystore).and_then( + |(_, index)| polkadot_node_subsystem_util::find_validator_group(&groups, index), + ) { + rotation_info.core_for_group(group, cores.len()) + } else { + gum::trace!(target: LOG_TARGET, ?relay_parent, "Not a validator"); + return Ok(()) }; - // This code won't work well, if at all for on-demand parachains. For on-demand we'll - // have to be aware of which core the on-demand claim is going to be multiplexed - // onto. The on-demand claim will also have a known collator, and we should always - // allow an incoming connection from that collator. If not even connecting to them - // directly. - // - // However, this'll work fine for parachains, as each parachain gets a dedicated - // core. - if let Some(para_id) = para_now.as_ref() { + let paras_now = match fetch_claim_queue(sender, relay_parent).await.map_err(Error::Runtime)? { + // Runtime supports claim queue - use it + // + // `relay_parent_mode` is not examined here because if the runtime supports claim queue + // then it supports async backing params too (`ASYNC_BACKING_STATE_RUNTIME_REQUIREMENT` + // < `CLAIM_QUEUE_RUNTIME_REQUIREMENT`). + Some(mut claim_queue) => claim_queue.0.remove(&core_now), + // Claim queue is not supported by the runtime - use availability cores instead. + None => cores.get(core_now.0 as usize).and_then(|c| match c { + CoreState::Occupied(core) if relay_parent_mode.is_enabled() => + core.next_up_on_available.as_ref().map(|c| [c.para_id].into_iter().collect()), + CoreState::Scheduled(core) => Some([core.para_id].into_iter().collect()), + CoreState::Occupied(_) | CoreState::Free => None, + }), + } + .unwrap_or_else(|| VecDeque::new()); + + for para_id in paras_now.iter() { let entry = current_assignments.entry(*para_id).or_default(); *entry += 1; if *entry == 1 { @@ -531,7 +531,7 @@ where } } - *group_assignment = GroupAssignments { current: para_now }; + *group_assignment = GroupAssignments { current: paras_now.into_iter().collect() }; Ok(()) } @@ -542,7 +542,7 @@ fn remove_outgoing( ) { let GroupAssignments { current, .. } = per_relay_parent.assignment; - if let Some(cur) = current { + for cur in current { if let Entry::Occupied(mut occupied) = current_assignments.entry(cur) { *occupied.get_mut() -= 1; if *occupied.get() == 0 { @@ -857,7 +857,8 @@ async fn process_incoming_peer_message( peer_id = ?origin, ?collator_id, ?para_id, - "Declared as collator for unneeded para", + "Declared as collator for unneeded para. Current assignments: {:?}", + &state.current_assignments ); modify_reputation( @@ -953,6 +954,8 @@ enum AdvertisementError { /// Advertisement is invalid. #[allow(dead_code)] Invalid(InsertAdvertisementError), + /// Seconding not allowed by backing subsystem + BlockedByBacking, } impl AdvertisementError { @@ -962,7 +965,7 @@ impl AdvertisementError { InvalidAssignment => Some(COST_WRONG_PARA), ProtocolMisuse => Some(COST_PROTOCOL_MISUSE), RelayParentUnknown | UndeclaredCollator | Invalid(_) => Some(COST_UNEXPECTED_MESSAGE), - UnknownPeer | SecondedLimitReached => None, + UnknownPeer | SecondedLimitReached | BlockedByBacking => None, } } } @@ -1001,57 +1004,55 @@ where }) } -/// Checks whether any of the advertisements are unblocked and attempts to fetch them. -async fn request_unblocked_collations(sender: &mut Sender, state: &mut State, blocked: I) -where - Sender: CollatorProtocolSenderTrait, - I: IntoIterator)>, -{ - let _timer = state.metrics.time_request_unblocked_collations(); +// Try seconding any collations which were waiting on the validation of their parent +#[overseer::contextbounds(CollatorProtocol, prefix = self::overseer)] +async fn second_unblocked_collations( + ctx: &mut Context, + state: &mut State, + para_id: ParaId, + head_data: HeadData, + head_data_hash: Hash, +) { + if let Some(unblocked_collations) = state + .blocked_from_seconding + .remove(&BlockedCollationId { para_id, parent_head_data_hash: head_data_hash }) + { + if !unblocked_collations.is_empty() { + gum::debug!( + target: LOG_TARGET, + "Candidate outputting head data with hash {} unblocked {} collations for seconding.", + head_data_hash, + unblocked_collations.len() + ); + } - for (key, mut value) in blocked { - let (para_id, para_head) = key; - let blocked = std::mem::take(&mut value); - for blocked in blocked { - let is_seconding_allowed = can_second( - sender, - para_id, - blocked.candidate_relay_parent, - blocked.candidate_hash, - para_head, - ) - .await; + for mut unblocked_collation in unblocked_collations { + unblocked_collation.maybe_parent_head_data = Some(head_data.clone()); + let peer_id = unblocked_collation.collation_event.pending_collation.peer_id; + let relay_parent = unblocked_collation.candidate_receipt.descriptor.relay_parent; - if is_seconding_allowed { - let result = enqueue_collation( - sender, - state, - blocked.candidate_relay_parent, - para_id, - blocked.peer_id, - blocked.collator_id, - Some((blocked.candidate_hash, para_head)), - ) - .await; - if let Err(fetch_error) = result { - gum::debug!( - target: LOG_TARGET, - relay_parent = ?blocked.candidate_relay_parent, - para_id = ?para_id, - peer_id = ?blocked.peer_id, - error = %fetch_error, - "Failed to request unblocked collation", - ); + if let Err(err) = kick_off_seconding(ctx, state, unblocked_collation).await { + gum::warn!( + target: LOG_TARGET, + ?relay_parent, + ?para_id, + ?peer_id, + error = %err, + "Seconding aborted due to an error", + ); + + if err.is_malicious() { + // Report malicious peer. + modify_reputation( + &mut state.reputation, + ctx.sender(), + peer_id, + COST_REPORT_BAD, + ) + .await; } - } else { - // Keep the advertisement. - value.push(blocked); } } - - if !value.is_empty() { - state.blocked_advertisements.insert(key, value); - } } } @@ -1089,7 +1090,7 @@ where peer_data.collating_para().ok_or(AdvertisementError::UndeclaredCollator)?; // Check if this is assigned to us. - if assignment.current.map_or(true, |id| id != collator_para_id) { + if !assignment.current.contains(&collator_para_id) { return Err(AdvertisementError::InvalidAssignment) } @@ -1105,15 +1106,15 @@ where ) .map_err(AdvertisementError::Invalid)?; - if !per_relay_parent.collations.is_seconded_limit_reached(relay_parent_mode) { + if per_relay_parent.collations.is_seconded_limit_reached(relay_parent_mode) { return Err(AdvertisementError::SecondedLimitReached) } if let Some((candidate_hash, parent_head_data_hash)) = prospective_candidate { - // We need to queue the advertisement if we are not allowed to second it. + // Check if backing subsystem allows to second this candidate. // - // This is also only important when async backing is enabled. - let queue_advertisement = relay_parent_mode.is_enabled() && + // This is also only important when async backing or elastic scaling is enabled. + let seconding_not_allowed = relay_parent_mode.is_enabled() && !can_second( sender, collator_para_id, @@ -1123,26 +1124,8 @@ where ) .await; - if queue_advertisement { - gum::debug!( - target: LOG_TARGET, - relay_parent = ?relay_parent, - para_id = ?para_id, - ?candidate_hash, - "Seconding is not allowed by backing, queueing advertisement", - ); - state - .blocked_advertisements - .entry((collator_para_id, parent_head_data_hash)) - .or_default() - .push(BlockedAdvertisement { - peer_id, - collator_id: collator_id.clone(), - candidate_relay_parent: relay_parent, - candidate_hash, - }); - - return Ok(()) + if seconding_not_allowed { + return Err(AdvertisementError::BlockedByBacking) } } @@ -1215,7 +1198,7 @@ where }); let collations = &mut per_relay_parent.collations; - if !collations.is_seconded_limit_reached(relay_parent_mode) { + if collations.is_seconded_limit_reached(relay_parent_mode) { gum::trace!( target: LOG_TARGET, peer_id = ?peer_id, @@ -1358,20 +1341,17 @@ where state.span_per_relay_parent.remove(&removed); } } - // Remove blocked advertisements that left the view. - state.blocked_advertisements.retain(|_, ads| { - ads.retain(|ad| state.per_relay_parent.contains_key(&ad.candidate_relay_parent)); - !ads.is_empty() + // Remove blocked seconding requests that left the view. + state.blocked_from_seconding.retain(|_, collations| { + collations.retain(|collation| { + state + .per_relay_parent + .contains_key(&collation.candidate_receipt.descriptor.relay_parent) + }); + + !collations.is_empty() }); - // Re-trigger previously failed requests again. - // - // This makes sense for several reasons, one simple example: if a hypothetical depth - // for an advertisement initially exceeded the limit and the candidate was included - // in a new leaf. - let maybe_unblocked = std::mem::take(&mut state.blocked_advertisements); - // Could be optimized to only sanity check new leaves. - request_unblocked_collations(sender, state, maybe_unblocked).await; for (peer_id, peer_data) in state.peer_data.iter_mut() { peer_data.prune_old_advertisements( @@ -1508,6 +1488,8 @@ async fn process_msg( return }, }; + let output_head_data = receipt.commitments.head_data.clone(); + let output_head_data_hash = receipt.descriptor.para_head; let fetched_collation = FetchedCollation::from(&receipt.to_plain()); if let Some(CollationEvent { collator_id, pending_collation, .. }) = state.fetched_candidates.remove(&fetched_collation) @@ -1536,6 +1518,17 @@ async fn process_msg( rp_state.collations.status = CollationStatus::Seconded; rp_state.collations.note_seconded(); } + + // See if we've unblocked other collations for seconding. + second_unblocked_collations( + ctx, + state, + fetched_collation.para_id, + output_head_data, + output_head_data_hash, + ) + .await; + // If async backing is enabled, make an attempt to fetch next collation. let maybe_candidate_hash = prospective_candidate.as_ref().map(ProspectiveCandidate::candidate_hash); @@ -1554,11 +1547,13 @@ async fn process_msg( ); } }, - Backed { para_id, para_head } => { - let maybe_unblocked = state.blocked_advertisements.remove_entry(&(para_id, para_head)); - request_unblocked_collations(ctx.sender(), state, maybe_unblocked).await; - }, Invalid(parent, candidate_receipt) => { + // Remove collations which were blocked from seconding and had this candidate as parent. + state.blocked_from_seconding.remove(&BlockedCollationId { + para_id: candidate_receipt.descriptor.para_id, + parent_head_data_hash: candidate_receipt.descriptor.para_head, + }); + let fetched_collation = FetchedCollation::from(&candidate_receipt); let candidate_hash = fetched_collation.candidate_hash; let id = match state.fetched_candidates.entry(fetched_collation) { @@ -1668,29 +1663,45 @@ async fn run_inner( }; let CollationEvent {collator_id, pending_collation, .. } = res.collation_event.clone(); - if let Err(err) = kick_off_seconding(&mut ctx, &mut state, res).await { - gum::warn!( - target: LOG_TARGET, - relay_parent = ?pending_collation.relay_parent, - para_id = ?pending_collation.para_id, - peer_id = ?pending_collation.peer_id, - error = %err, - "Seconding aborted due to an error", - ); - if err.is_malicious() { - // Report malicious peer. - modify_reputation(&mut state.reputation, ctx.sender(), pending_collation.peer_id, COST_REPORT_BAD).await; + match kick_off_seconding(&mut ctx, &mut state, res).await { + Err(err) => { + gum::warn!( + target: LOG_TARGET, + relay_parent = ?pending_collation.relay_parent, + para_id = ?pending_collation.para_id, + peer_id = ?pending_collation.peer_id, + error = %err, + "Seconding aborted due to an error", + ); + + if err.is_malicious() { + // Report malicious peer. + modify_reputation(&mut state.reputation, ctx.sender(), pending_collation.peer_id, COST_REPORT_BAD).await; + } + let maybe_candidate_hash = + pending_collation.prospective_candidate.as_ref().map(ProspectiveCandidate::candidate_hash); + dequeue_next_collation_and_fetch( + &mut ctx, + &mut state, + pending_collation.relay_parent, + (collator_id, maybe_candidate_hash), + ) + .await; + }, + Ok(false) => { + // No hard error occurred, but we can try fetching another collation. + let maybe_candidate_hash = + pending_collation.prospective_candidate.as_ref().map(ProspectiveCandidate::candidate_hash); + dequeue_next_collation_and_fetch( + &mut ctx, + &mut state, + pending_collation.relay_parent, + (collator_id, maybe_candidate_hash), + ) + .await; } - let maybe_candidate_hash = - pending_collation.prospective_candidate.as_ref().map(ProspectiveCandidate::candidate_hash); - dequeue_next_collation_and_fetch( - &mut ctx, - &mut state, - pending_collation.relay_parent, - (collator_id, maybe_candidate_hash), - ) - .await; + Ok(true) => {} } } res = state.collation_fetch_timeouts.select_next_some() => { @@ -1800,12 +1811,13 @@ where } /// Handle a fetched collation result. +/// Returns whether or not seconding has begun. #[overseer::contextbounds(CollatorProtocol, prefix = self::overseer)] async fn kick_off_seconding( ctx: &mut Context, state: &mut State, PendingCollationFetch { mut collation_event, candidate_receipt, pov, maybe_parent_head_data }: PendingCollationFetch, -) -> std::result::Result<(), SecondingError> { +) -> std::result::Result { let pending_collation = collation_event.pending_collation; let relay_parent = pending_collation.relay_parent; @@ -1818,7 +1830,7 @@ async fn kick_off_seconding( relay_parent = ?relay_parent, "Fetched collation for a parent out of view", ); - return Ok(()) + return Ok(false) }, }; let collations = &mut per_relay_parent.collations; @@ -1828,7 +1840,7 @@ async fn kick_off_seconding( collation_event.pending_collation.commitments_hash = Some(candidate_receipt.commitments_hash); - let (maybe_pvd, maybe_parent_head_and_hash) = match ( + let (maybe_pvd, maybe_parent_head, maybe_parent_head_hash) = match ( collation_event.collator_protocol_version, collation_event.pending_collation.prospective_candidate, ) { @@ -1844,7 +1856,7 @@ async fn kick_off_seconding( ) .await?; - (pvd, maybe_parent_head_data.map(|head_data| (head_data, parent_head_data_hash))) + (pvd, maybe_parent_head_data, Some(parent_head_data_hash)) }, // Support V2 collators without async backing enabled. (CollationVersion::V2, Some(_)) | (CollationVersion::V1, _) => { @@ -1854,20 +1866,60 @@ async fn kick_off_seconding( candidate_receipt.descriptor().para_id, ) .await?; - (pvd, None) + ( + Some(pvd.ok_or(SecondingError::PersistedValidationDataNotFound)?), + maybe_parent_head_data, + None, + ) }, _ => { // `handle_advertisement` checks for protocol mismatch. - return Ok(()) + return Ok(false) + }, + }; + + let pvd = match (maybe_pvd, maybe_parent_head.clone(), maybe_parent_head_hash) { + (Some(pvd), _, _) => pvd, + (None, None, Some(parent_head_data_hash)) => { + // In this case, the collator did not supply the head data and neither could + // prospective-parachains. We add this to the blocked_from_seconding collection + // until we second its parent. + let blocked_collation = PendingCollationFetch { + collation_event, + candidate_receipt, + pov, + maybe_parent_head_data: None, + }; + gum::debug!( + target: LOG_TARGET, + candidate_hash = ?blocked_collation.candidate_receipt.hash(), + relay_parent = ?blocked_collation.candidate_receipt.descriptor.relay_parent, + "Collation having parent head data hash {} is blocked from seconding. Waiting on its parent to be validated.", + parent_head_data_hash + ); + state + .blocked_from_seconding + .entry(BlockedCollationId { + para_id: blocked_collation.candidate_receipt.descriptor.para_id, + parent_head_data_hash, + }) + .or_insert_with(Vec::new) + .push(blocked_collation); + + return Ok(false) + }, + (None, _, _) => { + // Even though we already have the parent head data, the pvd fetching failed. We + // don't need to wait for seconding another collation outputting this head data. + return Err(SecondingError::PersistedValidationDataNotFound) }, }; - let pvd = maybe_pvd.ok_or(SecondingError::PersistedValidationDataNotFound)?; fetched_collation_sanity_check( &collation_event.pending_collation, &candidate_receipt, &pvd, - maybe_parent_head_and_hash, + maybe_parent_head.and_then(|head| maybe_parent_head_hash.map(|hash| (head, hash))), )?; ctx.send_message(CandidateBackingMessage::Second( @@ -1882,7 +1934,7 @@ async fn kick_off_seconding( collations.status = CollationStatus::WaitingOnValidation; entry.insert(collation_event); - Ok(()) + Ok(true) } else { Err(SecondingError::Duplicate) } diff --git a/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs b/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs index 1ba6389212cc5beffdd6cb94a0fed194dd1cb048..86c8bcb6bdcdbcad7fb7fbf6f1d73666331348ff 100644 --- a/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs +++ b/polkadot/node/network/collator-protocol/src/validator_side/tests/mod.rs @@ -21,7 +21,12 @@ use sc_network::ProtocolName; use sp_core::{crypto::Pair, Encode}; use sp_keyring::Sr25519Keyring; use sp_keystore::Keystore; -use std::{iter, sync::Arc, time::Duration}; +use std::{ + collections::{BTreeMap, VecDeque}, + iter, + sync::Arc, + time::Duration, +}; use polkadot_node_network_protocol::{ our_view, @@ -37,7 +42,7 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_node_subsystem_util::{reputation::add_reputation, TimeoutExt}; use polkadot_primitives::{ - CandidateReceipt, CollatorPair, CoreState, GroupIndex, GroupRotationInfo, HeadData, + CandidateReceipt, CollatorPair, CoreIndex, CoreState, GroupIndex, GroupRotationInfo, HeadData, OccupiedCore, PersistedValidationData, ScheduledCore, ValidatorId, ValidatorIndex, }; use polkadot_primitives_test_helpers::{ @@ -71,6 +76,7 @@ struct TestState { validator_groups: Vec>, group_rotation_info: GroupRotationInfo, cores: Vec, + claim_queue: BTreeMap>, } impl Default for TestState { @@ -104,7 +110,7 @@ impl Default for TestState { CoreState::Scheduled(ScheduledCore { para_id: chain_ids[0], collator: None }), CoreState::Free, CoreState::Occupied(OccupiedCore { - next_up_on_available: None, + next_up_on_available: Some(ScheduledCore { para_id: chain_ids[1], collator: None }), occupied_since: 0, time_out_at: 1, next_up_on_time_out: None, @@ -120,6 +126,11 @@ impl Default for TestState { }), ]; + let mut claim_queue = BTreeMap::new(); + claim_queue.insert(CoreIndex(0), [chain_ids[0]].into_iter().collect()); + claim_queue.insert(CoreIndex(1), VecDeque::new()); + claim_queue.insert(CoreIndex(2), [chain_ids[1]].into_iter().collect()); + Self { chain_ids, relay_parent, @@ -128,11 +139,13 @@ impl Default for TestState { validator_groups, group_rotation_info, cores, + claim_queue, } } } -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; struct TestHarness { virtual_overseer: VirtualOverseer, @@ -143,15 +156,12 @@ fn test_harness>( reputation: ReputationAggregator, test: impl FnOnce(TestHarness) -> T, ) { - let _ = env_logger::builder() - .is_test(true) - .filter(Some("polkadot_collator_protocol"), log::LevelFilter::Trace) - .filter(Some(LOG_TARGET), log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let keystore = Arc::new(sc_keystore::LocalKeystore::in_memory()); Keystore::sr25519_generate_new( @@ -262,6 +272,26 @@ async fn respond_to_core_info_queries( let _ = tx.send(Ok(test_state.cores.clone())); } ); + + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _, + RuntimeApiRequest::Version(tx), + )) => { + let _ = tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)); + } + ); + + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _, + RuntimeApiRequest::ClaimQueue(tx), + )) => { + let _ = tx.send(Ok(test_state.claim_queue.clone())); + } + ); } /// Assert that the next message is a `CandidateBacking(Second())`. diff --git a/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs b/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs index eaa725f2642ed38e3a6f222f9624dd6e2bc4fcce..472731b506ab1c5d59a756a9e80b47016bcceb6c 100644 --- a/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs +++ b/polkadot/node/network/collator-protocol/src/validator_side/tests/prospective_parachains.rs @@ -23,6 +23,7 @@ use polkadot_primitives::{ AsyncBackingParams, BlockNumber, CandidateCommitments, CommittedCandidateReceipt, Header, SigningContext, ValidatorId, }; +use rstest::rstest; const ASYNC_BACKING_PARAMETERS: AsyncBackingParams = AsyncBackingParams { max_candidate_depth: 4, allowed_ancestry_len: 3 }; @@ -71,6 +72,26 @@ async fn assert_assign_incoming( tx.send(Ok(test_state.cores.clone())).unwrap(); } ); + + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + parent, + RuntimeApiRequest::Version(tx), + )) if parent == hash => { + let _ = tx.send(Ok(RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT)); + } + ); + + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + parent, + RuntimeApiRequest::ClaimQueue(tx), + )) if parent == hash => { + let _ = tx.send(Ok(test_state.claim_queue.clone())); + } + ); } /// Handle a view update. @@ -115,15 +136,6 @@ pub(super) async fn update_view( let min_number = leaf_number.saturating_sub(ASYNC_BACKING_PARAMETERS.allowed_ancestry_len); - assert_matches!( - overseer_recv(virtual_overseer).await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx), - ) if parent == leaf_hash => { - tx.send(test_state.chain_ids.iter().map(|para_id| (*para_id, min_number)).collect()).unwrap(); - } - ); - let ancestry_len = leaf_number + 1 - min_number; let ancestry_hashes = std::iter::successors(Some(leaf_hash), |h| Some(get_parent_hash(*h))) .take(ancestry_len as usize); @@ -165,6 +177,17 @@ pub(super) async fn update_view( } ); + if requested_len == 0 { + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::ProspectiveParachains( + ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx), + ) if parent == leaf_hash => { + tx.send(test_state.chain_ids.iter().map(|para_id| (*para_id, min_number)).collect()).unwrap(); + } + ); + } + requested_len += 1; } } @@ -262,6 +285,48 @@ async fn assert_collation_seconded( } } +/// Assert that the next message is a persisted validation data request and respond with the +/// supplied PVD. +async fn assert_persisted_validation_data( + virtual_overseer: &mut VirtualOverseer, + version: CollationVersion, + expected_relay_parent: Hash, + expected_para_id: ParaId, + expected_parent_head_data_hash: Option, + pvd: Option, +) { + // Depending on relay parent mode pvd will be either requested + // from the Runtime API or Prospective Parachains. + let msg = overseer_recv(virtual_overseer).await; + match version { + CollationVersion::V1 => assert_matches!( + msg, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + hash, + RuntimeApiRequest::PersistedValidationData(para_id, assumption, tx), + )) => { + assert_eq!(expected_relay_parent, hash); + assert_eq!(expected_para_id, para_id); + assert_eq!(OccupiedCoreAssumption::Free, assumption); + tx.send(Ok(pvd)).unwrap(); + } + ), + CollationVersion::V2 => assert_matches!( + msg, + AllMessages::ProspectiveParachains( + ProspectiveParachainsMessage::GetProspectiveValidationData(request, tx), + ) => { + assert_eq!(expected_relay_parent, request.candidate_relay_parent); + assert_eq!(expected_para_id, request.para_id); + if let Some(expected_parent_head_data_hash) = expected_parent_head_data_hash { + assert_eq!(expected_parent_head_data_hash, request.parent_head_data.hash()); + } + tx.send(pvd).unwrap(); + } + ), + } +} + #[test] fn v1_advertisement_accepted_and_seconded() { let test_state = TestState::default(); @@ -946,56 +1011,73 @@ fn advertisement_spam_protection() { }); } -#[test] -fn backed_candidate_unblocks_advertisements() { +#[rstest] +#[case(true)] +#[case(false)] +fn child_blocked_from_seconding_by_parent(#[case] valid_parent: bool) { let test_state = TestState::default(); test_harness(ReputationAggregator::new(|_| true), |test_harness| async move { - let TestHarness { mut virtual_overseer, .. } = test_harness; + let TestHarness { mut virtual_overseer, keystore } = test_harness; - let pair_a = CollatorPair::generate().0; - let pair_b = CollatorPair::generate().0; + let pair = CollatorPair::generate().0; + // Grandparent of head `a`. let head_b = Hash::from_low_u64_be(128); let head_b_num: u32 = 2; - let head_c = get_parent_hash(head_b); // Grandparent of head `b`. - // Group rotation frequency is 1 by default, at `d` we're assigned + // Group rotation frequency is 1 by default, at `c` we're assigned // to the first para. - let head_d = get_parent_hash(head_c); + let head_c = Hash::from_low_u64_be(130); // Activated leaf is `b`, but the collation will be based on `c`. update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await; let peer_a = PeerId::random(); - let peer_b = PeerId::random(); - // Accept both collators from the implicit view. connect_and_declare_collator( &mut virtual_overseer, peer_a, - pair_a.clone(), + pair.clone(), test_state.chain_ids[0], CollationVersion::V2, ) .await; - connect_and_declare_collator( - &mut virtual_overseer, - peer_b, - pair_b.clone(), - test_state.chain_ids[1], - CollationVersion::V2, - ) - .await; - let candidate_hash = CandidateHash::default(); - let parent_head_data_hash = Hash::zero(); + // Candidate A transitions from head data 0 to 1. + // Candidate B transitions from head data 1 to 2. + + // Candidate B is advertised and fetched before candidate A. + + let mut candidate_b = dummy_candidate_receipt_bad_sig(head_c, Some(Default::default())); + candidate_b.descriptor.para_id = test_state.chain_ids[0]; + candidate_b.descriptor.para_head = HeadData(vec![2]).hash(); + candidate_b.descriptor.persisted_validation_data_hash = + PersistedValidationData:: { + parent_head: HeadData(vec![1]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + } + .hash(); + let candidate_b_commitments = CandidateCommitments { + head_data: HeadData(vec![2]), + horizontal_messages: Default::default(), + upward_messages: Default::default(), + new_validation_code: None, + processed_downward_messages: 0, + hrmp_watermark: 0, + }; + candidate_b.commitments_hash = candidate_b_commitments.hash(); + + let candidate_b_hash = candidate_b.hash(); + advertise_collation( &mut virtual_overseer, - peer_b, + peer_a, head_c, - Some((candidate_hash, parent_head_data_hash)), + Some((candidate_b_hash, HeadData(vec![1]).hash())), ) .await; assert_matches!( @@ -1003,40 +1085,73 @@ fn backed_candidate_unblocks_advertisements() { AllMessages::CandidateBacking( CandidateBackingMessage::CanSecond(request, tx), ) => { - assert_eq!(request.candidate_hash, candidate_hash); - assert_eq!(request.candidate_para_id, test_state.chain_ids[1]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); - // Reject it. - tx.send(false).expect("receiving side should be alive"); + assert_eq!(request.candidate_hash, candidate_b_hash); + assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); + assert_eq!(request.parent_head_data_hash, HeadData(vec![1]).hash()); + tx.send(true).expect("receiving side should be alive"); } ); - // Advertise with different para. - advertise_collation( + let response_channel = assert_fetch_collation_request( &mut virtual_overseer, - peer_a, - head_d, // Note different relay parent. - Some((candidate_hash, parent_head_data_hash)), + head_c, + test_state.chain_ids[0], + Some(candidate_b_hash), ) .await; - assert_matches!( - overseer_recv(&mut virtual_overseer).await, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidate_hash); - assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); - tx.send(false).expect("receiving side should be alive"); + + response_channel + .send(Ok(( + request_v2::CollationFetchingResponse::Collation( + candidate_b.clone(), + PoV { block_data: BlockData(vec![1]) }, + ) + .encode(), + ProtocolName::from(""), + ))) + .expect("Sending response should succeed"); + + // Persisted validation data of candidate B is not found. + assert_persisted_validation_data( + &mut virtual_overseer, + CollationVersion::V2, + head_c, + test_state.chain_ids[0], + Some(HeadData(vec![1]).hash()), + None, + ) + .await; + + // Now advertise, fetch and validate candidate A, which is the parent of B. + + let mut candidate_a = dummy_candidate_receipt_bad_sig(head_c, Some(Default::default())); + candidate_a.descriptor.para_id = test_state.chain_ids[0]; + candidate_a.descriptor.para_head = HeadData(vec![1]).hash(); + candidate_a.descriptor.persisted_validation_data_hash = + PersistedValidationData:: { + parent_head: HeadData(vec![0]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), } - ); + .hash(); + let candidate_a_commitments = CandidateCommitments { + head_data: HeadData(vec![1]), + horizontal_messages: Default::default(), + upward_messages: Default::default(), + new_validation_code: None, + processed_downward_messages: 0, + hrmp_watermark: 0, + }; + candidate_a.commitments_hash = candidate_a_commitments.hash(); + + let candidate_a_hash = candidate_a.hash(); - overseer_send( + advertise_collation( &mut virtual_overseer, - CollatorProtocolMessage::Backed { - para_id: test_state.chain_ids[0], - para_head: parent_head_data_hash, - }, + peer_a, + head_c, + Some((candidate_a_hash, HeadData(vec![0]).hash())), ) .await; assert_matches!( @@ -1044,174 +1159,155 @@ fn backed_candidate_unblocks_advertisements() { AllMessages::CandidateBacking( CandidateBackingMessage::CanSecond(request, tx), ) => { - assert_eq!(request.candidate_hash, candidate_hash); + assert_eq!(request.candidate_hash, candidate_a_hash); assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); + assert_eq!(request.parent_head_data_hash, HeadData(vec![0]).hash()); tx.send(true).expect("receiving side should be alive"); } ); - assert_fetch_collation_request( + + let response_channel = assert_fetch_collation_request( &mut virtual_overseer, - head_d, + head_c, test_state.chain_ids[0], - Some(candidate_hash), + Some(candidate_a_hash), ) .await; - virtual_overseer - }); -} -#[test] -fn active_leave_unblocks_advertisements() { - let mut test_state = TestState::default(); - test_state.group_rotation_info.group_rotation_frequency = 100; + response_channel + .send(Ok(( + request_v2::CollationFetchingResponse::Collation( + candidate_a.clone(), + PoV { block_data: BlockData(vec![2]) }, + ) + .encode(), + ProtocolName::from(""), + ))) + .expect("Sending response should succeed"); - test_harness(ReputationAggregator::new(|_| true), |test_harness| async move { - let TestHarness { mut virtual_overseer, .. } = test_harness; + assert_persisted_validation_data( + &mut virtual_overseer, + CollationVersion::V2, + head_c, + test_state.chain_ids[0], + Some(HeadData(vec![0]).hash()), + Some(PersistedValidationData:: { + parent_head: HeadData(vec![0]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }), + ) + .await; - let head_b = Hash::from_low_u64_be(128); - let head_b_num: u32 = 0; + assert_matches!( + overseer_recv(&mut virtual_overseer).await, + AllMessages::CandidateBacking(CandidateBackingMessage::Second( + relay_parent, + candidate_receipt, + received_pvd, + incoming_pov, + )) => { + assert_eq!(head_c, relay_parent); + assert_eq!(test_state.chain_ids[0], candidate_receipt.descriptor.para_id); + assert_eq!(PoV { block_data: BlockData(vec![2]) }, incoming_pov); + assert_eq!(PersistedValidationData:: { + parent_head: HeadData(vec![0]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }, received_pvd); + candidate_receipt + } + ); - update_view(&mut virtual_overseer, &test_state, vec![(head_b, head_b_num)], 1).await; + // If candidate A is valid, proceed with seconding B. + if valid_parent { + send_seconded_statement( + &mut virtual_overseer, + keystore.clone(), + &CommittedCandidateReceipt { + descriptor: candidate_a.descriptor, + commitments: candidate_a_commitments, + }, + ) + .await; + + assert_collation_seconded(&mut virtual_overseer, head_c, peer_a, CollationVersion::V2) + .await; - let peers: Vec = (0..3).map(|_| CollatorPair::generate().0).collect(); - let peer_ids: Vec = (0..3).map(|_| PeerId::random()).collect(); - let candidates: Vec = - (0u8..3).map(|i| CandidateHash(Hash::repeat_byte(i))).collect(); + // Now that candidate A has been seconded, candidate B can be seconded as well. - for (peer, peer_id) in peers.iter().zip(&peer_ids) { - connect_and_declare_collator( + assert_persisted_validation_data( &mut virtual_overseer, - *peer_id, - peer.clone(), - test_state.chain_ids[0], CollationVersion::V2, + head_c, + test_state.chain_ids[0], + Some(HeadData(vec![1]).hash()), + Some(PersistedValidationData:: { + parent_head: HeadData(vec![1]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }), ) .await; - } - let parent_head_data_hash = Hash::zero(); - for (peer, candidate) in peer_ids.iter().zip(&candidates).take(2) { - advertise_collation( + assert_matches!( + overseer_recv(&mut virtual_overseer).await, + AllMessages::CandidateBacking(CandidateBackingMessage::Second( + relay_parent, + candidate_receipt, + received_pvd, + incoming_pov, + )) => { + assert_eq!(head_c, relay_parent); + assert_eq!(test_state.chain_ids[0], candidate_receipt.descriptor.para_id); + assert_eq!(PoV { block_data: BlockData(vec![1]) }, incoming_pov); + assert_eq!(PersistedValidationData:: { + parent_head: HeadData(vec![1]), + relay_parent_number: 5, + max_pov_size: 1024, + relay_parent_storage_root: Default::default(), + }, received_pvd); + candidate_receipt + } + ); + + send_seconded_statement( + &mut virtual_overseer, + keystore.clone(), + &CommittedCandidateReceipt { + descriptor: candidate_b.descriptor, + commitments: candidate_b_commitments, + }, + ) + .await; + + assert_collation_seconded(&mut virtual_overseer, head_c, peer_a, CollationVersion::V2) + .await; + } else { + // If candidate A is invalid, B won't be seconded. + overseer_send( &mut virtual_overseer, - *peer, - head_b, - Some((*candidate, parent_head_data_hash)), + CollatorProtocolMessage::Invalid(head_c, candidate_a), ) .await; assert_matches!( overseer_recv(&mut virtual_overseer).await, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), + AllMessages::NetworkBridgeTx( + NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(peer, rep)), ) => { - assert_eq!(request.candidate_hash, *candidate); - assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); - // Send false. - tx.send(false).expect("receiving side should be alive"); + assert_eq!(peer, peer_a); + assert_eq!(rep.value, COST_REPORT_BAD.cost_or_benefit()); } ); } - let head_c = Hash::from_low_u64_be(127); - let head_c_num: u32 = 1; - - let next_overseer_message = - update_view(&mut virtual_overseer, &test_state, vec![(head_c, head_c_num)], 1) - .await - .expect("should've sent request to backing"); - - // Unblock first request. - assert_matches!( - next_overseer_message, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidates[0]); - assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); - tx.send(true).expect("receiving side should be alive"); - } - ); - - assert_fetch_collation_request( - &mut virtual_overseer, - head_b, - test_state.chain_ids[0], - Some(candidates[0]), - ) - .await; - - assert_matches!( - overseer_recv(&mut virtual_overseer).await, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidates[1]); - assert_eq!(request.candidate_para_id, test_state.chain_ids[0]); - assert_eq!(request.parent_head_data_hash, parent_head_data_hash); - tx.send(false).expect("receiving side should be alive"); - } - ); - - // Collation request was discarded. test_helpers::Yield::new().await; assert_matches!(virtual_overseer.recv().now_or_never(), None); - advertise_collation( - &mut virtual_overseer, - peer_ids[2], - head_c, - Some((candidates[2], parent_head_data_hash)), - ) - .await; - - assert_matches!( - overseer_recv(&mut virtual_overseer).await, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidates[2]); - tx.send(false).expect("receiving side should be alive"); - } - ); - - let head_d = Hash::from_low_u64_be(126); - let head_d_num: u32 = 2; - - let next_overseer_message = - update_view(&mut virtual_overseer, &test_state, vec![(head_d, head_d_num)], 1) - .await - .expect("should've sent request to backing"); - - // Reject 2, accept 3. - assert_matches!( - next_overseer_message, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidates[1]); - tx.send(false).expect("receiving side should be alive"); - } - ); - assert_matches!( - overseer_recv(&mut virtual_overseer).await, - AllMessages::CandidateBacking( - CandidateBackingMessage::CanSecond(request, tx), - ) => { - assert_eq!(request.candidate_hash, candidates[2]); - tx.send(true).expect("receiving side should be alive"); - } - ); - assert_fetch_collation_request( - &mut virtual_overseer, - head_c, - test_state.chain_ids[0], - Some(candidates[2]), - ) - .await; - virtual_overseer }); } diff --git a/polkadot/node/network/dispute-distribution/Cargo.toml b/polkadot/node/network/dispute-distribution/Cargo.toml index ff9c302c73146d501114728c4a483e4465d199a9..ccf1b5daad7c3b7f3dd7d5525cb619781c01bce8 100644 --- a/polkadot/node/network/dispute-distribution/Cargo.toml +++ b/polkadot/node/network/dispute-distribution/Cargo.toml @@ -10,33 +10,33 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } -derive_more = "0.99.17" -parity-scale-codec = { version = "3.6.1", features = ["std"] } -polkadot-primitives = { path = "../../../primitives" } -polkadot-erasure-coding = { path = "../../../erasure-coding" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-primitives = { path = "../../primitives" } -sc-network = { path = "../../../../substrate/client/network" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +derive_more = { workspace = true, default-features = true } +codec = { features = ["std"], workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } thiserror = { workspace = true } -fatality = "0.0.6" -schnellru = "0.2.1" -indexmap = "2.0.0" +fatality = { workspace = true } +schnellru = { workspace = true } +indexmap = { workspace = true } [dev-dependencies] -async-channel = "1.8.0" -async-trait = "0.1.79" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -futures-timer = "3.0.2" -assert_matches = "1.4.0" -lazy_static = "1.4.0" -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } +async-channel = { workspace = true } +async-trait = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +futures-timer = { workspace = true } +assert_matches = { workspace = true } +lazy_static = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } diff --git a/polkadot/node/network/dispute-distribution/src/receiver/mod.rs b/polkadot/node/network/dispute-distribution/src/receiver/mod.rs index 2b3fc45983a98f67954a16fd342d76ac8068ae07..77c1e41aac050168e8e5b204a9ef1d1528c67014 100644 --- a/polkadot/node/network/dispute-distribution/src/receiver/mod.rs +++ b/polkadot/node/network/dispute-distribution/src/receiver/mod.rs @@ -66,9 +66,12 @@ use self::{ const COST_INVALID_REQUEST: Rep = Rep::CostMajor("Received message could not be decoded."); const COST_INVALID_SIGNATURE: Rep = Rep::Malicious("Signatures were invalid."); -const COST_INVALID_IMPORT: Rep = - Rep::Malicious("Import was deemed invalid by dispute-coordinator."); const COST_NOT_A_VALIDATOR: Rep = Rep::CostMajor("Reporting peer was not a validator."); + +/// Invalid imports can be caused by flooding, e.g. by a disabled validator. +const COST_INVALID_IMPORT: Rep = + Rep::CostMinor("Import was deemed invalid by dispute-coordinator."); + /// Mildly punish peers exceeding their rate limit. /// /// For honest peers this should rarely happen, but if it happens we would not want to disconnect @@ -132,7 +135,7 @@ enum MuxedMessage { /// A new request has arrived and should be handled. NewRequest(IncomingRequest), - /// Rate limit timer hit - is is time to process one row of messages. + /// Rate limit timer hit - is time to process one row of messages. /// /// This is the result of calling `self.peer_queues.pop_reqs()`. WakePeerQueuesPopReqs(Vec>), diff --git a/polkadot/node/network/dispute-distribution/src/tests/mod.rs b/polkadot/node/network/dispute-distribution/src/tests/mod.rs index 1d0d667f5ccf4a156316110f1493ac180615b877..60820e62ca2d6dbab4d8ba5defe037e12ed1a463 100644 --- a/polkadot/node/network/dispute-distribution/src/tests/mod.rs +++ b/polkadot/node/network/dispute-distribution/src/tests/mod.rs @@ -24,13 +24,13 @@ use std::{ }; use assert_matches::assert_matches; +use codec::{Decode, Encode}; use futures::{ channel::oneshot, future::{poll_fn, ready}, pin_mut, Future, }; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; use sc_network::{config::RequestResponseConfig, ProtocolName}; diff --git a/polkadot/node/network/gossip-support/Cargo.toml b/polkadot/node/network/gossip-support/Cargo.toml index 2d6f2f954c667a8a97aff093f1fa734f6afce9aa..83fdc7e26191e6b2568a9733b163a0f0239f6709 100644 --- a/polkadot/node/network/gossip-support/Cargo.toml +++ b/polkadot/node/network/gossip-support/Cargo.toml @@ -10,34 +10,34 @@ license.workspace = true workspace = true [dependencies] -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-crypto-hashing = { path = "../../../../substrate/primitives/crypto/hashing" } -sc-network = { path = "../../../../substrate/client/network" } -sc-network-common = { path = "../../../../substrate/client/network/common" } +sp-application-crypto = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-common = { workspace = true, default-features = true } -polkadot-node-network-protocol = { path = "../protocol" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-primitives = { path = "../../../primitives" } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } -futures = "0.3.30" -futures-timer = "3.0.2" -rand = { version = "0.8.5", default-features = false } -rand_chacha = { version = "0.3.1", default-features = false } -gum = { package = "tracing-gum", path = "../../gum" } +futures = { workspace = true } +futures-timer = { workspace = true } +rand = { workspace = true } +rand_chacha = { workspace = true } +gum = { workspace = true, default-features = true } [dev-dependencies] -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" } +sp-keyring = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } +polkadot-node-subsystem-test-helpers = { workspace = true } -assert_matches = "1.4.0" -async-trait = "0.1.79" -parking_lot = "0.12.1" -lazy_static = "1.4.0" -quickcheck = "1.0.3" +assert_matches = { workspace = true } +async-trait = { workspace = true } +parking_lot = { workspace = true, default-features = true } +lazy_static = { workspace = true } +quickcheck = { workspace = true, default-features = true } diff --git a/polkadot/node/network/gossip-support/src/lib.rs b/polkadot/node/network/gossip-support/src/lib.rs index 4dfdd1f7208f66ec4a787ffe8bc7f72c41575c9d..cd327c11e408c5117f9679938eb157e713b7afd9 100644 --- a/polkadot/node/network/gossip-support/src/lib.rs +++ b/polkadot/node/network/gossip-support/src/lib.rs @@ -69,6 +69,16 @@ const BACKOFF_DURATION: Duration = Duration::from_secs(5); #[cfg(test)] const BACKOFF_DURATION: Duration = Duration::from_millis(500); +// The authorithy_discovery queries runs every ten minutes, +// so it make sense to run a bit more often than that to +// detect changes as often as we can, but not too often since +// it won't help. +#[cfg(not(test))] +const TRY_RERESOLVE_AUTHORITIES: Duration = Duration::from_secs(5 * 60); + +#[cfg(test)] +const TRY_RERESOLVE_AUTHORITIES: Duration = Duration::from_secs(2); + /// Duration after which we consider low connectivity a problem. /// /// Especially at startup low connectivity is expected (authority discovery cache needs to be @@ -91,6 +101,14 @@ pub struct GossipSupport { // `None` otherwise. last_failure: Option, + // Validators can restart during a session, so if they change + // their PeerID, we will connect to them in the best case after + // a session, so we need to try more often to resolved peers and + // reconnect to them. The authorithy_discovery queries runs every ten + // minutes, so we can't detect changes in the address more often + // that that. + last_connection_request: Option, + /// First time we did not reach our connectivity threshold. /// /// This is the time of the first failed attempt to connect to >2/3 of all validators in a @@ -131,6 +149,7 @@ where keystore, last_session_index: None, last_failure: None, + last_connection_request: None, failure_start: None, resolved_authorities: HashMap::new(), connected_authorities: HashMap::new(), @@ -196,15 +215,22 @@ where for leaf in leaves { let current_index = util::request_session_index_for_child(leaf, sender).await.await??; let since_failure = self.last_failure.map(|i| i.elapsed()).unwrap_or_default(); + let since_last_reconnect = + self.last_connection_request.map(|i| i.elapsed()).unwrap_or_default(); + let force_request = since_failure >= BACKOFF_DURATION; + let re_resolve_authorities = since_last_reconnect >= TRY_RERESOLVE_AUTHORITIES; let leaf_session = Some((current_index, leaf)); let maybe_new_session = match self.last_session_index { Some(i) if current_index <= i => None, _ => leaf_session, }; - let maybe_issue_connection = - if force_request { leaf_session } else { maybe_new_session }; + let maybe_issue_connection = if force_request || re_resolve_authorities { + leaf_session + } else { + maybe_new_session + }; if let Some((session_index, relay_parent)) = maybe_issue_connection { let session_info = @@ -248,7 +274,7 @@ where // connections to a much broader set of validators. { let mut connections = authorities_past_present_future(sender, leaf).await?; - + self.last_connection_request = Some(Instant::now()); // Remove all of our locally controlled validator indices so we don't connect to // ourself. let connections = @@ -259,7 +285,12 @@ where // to clean up all connections. Vec::new() }; - self.issue_connection_request(sender, connections).await; + + if force_request || is_new_session { + self.issue_connection_request(sender, connections).await; + } else if re_resolve_authorities { + self.issue_connection_request_to_changed(sender, connections).await; + } } if is_new_session { @@ -324,17 +355,14 @@ where authority_check_result } - async fn issue_connection_request( + async fn resolve_authorities( &mut self, - sender: &mut Sender, authorities: Vec, - ) where - Sender: overseer::GossipSupportSenderTrait, - { - let num = authorities.len(); + ) -> (Vec>, HashMap>, usize) { let mut validator_addrs = Vec::with_capacity(authorities.len()); - let mut failures = 0; let mut resolved = HashMap::with_capacity(authorities.len()); + let mut failures = 0; + for authority in authorities { if let Some(addrs) = self.authority_discovery.get_addresses_by_authority_id(authority.clone()).await @@ -350,6 +378,67 @@ where ); } } + (validator_addrs, resolved, failures) + } + + async fn issue_connection_request_to_changed( + &mut self, + sender: &mut Sender, + authorities: Vec, + ) where + Sender: overseer::GossipSupportSenderTrait, + { + let (_, resolved, _) = self.resolve_authorities(authorities).await; + + let mut changed = Vec::new(); + + for (authority, new_addresses) in &resolved { + let new_peer_ids = new_addresses + .iter() + .flat_map(|addr| parse_addr(addr.clone()).ok().map(|(p, _)| p)) + .collect::>(); + match self.resolved_authorities.get(authority) { + Some(old_addresses) => { + let old_peer_ids = old_addresses + .iter() + .flat_map(|addr| parse_addr(addr.clone()).ok().map(|(p, _)| p)) + .collect::>(); + if !old_peer_ids.is_superset(&new_peer_ids) { + changed.push(new_addresses.clone()); + } + }, + None => changed.push(new_addresses.clone()), + } + } + gum::debug!( + target: LOG_TARGET, + num_changed = ?changed.len(), + ?changed, + "Issuing a connection request to changed validators" + ); + if !changed.is_empty() { + self.resolved_authorities = resolved; + + sender + .send_message(NetworkBridgeTxMessage::AddToResolvedValidators { + validator_addrs: changed, + peer_set: PeerSet::Validation, + }) + .await; + } + } + + async fn issue_connection_request( + &mut self, + sender: &mut Sender, + authorities: Vec, + ) where + Sender: overseer::GossipSupportSenderTrait, + { + let num = authorities.len(); + + let (validator_addrs, resolved, failures) = self.resolve_authorities(authorities).await; + self.resolved_authorities = resolved; gum::debug!(target: LOG_TARGET, %num, "Issuing a connection request"); @@ -399,16 +488,24 @@ where { let mut authority_ids: HashMap> = HashMap::new(); for authority in authorities { - let peer_id = self + let peer_ids = self .authority_discovery .get_addresses_by_authority_id(authority.clone()) .await .into_iter() .flat_map(|list| list.into_iter()) - .find_map(|addr| parse_addr(addr).ok().map(|(p, _)| p)); + .flat_map(|addr| parse_addr(addr).ok().map(|(p, _)| p)) + .collect::>(); + + gum::trace!( + target: LOG_TARGET, + ?peer_ids, + ?authority, + "Resolved to peer ids" + ); - if let Some(p) = peer_id { - authority_ids.entry(p).or_default().insert(authority); + for p in peer_ids { + authority_ids.entry(p).or_default().insert(authority.clone()); } } diff --git a/polkadot/node/network/gossip-support/src/tests.rs b/polkadot/node/network/gossip-support/src/tests.rs index cce78df38f308e34e1c663ab2c27850c818e26f8..09622254f523e5605f8b203645819b2ea176dcfd 100644 --- a/polkadot/node/network/gossip-support/src/tests.rs +++ b/polkadot/node/network/gossip-support/src/tests.rs @@ -90,7 +90,8 @@ lazy_static! { ]; } -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; #[derive(Debug, Clone)] struct MockAuthorityDiscovery { @@ -118,6 +119,14 @@ impl MockAuthorityDiscovery { } } + fn change_address_for_authority(&self, authority_id: AuthorityDiscoveryId) -> PeerId { + let new_peer_id = PeerId::random(); + let addr = Multiaddr::empty().with(Protocol::P2p(new_peer_id.into())); + self.addrs.lock().insert(authority_id.clone(), HashSet::from([addr])); + self.authorities.lock().insert(new_peer_id, HashSet::from([authority_id])); + new_peer_id + } + fn authorities(&self) -> HashMap> { self.authorities.lock().clone() } @@ -200,7 +209,8 @@ fn test_harness, AD: AuthorityDiscovery>( test_fn: impl FnOnce(VirtualOverseer) -> T, ) -> GossipSupport { let pool = sp_core::testing::TaskExecutor::new(); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = subsystem.run(context); @@ -807,6 +817,313 @@ fn issues_update_authorities_after_session() { ); } +// Test we connect to authorities that changed their address `TRY_RERESOLVE_AUTHORITIES` rate +// and that is is no-op if no authority changed. +#[test] +fn test_quickly_connect_to_authorities_that_changed_address() { + let hash = Hash::repeat_byte(0xAA); + + let authorities = PAST_PRESENT_FUTURE_AUTHORITIES.clone(); + let authority_that_changes_address = authorities.get(5).unwrap().clone(); + + let mut authority_discovery_mock = MockAuthorityDiscovery::new(authorities); + + test_harness( + make_subsystem_with_authority_discovery(authority_discovery_mock.clone()), + |mut virtual_overseer| async move { + let overseer = &mut virtual_overseer; + // 1. Initialize with the first leaf in the session. + overseer_signal_active_leaves(overseer, hash).await; + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionIndexForChild(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(1)).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionInfo(s, tx), + )) => { + assert_eq!(relay_parent, hash); + assert_eq!(s, 1); + let mut session_info = make_session_info(); + session_info.discovery_keys = PAST_PRESENT_FUTURE_AUTHORITIES.clone(); + tx.send(Ok(Some(session_info))).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::Authorities(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(PAST_PRESENT_FUTURE_AUTHORITIES.clone())).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ConnectToResolvedValidators { + validator_addrs, + peer_set, + }) => { + let all_without_ferdie: Vec<_> = PAST_PRESENT_FUTURE_AUTHORITIES + .iter() + .cloned() + .filter(|p| p != &Sr25519Keyring::Ferdie.public().into()) + .collect(); + + let addrs = get_multiaddrs(all_without_ferdie, authority_discovery_mock.clone()).await; + + assert_eq!(validator_addrs, addrs); + assert_eq!(peer_set, PeerSet::Validation); + } + ); + + // Ensure neighbors are unaffected + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + _, + RuntimeApiRequest::CurrentBabeEpoch(tx), + )) => { + let _ = tx.send(Ok(BabeEpoch { + epoch_index: 2 as _, + start_slot: 0.into(), + duration: 200, + authorities: vec![(Sr25519Keyring::Alice.public().into(), 1)], + randomness: [0u8; 32], + config: BabeEpochConfiguration { + c: (1, 4), + allowed_slots: AllowedSlots::PrimarySlots, + }, + })).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeRx(NetworkBridgeRxMessage::NewGossipTopology { + session: _, + local_index: _, + canonical_shuffling: _, + shuffled_indices: _, + }) => { + + } + ); + + // 2. Connect all authorities that are known so far. + let known_authorities = authority_discovery_mock.authorities(); + for (peer_id, _id) in known_authorities.iter() { + let msg = + GossipSupportMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerConnected( + *peer_id, + ObservedRole::Authority, + ValidationVersion::V3.into(), + None, + )); + overseer.send(FromOrchestra::Communication { msg }).await + } + + // 3. Send a new leaf after TRY_RERESOLVE_AUTHORITIES, we should notice + // UpdateAuthorithies is emitted for all ConnectedPeers. + Delay::new(TRY_RERESOLVE_AUTHORITIES).await; + let hash = Hash::repeat_byte(0xBB); + overseer_signal_active_leaves(overseer, hash).await; + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionIndexForChild(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(1)).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionInfo(s, tx), + )) => { + assert_eq!(relay_parent, hash); + assert_eq!(s, 1); + let mut session_info = make_session_info(); + session_info.discovery_keys = PAST_PRESENT_FUTURE_AUTHORITIES.clone(); + tx.send(Ok(Some(session_info))).unwrap(); + + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::Authorities(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(PAST_PRESENT_FUTURE_AUTHORITIES.clone())).unwrap(); + } + ); + + for _ in 0..known_authorities.len() { + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeRx(NetworkBridgeRxMessage::UpdatedAuthorityIds { + peer_id, + authority_ids, + }) => { + assert_eq!(authority_discovery_mock.get_authority_ids_by_peer_id(peer_id).await.unwrap_or_default(), authority_ids); + } + ); + } + + // 4. At next re-resolve no-authorithy changes their address, so it should be no-op. + Delay::new(TRY_RERESOLVE_AUTHORITIES).await; + let hash = Hash::repeat_byte(0xCC); + overseer_signal_active_leaves(overseer, hash).await; + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionIndexForChild(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(1)).unwrap(); + } + ); + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionInfo(s, tx), + )) => { + assert_eq!(relay_parent, hash); + assert_eq!(s, 1); + let mut session_info = make_session_info(); + session_info.discovery_keys = PAST_PRESENT_FUTURE_AUTHORITIES.clone(); + tx.send(Ok(Some(session_info))).unwrap(); + + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::Authorities(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(PAST_PRESENT_FUTURE_AUTHORITIES.clone())).unwrap(); + } + ); + assert!(overseer.recv().timeout(TIMEOUT).await.is_none()); + + // Change address for one authorithy and check we try to connect to it and + // that we emit UpdateAuthorityID for the old PeerId and the new one. + Delay::new(TRY_RERESOLVE_AUTHORITIES).await; + let changed_peerid = authority_discovery_mock + .change_address_for_authority(authority_that_changes_address.clone()); + let hash = Hash::repeat_byte(0xDD); + let msg = GossipSupportMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerConnected( + changed_peerid, + ObservedRole::Authority, + ValidationVersion::V3.into(), + None, + )); + overseer.send(FromOrchestra::Communication { msg }).await; + + overseer_signal_active_leaves(overseer, hash).await; + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionIndexForChild(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(1)).unwrap(); + } + ); + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::SessionInfo(s, tx), + )) => { + assert_eq!(relay_parent, hash); + assert_eq!(s, 1); + let mut session_info = make_session_info(); + session_info.discovery_keys = PAST_PRESENT_FUTURE_AUTHORITIES.clone(); + tx.send(Ok(Some(session_info))).unwrap(); + + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::RuntimeApi(RuntimeApiMessage::Request( + relay_parent, + RuntimeApiRequest::Authorities(tx), + )) => { + assert_eq!(relay_parent, hash); + tx.send(Ok(PAST_PRESENT_FUTURE_AUTHORITIES.clone())).unwrap(); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::AddToResolvedValidators { + validator_addrs, + peer_set, + }) => { + let expected = get_address_map(vec![authority_that_changes_address.clone()], authority_discovery_mock.clone()).await; + let expected: HashSet = expected.into_values().flat_map(|v| v.into_iter()).collect(); + assert_eq!(validator_addrs.into_iter().flat_map(|v| v.into_iter()).collect::>(), expected); + assert_eq!(peer_set, PeerSet::Validation); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeRx(NetworkBridgeRxMessage::UpdatedAuthorityIds { + peer_id, + authority_ids, + }) => { + assert_eq!(authority_discovery_mock.get_authority_ids_by_peer_id(peer_id).await.unwrap(), HashSet::from([authority_that_changes_address.clone()])); + assert!(authority_ids.is_empty()); + } + ); + + assert_matches!( + overseer_recv(overseer).await, + AllMessages::NetworkBridgeRx(NetworkBridgeRxMessage::UpdatedAuthorityIds { + peer_id, + authority_ids, + }) => { + assert_eq!(authority_ids, HashSet::from([authority_that_changes_address])); + assert_eq!(changed_peerid, peer_id); + } + ); + + assert!(overseer.recv().timeout(TIMEOUT).await.is_none()); + + virtual_overseer + }, + ); +} + #[test] fn disconnect_when_not_in_past_present_future() { sp_tracing::try_init_simple(); diff --git a/polkadot/node/network/protocol/Cargo.toml b/polkadot/node/network/protocol/Cargo.toml index 0408e673791114793da1b231baa7448f185b0db6..c9ae23d756cfc4d39d44286b7a567ed46969bf02 100644 --- a/polkadot/node/network/protocol/Cargo.toml +++ b/polkadot/node/network/protocol/Cargo.toml @@ -10,25 +10,25 @@ description = "Primitives types for the Node-side" workspace = true [dependencies] -async-channel = "1.8.0" -async-trait = "0.1.79" -hex = "0.4.3" -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-jaeger = { path = "../../jaeger" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sc-network = { path = "../../../../substrate/client/network" } -sc-network-types = { path = "../../../../substrate/client/network/types" } -sc-authority-discovery = { path = "../../../../substrate/client/authority-discovery" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -strum = { version = "0.26.2", features = ["derive"] } -futures = "0.3.30" +async-channel = { workspace = true } +async-trait = { workspace = true } +hex = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } +codec = { features = ["derive"], workspace = true } +sc-network = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sc-authority-discovery = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +strum = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } thiserror = { workspace = true } -fatality = "0.0.6" -rand = "0.8" -derive_more = "0.99" -gum = { package = "tracing-gum", path = "../../gum" } -bitvec = "1" +fatality = { workspace = true } +rand = { workspace = true, default-features = true } +derive_more = { workspace = true, default-features = true } +gum = { workspace = true, default-features = true } +bitvec = { workspace = true, default-features = true } [dev-dependencies] -rand_chacha = "0.3.1" +rand_chacha = { workspace = true, default-features = true } diff --git a/polkadot/node/network/protocol/src/grid_topology.rs b/polkadot/node/network/protocol/src/grid_topology.rs index a14d24610722bfad2d26df9526d8e6d7411e6f68..4dd7d29fc25cde5a010e6c4c28969c142dba6098 100644 --- a/polkadot/node/network/protocol/src/grid_topology.rs +++ b/polkadot/node/network/protocol/src/grid_topology.rs @@ -313,6 +313,23 @@ impl SessionGridTopologyEntry { self.topology.is_validator(peer) } + /// Returns the list of peers to route based on the required routing. + pub fn peers_to_route(&self, required_routing: RequiredRouting) -> Vec { + match required_routing { + RequiredRouting::All => self.topology.peer_ids.iter().copied().collect(), + RequiredRouting::GridX => self.local_neighbors.peers_x.iter().copied().collect(), + RequiredRouting::GridY => self.local_neighbors.peers_y.iter().copied().collect(), + RequiredRouting::GridXY => self + .local_neighbors + .peers_x + .iter() + .chain(self.local_neighbors.peers_y.iter()) + .copied() + .collect(), + RequiredRouting::None | RequiredRouting::PendingTopology => Vec::new(), + } + } + /// Updates the known peer ids for the passed authorities ids. pub fn update_authority_ids( &mut self, @@ -524,6 +541,11 @@ impl RandomRouting { pub fn inc_sent(&mut self) { self.sent += 1 } + + /// Returns `true` if we already took all the necessary samples. + pub fn is_complete(&self) -> bool { + self.sent >= self.target + } } /// Routing mode diff --git a/polkadot/node/network/protocol/src/lib.rs b/polkadot/node/network/protocol/src/lib.rs index c38838b1ef9845eb85c929066eb7de108374fa0d..ca0f8a4e48493691d7c1cb43579e9420c8a88274 100644 --- a/polkadot/node/network/protocol/src/lib.rs +++ b/polkadot/node/network/protocol/src/lib.rs @@ -19,7 +19,7 @@ #![deny(unused_crate_dependencies)] #![warn(missing_docs)] -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_primitives::{BlockNumber, Hash}; use std::{collections::HashMap, fmt}; @@ -462,7 +462,7 @@ impl_versioned_try_from!( /// v1 notification protocol types. pub mod v1 { - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; use polkadot_primitives::{ CandidateHash, CandidateIndex, CollatorId, CollatorSignature, CompactStatement, Hash, @@ -621,7 +621,7 @@ pub mod v1 { /// v2 network protocol types. pub mod v2 { use bitvec::{order::Lsb0, slice::BitSlice, vec::BitVec}; - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; use polkadot_primitives::{ CandidateHash, CandidateIndex, CollatorId, CollatorSignature, GroupIndex, Hash, @@ -875,7 +875,7 @@ pub mod v2 { /// Purpose is for changing ApprovalDistributionMessage to /// include more than one assignment and approval in a message. pub mod v3 { - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; use polkadot_node_primitives::approval::v2::{ CandidateBitfield, IndirectAssignmentCertV2, IndirectSignedApprovalVoteV2, diff --git a/polkadot/node/network/protocol/src/request_response/incoming/error.rs b/polkadot/node/network/protocol/src/request_response/incoming/error.rs index 7de9d919058ab05d3c91832c7d9829173d948e43..d3aa0b7275c13501f62fb0ca3be2c364e79d1883 100644 --- a/polkadot/node/network/protocol/src/request_response/incoming/error.rs +++ b/polkadot/node/network/protocol/src/request_response/incoming/error.rs @@ -18,7 +18,7 @@ use sc_network_types::PeerId; -use parity_scale_codec::Error as DecodingError; +use codec::Error as DecodingError; #[allow(missing_docs)] #[fatality::fatality(splitable)] diff --git a/polkadot/node/network/protocol/src/request_response/incoming/mod.rs b/polkadot/node/network/protocol/src/request_response/incoming/mod.rs index e85390729ee3f99f4a74b4cf2b90ac225c819fc6..9577c690ebdc8c9b64fa66426af178c63e58cc34 100644 --- a/polkadot/node/network/protocol/src/request_response/incoming/mod.rs +++ b/polkadot/node/network/protocol/src/request_response/incoming/mod.rs @@ -18,7 +18,7 @@ use std::marker::PhantomData; use futures::{channel::oneshot, StreamExt}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use sc_network::{config as netconfig, NetworkBackend}; use sc_network_types::PeerId; diff --git a/polkadot/node/network/protocol/src/request_response/mod.rs b/polkadot/node/network/protocol/src/request_response/mod.rs index cab02bb88a00b429a80ce25e342fd38e25b3f3d5..fe06593bd7a0f58202471483cc06980ee35a2926 100644 --- a/polkadot/node/network/protocol/src/request_response/mod.rs +++ b/polkadot/node/network/protocol/src/request_response/mod.rs @@ -98,6 +98,10 @@ pub enum Protocol { /// Protocol for requesting candidates with attestations in statement distribution /// when async backing is enabled. AttestedCandidateV2, + + /// Protocol for chunk fetching version 2, used by availability distribution and availability + /// recovery. + ChunkFetchingV2, } /// Minimum bandwidth we expect for validators - 500Mbit/s is the recommendation, so approximately @@ -209,7 +213,7 @@ impl Protocol { let name = req_protocol_names.get_name(self); let legacy_names = self.get_legacy_name().into_iter().map(Into::into).collect(); match self { - Protocol::ChunkFetchingV1 => N::request_response_config( + Protocol::ChunkFetchingV1 | Protocol::ChunkFetchingV2 => N::request_response_config( name, legacy_names, 1_000, @@ -292,7 +296,7 @@ impl Protocol { // times (due to network delays), 100 seems big enough to accommodate for "bursts", // assuming we can service requests relatively quickly, which would need to be measured // as well. - Protocol::ChunkFetchingV1 => 100, + Protocol::ChunkFetchingV1 | Protocol::ChunkFetchingV2 => 100, // 10 seems reasonable, considering group sizes of max 10 validators. Protocol::CollationFetchingV1 | Protocol::CollationFetchingV2 => 10, // 10 seems reasonable, considering group sizes of max 10 validators. @@ -362,6 +366,7 @@ impl Protocol { // Introduced after legacy names became legacy. Protocol::AttestedCandidateV2 => None, Protocol::CollationFetchingV2 => None, + Protocol::ChunkFetchingV2 => None, } } } @@ -412,6 +417,7 @@ impl ReqProtocolNames { }; let short_name = match protocol { + // V1: Protocol::ChunkFetchingV1 => "/req_chunk/1", Protocol::CollationFetchingV1 => "/req_collation/1", Protocol::PoVFetchingV1 => "/req_pov/1", @@ -419,8 +425,10 @@ impl ReqProtocolNames { Protocol::StatementFetchingV1 => "/req_statement/1", Protocol::DisputeSendingV1 => "/send_dispute/1", + // V2: Protocol::CollationFetchingV2 => "/req_collation/2", Protocol::AttestedCandidateV2 => "/req_attested_candidate/2", + Protocol::ChunkFetchingV2 => "/req_chunk/2", }; format!("{}{}", prefix, short_name).into() diff --git a/polkadot/node/network/protocol/src/request_response/outgoing.rs b/polkadot/node/network/protocol/src/request_response/outgoing.rs index 96ef4a6ab25dcc13949e6b3dfbc0e8c6856393f5..27f0f34bf8d4ac43080077a964243f8085c1a12b 100644 --- a/polkadot/node/network/protocol/src/request_response/outgoing.rs +++ b/polkadot/node/network/protocol/src/request_response/outgoing.rs @@ -16,8 +16,8 @@ use futures::{channel::oneshot, prelude::Future, FutureExt}; +use codec::{Decode, Encode, Error as DecodingError}; use network::ProtocolName; -use parity_scale_codec::{Decode, Encode, Error as DecodingError}; use sc_network as network; use sc_network_types::PeerId; @@ -30,7 +30,7 @@ use super::{v1, v2, IsRequest, Protocol}; #[derive(Debug)] pub enum Requests { /// Request an availability chunk from a node. - ChunkFetchingV1(OutgoingRequest), + ChunkFetching(OutgoingRequest), /// Fetch a collation from a collator which previously announced it. CollationFetchingV1(OutgoingRequest), /// Fetch a PoV from a validator which previously sent out a seconded statement. @@ -59,7 +59,7 @@ impl Requests { /// contained in the `enum`. pub fn encode_request(self) -> (Protocol, OutgoingRequest>) { match self { - Self::ChunkFetchingV1(r) => r.encode_request(), + Self::ChunkFetching(r) => r.encode_request(), Self::CollationFetchingV1(r) => r.encode_request(), Self::CollationFetchingV2(r) => r.encode_request(), Self::PoVFetchingV1(r) => r.encode_request(), @@ -164,24 +164,20 @@ where /// /// Returns a raw `Vec` response over the channel. Use the associated `ProtocolName` to know /// which request was the successful one and appropriately decode the response. - // WARNING: This is commented for now because it's not used yet. - // If you need it, make sure to test it. You may need to enable the V1 substream upgrade - // protocol, unless libp2p was in the meantime updated to a version that fixes the problem - // described in https://github.com/libp2p/rust-libp2p/issues/5074 - // pub fn new_with_fallback( - // peer: Recipient, - // payload: Req, - // fallback_request: FallbackReq, - // ) -> (Self, impl Future, ProtocolName)>>) { - // let (tx, rx) = oneshot::channel(); - // let r = Self { - // peer, - // payload, - // pending_response: tx, - // fallback_request: Some((fallback_request, FallbackReq::PROTOCOL)), - // }; - // (r, async { Ok(rx.await??) }) - // } + pub fn new_with_fallback( + peer: Recipient, + payload: Req, + fallback_request: FallbackReq, + ) -> (Self, impl Future, ProtocolName)>>) { + let (tx, rx) = oneshot::channel(); + let r = Self { + peer, + payload, + pending_response: tx, + fallback_request: Some((fallback_request, FallbackReq::PROTOCOL)), + }; + (r, async { Ok(rx.await??) }) + } /// Encode a request into a `Vec`. /// diff --git a/polkadot/node/network/protocol/src/request_response/v1.rs b/polkadot/node/network/protocol/src/request_response/v1.rs index 60eecb69f738912ddb0240c890e2283db7f91a72..80721f1884afd04e7abd0634dc62b3357b2307b4 100644 --- a/polkadot/node/network/protocol/src/request_response/v1.rs +++ b/polkadot/node/network/protocol/src/request_response/v1.rs @@ -16,7 +16,7 @@ //! Requests and responses as sent over the wire for the individual protocols. -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_primitives::{ AvailableData, DisputeMessage, ErasureChunk, PoV, Proof, UncheckedDisputeMessage, @@ -33,7 +33,8 @@ use super::{IsRequest, Protocol}; pub struct ChunkFetchingRequest { /// Hash of candidate we want a chunk for. pub candidate_hash: CandidateHash, - /// The index of the chunk to fetch. + /// The validator index we are requesting from. This must be identical to the index of the + /// chunk we'll receive. For v2, this may not be the case. pub index: ValidatorIndex, } @@ -57,6 +58,15 @@ impl From> for ChunkFetchingResponse { } } +impl From for Option { + fn from(x: ChunkFetchingResponse) -> Self { + match x { + ChunkFetchingResponse::Chunk(c) => Some(c), + ChunkFetchingResponse::NoSuchChunk => None, + } + } +} + /// Skimmed down variant of `ErasureChunk`. /// /// Instead of transmitting a full `ErasureChunk` we transmit `ChunkResponse` in @@ -80,7 +90,7 @@ impl From for ChunkResponse { impl ChunkResponse { /// Re-build an `ErasureChunk` from response and request. pub fn recombine_into_chunk(self, req: &ChunkFetchingRequest) -> ErasureChunk { - ErasureChunk { chunk: self.chunk, proof: self.proof, index: req.index } + ErasureChunk { chunk: self.chunk, proof: self.proof, index: req.index.into() } } } diff --git a/polkadot/node/network/protocol/src/request_response/v2.rs b/polkadot/node/network/protocol/src/request_response/v2.rs index 6b90c579237fbff95496035f461c5cc4c5202984..ae65b39cd406e9f337a1e7d6a1d04468249c22c8 100644 --- a/polkadot/node/network/protocol/src/request_response/v2.rs +++ b/polkadot/node/network/protocol/src/request_response/v2.rs @@ -16,14 +16,15 @@ //! Requests and responses as sent over the wire for the individual protocols. -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; +use polkadot_node_primitives::ErasureChunk; use polkadot_primitives::{ CandidateHash, CommittedCandidateReceipt, Hash, Id as ParaId, PersistedValidationData, - UncheckedSignedStatement, + UncheckedSignedStatement, ValidatorIndex, }; -use super::{IsRequest, Protocol}; +use super::{v1, IsRequest, Protocol}; use crate::v2::StatementFilter; /// Request a candidate with statements. @@ -78,3 +79,60 @@ impl IsRequest for CollationFetchingRequest { type Response = CollationFetchingResponse; const PROTOCOL: Protocol = Protocol::CollationFetchingV2; } + +/// Request an availability chunk. +#[derive(Debug, Copy, Clone, Encode, Decode)] +pub struct ChunkFetchingRequest { + /// Hash of candidate we want a chunk for. + pub candidate_hash: CandidateHash, + /// The validator index we are requesting from. This may not be identical to the index of the + /// chunk we'll receive. It's up to the caller to decide whether they need to validate they got + /// the chunk they were expecting. + pub index: ValidatorIndex, +} + +/// Receive a requested erasure chunk. +#[derive(Debug, Clone, Encode, Decode)] +pub enum ChunkFetchingResponse { + /// The requested chunk data. + #[codec(index = 0)] + Chunk(ErasureChunk), + /// Node was not in possession of the requested chunk. + #[codec(index = 1)] + NoSuchChunk, +} + +impl From> for ChunkFetchingResponse { + fn from(x: Option) -> Self { + match x { + Some(c) => ChunkFetchingResponse::Chunk(c), + None => ChunkFetchingResponse::NoSuchChunk, + } + } +} + +impl From for Option { + fn from(x: ChunkFetchingResponse) -> Self { + match x { + ChunkFetchingResponse::Chunk(c) => Some(c), + ChunkFetchingResponse::NoSuchChunk => None, + } + } +} + +impl From for ChunkFetchingRequest { + fn from(v1::ChunkFetchingRequest { candidate_hash, index }: v1::ChunkFetchingRequest) -> Self { + Self { candidate_hash, index } + } +} + +impl From for v1::ChunkFetchingRequest { + fn from(ChunkFetchingRequest { candidate_hash, index }: ChunkFetchingRequest) -> Self { + Self { candidate_hash, index } + } +} + +impl IsRequest for ChunkFetchingRequest { + type Response = ChunkFetchingResponse; + const PROTOCOL: Protocol = Protocol::ChunkFetchingV2; +} diff --git a/polkadot/node/network/statement-distribution/Cargo.toml b/polkadot/node/network/statement-distribution/Cargo.toml index d8ae031cbf36dabf2899e61574958ffdbde62921..2a9773ddde4bd316d3133086131399829ffc5626 100644 --- a/polkadot/node/network/statement-distribution/Cargo.toml +++ b/polkadot/node/network/statement-distribution/Cargo.toml @@ -10,35 +10,45 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -futures-timer = "3.0.2" -gum = { package = "tracing-gum", path = "../../gum" } -polkadot-primitives = { path = "../../../primitives" } -sp-staking = { path = "../../../../substrate/primitives/staking", default-features = false } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-node-subsystem-util = { path = "../../subsystem-util" } -polkadot-node-network-protocol = { path = "../protocol" } -arrayvec = "0.7.4" -indexmap = "2.0.0" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +futures = { workspace = true } +futures-timer = { workspace = true } +gum = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +sp-staking = { workspace = true } +sp-keystore = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +arrayvec = { workspace = true } +indexmap = { workspace = true } +codec = { features = ["derive"], workspace = true } thiserror = { workspace = true } -fatality = "0.0.6" -bitvec = "1" +fatality = { workspace = true } +bitvec = { workspace = true, default-features = true } [dev-dependencies] -async-channel = "1.8.0" -assert_matches = "1.4.0" -polkadot-node-subsystem-test-helpers = { path = "../../subsystem-test-helpers" } -sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-application-crypto = { path = "../../../../substrate/primitives/application-crypto" } -sp-keystore = { path = "../../../../substrate/primitives/keystore" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -sc-keystore = { path = "../../../../substrate/client/keystore" } -sc-network = { path = "../../../../substrate/client/network" } -futures-timer = "3.0.2" -polkadot-primitives-test-helpers = { path = "../../../primitives/test-helpers" } -rand_chacha = "0.3" +async-channel = { workspace = true } +assert_matches = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-authority-discovery = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +futures-timer = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +rand_chacha = { workspace = true, default-features = true } +polkadot-subsystem-bench = { workspace = true } + +[[bench]] +name = "statement-distribution-regression-bench" +path = "benches/statement-distribution-regression-bench.rs" +harness = false +required-features = ["subsystem-benchmarks"] + +[features] +subsystem-benchmarks = [] diff --git a/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs b/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs new file mode 100644 index 0000000000000000000000000000000000000000..4e7206e0a366d0ff85728313f307ec4a8caf81ea --- /dev/null +++ b/polkadot/node/network/statement-distribution/benches/statement-distribution-regression-bench.rs @@ -0,0 +1,74 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! statement-distribution regression tests +//! +//! Statement distribution benchmark based on Kusama parameters and scale. + +use polkadot_subsystem_bench::{ + configuration::TestConfiguration, + statement::{benchmark_statement_distribution, prepare_test, TestState}, + usage::BenchmarkUsage, + utils::save_to_file, +}; +use std::io::Write; + +const BENCH_COUNT: usize = 50; + +fn main() -> Result<(), String> { + let mut messages = vec![]; + let mut config = TestConfiguration::default(); + config.n_cores = 100; + config.n_validators = 500; + config.num_blocks = 10; + config.connectivity = 100; + config.generate_pov_sizes(); + let state = TestState::new(&config); + + println!("Benchmarking..."); + let usages: Vec = (0..BENCH_COUNT) + .map(|n| { + print!("\r[{}{}]", "#".repeat(n), "_".repeat(BENCH_COUNT - n)); + std::io::stdout().flush().unwrap(); + let (mut env, _cfgs) = prepare_test(&state, false); + env.runtime().block_on(benchmark_statement_distribution(&mut env, &state)) + }) + .collect(); + println!("\rDone!{}", " ".repeat(BENCH_COUNT)); + + let average_usage = BenchmarkUsage::average(&usages); + save_to_file( + "charts/statement-distribution-regression-bench.json", + average_usage.to_chart_json().map_err(|e| e.to_string())?, + ) + .map_err(|e| e.to_string())?; + println!("{}", average_usage); + + // We expect no variance for received and sent + // but use 0.001 because we operate with floats + messages.extend(average_usage.check_network_usage(&[ + ("Received from peers", 106.4000, 0.001), + ("Sent to peers", 127.9100, 0.001), + ])); + messages.extend(average_usage.check_cpu_usage(&[("statement-distribution", 0.0374, 0.1)])); + + if messages.is_empty() { + Ok(()) + } else { + eprintln!("{}", messages.join("\n")); + Err("Regressions found".to_string()) + } +} diff --git a/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs b/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs index e22883f8937606475efc01225fcd6f98e4ee0f08..264333435a00ed074e0b1b47b96a51ae2e3e4441 100644 --- a/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs +++ b/polkadot/node/network/statement-distribution/src/legacy_v1/mod.rs @@ -14,8 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use codec::Encode; use net_protocol::{filter_by_peer_version, peer_set::ProtocolVersion}; -use parity_scale_codec::Encode; use polkadot_node_network_protocol::{ self as net_protocol, diff --git a/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs b/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs index d4c5f95034ae8061b81f8019c86fcd44b0530cf5..8e6fcbaebbf1404f123321e2fe7ff3e90d8cf43a 100644 --- a/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs +++ b/polkadot/node/network/statement-distribution/src/legacy_v1/tests.rs @@ -20,9 +20,9 @@ use super::*; use crate::{metrics::Metrics, *}; use assert_matches::assert_matches; +use codec::{Decode, Encode}; use futures::executor; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_network_protocol::{ grid_topology::{SessionGridTopology, TopologyPeerInfo}, peer_set::ValidationVersion, diff --git a/polkadot/node/network/statement-distribution/src/lib.rs b/polkadot/node/network/statement-distribution/src/lib.rs index 4ca199c3378bfc80eeee9c5f2985b1ad570e5736..33431eb1edce585943100e4c23d7234a39779f9c 100644 --- a/polkadot/node/network/statement-distribution/src/lib.rs +++ b/polkadot/node/network/statement-distribution/src/lib.rs @@ -19,7 +19,6 @@ //! This is responsible for distributing signed statements about candidate //! validity among validators. -#![deny(unused_crate_dependencies)] #![warn(missing_docs)] use error::{log_error, FatalResult}; @@ -285,7 +284,14 @@ impl StatementDistributionSubsystem { ); }, MuxedMessage::Response(result) => { - v2::handle_response(&mut ctx, &mut state, result, &mut self.reputation).await; + v2::handle_response( + &mut ctx, + &mut state, + result, + &mut self.reputation, + &self.metrics, + ) + .await; }, MuxedMessage::RetryRequest(()) => { // A pending request is ready to retry. This is only a signal to call @@ -321,7 +327,8 @@ impl StatementDistributionSubsystem { let mode = prospective_parachains_mode(ctx.sender(), activated.hash).await?; if let ProspectiveParachainsMode::Enabled { .. } = mode { let res = - v2::handle_active_leaves_update(ctx, state, activated, mode).await; + v2::handle_active_leaves_update(ctx, state, activated, mode, &metrics) + .await; // Regardless of the result of leaf activation, we always prune before // handling it to avoid leaks. v2::handle_deactivate_leaves(state, &deactivated); @@ -371,6 +378,7 @@ impl StatementDistributionSubsystem { relay_parent, statement, &mut self.reputation, + &self.metrics, ) .await?; } @@ -429,11 +437,24 @@ impl StatementDistributionSubsystem { if target.targets_current() { // pass to v2. - v2::handle_network_update(ctx, state, event, &mut self.reputation).await; + v2::handle_network_update( + ctx, + state, + event, + &mut self.reputation, + &self.metrics, + ) + .await; } }, StatementDistributionMessage::Backed(candidate_hash) => { - crate::v2::handle_backed_candidate_message(ctx, state, candidate_hash).await; + crate::v2::handle_backed_candidate_message( + ctx, + state, + candidate_hash, + &self.metrics, + ) + .await; }, }, } diff --git a/polkadot/node/network/statement-distribution/src/metrics.rs b/polkadot/node/network/statement-distribution/src/metrics.rs index 1bc994174263905d3058154ead29eaaa16bd2ad4..e21fff1e6421e3c90df07c6c1c1237721ce33760 100644 --- a/polkadot/node/network/statement-distribution/src/metrics.rs +++ b/polkadot/node/network/statement-distribution/src/metrics.rs @@ -25,13 +25,13 @@ const HISTOGRAM_LATENCY_BUCKETS: &[f64] = &[ #[derive(Clone)] struct MetricsInner { // V1 - statements_distributed: prometheus::Counter, sent_requests: prometheus::Counter, received_responses: prometheus::CounterVec, network_bridge_update: prometheus::HistogramVec, statements_unexpected: prometheus::CounterVec, created_message_size: prometheus::Gauge, // V1+ + statements_distributed: prometheus::Counter, active_leaves_update: prometheus::Histogram, share: prometheus::Histogram, // V2+ @@ -51,6 +51,13 @@ impl Metrics { } } + /// Update statements distributed counter by an amount + pub fn on_statements_distributed(&self, n: usize) { + if let Some(metrics) = &self.0 { + metrics.statements_distributed.inc_by(n as u64); + } + } + /// Update sent requests counter /// This counter is updated merely for the statements sent via request/response method, /// meaning that it counts large statements only diff --git a/polkadot/node/network/statement-distribution/src/v2/candidates.rs b/polkadot/node/network/statement-distribution/src/v2/candidates.rs index ad56ad4a2365b94e6ced0e43ce0747d99fb6a80d..a4f2455c28401f536d449268591e2f9746a9db81 100644 --- a/polkadot/node/network/statement-distribution/src/v2/candidates.rs +++ b/polkadot/node/network/statement-distribution/src/v2/candidates.rs @@ -243,12 +243,12 @@ impl Candidates { /// Whether statements from a candidate are importable. /// /// This is only true when the candidate is known, confirmed, - /// and is importable in a fragment tree. + /// and is importable in a fragment chain. pub fn is_importable(&self, candidate_hash: &CandidateHash) -> bool { self.get_confirmed(candidate_hash).map_or(false, |c| c.is_importable(None)) } - /// Note that a candidate is importable in a fragment tree indicated by the given + /// Note that a candidate is importable in a fragment chain indicated by the given /// leaf hash. pub fn note_importable_under(&mut self, candidate: &HypotheticalCandidate, leaf_hash: Hash) { match candidate { diff --git a/polkadot/node/network/statement-distribution/src/v2/cluster.rs b/polkadot/node/network/statement-distribution/src/v2/cluster.rs index c3f45314b2464e1125a797686c51827e022b0403..26d7a68eb2a74256c8fd73cc684bde80995db291 100644 --- a/polkadot/node/network/statement-distribution/src/v2/cluster.rs +++ b/polkadot/node/network/statement-distribution/src/v2/cluster.rs @@ -60,13 +60,6 @@ use polkadot_primitives::{CandidateHash, CompactStatement, Hash, ValidatorIndex} use crate::LOG_TARGET; use std::collections::{HashMap, HashSet}; -#[derive(Hash, PartialEq, Eq)] -struct ValidStatementManifest { - remote: ValidatorIndex, - originator: ValidatorIndex, - candidate_hash: CandidateHash, -} - // A piece of knowledge about a candidate #[derive(Hash, Clone, PartialEq, Eq)] enum Knowledge { @@ -436,7 +429,9 @@ impl ClusterTracker { pub fn warn_if_too_many_pending_statements(&self, parent_hash: Hash) { if self.pending.iter().filter(|pending| !pending.1.is_empty()).count() >= - self.validators.len() + self.validators.len() && + // No reason to warn if we are the only node in the cluster. + self.validators.len() > 1 { gum::warn!( target: LOG_TARGET, diff --git a/polkadot/node/network/statement-distribution/src/v2/grid.rs b/polkadot/node/network/statement-distribution/src/v2/grid.rs index 24d846c840e00c49446a0525b3768353f56ae524..b6e4163090c4d5fe00a22c61b50d99b74e69c8bd 100644 --- a/polkadot/node/network/statement-distribution/src/v2/grid.rs +++ b/polkadot/node/network/statement-distribution/src/v2/grid.rs @@ -46,10 +46,8 @@ //! - Request/response for the candidate + votes. //! - Ignore if they are inconsistent with the manifest. //! - A malicious backing group is capable of producing an unbounded number of backed candidates. -//! - We request the candidate only if the candidate has a hypothetical depth in any of our -//! fragment trees, and: -//! - the seconding validators have not seconded any other candidates at that depth in any of -//! those fragment trees +//! - We request the candidate only if the candidate is a hypothetical member in any of our +//! fragment chains, and: //! - All members of the group attempt to circulate all statements (in compact form) from the rest //! of the group on candidates that have already been backed. //! - They do this via the grid topology. diff --git a/polkadot/node/network/statement-distribution/src/v2/mod.rs b/polkadot/node/network/statement-distribution/src/v2/mod.rs index 8579ac15cbc13f5186acea86f4dab492b943c4aa..f9c2d0ddbae8b373485f90a510137bc7e42c9271 100644 --- a/polkadot/node/network/statement-distribution/src/v2/mod.rs +++ b/polkadot/node/network/statement-distribution/src/v2/mod.rs @@ -37,7 +37,7 @@ use polkadot_node_primitives::{ use polkadot_node_subsystem::{ messages::{ network_bridge_event::NewGossipTopology, CandidateBackingMessage, HypotheticalCandidate, - HypotheticalFrontierRequest, NetworkBridgeEvent, NetworkBridgeTxMessage, + HypotheticalMembershipRequest, NetworkBridgeEvent, NetworkBridgeTxMessage, ProspectiveParachainsMessage, }, overseer, ActivatedLeaf, @@ -45,8 +45,9 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_util::{ backing_implicit_view::View as ImplicitView, reputation::ReputationAggregator, - runtime::{request_min_backing_votes, ProspectiveParachainsMode}, - vstaging::{fetch_claim_queue, ClaimQueueSnapshot}, + runtime::{ + fetch_claim_queue, request_min_backing_votes, ClaimQueueSnapshot, ProspectiveParachainsMode, + }, }; use polkadot_primitives::{ AuthorityDiscoveryId, CandidateHash, CompactStatement, CoreIndex, CoreState, GroupIndex, @@ -68,7 +69,7 @@ use futures::{ use std::{ collections::{ hash_map::{Entry, HashMap}, - BTreeSet, HashSet, + HashSet, }, time::{Duration, Instant}, }; @@ -156,6 +157,7 @@ struct PerRelayParentState { seconding_limit: usize, session: SessionIndex, groups_per_para: HashMap>, + disabled_validators: HashSet, } impl PerRelayParentState { @@ -166,6 +168,17 @@ impl PerRelayParentState { fn active_validator_state_mut(&mut self) -> Option<&mut ActiveValidatorState> { self.local_validator.as_mut().and_then(|local| local.active.as_mut()) } + + /// Returns `true` if the given validator is disabled in the context of the relay parent. + pub fn is_disabled(&self, validator_index: &ValidatorIndex) -> bool { + self.disabled_validators.contains(validator_index) + } + + /// A convenience function to generate a disabled bitmask for the given backing group. + /// The output bits are set to `true` for validators that are disabled. + pub fn disabled_bitmask(&self, group: &[ValidatorIndex]) -> BitVec { + BitVec::from_iter(group.iter().map(|v| self.is_disabled(v))) + } } // per-relay-parent local validator state. @@ -183,8 +196,8 @@ struct ActiveValidatorState { index: ValidatorIndex, // our validator group group: GroupIndex, - // the assignment of our validator group, if any. - assignment: Option, + // the assignments of our validator group, if any. + assignments: Vec, // the 'direct-in-group' communication at this relay-parent. cluster_tracker: ClusterTracker, } @@ -206,8 +219,6 @@ struct PerSessionState { // getting the topology from the gossip-support subsystem grid_view: Option, local_validator: Option, - // We store the latest state here based on union of leaves. - disabled_validators: BTreeSet, } impl PerSessionState { @@ -224,16 +235,7 @@ impl PerSessionState { ) .map(|(_, index)| LocalValidatorIndex::Active(index)); - let disabled_validators = BTreeSet::new(); - - PerSessionState { - session_info, - groups, - authority_lookup, - grid_view: None, - local_validator, - disabled_validators, - } + PerSessionState { session_info, groups, authority_lookup, grid_view: None, local_validator } } fn supply_topology( @@ -269,33 +271,6 @@ impl PerSessionState { fn is_not_validator(&self) -> bool { self.grid_view.is_some() && self.local_validator.is_none() } - - /// A convenience function to generate a disabled bitmask for the given backing group. - /// The output bits are set to `true` for validators that are disabled. - /// Returns `None` if the group index is out of bounds. - pub fn disabled_bitmask(&self, group: GroupIndex) -> Option> { - let group = self.groups.get(group)?; - let mask = BitVec::from_iter(group.iter().map(|v| self.is_disabled(v))); - Some(mask) - } - - /// Returns `true` if the given validator is disabled in the current session. - pub fn is_disabled(&self, validator_index: &ValidatorIndex) -> bool { - self.disabled_validators.contains(validator_index) - } - - /// Extend the list of disabled validators. - pub fn extend_disabled_validators( - &mut self, - disabled: impl IntoIterator, - ) { - self.disabled_validators.extend(disabled); - } - - /// Clear the list of disabled validators. - pub fn clear_disabled_validators(&mut self) { - self.disabled_validators.clear(); - } } pub(crate) struct State { @@ -426,6 +401,7 @@ pub(crate) async fn handle_network_update( state: &mut State, update: NetworkBridgeEvent, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { match update { NetworkBridgeEvent::PeerConnected(peer_id, role, protocol_version, mut authority_ids) => { @@ -509,23 +485,33 @@ pub(crate) async fn handle_network_update( net_protocol::StatementDistributionMessage::V3( protocol_v3::StatementDistributionMessage::Statement(relay_parent, statement), ) => - handle_incoming_statement(ctx, state, peer_id, relay_parent, statement, reputation) - .await, + handle_incoming_statement( + ctx, + state, + peer_id, + relay_parent, + statement, + reputation, + metrics, + ) + .await, net_protocol::StatementDistributionMessage::V2( protocol_v2::StatementDistributionMessage::BackedCandidateManifest(inner), ) | net_protocol::StatementDistributionMessage::V3( protocol_v3::StatementDistributionMessage::BackedCandidateManifest(inner), - ) => handle_incoming_manifest(ctx, state, peer_id, inner, reputation).await, + ) => handle_incoming_manifest(ctx, state, peer_id, inner, reputation, metrics).await, net_protocol::StatementDistributionMessage::V2( protocol_v2::StatementDistributionMessage::BackedCandidateKnown(inner), ) | net_protocol::StatementDistributionMessage::V3( protocol_v3::StatementDistributionMessage::BackedCandidateKnown(inner), - ) => handle_incoming_acknowledgement(ctx, state, peer_id, inner, reputation).await, + ) => + handle_incoming_acknowledgement(ctx, state, peer_id, inner, reputation, metrics) + .await, }, NetworkBridgeEvent::PeerViewChange(peer_id, view) => - handle_peer_view_update(ctx, state, peer_id, view).await, + handle_peer_view_update(ctx, state, peer_id, view, metrics).await, NetworkBridgeEvent::OurViewChange(_view) => { // handled by `handle_activated_leaf` }, @@ -565,6 +551,7 @@ pub(crate) async fn handle_active_leaves_update( state: &mut State, activated: &ActivatedLeaf, leaf_mode: ProspectiveParachainsMode, + metrics: &Metrics, ) -> JfyiErrorResult<()> { let max_candidate_depth = match leaf_mode { ProspectiveParachainsMode::Disabled => return Ok(()), @@ -582,19 +569,16 @@ pub(crate) async fn handle_active_leaves_update( let new_relay_parents = state.implicit_view.all_allowed_relay_parents().cloned().collect::>(); - // We clear the list of disabled validators to reset it properly based on union of leaves. - let mut cleared_disabled_validators: BTreeSet = BTreeSet::new(); - for new_relay_parent in new_relay_parents.iter().cloned() { - // Even if we processed this relay parent before, we need to fetch the list of disabled - // validators based on union of active leaves. - let disabled_validators = - polkadot_node_subsystem_util::vstaging::get_disabled_validators_with_fallback( + let disabled_validators: HashSet<_> = + polkadot_node_subsystem_util::runtime::get_disabled_validators_with_fallback( ctx.sender(), new_relay_parent, ) .await - .map_err(JfyiError::FetchDisabledValidators)?; + .map_err(JfyiError::FetchDisabledValidators)? + .into_iter() + .collect(); let session_index = polkadot_node_subsystem_util::request_session_index_for_child( new_relay_parent, @@ -644,10 +628,6 @@ pub(crate) async fn handle_active_leaves_update( .get_mut(&session_index) .expect("either existed or just inserted; qed"); - if cleared_disabled_validators.insert(session_index) { - per_session.clear_disabled_validators(); - } - if !disabled_validators.is_empty() { gum::debug!( target: LOG_TARGET, @@ -656,8 +636,6 @@ pub(crate) async fn handle_active_leaves_update( ?disabled_validators, "Disabled validators detected" ); - - per_session.extend_disabled_validators(disabled_validators); } if state.per_relay_parent.contains_key(&new_relay_parent) { @@ -723,6 +701,7 @@ pub(crate) async fn handle_active_leaves_update( seconding_limit, session: session_index, groups_per_para, + disabled_validators, }, ); } @@ -748,12 +727,13 @@ pub(crate) async fn handle_active_leaves_update( for (peer, fresh) in update_peers { for fresh_relay_parent in fresh { - send_peer_messages_for_relay_parent(ctx, state, peer, fresh_relay_parent).await; + send_peer_messages_for_relay_parent(ctx, state, peer, fresh_relay_parent, metrics) + .await; } } } - new_leaf_fragment_tree_updates(ctx, state, activated.hash).await; + new_leaf_fragment_chain_updates(ctx, state, activated.hash).await; Ok(()) } @@ -774,8 +754,8 @@ fn find_active_validator_state( let our_group = groups.by_validator_index(validator_index)?; let core_index = group_rotation_info.core_for_group(our_group, availability_cores.len()); - let para_assigned_to_core = if let Some(claim_queue) = maybe_claim_queue { - claim_queue.get_claim_for(core_index, 0) + let paras_assigned_to_core = if let Some(claim_queue) = maybe_claim_queue { + claim_queue.iter_claims_for_core(&core_index).copied().collect() } else { availability_cores .get(core_index.0 as usize) @@ -787,6 +767,8 @@ fn find_active_validator_state( .map(|scheduled_core| scheduled_core.para_id), CoreState::Free | CoreState::Occupied(_) => None, }) + .into_iter() + .collect() }; let group_validators = groups.get(our_group)?.to_owned(); @@ -794,7 +776,7 @@ fn find_active_validator_state( active: Some(ActiveValidatorState { index: validator_index, group: our_group, - assignment: para_assigned_to_core, + assignments: paras_assigned_to_core, cluster_tracker: ClusterTracker::new(group_validators, seconding_limit) .expect("group is non-empty because we are in it; qed"), }), @@ -847,6 +829,7 @@ async fn handle_peer_view_update( state: &mut State, peer: PeerId, new_view: View, + metrics: &Metrics, ) { let fresh_implicit = { let peer_data = match state.peers.get_mut(&peer) { @@ -858,7 +841,7 @@ async fn handle_peer_view_update( }; for new_relay_parent in fresh_implicit { - send_peer_messages_for_relay_parent(ctx, state, peer, new_relay_parent).await; + send_peer_messages_for_relay_parent(ctx, state, peer, new_relay_parent, metrics).await; } } @@ -889,6 +872,7 @@ async fn send_peer_messages_for_relay_parent( state: &mut State, peer: PeerId, relay_parent: Hash, + metrics: &Metrics, ) { let peer_data = match state.peers.get_mut(&peer) { None => return, @@ -921,6 +905,7 @@ async fn send_peer_messages_for_relay_parent( &mut active.cluster_tracker, &state.candidates, &relay_parent_state.statement_store, + metrics, ) .await; } @@ -933,6 +918,7 @@ async fn send_peer_messages_for_relay_parent( &per_session_state.groups, relay_parent_state, &state.candidates, + metrics, ) .await; } @@ -981,6 +967,7 @@ async fn send_pending_cluster_statements( cluster_tracker: &mut ClusterTracker, candidates: &Candidates, statement_store: &StatementStore, + metrics: &Metrics, ) { let pending_statements = cluster_tracker.pending_statements_for(peer_validator_id); let network_messages = pending_statements @@ -1006,12 +993,12 @@ async fn send_pending_cluster_statements( }) .collect::>(); - if network_messages.is_empty() { - return + if !network_messages.is_empty() { + let count = network_messages.len(); + ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(network_messages)) + .await; + metrics.on_statements_distributed(count); } - - ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(network_messages)) - .await; } /// Send a peer all pending grid messages / acknowledgements / follow up statements @@ -1025,6 +1012,7 @@ async fn send_pending_grid_messages( groups: &Groups, relay_parent_state: &mut PerRelayParentState, candidates: &Candidates, + metrics: &Metrics, ) { let pending_manifests = { let local_validator = match relay_parent_state.local_validator.as_mut() { @@ -1037,6 +1025,7 @@ async fn send_pending_grid_messages( }; let mut messages: Vec<(Vec, net_protocol::VersionedValidationProtocol)> = Vec::new(); + let mut statements_count = 0; for (candidate_hash, kind) in pending_manifests { let confirmed_candidate = match candidates.get_confirmed(&candidate_hash) { None => continue, // sanity @@ -1111,7 +1100,7 @@ async fn send_pending_grid_messages( }; }, grid::ManifestKind::Acknowledgement => { - messages.extend(acknowledgement_and_statement_messages( + let (m, c) = acknowledgement_and_statement_messages( peer_id, peer_validator_id, groups, @@ -1120,7 +1109,9 @@ async fn send_pending_grid_messages( group_index, candidate_hash, local_knowledge, - )); + ); + messages.extend(m); + statements_count += c; }, } } @@ -1139,8 +1130,9 @@ async fn send_pending_grid_messages( let pending_statements = grid_tracker.all_pending_statements_for(peer_validator_id); - let extra_statements = - pending_statements.into_iter().filter_map(|(originator, compact)| { + let extra_statements = pending_statements + .into_iter() + .filter_map(|(originator, compact)| { let res = pending_statement_network_message( &relay_parent_state.statement_store, relay_parent, @@ -1160,15 +1152,17 @@ async fn send_pending_grid_messages( } res - }); + }) + .collect::>(); + statements_count += extra_statements.len(); messages.extend(extra_statements); } - if messages.is_empty() { - return + if !messages.is_empty() { + ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(messages)).await; + metrics.on_statements_distributed(statements_count); } - ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(messages)).await; } // Imports a locally originating statement and distributes it to peers. @@ -1179,6 +1173,7 @@ pub(crate) async fn share_local_statement( relay_parent: Hash, statement: SignedFullStatementWithPVD, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) -> JfyiErrorResult<()> { let per_relay_parent = match state.per_relay_parent.get_mut(&relay_parent) { None => return Err(JfyiError::InvalidShare), @@ -1196,10 +1191,10 @@ pub(crate) async fn share_local_statement( None => return Ok(()), }; - let (local_index, local_assignment, local_group) = + let (local_index, local_assignments, local_group) = match per_relay_parent.active_validator_state() { None => return Err(JfyiError::InvalidShare), - Some(l) => (l.index, l.assignment, l.group), + Some(l) => (l.index, &l.assignments, l.group), }; // Two possibilities: either the statement is `Seconded` or we already @@ -1237,7 +1232,7 @@ pub(crate) async fn share_local_statement( return Err(JfyiError::InvalidShare) } - if local_assignment != Some(expected_para) || relay_parent != expected_relay_parent { + if !local_assignments.contains(&expected_para) || relay_parent != expected_relay_parent { return Err(JfyiError::InvalidShare) } @@ -1301,11 +1296,12 @@ pub(crate) async fn share_local_statement( &state.authorities, &state.peers, compact_statement, + metrics, ) .await; if let Some(post_confirmation) = post_confirmation { - apply_post_confirmation(ctx, state, post_confirmation, reputation).await; + apply_post_confirmation(ctx, state, post_confirmation, reputation, metrics).await; } Ok(()) @@ -1342,6 +1338,7 @@ async fn circulate_statement( authorities: &HashMap, peers: &HashMap, statement: SignedStatement, + metrics: &Metrics, ) { let session_info = &per_session.session_info; @@ -1478,6 +1475,7 @@ async fn circulate_statement( .into(), )) .await; + metrics.on_statement_distributed(); } if !statement_to_v3_peers.is_empty() { @@ -1497,6 +1495,7 @@ async fn circulate_statement( .into(), )) .await; + metrics.on_statement_distributed(); } } /// Check a statement signature under this parent hash. @@ -1543,6 +1542,7 @@ async fn handle_incoming_statement( relay_parent: Hash, statement: UncheckedSignedStatement, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { let peer_state = match state.peers.get(&peer) { None => { @@ -1581,6 +1581,17 @@ async fn handle_incoming_statement( }; let session_info = &per_session.session_info; + if per_relay_parent.is_disabled(&statement.unchecked_validator_index()) { + gum::debug!( + target: LOG_TARGET, + ?relay_parent, + validator_index = ?statement.unchecked_validator_index(), + "Ignoring a statement from disabled validator." + ); + modify_reputation(reputation, ctx.sender(), peer, COST_DISABLED_VALIDATOR).await; + return + } + let local_validator = match per_relay_parent.local_validator.as_mut() { None => { // we shouldn't be receiving statements unless we're a validator @@ -1614,17 +1625,6 @@ async fn handle_incoming_statement( }, }; - if per_session.is_disabled(&statement.unchecked_validator_index()) { - gum::debug!( - target: LOG_TARGET, - ?relay_parent, - validator_index = ?statement.unchecked_validator_index(), - "Ignoring a statement from disabled validator." - ); - modify_reputation(reputation, ctx.sender(), peer, COST_DISABLED_VALIDATOR).await; - return - } - let (active, cluster_sender_index) = { // This block of code only returns `Some` when both the originator and // the sending peer are in the cluster. @@ -1819,6 +1819,7 @@ async fn handle_incoming_statement( &state.authorities, &state.peers, checked_statement, + metrics, ) .await; } else { @@ -1976,6 +1977,7 @@ async fn provide_candidate_to_grid( per_session: &PerSessionState, authorities: &HashMap, peers: &HashMap, + metrics: &Metrics, ) { let local_validator = match relay_parent_state.local_validator { Some(ref mut v) => v, @@ -2163,8 +2165,10 @@ async fn provide_candidate_to_grid( .await; } if !post_statements.is_empty() { + let count = post_statements.len(); ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(post_statements)) .await; + metrics.on_statements_distributed(count); } } @@ -2178,12 +2182,11 @@ async fn determine_groups_per_para( let n_cores = availability_cores.len(); // Determine the core indices occupied by each para at the current relay parent. To support - // on-demand parachains we also consider the core indices at next block if core has a candidate - // pending availability. - let para_core_indices: Vec<_> = if let Some(claim_queue) = maybe_claim_queue { + // on-demand parachains we also consider the core indices at next blocks. + let schedule: HashMap> = if let Some(claim_queue) = maybe_claim_queue { claim_queue - .iter_claims_at_depth(0) - .map(|(core_index, para)| (para, core_index)) + .iter_all_claims() + .map(|(core_index, paras)| (*core_index, paras.iter().copied().collect())) .collect() } else { availability_cores @@ -2191,12 +2194,12 @@ async fn determine_groups_per_para( .enumerate() .filter_map(|(index, core)| match core { CoreState::Scheduled(scheduled_core) => - Some((scheduled_core.para_id, CoreIndex(index as u32))), + Some((CoreIndex(index as u32), vec![scheduled_core.para_id])), CoreState::Occupied(occupied_core) => if max_candidate_depth >= 1 { - occupied_core - .next_up_on_available - .map(|scheduled_core| (scheduled_core.para_id, CoreIndex(index as u32))) + occupied_core.next_up_on_available.map(|scheduled_core| { + (CoreIndex(index as u32), vec![scheduled_core.para_id]) + }) } else { None }, @@ -2207,16 +2210,19 @@ async fn determine_groups_per_para( let mut groups_per_para = HashMap::new(); // Map from `CoreIndex` to `GroupIndex` and collect as `HashMap`. - for (para, core_index) in para_core_indices { + for (core_index, paras) in schedule { let group_index = group_rotation_info.group_for_core(core_index, n_cores); - groups_per_para.entry(para).or_insert_with(Vec::new).push(group_index) + + for para in paras { + groups_per_para.entry(para).or_insert_with(Vec::new).push(group_index); + } } groups_per_para } #[overseer::contextbounds(StatementDistribution, prefix=self::overseer)] -async fn fragment_tree_update_inner( +async fn fragment_chain_update_inner( ctx: &mut Context, state: &mut State, active_leaf_hash: Option, @@ -2230,31 +2236,36 @@ async fn fragment_tree_update_inner( }; // 2. find out which are in the frontier - let frontier = { + gum::debug!( + target: LOG_TARGET, + active_leaf_hash = ?active_leaf_hash, + "Calling getHypotheticalMembership from statement distribution for candidates: {:?}", + &hypotheticals.iter().map(|hypo| hypo.candidate_hash()).collect::>() + ); + let candidate_memberships = { let (tx, rx) = oneshot::channel(); - ctx.send_message(ProspectiveParachainsMessage::GetHypotheticalFrontier( - HypotheticalFrontierRequest { + ctx.send_message(ProspectiveParachainsMessage::GetHypotheticalMembership( + HypotheticalMembershipRequest { candidates: hypotheticals, - fragment_tree_relay_parent: active_leaf_hash, - backed_in_path_only: false, + fragment_chain_relay_parent: active_leaf_hash, }, tx, )) .await; match rx.await { - Ok(frontier) => frontier, + Ok(candidate_memberships) => candidate_memberships, Err(oneshot::Canceled) => return, } }; // 3. note that they are importable under a given leaf hash. - for (hypo, membership) in frontier { - // skip parablocks outside of the frontier + for (hypo, membership) in candidate_memberships { + // skip parablocks which aren't potential candidates if membership.is_empty() { continue } - for (leaf_hash, _) in membership { + for leaf_hash in membership { state.candidates.note_importable_under(&hypo, leaf_hash); } @@ -2298,31 +2309,31 @@ async fn fragment_tree_update_inner( } #[overseer::contextbounds(StatementDistribution, prefix=self::overseer)] -async fn new_leaf_fragment_tree_updates( +async fn new_leaf_fragment_chain_updates( ctx: &mut Context, state: &mut State, leaf_hash: Hash, ) { - fragment_tree_update_inner(ctx, state, Some(leaf_hash), None, None).await + fragment_chain_update_inner(ctx, state, Some(leaf_hash), None, None).await } #[overseer::contextbounds(StatementDistribution, prefix=self::overseer)] -async fn prospective_backed_notification_fragment_tree_updates( +async fn prospective_backed_notification_fragment_chain_updates( ctx: &mut Context, state: &mut State, para_id: ParaId, para_head: Hash, ) { - fragment_tree_update_inner(ctx, state, None, Some((para_head, para_id)), None).await + fragment_chain_update_inner(ctx, state, None, Some((para_head, para_id)), None).await } #[overseer::contextbounds(StatementDistribution, prefix=self::overseer)] -async fn new_confirmed_candidate_fragment_tree_updates( +async fn new_confirmed_candidate_fragment_chain_updates( ctx: &mut Context, state: &mut State, candidate: HypotheticalCandidate, ) { - fragment_tree_update_inner(ctx, state, None, None, Some(vec![candidate])).await + fragment_chain_update_inner(ctx, state, None, None, Some(vec![candidate])).await } struct ManifestImportSuccess<'a> { @@ -2376,21 +2387,18 @@ async fn handle_incoming_manifest_common<'a, Context>( Some(s) => s, }; - let local_validator = match relay_parent_state.local_validator.as_mut() { - None => { - if per_session.is_not_validator() { - modify_reputation( - reputation, - ctx.sender(), - peer, - COST_UNEXPECTED_MANIFEST_MISSING_KNOWLEDGE, - ) - .await; - } - return None - }, - Some(x) => x, - }; + if relay_parent_state.local_validator.is_none() { + if per_session.is_not_validator() { + modify_reputation( + reputation, + ctx.sender(), + peer, + COST_UNEXPECTED_MANIFEST_MISSING_KNOWLEDGE, + ) + .await; + } + return None + } let Some(expected_groups) = relay_parent_state.groups_per_para.get(¶_id) else { modify_reputation(reputation, ctx.sender(), peer, COST_MALFORMED_MANIFEST).await; @@ -2433,10 +2441,13 @@ async fn handle_incoming_manifest_common<'a, Context>( let claimed_parent_hash = manifest_summary.claimed_parent_hash; // Ignore votes from disabled validators when counting towards the threshold. - let disabled_mask = per_session.disabled_bitmask(group_index).unwrap_or_default(); + let group = per_session.groups.get(group_index).unwrap_or(&[]); + let disabled_mask = relay_parent_state.disabled_bitmask(group); manifest_summary.statement_knowledge.mask_seconded(&disabled_mask); manifest_summary.statement_knowledge.mask_valid(&disabled_mask); + let local_validator = relay_parent_state.local_validator.as_mut().expect("checked above; qed"); + let acknowledge = match local_validator.grid_tracker.import_manifest( grid_topology, &per_session.groups, @@ -2559,6 +2570,7 @@ async fn handle_incoming_manifest( peer: PeerId, manifest: net_protocol::v2::BackedCandidateManifest, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { gum::debug!( target: LOG_TARGET, @@ -2615,7 +2627,7 @@ async fn handle_incoming_manifest( ) }; - let messages = acknowledgement_and_statement_messages( + let (messages, statements_count) = acknowledgement_and_statement_messages( &( peer, state @@ -2636,6 +2648,7 @@ async fn handle_incoming_manifest( if !messages.is_empty() { ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages(messages)).await; + metrics.on_statements_distributed(statements_count); } } else if !state.candidates.is_confirmed(&manifest.candidate_hash) { // 5. if unconfirmed, add request entry @@ -2663,9 +2676,9 @@ fn acknowledgement_and_statement_messages( group_index: GroupIndex, candidate_hash: CandidateHash, local_knowledge: StatementFilter, -) -> Vec<(Vec, net_protocol::VersionedValidationProtocol)> { +) -> (Vec<(Vec, net_protocol::VersionedValidationProtocol)>, usize) { let local_validator = match relay_parent_state.local_validator.as_mut() { - None => return Vec::new(), + None => return (Vec::new(), 0), Some(l) => l, }; @@ -2693,7 +2706,7 @@ fn acknowledgement_and_statement_messages( "Bug ValidationVersion::V1 should not be used in statement-distribution v2, legacy should have handled this" ); - return Vec::new() + return (Vec::new(), 0) }, }; @@ -2714,10 +2727,11 @@ fn acknowledgement_and_statement_messages( candidate_hash, peer, ); + let statements_count = statement_messages.len(); messages.extend(statement_messages.into_iter().map(|m| (vec![peer.0], m))); - messages + (messages, statements_count) } #[overseer::contextbounds(StatementDistribution, prefix=self::overseer)] @@ -2727,6 +2741,7 @@ async fn handle_incoming_acknowledgement( peer: PeerId, acknowledgement: net_protocol::v2::BackedCandidateAcknowledgement, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { // The key difference between acknowledgments and full manifests is that only // the candidate hash is included alongside the bitfields, so the candidate @@ -2807,10 +2822,12 @@ async fn handle_incoming_acknowledgement( ); if !messages.is_empty() { + let count = messages.len(); ctx.send_message(NetworkBridgeTxMessage::SendValidationMessages( messages.into_iter().map(|m| (vec![peer], m)).collect(), )) .await; + metrics.on_statements_distributed(count); } } @@ -2820,6 +2837,7 @@ pub(crate) async fn handle_backed_candidate_message( ctx: &mut Context, state: &mut State, candidate_hash: CandidateHash, + metrics: &Metrics, ) { // If the candidate is unknown or unconfirmed, it's a race (pruned before receiving message) // or a bug. Ignore if so @@ -2861,11 +2879,12 @@ pub(crate) async fn handle_backed_candidate_message( per_session, &state.authorities, &state.peers, + metrics, ) .await; // Search for children of the backed candidate to request. - prospective_backed_notification_fragment_tree_updates( + prospective_backed_notification_fragment_chain_updates( ctx, state, confirmed.para_id(), @@ -2882,6 +2901,7 @@ async fn send_cluster_candidate_statements( state: &mut State, candidate_hash: CandidateHash, relay_parent: Hash, + metrics: &Metrics, ) { let relay_parent_state = match state.per_relay_parent.get_mut(&relay_parent) { None => return, @@ -2924,6 +2944,7 @@ async fn send_cluster_candidate_statements( &state.authorities, &state.peers, statement, + metrics, ) .await; } @@ -2941,6 +2962,7 @@ async fn apply_post_confirmation( state: &mut State, post_confirmation: PostConfirmation, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { for peer in post_confirmation.reckoning.incorrect { modify_reputation(reputation, ctx.sender(), peer, COST_INACCURATE_ADVERTISEMENT).await; @@ -2954,9 +2976,11 @@ async fn apply_post_confirmation( state, candidate_hash, post_confirmation.hypothetical.relay_parent(), + metrics, ) .await; - new_confirmed_candidate_fragment_tree_updates(ctx, state, post_confirmation.hypothetical).await; + new_confirmed_candidate_fragment_chain_updates(ctx, state, post_confirmation.hypothetical) + .await; } /// Dispatch pending requests for candidate data & statements. @@ -3014,9 +3038,7 @@ pub(crate) async fn dispatch_requests(ctx: &mut Context, state: &mut St } // Add disabled validators to the unwanted mask. - let disabled_mask = per_session - .disabled_bitmask(group_index) - .expect("group existence checked above; qed"); + let disabled_mask = relay_parent_state.disabled_bitmask(group); unwanted_mask.seconded_in_group |= &disabled_mask; unwanted_mask.validated_in_group |= &disabled_mask; @@ -3080,6 +3102,7 @@ pub(crate) async fn handle_response( state: &mut State, response: UnhandledResponse, reputation: &mut ReputationAggregator, + metrics: &Metrics, ) { let &requests::CandidateIdentifier { relay_parent, candidate_hash, group_index } = response.candidate_identifier(); @@ -3107,9 +3130,7 @@ pub(crate) async fn handle_response( Some(g) => g, }; - let disabled_mask = per_session - .disabled_bitmask(group_index) - .expect("group_index checked above; qed"); + let disabled_mask = relay_parent_state.disabled_bitmask(group); let res = response.validate_response( &mut state.request_manager, @@ -3181,12 +3202,12 @@ pub(crate) async fn handle_response( }; // Note that this implicitly circulates all statements via the cluster. - apply_post_confirmation(ctx, state, post_confirmation, reputation).await; + apply_post_confirmation(ctx, state, post_confirmation, reputation, metrics).await; let confirmed = state.candidates.get_confirmed(&candidate_hash).expect("just confirmed; qed"); - // Although the candidate is confirmed, it isn't yet on the - // hypothetical frontier of the fragment tree. Later, when it is, + // Although the candidate is confirmed, it isn't yet a + // hypothetical member of the fragment chain. Later, when it is, // we will import statements. if !confirmed.is_importable(None) { return @@ -3254,7 +3275,7 @@ pub(crate) fn answer_request(state: &mut State, message: ResponderMessage) { Some(s) => s, }; - let local_validator = match relay_parent_state.local_validator.as_mut() { + let local_validator = match relay_parent_state.local_validator.as_ref() { None => return, Some(s) => s, }; @@ -3328,16 +3349,15 @@ pub(crate) fn answer_request(state: &mut State, message: ResponderMessage) { // Transform mask with 'OR' semantics into one with 'AND' semantics for the API used // below. - let mut and_mask = StatementFilter { + let and_mask = StatementFilter { seconded_in_group: !mask.seconded_in_group.clone(), validated_in_group: !mask.validated_in_group.clone(), }; - // Ignore disabled validators from the latest state when sending the response. - let disabled_mask = - per_session.disabled_bitmask(group_index).expect("group existence checked; qed"); - and_mask.mask_seconded(&disabled_mask); - and_mask.mask_valid(&disabled_mask); + let local_validator = match relay_parent_state.local_validator.as_mut() { + None => return, + Some(s) => s, + }; let mut sent_filter = StatementFilter::blank(group_size); let statements: Vec<_> = relay_parent_state diff --git a/polkadot/node/network/statement-distribution/src/v2/statement_store.rs b/polkadot/node/network/statement-distribution/src/v2/statement_store.rs index a3b2636d2ffcb6c761a3f9c2da89f88fecd9d981..56a54f6316c070df0111d22bbc9649fb8de6d0b4 100644 --- a/polkadot/node/network/statement-distribution/src/v2/statement_store.rs +++ b/polkadot/node/network/statement-distribution/src/v2/statement_store.rs @@ -292,7 +292,7 @@ impl GroupStatements { mod tests { use super::*; - use polkadot_primitives::v7::{Hash, SigningContext, ValidatorPair}; + use polkadot_primitives::{Hash, SigningContext, ValidatorPair}; use sp_application_crypto::Pair as PairT; #[test] diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/cluster.rs b/polkadot/node/network/statement-distribution/src/v2/tests/cluster.rs index 4fb033e08ce3af0724d5a8770bdb0abf942e38a5..fe51f953e244a560d7fe2e0bf414279fd0b8bf89 100644 --- a/polkadot/node/network/statement-distribution/src/v2/tests/cluster.rs +++ b/polkadot/node/network/statement-distribution/src/v2/tests/cluster.rs @@ -111,8 +111,8 @@ fn share_seconded_circulated_to_cluster() { ); // sharing a `Seconded` message confirms a candidate, which leads to new - // fragment tree updates. - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + // fragment chain updates. + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer }); @@ -509,7 +509,7 @@ fn seconded_statement_leads_to_request() { if p == peer_a && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer }); @@ -583,7 +583,7 @@ fn cluster_statements_shared_seconded_first() { .await; // result of new confirmed candidate. - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer .send(FromOrchestra::Communication { @@ -717,8 +717,8 @@ fn cluster_accounts_for_implicit_view() { ); // sharing a `Seconded` message confirms a candidate, which leads to new - // fragment tree updates. - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + // fragment chain updates. + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; // activate new leaf, which has relay-parent in implicit view. let next_relay_parent = Hash::repeat_byte(2); @@ -855,7 +855,7 @@ fn cluster_messages_imported_after_confirmed_candidate_importable_check() { ); } - answer_expected_hypothetical_depth_request( + answer_expected_hypothetical_membership_request( &mut overseer, vec![( HypotheticalCandidate::Complete { @@ -863,7 +863,7 @@ fn cluster_messages_imported_after_confirmed_candidate_importable_check() { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }, - vec![(relay_parent, vec![0])], + vec![relay_parent], )], ) .await; @@ -978,7 +978,7 @@ fn cluster_messages_imported_after_new_leaf_importable_check() { ); } - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; let next_relay_parent = Hash::repeat_byte(2); let mut next_test_leaf = state.make_dummy_leaf(next_relay_parent); @@ -996,7 +996,7 @@ fn cluster_messages_imported_after_new_leaf_importable_check() { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }, - vec![(relay_parent, vec![0])], + vec![relay_parent], )], ) .await; @@ -1113,7 +1113,7 @@ fn ensure_seconding_limit_is_respected() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Candidate 2. @@ -1139,7 +1139,7 @@ fn ensure_seconding_limit_is_respected() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Send first statement from peer A. diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/grid.rs b/polkadot/node/network/statement-distribution/src/v2/tests/grid.rs index 9d00a92e742bb6a304004ed74eb59ea8b6c5440c..d2bf031368c14a13f5da44dd29ba28376109f9bf 100644 --- a/polkadot/node/network/statement-distribution/src/v2/tests/grid.rs +++ b/polkadot/node/network/statement-distribution/src/v2/tests/grid.rs @@ -129,7 +129,7 @@ fn backed_candidate_leads_to_advertisement() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Send enough statements to make candidate backable, make sure announcements are sent. @@ -224,7 +224,7 @@ fn backed_candidate_leads_to_advertisement() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer @@ -384,7 +384,7 @@ fn received_advertisement_before_confirmation_leads_to_request() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer @@ -515,7 +515,7 @@ fn received_advertisement_after_backing_leads_to_acknowledgement() { assert_peer_reported!(&mut overseer, peer_c, BENEFIT_VALID_STATEMENT); assert_peer_reported!(&mut overseer, peer_c, BENEFIT_VALID_RESPONSE); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive Backed message. @@ -546,7 +546,7 @@ fn received_advertisement_after_backing_leads_to_acknowledgement() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive a manifest about the same candidate from peer D. @@ -720,7 +720,7 @@ fn received_acknowledgements_for_locally_confirmed() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive an unexpected acknowledgement from peer D. @@ -785,7 +785,7 @@ fn received_acknowledgements_for_locally_confirmed() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive an unexpected acknowledgement from peer D. @@ -918,7 +918,7 @@ fn received_acknowledgements_for_externally_confirmed() { assert_peer_reported!(&mut overseer, peer_c, BENEFIT_VALID_STATEMENT); assert_peer_reported!(&mut overseer, peer_c, BENEFIT_VALID_RESPONSE); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } let ack = BackedCandidateAcknowledgement { @@ -1101,7 +1101,7 @@ fn received_advertisement_after_confirmation_before_backing() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive advertisement from peer D (after confirmation but before backing). @@ -1272,9 +1272,12 @@ fn additional_statements_are_shared_after_manifest_exchange() { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }; - let membership = vec![(relay_parent, vec![0])]; - answer_expected_hypothetical_depth_request(&mut overseer, vec![(hypothetical, membership)]) - .await; + let membership = vec![relay_parent]; + answer_expected_hypothetical_membership_request( + &mut overseer, + vec![(hypothetical, membership)], + ) + .await; // Statements are sent to the Backing subsystem. { @@ -1338,7 +1341,7 @@ fn additional_statements_are_shared_after_manifest_exchange() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive a manifest about the same candidate from peer D. Contains different statements. @@ -1507,7 +1510,7 @@ fn advertisement_sent_when_peer_enters_relay_parent_view() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Send enough statements to make candidate backable, make sure announcements are sent. @@ -1574,7 +1577,7 @@ fn advertisement_sent_when_peer_enters_relay_parent_view() { }) .await; - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; // Relay parent enters view of peer C. { @@ -1721,7 +1724,7 @@ fn advertisement_not_re_sent_when_peer_re_enters_view() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Send enough statements to make candidate backable, make sure announcements are sent. @@ -1816,7 +1819,7 @@ fn advertisement_not_re_sent_when_peer_re_enters_view() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Peer leaves view. @@ -1982,9 +1985,12 @@ fn inner_grid_statements_imported_to_backing(groups_for_first_para: usize) { receipt: Arc::new(candidate.clone()), persisted_validation_data: pvd.clone(), }; - let membership = vec![(relay_parent, vec![0])]; - answer_expected_hypothetical_depth_request(&mut overseer, vec![(hypothetical, membership)]) - .await; + let membership = vec![relay_parent]; + answer_expected_hypothetical_membership_request( + &mut overseer, + vec![(hypothetical, membership)], + ) + .await; // Receive messages from Backing subsystem. { @@ -2616,7 +2622,7 @@ fn peer_reported_for_advertisement_conflicting_with_confirmed_candidate() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Receive conflicting advertisement from peer C after confirmation. @@ -2763,7 +2769,7 @@ fn inactive_local_participates_in_grid() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) if p == peer_a && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer }); diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs b/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs index 3d987d3fc433fbf62c1b05675da864b82f019536..119dc832d13a197c7e76c95c898c5f49e21b299f 100644 --- a/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs +++ b/polkadot/node/network/statement-distribution/src/v2/tests/mod.rs @@ -26,8 +26,8 @@ use polkadot_node_network_protocol::{ }; use polkadot_node_primitives::Statement; use polkadot_node_subsystem::messages::{ - network_bridge_event::NewGossipTopology, AllMessages, ChainApiMessage, FragmentTreeMembership, - HypotheticalCandidate, NetworkBridgeEvent, ProspectiveParachainsMessage, ReportPeerMessage, + network_bridge_event::NewGossipTopology, AllMessages, ChainApiMessage, HypotheticalCandidate, + HypotheticalMembership, NetworkBridgeEvent, ProspectiveParachainsMessage, ReportPeerMessage, RuntimeApiMessage, RuntimeApiRequest, }; use polkadot_node_subsystem_test_helpers as test_helpers; @@ -44,8 +44,8 @@ use sp_authority_discovery::AuthorityPair as AuthorityDiscoveryPair; use sp_keyring::Sr25519Keyring; use assert_matches::assert_matches; +use codec::Encode; use futures::Future; -use parity_scale_codec::Encode; use rand::{Rng, SeedableRng}; use test_helpers::mock::new_leaf; @@ -55,7 +55,8 @@ mod cluster; mod grid; mod requests; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; const DEFAULT_ASYNC_BACKING_PARAMETERS: AsyncBackingParams = AsyncBackingParams { max_candidate_depth: 4, allowed_ancestry_len: 3 }; @@ -371,7 +372,8 @@ fn test_harness>( let test_state = TestState::from_config(config, req_cfg.inbound_queue.unwrap(), &mut rng); - let (context, virtual_overseer) = test_helpers::make_subsystem_context(pool.clone()); + let (context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool.clone()); let subsystem = async move { let subsystem = crate::StatementDistributionSubsystem { keystore, @@ -422,7 +424,7 @@ struct TestLeaf { parent_hash: Hash, session: SessionIndex, availability_cores: Vec, - disabled_validators: Vec, + pub disabled_validators: Vec, para_data: Vec<(ParaId, PerParaData)>, minimum_backing_votes: u32, } @@ -539,7 +541,7 @@ async fn activate_leaf( leaf: &TestLeaf, test_state: &TestState, is_new_session: bool, - hypothetical_frontier: Vec<(HypotheticalCandidate, FragmentTreeMembership)>, + hypothetical_memberships: Vec<(HypotheticalCandidate, HypotheticalMembership)>, ) { let activated = new_leaf(leaf.hash, leaf.number); @@ -554,7 +556,7 @@ async fn activate_leaf( leaf, test_state, is_new_session, - hypothetical_frontier, + hypothetical_memberships, ) .await; } @@ -564,7 +566,7 @@ async fn handle_leaf_activation( leaf: &TestLeaf, test_state: &TestState, is_new_session: bool, - hypothetical_frontier: Vec<(HypotheticalCandidate, FragmentTreeMembership)>, + hypothetical_memberships: Vec<(HypotheticalCandidate, HypotheticalMembership)>, ) { let TestLeaf { number, @@ -586,19 +588,6 @@ async fn handle_leaf_activation( } ); - let mrp_response: Vec<(ParaId, BlockNumber)> = para_data - .iter() - .map(|(para_id, data)| (*para_id, data.min_relay_parent)) - .collect(); - assert_matches!( - virtual_overseer.recv().await, - AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx) - ) if parent == *hash => { - tx.send(mrp_response).unwrap(); - } - ); - let header = Header { parent_hash: *parent_hash, number: *number, @@ -615,6 +604,19 @@ async fn handle_leaf_activation( } ); + let mrp_response: Vec<(ParaId, BlockNumber)> = para_data + .iter() + .map(|(para_id, data)| (*para_id, data.min_relay_parent)) + .collect(); + assert_matches!( + virtual_overseer.recv().await, + AllMessages::ProspectiveParachains( + ProspectiveParachainsMessage::GetMinimumRelayParents(parent, tx) + ) if parent == *hash => { + tx.send(mrp_response).unwrap(); + } + ); + loop { match virtual_overseer.recv().await { AllMessages::RuntimeApi(RuntimeApiMessage::Request( @@ -674,18 +676,17 @@ async fn handle_leaf_activation( tx.send(Ok((validator_groups, group_rotation_info))).unwrap(); }, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetHypotheticalFrontier(req, tx), + ProspectiveParachainsMessage::GetHypotheticalMembership(req, tx), ) => { - assert_eq!(req.fragment_tree_relay_parent, Some(*hash)); - assert!(!req.backed_in_path_only); - for (i, (candidate, _)) in hypothetical_frontier.iter().enumerate() { + assert_eq!(req.fragment_chain_relay_parent, Some(*hash)); + for (i, (candidate, _)) in hypothetical_memberships.iter().enumerate() { assert!( req.candidates.iter().any(|c| &c == &candidate), "did not receive request for hypothetical candidate {}", i, ); } - tx.send(hypothetical_frontier).unwrap(); + tx.send(hypothetical_memberships).unwrap(); // this is the last expected runtime api call break }, @@ -727,17 +728,16 @@ async fn handle_sent_request( ); } -async fn answer_expected_hypothetical_depth_request( +async fn answer_expected_hypothetical_membership_request( virtual_overseer: &mut VirtualOverseer, - responses: Vec<(HypotheticalCandidate, FragmentTreeMembership)>, + responses: Vec<(HypotheticalCandidate, HypotheticalMembership)>, ) { assert_matches!( virtual_overseer.recv().await, AllMessages::ProspectiveParachains( - ProspectiveParachainsMessage::GetHypotheticalFrontier(req, tx) + ProspectiveParachainsMessage::GetHypotheticalMembership(req, tx) ) => { - assert_eq!(req.fragment_tree_relay_parent, None); - assert!(!req.backed_in_path_only); + assert_eq!(req.fragment_chain_relay_parent, None); for (i, (candidate, _)) in responses.iter().enumerate() { assert!( req.candidates.iter().any(|c| &c == &candidate), diff --git a/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs b/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs index c9de42d2c4681b0b8cd13677964a85474b183201..dcb90bacdcde2cfcff065396cb353b95fa504e7c 100644 --- a/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs +++ b/polkadot/node/network/statement-distribution/src/v2/tests/requests.rs @@ -17,14 +17,13 @@ use super::*; use bitvec::order::Lsb0; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_node_network_protocol::{ request_response::v2 as request_v2, v2::BackedCandidateManifest, }; use polkadot_primitives_test_helpers::make_candidate; -use sc_network::{ - config::{IncomingRequest as RawIncomingRequest, OutgoingResponse as RawOutgoingResponse}, - ProtocolName, +use sc_network::config::{ + IncomingRequest as RawIncomingRequest, OutgoingResponse as RawOutgoingResponse, }; #[test] @@ -169,7 +168,7 @@ fn cluster_peer_allowed_to_send_incomplete_statements() { ); } - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer }); @@ -339,7 +338,7 @@ fn peer_reported_for_providing_statements_meant_to_be_masked_out() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Peer C advertises candidate 2. @@ -411,7 +410,7 @@ fn peer_reported_for_providing_statements_meant_to_be_masked_out() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Peer C sends an announcement for candidate 3. Should hit seconding limit for validator 1. @@ -634,7 +633,7 @@ fn peer_reported_for_not_enough_statements() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer @@ -789,7 +788,7 @@ fn peer_reported_for_duplicate_statements() { ); } - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; overseer }); @@ -919,7 +918,7 @@ fn peer_reported_for_providing_statements_with_invalid_signatures() { if p == peer_a && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer @@ -1049,7 +1048,7 @@ fn peer_reported_for_providing_statements_with_wrong_validator_id() { if p == peer_a && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer @@ -1215,399 +1214,15 @@ fn disabled_validators_added_to_unwanted_mask() { assert_eq!(statement, seconded_b); } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer }); } -// We send a request to a peer and after receiving the response -// we learn about a validator being disabled. We should filter out -// the statement from the disabled validator when receiving it. #[test] -fn when_validator_disabled_after_sending_the_request() { - let group_size = 3; - let config = TestConfig { - validator_count: 20, - group_size, - local_validator: LocalRole::Validator, - async_backing_params: None, - }; - - let relay_parent = Hash::repeat_byte(1); - let another_relay_parent = Hash::repeat_byte(2); - let peer_disabled_later = PeerId::random(); - let peer_b = PeerId::random(); - - test_harness(config, |state, mut overseer| async move { - let local_validator = state.local.clone().unwrap(); - let local_group_index = local_validator.group_index.unwrap(); - let local_para = ParaId::from(local_group_index.0); - let other_group_validators = state.group_validators(local_group_index, true); - let index_disabled = other_group_validators[0]; - let index_b = other_group_validators[1]; - - let test_leaf = state.make_dummy_leaf_with_disabled_validators(relay_parent, vec![]); - let test_leaf_disabled = state - .make_dummy_leaf_with_disabled_validators(another_relay_parent, vec![index_disabled]); - - let (candidate, pvd) = make_candidate( - relay_parent, - 1, - local_para, - test_leaf.para_data(local_para).head_data.clone(), - vec![4, 5, 6].into(), - Hash::repeat_byte(42).into(), - ); - let candidate_hash = candidate.hash(); - - // peer A is in group, has relay parent in view and disabled later. - // peer B is in group, has relay parent in view. - { - connect_peer( - &mut overseer, - peer_disabled_later.clone(), - Some(vec![state.discovery_id(index_disabled)].into_iter().collect()), - ) - .await; - connect_peer( - &mut overseer, - peer_b.clone(), - Some(vec![state.discovery_id(index_b)].into_iter().collect()), - ) - .await; - send_peer_view_change(&mut overseer, peer_disabled_later.clone(), view![relay_parent]) - .await; - send_peer_view_change(&mut overseer, peer_b.clone(), view![relay_parent]).await; - } - - activate_leaf(&mut overseer, &test_leaf, &state, true, vec![]).await; - - let seconded_disabled = state - .sign_statement( - index_disabled, - CompactStatement::Seconded(candidate_hash), - &SigningContext { parent_hash: relay_parent, session_index: 1 }, - ) - .as_unchecked() - .clone(); - - let seconded_b = state - .sign_statement( - index_b, - CompactStatement::Seconded(candidate_hash), - &SigningContext { parent_hash: relay_parent, session_index: 1 }, - ) - .as_unchecked() - .clone(); - { - send_peer_message( - &mut overseer, - peer_b.clone(), - protocol_v2::StatementDistributionMessage::Statement( - relay_parent, - seconded_b.clone(), - ), - ) - .await; - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) - if p == peer_b && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { } - ); - } - - // Send a request to peer and activate leaf when a validator is disabled; - // mock the response with a statement from disabled validator. - { - let statements = vec![seconded_disabled]; - let mask = StatementFilter::blank(group_size); - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendRequests(mut requests, IfDisconnected::ImmediateError)) => { - assert_eq!(requests.len(), 1); - assert_matches!( - requests.pop().unwrap(), - Requests::AttestedCandidateV2(outgoing) => { - assert_eq!(outgoing.peer, Recipient::Peer(peer_b)); - assert_eq!(outgoing.payload.candidate_hash, candidate_hash); - assert_eq!(outgoing.payload.mask, mask); - - activate_leaf(&mut overseer, &test_leaf_disabled, &state, false, vec![]).await; - - let res = AttestedCandidateResponse { - candidate_receipt: candidate, - persisted_validation_data: pvd, - statements, - }; - outgoing.pending_response.send(Ok((res.encode(), ProtocolName::from("")))).unwrap(); - } - ); - } - ); - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) - if p == peer_b && r == BENEFIT_VALID_RESPONSE.into() => { } - ); - - assert_matches!( - overseer.recv().await, - AllMessages:: NetworkBridgeTx( - NetworkBridgeTxMessage::SendValidationMessage( - peers, - Versioned::V2( - protocol_v2::ValidationProtocol::StatementDistribution( - protocol_v2::StatementDistributionMessage::Statement(hash, statement), - ), - ), - ) - ) => { - assert_eq!(peers, vec![peer_disabled_later]); - assert_eq!(hash, relay_parent); - assert_eq!(statement, seconded_b); - } - ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; - } - - overseer - }); -} - -#[test] -fn no_response_for_grid_request_not_meeting_quorum() { - let validator_count = 6; - let group_size = 3; - let config = TestConfig { - validator_count, - group_size, - local_validator: LocalRole::Validator, - async_backing_params: None, - }; - - let relay_parent = Hash::repeat_byte(1); - let peer_a = PeerId::random(); - let peer_b = PeerId::random(); - let peer_c = PeerId::random(); - - test_harness(config, |mut state, mut overseer| async move { - let local_validator = state.local.clone().unwrap(); - let local_group_index = local_validator.group_index.unwrap(); - let local_para = ParaId::from(local_group_index.0); - - let test_leaf = state.make_dummy_leaf_with_min_backing_votes(relay_parent, 2); - - let (candidate, pvd) = make_candidate( - relay_parent, - 1, - local_para, - test_leaf.para_data(local_para).head_data.clone(), - vec![4, 5, 6].into(), - Hash::repeat_byte(42).into(), - ); - let candidate_hash = candidate.hash(); - - let other_group_validators = state.group_validators(local_group_index, true); - let target_group_validators = - state.group_validators((local_group_index.0 + 1).into(), true); - let v_a = other_group_validators[0]; - let v_b = other_group_validators[1]; - let v_c = target_group_validators[0]; - - // peer A is in group, has relay parent in view. - // peer B is in group, has no relay parent in view. - // peer C is not in group, has relay parent in view. - { - connect_peer( - &mut overseer, - peer_a.clone(), - Some(vec![state.discovery_id(v_a)].into_iter().collect()), - ) - .await; - - connect_peer( - &mut overseer, - peer_b.clone(), - Some(vec![state.discovery_id(v_b)].into_iter().collect()), - ) - .await; - - connect_peer( - &mut overseer, - peer_c.clone(), - Some(vec![state.discovery_id(v_c)].into_iter().collect()), - ) - .await; - - send_peer_view_change(&mut overseer, peer_a.clone(), view![relay_parent]).await; - send_peer_view_change(&mut overseer, peer_c.clone(), view![relay_parent]).await; - } - - activate_leaf(&mut overseer, &test_leaf, &state, true, vec![]).await; - - // Send gossip topology. - send_new_topology(&mut overseer, state.make_dummy_topology()).await; - - // Confirm the candidate locally so that we don't send out requests. - { - let statement = state - .sign_full_statement( - local_validator.validator_index, - Statement::Seconded(candidate.clone()), - &SigningContext { parent_hash: relay_parent, session_index: 1 }, - pvd.clone(), - ) - .clone(); - - overseer - .send(FromOrchestra::Communication { - msg: StatementDistributionMessage::Share(relay_parent, statement), - }) - .await; - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] - ); - - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; - } - - // Send enough statements to make candidate backable, make sure announcements are sent. - - // Send statement from peer A. - { - let statement = state - .sign_statement( - v_a, - CompactStatement::Seconded(candidate_hash), - &SigningContext { parent_hash: relay_parent, session_index: 1 }, - ) - .as_unchecked() - .clone(); - - send_peer_message( - &mut overseer, - peer_a.clone(), - protocol_v2::StatementDistributionMessage::Statement(relay_parent, statement), - ) - .await; - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) - if p == peer_a && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { } - ); - } - - // Send statement from peer B. - let statement_b = state - .sign_statement( - v_b, - CompactStatement::Seconded(candidate_hash), - &SigningContext { parent_hash: relay_parent, session_index: 1 }, - ) - .as_unchecked() - .clone(); - { - send_peer_message( - &mut overseer, - peer_b.clone(), - protocol_v2::StatementDistributionMessage::Statement( - relay_parent, - statement_b.clone(), - ), - ) - .await; - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) - if p == peer_b && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { } - ); - - assert_matches!( - overseer.recv().await, - AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] - ); - } - - // Send Backed notification. - { - overseer - .send(FromOrchestra::Communication { - msg: StatementDistributionMessage::Backed(candidate_hash), - }) - .await; - - assert_matches!( - overseer.recv().await, - AllMessages:: NetworkBridgeTx( - NetworkBridgeTxMessage::SendValidationMessage( - peers, - Versioned::V2( - protocol_v2::ValidationProtocol::StatementDistribution( - protocol_v2::StatementDistributionMessage::BackedCandidateManifest(manifest), - ), - ), - ) - ) => { - assert_eq!(peers, vec![peer_c]); - assert_eq!(manifest, BackedCandidateManifest { - relay_parent, - candidate_hash, - group_index: local_validator.group_index.unwrap(), - para_id: local_para, - parent_head_data_hash: pvd.parent_head.hash(), - statement_knowledge: StatementFilter { - seconded_in_group: bitvec::bitvec![u8, Lsb0; 1, 1, 1], - validated_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 0], - }, - }); - } - ); - - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; - } - - let mask = StatementFilter { - seconded_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 1], - validated_in_group: bitvec::bitvec![u8, Lsb0; 0, 0, 0], - }; - - let relay_2 = Hash::repeat_byte(2); - let disabled_validators = vec![v_a]; - let leaf_2 = state.make_dummy_leaf_with_disabled_validators(relay_2, disabled_validators); - activate_leaf(&mut overseer, &leaf_2, &state, false, vec![]).await; - - // Incoming request to local node. Local node should not send the response as v_a is - // disabled and hence the quorum is not reached. - { - let response = state - .send_request( - peer_c, - request_v2::AttestedCandidateRequest { candidate_hash: candidate.hash(), mask }, - ) - .await - .await; - - assert!( - response.is_none(), - "We should not send a response as the quorum is not reached yet" - ); - } - - overseer - }); -} - -#[test] -fn disabling_works_from_the_latest_state_not_relay_parent() { +fn disabling_works_from_relay_parent_not_the_latest_state() { let group_size = 3; let config = TestConfig { validator_count: 20, @@ -1642,7 +1257,7 @@ fn disabling_works_from_the_latest_state_not_relay_parent() { ); let candidate_1_hash = candidate_1.hash(); - let (candidate_2, _) = make_candidate( + let (candidate_2, pvd_2) = make_candidate( relay_1, 1, local_para, @@ -1652,6 +1267,16 @@ fn disabling_works_from_the_latest_state_not_relay_parent() { ); let candidate_2_hash = candidate_2.hash(); + let (candidate_3, _) = make_candidate( + relay_2, + 1, + local_para, + leaf_1.para_data(local_para).head_data.clone(), + vec![4, 5, 6, 7].into(), + Hash::repeat_byte(42).into(), + ); + let candidate_3_hash = candidate_3.hash(); + { connect_peer( &mut overseer, @@ -1681,6 +1306,16 @@ fn disabling_works_from_the_latest_state_not_relay_parent() { ) .as_unchecked() .clone(); + + let seconded_3 = state + .sign_statement( + index_disabled, + CompactStatement::Seconded(candidate_3_hash), + &SigningContext { parent_hash: relay_2, session_index: 1 }, + ) + .as_unchecked() + .clone(); + { send_peer_message( &mut overseer, @@ -1720,7 +1355,7 @@ fn disabling_works_from_the_latest_state_not_relay_parent() { if p == peer_disabled && r == BENEFIT_VALID_RESPONSE.into() => { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } activate_leaf(&mut overseer, &leaf_2, &state, false, vec![]).await; @@ -1733,6 +1368,48 @@ fn disabling_works_from_the_latest_state_not_relay_parent() { ) .await; + assert_matches!( + overseer.recv().await, + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) + if p == peer_disabled && r == BENEFIT_VALID_STATEMENT_FIRST.into() => { } + ); + } + + { + handle_sent_request( + &mut overseer, + peer_disabled, + candidate_2_hash, + StatementFilter::blank(group_size), + candidate_2.clone(), + pvd_2.clone(), + vec![seconded_2.clone()], + ) + .await; + + assert_matches!( + overseer.recv().await, + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) + if p == peer_disabled && r == BENEFIT_VALID_STATEMENT.into() => { } + ); + + assert_matches!( + overseer.recv().await, + AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) + if p == peer_disabled && r == BENEFIT_VALID_RESPONSE.into() => { } + ); + + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; + } + + { + send_peer_message( + &mut overseer, + peer_disabled.clone(), + protocol_v2::StatementDistributionMessage::Statement(relay_2, seconded_3.clone()), + ) + .await; + assert_matches!( overseer.recv().await, AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::ReportPeer(ReportPeerMessage::Single(p, r))) @@ -1862,7 +1539,7 @@ fn local_node_sanity_checks_incoming_requests() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Should drop requests from unknown peers. @@ -2036,7 +1713,7 @@ fn local_node_checks_that_peer_can_request_before_responding() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; // Local node should respond to requests from peers in the same group // which appear to not have already seen the candidate @@ -2248,7 +1925,7 @@ fn local_node_respects_statement_mask() { AllMessages::NetworkBridgeTx(NetworkBridgeTxMessage::SendValidationMessage(peers, _)) if peers == vec![peer_a] ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Send enough statements to make candidate backable, make sure announcements are sent. @@ -2347,7 +2024,7 @@ fn local_node_respects_statement_mask() { } ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // `1` indicates statements NOT to request. @@ -2600,7 +2277,7 @@ fn should_delay_before_retrying_dropped_requests() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } // Sleep for the given amount of time. This should reset the delay for the first candidate. @@ -2691,7 +2368,7 @@ fn should_delay_before_retrying_dropped_requests() { if p == peer_c && r == BENEFIT_VALID_RESPONSE.into() ); - answer_expected_hypothetical_depth_request(&mut overseer, vec![]).await; + answer_expected_hypothetical_membership_request(&mut overseer, vec![]).await; } overseer diff --git a/polkadot/node/overseer/Cargo.toml b/polkadot/node/overseer/Cargo.toml index ef79cfe2f702bb2b32c7901448da5e1b073c0b72..2253a5ae0c668c0c107f19ad15ef933c1cf17abc 100644 --- a/polkadot/node/overseer/Cargo.toml +++ b/polkadot/node/overseer/Cargo.toml @@ -10,30 +10,30 @@ description = "System overseer of the Polkadot node" workspace = true [dependencies] -client = { package = "sc-client-api", path = "../../../substrate/client/api" } -sp-api = { path = "../../../substrate/primitives/api" } -futures = "0.3.30" -futures-timer = "3.0.2" -parking_lot = "0.12.1" -polkadot-node-network-protocol = { path = "../network/protocol" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-node-metrics = { path = "../metrics" } -polkadot-primitives = { path = "../../primitives" } -orchestra = { version = "0.3.5", default-features = false, features = ["futures_channel"] } -gum = { package = "tracing-gum", path = "../gum" } -sp-core = { path = "../../../substrate/primitives/core" } -async-trait = "0.1.79" -tikv-jemalloc-ctl = { version = "0.5.0", optional = true } +sc-client-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } +parking_lot = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +orchestra = { features = ["futures_channel"], workspace = true } +gum = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +async-trait = { workspace = true } +tikv-jemalloc-ctl = { optional = true, workspace = true } [dev-dependencies] -metered = { package = "prioritized-metered-channel", version = "0.6.1", default-features = false, features = ["futures_channel"] } -sp-core = { path = "../../../substrate/primitives/core" } -futures = { version = "0.3.30", features = ["thread-pool"] } -femme = "2.2.1" -assert_matches = "1.4.0" -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" } -node-test-helpers = { package = "polkadot-node-subsystem-test-helpers", path = "../subsystem-test-helpers" } +metered = { features = ["futures_channel"], workspace = true } +sp-core = { workspace = true, default-features = true } +futures = { features = ["thread-pool"], workspace = true } +femme = { workspace = true } +assert_matches = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } [target.'cfg(target_os = "linux")'.dependencies] tikv-jemalloc-ctl = "0.5.0" diff --git a/polkadot/node/overseer/examples/minimal-example.rs b/polkadot/node/overseer/examples/minimal-example.rs index 857cdba673db267d2824d8a995257316fc67225f..86a1801a5f2d8f08f2c176c53171031de3fceff0 100644 --- a/polkadot/node/overseer/examples/minimal-example.rs +++ b/polkadot/node/overseer/examples/minimal-example.rs @@ -23,7 +23,6 @@ use futures_timer::Delay; use orchestra::async_trait; use std::time::Duration; -use ::test_helpers::{dummy_candidate_descriptor, dummy_hash}; use polkadot_node_primitives::{BlockData, PoV}; use polkadot_node_subsystem_types::messages::CandidateValidationMessage; use polkadot_overseer::{ @@ -33,6 +32,7 @@ use polkadot_overseer::{ HeadSupportsParachains, SubsystemError, }; use polkadot_primitives::{CandidateReceipt, Hash, PvfExecKind}; +use polkadot_primitives_test_helpers::{dummy_candidate_descriptor, dummy_hash}; struct AlwaysSupportsParachains; diff --git a/polkadot/node/overseer/src/lib.rs b/polkadot/node/overseer/src/lib.rs index 167b32a15bc4d1e6cdb150a3e1d0133e035fb617..baaff9c7c9f63c5cff812e5ae01097ca538c4d75 100644 --- a/polkadot/node/overseer/src/lib.rs +++ b/polkadot/node/overseer/src/lib.rs @@ -71,8 +71,8 @@ use std::{ use futures::{channel::oneshot, future::BoxFuture, select, Future, FutureExt, StreamExt}; -use client::{BlockImportNotification, BlockchainEvents, FinalityNotification}; use polkadot_primitives::{Block, BlockNumber, Hash}; +use sc_client_api::{BlockImportNotification, BlockchainEvents, FinalityNotification}; use self::messages::{BitfieldSigningMessage, PvfCheckerMessage}; use polkadot_node_subsystem_types::messages::{ @@ -105,10 +105,11 @@ pub use polkadot_node_metrics::{ pub use orchestra as gen; pub use orchestra::{ - contextbounds, orchestra, subsystem, FromOrchestra, MapSubsystem, MessagePacket, - OrchestraError as OverseerError, SignalsReceived, Spawner, Subsystem, SubsystemContext, - SubsystemIncomingMessages, SubsystemInstance, SubsystemMeterReadouts, SubsystemMeters, - SubsystemSender, TimeoutExt, ToOrchestra, TrySendError, + contextbounds, orchestra, subsystem, FromOrchestra, HighPriority, MapSubsystem, MessagePacket, + NormalPriority, OrchestraError as OverseerError, Priority, PriorityLevel, SignalsReceived, + Spawner, Subsystem, SubsystemContext, SubsystemIncomingMessages, SubsystemInstance, + SubsystemMeterReadouts, SubsystemMeters, SubsystemSender, TimeoutExt, ToOrchestra, + TrySendError, }; #[cfg(any(target_os = "linux", feature = "jemalloc-allocator"))] @@ -465,7 +466,7 @@ pub async fn forward_events>(client: Arc

, mut hand message_capacity=2048, )] pub struct Overseer { - #[subsystem(blocking, CandidateValidationMessage, sends: [ + #[subsystem(CandidateValidationMessage, sends: [ RuntimeApiMessage, ])] candidate_validation: CandidateValidation, @@ -495,7 +496,7 @@ pub struct Overseer { RuntimeApiMessage, ProspectiveParachainsMessage, ChainApiMessage, - ])] + ], can_receive_priority_messages)] statement_distribution: StatementDistribution, #[subsystem(AvailabilityDistributionMessage, sends: [ @@ -524,7 +525,7 @@ pub struct Overseer { RuntimeApiMessage, NetworkBridgeTxMessage, ProvisionerMessage, - ])] + ], can_receive_priority_messages)] bitfield_distribution: BitfieldDistribution, #[subsystem(ProvisionerMessage, sends: [ @@ -580,7 +581,7 @@ pub struct Overseer { #[subsystem(blocking, message_capacity: 64000, ApprovalDistributionMessage, sends: [ NetworkBridgeTxMessage, ApprovalVotingMessage, - ])] + ], can_receive_priority_messages)] approval_distribution: ApprovalDistribution, #[subsystem(blocking, ApprovalVotingMessage, sends: [ @@ -599,7 +600,7 @@ pub struct Overseer { NetworkBridgeRxMessage, // TODO RuntimeApiMessage, ChainSelectionMessage, - ])] + ], can_receive_priority_messages)] gossip_support: GossipSupport, #[subsystem(blocking, message_capacity: 32000, DisputeCoordinatorMessage, sends: [ diff --git a/polkadot/node/overseer/src/tests.rs b/polkadot/node/overseer/src/tests.rs index 55a6bdb74ba73c04bc66847a1b04ff6175608fa7..8e78d8fc8921a8bd26686e295b584c4e1fff6433 100644 --- a/polkadot/node/overseer/src/tests.rs +++ b/polkadot/node/overseer/src/tests.rs @@ -18,13 +18,12 @@ use async_trait::async_trait; use futures::{executor, pending, pin_mut, poll, select, stream, FutureExt}; use std::{collections::HashMap, sync::atomic, task::Poll}; -use ::test_helpers::{dummy_candidate_descriptor, dummy_candidate_receipt, dummy_hash}; -use node_test_helpers::mock::{dummy_unpin_handle, new_leaf}; use polkadot_node_network_protocol::{PeerId, UnifiedReputationChange}; use polkadot_node_primitives::{ BlockData, CollationGenerationConfig, CollationResult, DisputeMessage, InvalidDisputeVote, PoV, UncheckedDisputeMessage, ValidDisputeVote, }; +use polkadot_node_subsystem_test_helpers::mock::{dummy_unpin_handle, new_leaf}; use polkadot_node_subsystem_types::messages::{ NetworkBridgeEvent, ReportPeerMessage, RuntimeApiRequest, }; @@ -32,6 +31,9 @@ use polkadot_primitives::{ CandidateHash, CandidateReceipt, CollatorPair, Id as ParaId, InvalidDisputeStatementKind, PvfExecKind, SessionIndex, ValidDisputeStatementKind, ValidatorIndex, }; +use polkadot_primitives_test_helpers::{ + dummy_candidate_descriptor, dummy_candidate_receipt, dummy_hash, +}; use crate::{ self as overseer, @@ -811,7 +813,7 @@ fn test_candidate_validation_msg() -> CandidateValidationMessage { fn test_candidate_backing_msg() -> CandidateBackingMessage { let (sender, _) = oneshot::channel(); - CandidateBackingMessage::GetBackedCandidates(Default::default(), sender) + CandidateBackingMessage::GetBackableCandidates(Default::default(), sender) } fn test_chain_api_msg() -> ChainApiMessage { @@ -856,6 +858,7 @@ fn test_availability_recovery_msg() -> AvailabilityRecoveryMessage { dummy_candidate_receipt(dummy_hash()), Default::default(), None, + None, sender, ) } diff --git a/polkadot/node/primitives/Cargo.toml b/polkadot/node/primitives/Cargo.toml index a4bbd824e6712e001f1df1cd9d66f835d02822fb..cd642bf16ff9bf7d6ffeeea2ce0dac752128bd3c 100644 --- a/polkadot/node/primitives/Cargo.toml +++ b/polkadot/node/primitives/Cargo.toml @@ -10,24 +10,24 @@ license.workspace = true workspace = true [dependencies] -bounded-vec = "0.7" -futures = "0.3.30" -polkadot-primitives = { path = "../../primitives" } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sp-core = { path = "../../../substrate/primitives/core" } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sp-maybe-compressed-blob = { path = "../../../substrate/primitives/maybe-compressed-blob" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -polkadot-parachain-primitives = { path = "../../parachain", default-features = false } -schnorrkel = "0.11.4" +bounded-vec = { workspace = true } +futures = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +codec = { features = ["derive"], workspace = true } +sp-core = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true } +schnorrkel = { workspace = true, default-features = true } thiserror = { workspace = true } -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } +bitvec = { features = ["alloc"], workspace = true } serde = { features = ["derive"], workspace = true, default-features = true } [target.'cfg(not(target_os = "unknown"))'.dependencies] zstd = { version = "0.12.4", default-features = false } [dev-dependencies] -polkadot-erasure-coding = { path = "../../erasure-coding" } +polkadot-erasure-coding = { workspace = true, default-features = true } diff --git a/polkadot/node/primitives/src/approval.rs b/polkadot/node/primitives/src/approval.rs index b73cb4c717db7ff856669b528d5e065e413d6101..66883b33367bceaeeaa61cb7152e735eb8dbfcc6 100644 --- a/polkadot/node/primitives/src/approval.rs +++ b/polkadot/node/primitives/src/approval.rs @@ -23,7 +23,7 @@ pub mod v1 { Randomness, Slot, VrfPreOutput, VrfProof, VrfSignature, VrfTranscript, }; - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; use polkadot_primitives::{ BlockNumber, CandidateHash, CandidateIndex, CoreIndex, Hash, Header, SessionIndex, ValidatorIndex, ValidatorSignature, @@ -212,7 +212,7 @@ pub mod v1 { /// A list of primitives introduced by v2. pub mod v2 { - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; pub use sp_consensus_babe::{ Randomness, Slot, VrfPreOutput, VrfProof, VrfSignature, VrfTranscript, }; diff --git a/polkadot/node/primitives/src/disputes/message.rs b/polkadot/node/primitives/src/disputes/message.rs index 31fe73a7ba1c4dec821762714195f3c1792beac8..f9dec073bf50112437b4526b4cf5b4109ab07433 100644 --- a/polkadot/node/primitives/src/disputes/message.rs +++ b/polkadot/node/primitives/src/disputes/message.rs @@ -21,7 +21,7 @@ use thiserror::Error; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use super::{InvalidDisputeVote, SignedDisputeStatement, ValidDisputeVote}; use polkadot_primitives::{ diff --git a/polkadot/node/primitives/src/disputes/mod.rs b/polkadot/node/primitives/src/disputes/mod.rs index 5814ecee44f4e9ee333f1898c92341799978d646..0f08b4733654a483431be44fce11d2100e0c263c 100644 --- a/polkadot/node/primitives/src/disputes/mod.rs +++ b/polkadot/node/primitives/src/disputes/mod.rs @@ -19,7 +19,7 @@ use std::collections::{ BTreeMap, BTreeSet, }; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use sp_application_crypto::AppCrypto; use sp_keystore::{Error as KeystoreError, KeystorePtr}; diff --git a/polkadot/node/primitives/src/disputes/status.rs b/polkadot/node/primitives/src/disputes/status.rs index d93c3ec846ce6f45392e3baeb325afd56dccf9d9..b9a1c57d53de5727fb5af5a4d6b232cd6cec456c 100644 --- a/polkadot/node/primitives/src/disputes/status.rs +++ b/polkadot/node/primitives/src/disputes/status.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; /// Timestamp based on the 1 Jan 1970 UNIX base, which is persistent across node restarts and OS /// reboots. diff --git a/polkadot/node/primitives/src/lib.rs b/polkadot/node/primitives/src/lib.rs index 0f97250a934e0865d799fc1ea3923bbceff57a99..685a9fd337dfd3ef0281d681d74a116f26943e3c 100644 --- a/polkadot/node/primitives/src/lib.rs +++ b/polkadot/node/primitives/src/lib.rs @@ -25,18 +25,19 @@ use std::pin::Pin; use bounded_vec::BoundedVec; +use codec::{Decode, Encode, Error as CodecError, Input}; use futures::Future; -use parity_scale_codec::{Decode, Encode, Error as CodecError, Input}; use serde::{de, Deserialize, Deserializer, Serialize, Serializer}; use polkadot_primitives::{ - BlakeTwo256, BlockNumber, CandidateCommitments, CandidateHash, CollatorPair, + BlakeTwo256, BlockNumber, CandidateCommitments, CandidateHash, ChunkIndex, CollatorPair, CommittedCandidateReceipt, CompactStatement, CoreIndex, EncodeAs, Hash, HashT, HeadData, Id as ParaId, PersistedValidationData, SessionIndex, Signed, UncheckedSigned, ValidationCode, - ValidationCodeHash, ValidatorIndex, MAX_CODE_SIZE, MAX_POV_SIZE, + ValidationCodeHash, MAX_CODE_SIZE, MAX_POV_SIZE, }; pub use sp_consensus_babe::{ AllowedSlots as BabeAllowedSlots, BabeEpochConfiguration, Epoch as BabeEpoch, + Randomness as BabeRandomness, }; pub use polkadot_parachain_primitives::primitives::{ @@ -58,7 +59,7 @@ pub use disputes::{ /// relatively rare. /// /// The associated worker binaries should use the same version as the node that spawns them. -pub const NODE_VERSION: &'static str = "1.11.0"; +pub const NODE_VERSION: &'static str = "1.15.1"; // For a 16-ary Merkle Prefix Trie, we can expect at most 16 32-byte hashes per node // plus some overhead: @@ -639,7 +640,7 @@ pub struct ErasureChunk { /// The erasure-encoded chunk of data belonging to the candidate block. pub chunk: Vec, /// The index of this erasure-encoded chunk of data. - pub index: ValidatorIndex, + pub index: ChunkIndex, /// Proof for this chunk's branch in the Merkle tree. pub proof: Proof, } diff --git a/polkadot/node/service/Cargo.toml b/polkadot/node/service/Cargo.toml index 7c010778d50d3c1d10884562b6ea2c10fad8a272..216aa10e8acb8697ec78fb6e860d8d2f92c93b58 100644 --- a/polkadot/node/service/Cargo.toml +++ b/polkadot/node/service/Cargo.toml @@ -12,151 +12,152 @@ workspace = true [dependencies] # Substrate Client -sc-authority-discovery = { path = "../../../substrate/client/authority-discovery" } -babe = { package = "sc-consensus-babe", path = "../../../substrate/client/consensus/babe" } -beefy = { package = "sc-consensus-beefy", path = "../../../substrate/client/consensus/beefy" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../substrate/client/consensus/grandpa" } -mmr-gadget = { path = "../../../substrate/client/merkle-mountain-range" } -sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-range" } -sc-block-builder = { path = "../../../substrate/client/block-builder" } -sc-chain-spec = { path = "../../../substrate/client/chain-spec" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-client-db = { path = "../../../substrate/client/db" } -sc-consensus = { path = "../../../substrate/client/consensus/common" } -sc-consensus-slots = { path = "../../../substrate/client/consensus/slots" } -sc-executor = { path = "../../../substrate/client/executor" } -sc-network = { path = "../../../substrate/client/network" } -sc-network-common = { path = "../../../substrate/client/network/common" } -sc-network-sync = { path = "../../../substrate/client/network/sync" } -sc-transaction-pool = { path = "../../../substrate/client/transaction-pool" } -sc-transaction-pool-api = { path = "../../../substrate/client/transaction-pool/api" } -sc-sync-state-rpc = { path = "../../../substrate/client/sync-state-rpc" } -sc-keystore = { path = "../../../substrate/client/keystore" } -sc-basic-authorship = { path = "../../../substrate/client/basic-authorship" } -sc-offchain = { path = "../../../substrate/client/offchain" } -sc-sysinfo = { path = "../../../substrate/client/sysinfo" } -service = { package = "sc-service", path = "../../../substrate/client/service", default-features = false } -telemetry = { package = "sc-telemetry", path = "../../../substrate/client/telemetry" } +sc-authority-discovery = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +mmr-gadget = { workspace = true, default-features = true } +sp-mmr-primitives = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-client-db = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-slots = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-common = { workspace = true, default-features = true } +sc-network-sync = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sc-sync-state-rpc = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sc-basic-authorship = { workspace = true, default-features = true } +sc-offchain = { workspace = true, default-features = true } +sc-sysinfo = { workspace = true, default-features = true } +sc-service = { workspace = true } +sc-telemetry = { workspace = true, default-features = true } # Substrate Primitives -sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery" } -consensus_common = { package = "sp-consensus", path = "../../../substrate/primitives/consensus/common" } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy" } -grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../substrate/primitives/consensus/grandpa" } -sp-inherents = { path = "../../../substrate/primitives/inherents" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-block-builder = { path = "../../../substrate/primitives/block-builder" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sp-offchain = { package = "sp-offchain", path = "../../../substrate/primitives/offchain" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-session = { path = "../../../substrate/primitives/session" } -sp-storage = { path = "../../../substrate/primitives/storage" } -sp-transaction-pool = { path = "../../../substrate/primitives/transaction-pool" } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment" } -sp-timestamp = { path = "../../../substrate/primitives/timestamp" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-state-machine = { path = "../../../substrate/primitives/state-machine" } -sp-weights = { path = "../../../substrate/primitives/weights" } -sp-version = { path = "../../../substrate/primitives/version" } +sp-authority-discovery = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-offchain = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-session = { workspace = true, default-features = true } +sp-storage = { workspace = true, default-features = true } +sp-transaction-pool = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-weights = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } # Substrate Pallets -pallet-babe = { path = "../../../substrate/frame/babe" } -pallet-staking = { path = "../../../substrate/frame/staking" } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api" } -frame-system = { path = "../../../substrate/frame/system" } +pallet-babe = { workspace = true, default-features = true } +pallet-staking = { workspace = true, default-features = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true, default-features = true } +frame-metadata-hash-extension = { optional = true, workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } # Substrate Other -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api" } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" } -frame-support = { path = "../../../substrate/frame/support" } -frame-benchmarking-cli = { path = "../../../substrate/utils/frame/benchmarking-cli" } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking" } +frame-system-rpc-runtime-api = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +frame-support = { workspace = true, default-features = true } +frame-benchmarking-cli = { workspace = true, default-features = true } +frame-benchmarking = { workspace = true, default-features = true } # External Crates -async-trait = "0.1.79" -futures = "0.3.30" -hex-literal = "0.4.1" -is_executable = "1.0.1" -gum = { package = "tracing-gum", path = "../gum" } +async-trait = { workspace = true } +futures = { workspace = true } +hex-literal = { workspace = true, default-features = true } +is_executable = { workspace = true } +gum = { workspace = true, default-features = true } log = { workspace = true, default-features = true } -schnellru = "0.2.1" +schnellru = { workspace = true } serde = { features = ["derive"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } thiserror = { workspace = true } -kvdb = "0.13.0" -kvdb-rocksdb = { version = "0.19.0", optional = true } -parity-db = { version = "0.4.12", optional = true } -codec = { package = "parity-scale-codec", version = "3.6.1" } -parking_lot = "0.12.1" -bitvec = { version = "1.0.1", optional = true } +kvdb = { workspace = true } +kvdb-rocksdb = { optional = true, workspace = true } +parity-db = { optional = true, workspace = true } +codec = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } +bitvec = { optional = true, workspace = true, default-features = true } # Polkadot -polkadot-core-primitives = { path = "../../core-primitives" } -polkadot-node-core-parachains-inherent = { path = "../core/parachains-inherent" } -polkadot-overseer = { path = "../overseer" } -polkadot-parachain-primitives = { path = "../../parachain" } -polkadot-primitives = { path = "../../primitives" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-rpc = { path = "../../rpc" } -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-node-subsystem-util = { path = "../subsystem-util" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-runtime-parachains = { path = "../../runtime/parachains" } -polkadot-node-network-protocol = { path = "../network/protocol" } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-node-core-parachains-inherent = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-rpc = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } # Polkadot Runtime Constants -rococo-runtime-constants = { path = "../../runtime/rococo/constants", optional = true } -westend-runtime-constants = { path = "../../runtime/westend/constants", optional = true } +rococo-runtime-constants = { optional = true, workspace = true, default-features = true } +westend-runtime-constants = { optional = true, workspace = true, default-features = true } # Polkadot Runtimes -westend-runtime = { path = "../../runtime/westend", optional = true } -rococo-runtime = { path = "../../runtime/rococo", optional = true } +westend-runtime = { optional = true, workspace = true } +rococo-runtime = { optional = true, workspace = true } # Polkadot Subsystems -polkadot-approval-distribution = { path = "../network/approval-distribution", optional = true } -polkadot-availability-bitfield-distribution = { path = "../network/bitfield-distribution", optional = true } -polkadot-availability-distribution = { path = "../network/availability-distribution", optional = true } -polkadot-availability-recovery = { path = "../network/availability-recovery", optional = true } -polkadot-collator-protocol = { path = "../network/collator-protocol", optional = true } -polkadot-dispute-distribution = { path = "../network/dispute-distribution", optional = true } -polkadot-gossip-support = { path = "../network/gossip-support", optional = true } -polkadot-network-bridge = { path = "../network/bridge", optional = true } -polkadot-node-collation-generation = { path = "../collation-generation", optional = true } -polkadot-node-core-approval-voting = { path = "../core/approval-voting", optional = true } -polkadot-node-core-av-store = { path = "../core/av-store", optional = true } -polkadot-node-core-backing = { path = "../core/backing", optional = true } -polkadot-node-core-bitfield-signing = { path = "../core/bitfield-signing", optional = true } -polkadot-node-core-candidate-validation = { path = "../core/candidate-validation", optional = true } -polkadot-node-core-chain-api = { path = "../core/chain-api", optional = true } -polkadot-node-core-chain-selection = { path = "../core/chain-selection", optional = true } -polkadot-node-core-dispute-coordinator = { path = "../core/dispute-coordinator", optional = true } -polkadot-node-core-prospective-parachains = { path = "../core/prospective-parachains", optional = true } -polkadot-node-core-provisioner = { path = "../core/provisioner", optional = true } -polkadot-node-core-pvf = { path = "../core/pvf", optional = true } -polkadot-node-core-pvf-checker = { path = "../core/pvf-checker", optional = true } -polkadot-node-core-runtime-api = { path = "../core/runtime-api", optional = true } -polkadot-statement-distribution = { path = "../network/statement-distribution", optional = true } - -xcm = { package = "staging-xcm", path = "../../xcm" } -xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api" } +polkadot-approval-distribution = { optional = true, workspace = true, default-features = true } +polkadot-availability-bitfield-distribution = { optional = true, workspace = true, default-features = true } +polkadot-availability-distribution = { optional = true, workspace = true, default-features = true } +polkadot-availability-recovery = { optional = true, workspace = true, default-features = true } +polkadot-collator-protocol = { optional = true, workspace = true, default-features = true } +polkadot-dispute-distribution = { optional = true, workspace = true, default-features = true } +polkadot-gossip-support = { optional = true, workspace = true, default-features = true } +polkadot-network-bridge = { optional = true, workspace = true, default-features = true } +polkadot-node-collation-generation = { optional = true, workspace = true, default-features = true } +polkadot-node-core-approval-voting = { optional = true, workspace = true, default-features = true } +polkadot-node-core-av-store = { optional = true, workspace = true, default-features = true } +polkadot-node-core-backing = { optional = true, workspace = true, default-features = true } +polkadot-node-core-bitfield-signing = { optional = true, workspace = true, default-features = true } +polkadot-node-core-candidate-validation = { optional = true, workspace = true, default-features = true } +polkadot-node-core-chain-api = { optional = true, workspace = true, default-features = true } +polkadot-node-core-chain-selection = { optional = true, workspace = true, default-features = true } +polkadot-node-core-dispute-coordinator = { optional = true, workspace = true, default-features = true } +polkadot-node-core-prospective-parachains = { optional = true, workspace = true, default-features = true } +polkadot-node-core-provisioner = { optional = true, workspace = true, default-features = true } +polkadot-node-core-pvf = { optional = true, workspace = true, default-features = true } +polkadot-node-core-pvf-checker = { optional = true, workspace = true, default-features = true } +polkadot-node-core-runtime-api = { optional = true, workspace = true, default-features = true } +polkadot-statement-distribution = { optional = true, workspace = true, default-features = true } + +xcm = { workspace = true, default-features = true } +xcm-runtime-apis = { workspace = true, default-features = true } [dev-dependencies] -polkadot-test-client = { path = "../test/client" } -polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" } -env_logger = "0.11" -assert_matches = "1.5.0" -serial_test = "2.0.0" -tempfile = "3.2" +polkadot-test-client = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +sp-tracing = { workspace = true } +assert_matches = { workspace = true } +serial_test = { workspace = true } +tempfile = { workspace = true } [features] default = ["db", "full-node"] -db = ["service/rocksdb"] +db = ["sc-service/rocksdb"] full-node = [ "kvdb-rocksdb", @@ -187,8 +188,25 @@ full-node = [ ] # Configure the native runtimes to use. -westend-native = ["bitvec", "westend-runtime", "westend-runtime-constants"] -rococo-native = ["bitvec", "rococo-runtime", "rococo-runtime-constants"] +westend-native = [ + "bitvec", + "frame-metadata-hash-extension", + "westend-runtime", + "westend-runtime-constants", +] +rococo-native = [ + "bitvec", + "frame-metadata-hash-extension", + "rococo-runtime", + "rococo-runtime-constants", +] + +# Generate the metadata hash needed for CheckMetadataHash +# in the test runtimes. +metadata-hash = [ + "rococo-runtime?/metadata-hash", + "westend-runtime?/metadata-hash", +] runtime-benchmarks = [ "frame-benchmarking-cli/runtime-benchmarks", @@ -203,10 +221,10 @@ runtime-benchmarks = [ "polkadot-test-client/runtime-benchmarks", "rococo-runtime?/runtime-benchmarks", "sc-client-db/runtime-benchmarks", - "service/runtime-benchmarks", + "sc-service/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "westend-runtime?/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "frame-support/try-runtime", @@ -227,7 +245,3 @@ runtime-metrics = [ "rococo-runtime?/runtime-metrics", "westend-runtime?/runtime-metrics", ] - -elastic-scaling-experimental = [ - "polkadot-collator-protocol?/elastic-scaling-experimental", -] diff --git a/polkadot/node/service/chain-specs/kusama.json b/polkadot/node/service/chain-specs/kusama.json index aa5a199cfee64c674e3fbe65323ea82110016e0b..ff38192906da0e905fdddb878590a00a9ab41ad2 100644 --- a/polkadot/node/service/chain-specs/kusama.json +++ b/polkadot/node/service/chain-specs/kusama.json @@ -10,16 +10,16 @@ "/dns/kusama-bootnode-1.polkadot.io/tcp/443/wss/p2p/12D3KooWQKqane1SqWJNWMQkbia9qiMWXkcHtAdfW5eVF8hbwEDw", "/dns/kusama-boot.dwellir.com/tcp/30333/ws/p2p/12D3KooWFj2ndawdYyk2spc42Y2arYwb2TUoHLHFAsKuHRzWXwoJ", "/dns/kusama-boot.dwellir.com/tcp/443/wss/p2p/12D3KooWFj2ndawdYyk2spc42Y2arYwb2TUoHLHFAsKuHRzWXwoJ", - "/dns/boot.stake.plus/tcp/31333/p2p/12D3KooWLa1UyG5xLPds2GbiRBCTJjpsVwRWHWN7Dff14yiNJRpR", - "/dns/boot.stake.plus/tcp/31334/wss/p2p/12D3KooWLa1UyG5xLPds2GbiRBCTJjpsVwRWHWN7Dff14yiNJRpR", + "/dns/kusama.boot.stake.plus/tcp/30334/wss/p2p/12D3KooWDQ28HsssSyDnso7ZRiMXGtCGPRi2en6djKDsMf9f7mqE", + "/dns/kusama.boot.stake.plus/tcp/31334/wss/p2p/12D3KooWANYqS81DkERRrBW1swoMgqUHK69pJN8XjQCnS6dnUAps", "/dns/boot-node.helikon.io/tcp/7060/p2p/12D3KooWL4KPqfAsPE2aY1g5Zo1CxsDwcdJ7mmAghK7cg6M2fdbD", "/dns/boot-node.helikon.io/tcp/7062/wss/p2p/12D3KooWL4KPqfAsPE2aY1g5Zo1CxsDwcdJ7mmAghK7cg6M2fdbD", - "/dns/kusama.bootnode.amforc.com/tcp/30333/p2p/12D3KooWLx6nsj6Fpd8biP1VDyuCUjazvRiGWyBam8PsqRJkbUb9", - "/dns/kusama.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWLx6nsj6Fpd8biP1VDyuCUjazvRiGWyBam8PsqRJkbUb9", + "/dns/kusama.bootnode.amforc.com/tcp/30001/p2p/12D3KooWKvYf6qKaAF8UUDw3KsTwjHLnvkED23yxHbH3npMe8w4G", + "/dns/kusama.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWKvYf6qKaAF8UUDw3KsTwjHLnvkED23yxHbH3npMe8w4G", "/dns/kusama.bootnodes.polkadotters.com/tcp/30311/p2p/12D3KooWHB5rTeNkQdXNJ9ynvGz8Lpnmsctt7Tvp7mrYv6bcwbPG", "/dns/kusama.bootnodes.polkadotters.com/tcp/30313/wss/p2p/12D3KooWHB5rTeNkQdXNJ9ynvGz8Lpnmsctt7Tvp7mrYv6bcwbPG", - "/dns/boot-cr.gatotech.network/tcp/33200/p2p/12D3KooWRNZXf99BfzQDE1C8YhuBbuy7Sj18UEf7FNpD8egbURYD", - "/dns/boot-cr.gatotech.network/tcp/35200/wss/p2p/12D3KooWRNZXf99BfzQDE1C8YhuBbuy7Sj18UEf7FNpD8egbURYD", + "/dns/boot.gatotech.network/tcp/33200/p2p/12D3KooWRNZXf99BfzQDE1C8YhuBbuy7Sj18UEf7FNpD8egbURYD", + "/dns/boot.gatotech.network/tcp/35200/wss/p2p/12D3KooWRNZXf99BfzQDE1C8YhuBbuy7Sj18UEf7FNpD8egbURYD", "/dns/boot.metaspan.io/tcp/23012/p2p/12D3KooWE1tq9ZL9AAxMiUBBqy1ENmh5pwfWabnoBPMo8gFPXhn6", "/dns/boot.metaspan.io/tcp/23015/ws/p2p/12D3KooWE1tq9ZL9AAxMiUBBqy1ENmh5pwfWabnoBPMo8gFPXhn6", "/dns/boot.metaspan.io/tcp/23016/wss/p2p/12D3KooWE1tq9ZL9AAxMiUBBqy1ENmh5pwfWabnoBPMo8gFPXhn6", @@ -36,7 +36,9 @@ "/dns/ksm14.rotko.net/tcp/33224/p2p/12D3KooWAa5THTw8HPfnhEei23HdL8P9McBXdozG2oTtMMksjZkK", "/dns/ibp-boot-kusama.luckyfriday.io/tcp/30333/p2p/12D3KooW9vu1GWHBuxyhm7rZgD3fhGZpNajPXFexadvhujWMgwfT", "/dns/boot-kusama.luckyfriday.io/tcp/443/wss/p2p/12D3KooWS1Lu6DmK8YHSvkErpxpcXmk14vG6y4KVEFEkd9g62PP8", - "/dns/ibp-boot-kusama.luckyfriday.io/tcp/30334/wss/p2p/12D3KooW9vu1GWHBuxyhm7rZgD3fhGZpNajPXFexadvhujWMgwfT" + "/dns/ibp-boot-kusama.luckyfriday.io/tcp/30334/wss/p2p/12D3KooW9vu1GWHBuxyhm7rZgD3fhGZpNajPXFexadvhujWMgwfT", + "/dns4/kusama-0.boot.onfinality.io/tcp/27682/ws/p2p/12D3KooWFrwFo7ry3dEuFwhehGSSN96a5Xdzxot7SWfXeSbhELAe", + "/dns/kusama.bootnode.stkd.io/tcp/30633/wss/p2p/12D3KooWJHhnF64TXSmyxNkhPkXAHtYNRy86LuvGQu1LTi5vrJCL" ], "telemetryEndpoints": [ [ diff --git a/polkadot/node/service/chain-specs/paseo.json b/polkadot/node/service/chain-specs/paseo.json index 19eefd328994ed67c269fafc06acefaf28c751bf..aacfdb02578684bf11c25bf3fc08fcf2570d8683 100644 --- a/polkadot/node/service/chain-specs/paseo.json +++ b/polkadot/node/service/chain-specs/paseo.json @@ -3,10 +3,10 @@ "id": "paseo", "chainType": "Live", "bootNodes": [ - "/dns/paseo.bootnode.amforc.com/tcp/30333/wss/p2p/12D3KooWFD81HC9memUwuGMLvhDDEfmXjn6jC4n7zyNs3vToXapS", - "/dns/paseo.bootnode.amforc.com/tcp/30344/p2p/12D3KooWFD81HC9memUwuGMLvhDDEfmXjn6jC4n7zyNs3vToXapS", - "/dns/boot.stake.plus/tcp/43334/wss/p2p/12D3KooWNhgAC3hjZHxaT52EpPFZohkCL1AHFAijqcN8xB9Rwud2", - "/dns/boot.stake.plus/tcp/43333/p2p/12D3KooWNhgAC3hjZHxaT52EpPFZohkCL1AHFAijqcN8xB9Rwud2", + "/dns/paseo.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWSdf63rZjtGdeWXpQwQwPh8K8c22upcB3B1VmqW8rxrjw", + "/dns/paseo.bootnode.amforc.com/tcp/30001/p2p/12D3KooWSdf63rZjtGdeWXpQwQwPh8K8c22upcB3B1VmqW8rxrjw", + "/dns/paseo.boot.stake.plus/tcp/30334/wss/p2p/12D3KooWDVqd8JXGMPsdYynu2RoBhqftTrFibZyBYibqcjQpHoQu", + "/dns/paseo.boot.stake.plus/tcp/31334/wss/p2p/12D3KooWJ4HjAGR9FUHZhc2jjLQX5Zb2zdJBxPYwrE6Ldpg5jjk4", "/dns/boot.metaspan.io/tcp/36017/wss/p2p/12D3KooWSW6nDfM3SS8rUtjMyjdszivK31bu4a1sRngGa2hFETz7", "/dns/boot.metaspan.io/tcp/36018/p2p/12D3KooWSW6nDfM3SS8rUtjMyjdszivK31bu4a1sRngGa2hFETz7", "/dns/paseo.bootnodes.polkadotters.com/tcp/30538/p2p/12D3KooWPbbFy4TefEGTRF5eTYhq8LEzc4VAHdNUVCbY4nAnhqPP", @@ -17,8 +17,11 @@ "/dns/boot.gatotech.network/tcp/35400/wss/p2p/12D3KooWEvz5Ygv3MhCUNTVQbUTVhzhvf4KKcNoe5M5YbVLPBeeW", "/dns/paseo-bootnode.turboflakes.io/tcp/30630/p2p/12D3KooWMjCN2CrnN71hAdehn6M2iYKeGdGbZ1A3SKhf4hxrgG9e", "/dns/paseo-bootnode.turboflakes.io/tcp/30730/wss/p2p/12D3KooWMjCN2CrnN71hAdehn6M2iYKeGdGbZ1A3SKhf4hxrgG9e", + "/dns/pso16.rotko.net/tcp/33246/p2p/12D3KooWRH8eBMhw8c7bucy6pJfy94q4dKpLkF3pmeGohHmemdRu", + "/dns/pso16.rotko.net/tcp/35246/wss/p2p/12D3KooWRH8eBMhw8c7bucy6pJfy94q4dKpLkF3pmeGohHmemdRu", "/dns/paseo-boot-ng.dwellir.com/tcp/443/wss/p2p/12D3KooWBLLFKDGBxCwq3QmU3YwWKXUx953WwprRshJQicYu4Cfr", - "/dns/paseo-boot-ng.dwellir.com/tcp/30354/p2p/12D3KooWBLLFKDGBxCwq3QmU3YwWKXUx953WwprRshJQicYu4Cfr" + "/dns/paseo-boot-ng.dwellir.com/tcp/30354/p2p/12D3KooWBLLFKDGBxCwq3QmU3YwWKXUx953WwprRshJQicYu4Cfr", + "/dns/paseo.bootnode.stkd.io/tcp/30633/wss/p2p/12D3KooWMdND5nwfCs5M2rfp5kyRo41BGDgD8V67rVRaB3acgZ53" ], "telemetryEndpoints": null, "protocolId": "pas", diff --git a/polkadot/node/service/chain-specs/polkadot.json b/polkadot/node/service/chain-specs/polkadot.json index bf0599f0bdc5f003ad68b13a60c0c890612cc3e1..7e1e90f6a8c15e4491cd13176484903763044318 100644 --- a/polkadot/node/service/chain-specs/polkadot.json +++ b/polkadot/node/service/chain-specs/polkadot.json @@ -11,16 +11,16 @@ "/dns/polkadot-bootnode-1.polkadot.io/tcp/443/wss/p2p/12D3KooWFN2mhgpkJsDBuNuE5427AcDrsib8EoqGMZmkxWwx3Md4", "/dns/polkadot-boot.dwellir.com/tcp/30334/ws/p2p/12D3KooWKvdDyRKqUfSAaUCbYiLwKY8uK3wDWpCuy2FiDLbkPTDJ", "/dns/polkadot-boot.dwellir.com/tcp/443/wss/p2p/12D3KooWKvdDyRKqUfSAaUCbYiLwKY8uK3wDWpCuy2FiDLbkPTDJ", - "/dns/boot.stake.plus/tcp/30333/p2p/12D3KooWKT4ZHNxXH4icMjdrv7EwWBkfbz5duxE5sdJKKeWFYi5n", - "/dns/boot.stake.plus/tcp/30334/wss/p2p/12D3KooWKT4ZHNxXH4icMjdrv7EwWBkfbz5duxE5sdJKKeWFYi5n", + "/dns/polkadot.boot.stake.plus/tcp/30334/wss/p2p/12D3KooWCZKEvAMJRk9nwTHJcTjgVw6bDEqryQ3B7n7scNtfNqPB", + "/dns/polkadot.boot.stake.plus/tcp/31334/wss/p2p/12D3KooWMFwJV935CyJXE8twfkKxRDnNWeEFd8jZWaoWZF22Hv8S", "/dns/boot-node.helikon.io/tcp/7070/p2p/12D3KooWS9ZcvRxyzrSf6p63QfTCWs12nLoNKhGux865crgxVA4H", "/dns/boot-node.helikon.io/tcp/7072/wss/p2p/12D3KooWS9ZcvRxyzrSf6p63QfTCWs12nLoNKhGux865crgxVA4H", - "/dns/polkadot.bootnode.amforc.com/tcp/30333/p2p/12D3KooWAsuCEVCzUVUrtib8W82Yne3jgVGhQZN3hizko5FTnDg3", - "/dns/polkadot.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWAsuCEVCzUVUrtib8W82Yne3jgVGhQZN3hizko5FTnDg3", + "/dns/polkadot.bootnode.amforc.com/tcp/30001/p2p/12D3KooWT2HyZx5C6BBeLbCKhYG2SqJYuiu7sLMxGzUcQBko3BMr", + "/dns/polkadot.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWT2HyZx5C6BBeLbCKhYG2SqJYuiu7sLMxGzUcQBko3BMr", "/dns/polkadot.bootnodes.polkadotters.com/tcp/30314/p2p/12D3KooWPAVUgBaBk6n8SztLrMk8ESByncbAfRKUdxY1nygb9zG3", "/dns/polkadot.bootnodes.polkadotters.com/tcp/30316/wss/p2p/12D3KooWPAVUgBaBk6n8SztLrMk8ESByncbAfRKUdxY1nygb9zG3", - "/dns/boot-cr.gatotech.network/tcp/33100/p2p/12D3KooWK4E16jKk9nRhvC4RfrDVgcZzExg8Q3Q2G7ABUUitks1w", - "/dns/boot-cr.gatotech.network/tcp/35100/wss/p2p/12D3KooWK4E16jKk9nRhvC4RfrDVgcZzExg8Q3Q2G7ABUUitks1w", + "/dns/boot.gatotech.network/tcp/33100/p2p/12D3KooWK4E16jKk9nRhvC4RfrDVgcZzExg8Q3Q2G7ABUUitks1w", + "/dns/boot.gatotech.network/tcp/35100/wss/p2p/12D3KooWK4E16jKk9nRhvC4RfrDVgcZzExg8Q3Q2G7ABUUitks1w", "/dns/boot.metaspan.io/tcp/13012/p2p/12D3KooWRjHFApinuqSBjoaDjQHvxwubQSpEVy5hrgC9Smvh92WF", "/dns/boot.metaspan.io/tcp/13015/ws/p2p/12D3KooWRjHFApinuqSBjoaDjQHvxwubQSpEVy5hrgC9Smvh92WF", "/dns/boot.metaspan.io/tcp/13016/wss/p2p/12D3KooWRjHFApinuqSBjoaDjQHvxwubQSpEVy5hrgC9Smvh92WF", @@ -38,7 +38,8 @@ "/dns/ibp-boot-polkadot.luckyfriday.io/tcp/30333/p2p/12D3KooWEjk6QXrZJ26fLpaajisJGHiz6WiQsR8k7mkM9GmWKnRZ", "/dns/ibp-boot-polkadot.luckyfriday.io/tcp/30334/wss/p2p/12D3KooWEjk6QXrZJ26fLpaajisJGHiz6WiQsR8k7mkM9GmWKnRZ", "/dns/boot-polkadot.luckyfriday.io/tcp/443/wss/p2p/12D3KooWAdyiVAaeGdtBt6vn5zVetwA4z4qfm9Fi2QCSykN1wTBJ", - "/dns4/polkadot-0.boot.onfinality.io/tcp/24446/ws/p2p/12D3KooWT1PWaNdAwYrSr89dvStnoGdH3t4LNRbcVNN4JCtsotkR" + "/dns4/polkadot-0.boot.onfinality.io/tcp/24446/ws/p2p/12D3KooWT1PWaNdAwYrSr89dvStnoGdH3t4LNRbcVNN4JCtsotkR", + "/dns/polkadot.bootnode.stkd.io/tcp/30633/wss/p2p/12D3KooWEymrFRHz6c17YP3FAyd8kXS5gMRLgkW4U77ZJD2ZNCLZ" ], "telemetryEndpoints": [ [ diff --git a/polkadot/node/service/chain-specs/westend.json b/polkadot/node/service/chain-specs/westend.json index 9dfc715df46de3d09d6f901f11ca30a2c0b8cc69..08c5bd33b4bd7e9f6c9cc75dfeef4de6f55ab491 100644 --- a/polkadot/node/service/chain-specs/westend.json +++ b/polkadot/node/service/chain-specs/westend.json @@ -8,16 +8,16 @@ "/dns/westend-bootnode-1.polkadot.io/tcp/30333/p2p/12D3KooWPVPzs42GvRBShdUMtFsk4SvnByrSdWqb6aeAAHvLMSLS", "/dns/westend-bootnode-1.polkadot.io/tcp/30334/ws/p2p/12D3KooWPVPzs42GvRBShdUMtFsk4SvnByrSdWqb6aeAAHvLMSLS", "/dns/westend-bootnode-1.polkadot.io/tcp/443/wss/p2p/12D3KooWPVPzs42GvRBShdUMtFsk4SvnByrSdWqb6aeAAHvLMSLS", - "/dns/boot.stake.plus/tcp/32333/p2p/12D3KooWK8fjVoSvMq5copQYMsdYreSGPGgcMbGMgbMDPfpf3sm7", - "/dns/boot.stake.plus/tcp/32334/wss/p2p/12D3KooWK8fjVoSvMq5copQYMsdYreSGPGgcMbGMgbMDPfpf3sm7", + "/dns/westend.boot.stake.plus/tcp/30334/wss/p2p/12D3KooWAzfLkJarihZAyDeDet2WpYNkzjpXocGmmDFiRaHJjoyw", + "/dns/westend.boot.stake.plus/tcp/31334/wss/p2p/12D3KooWBdcVpUwnB3AgwZQXcyrvd4yzPBXtSLknvoBSHQZNoftP", "/dns/boot-node.helikon.io/tcp/7080/p2p/12D3KooWRFDPyT8vA8mLzh6dJoyujn4QNjeqi6Ch79eSMz9beKXC", "/dns/boot-node.helikon.io/tcp/7082/wss/p2p/12D3KooWRFDPyT8vA8mLzh6dJoyujn4QNjeqi6Ch79eSMz9beKXC", - "/dns/westend.bootnode.amforc.com/tcp/30333/p2p/12D3KooWJ5y9ZgVepBQNW4aabrxgmnrApdVnscqgKWiUu4BNJbC8", - "/dns/westend.bootnode.amforc.com/tcp/30334/wss/p2p/12D3KooWJ5y9ZgVepBQNW4aabrxgmnrApdVnscqgKWiUu4BNJbC8", + "/dns/westend.bootnode.amforc.com/tcp/30001/p2p/12D3KooWAPmR7rbm2axPjHzF51yvQNDM5GvWfkF5BTV44Y5vJ3ct", + "/dns/westend.bootnode.amforc.com/tcp/29999/wss/p2p/12D3KooWAPmR7rbm2axPjHzF51yvQNDM5GvWfkF5BTV44Y5vJ3ct", "/dns/westend.bootnodes.polkadotters.com/tcp/30308/p2p/12D3KooWHPHb64jXMtSRJDrYFATWeLnvChL8NtWVttY67DCH1eC5", "/dns/westend.bootnodes.polkadotters.com/tcp/30310/wss/p2p/12D3KooWHPHb64jXMtSRJDrYFATWeLnvChL8NtWVttY67DCH1eC5", - "/dns/boot-cr.gatotech.network/tcp/33300/p2p/12D3KooWQGR1vUhoy6mvQorFp3bZFn6NNezhQZ6NWnVV7tpFgoPd", - "/dns/boot-cr.gatotech.network/tcp/35300/wss/p2p/12D3KooWQGR1vUhoy6mvQorFp3bZFn6NNezhQZ6NWnVV7tpFgoPd", + "/dns/boot.gatotech.network/tcp/33300/p2p/12D3KooWQGR1vUhoy6mvQorFp3bZFn6NNezhQZ6NWnVV7tpFgoPd", + "/dns/boot.gatotech.network/tcp/35300/wss/p2p/12D3KooWQGR1vUhoy6mvQorFp3bZFn6NNezhQZ6NWnVV7tpFgoPd", "/dns/boot.metaspan.io/tcp/33012/p2p/12D3KooWNTau7iG4G9cUJSwwt2QJP1W88pUf2SgqsHjRU2RL8pfa", "/dns/boot.metaspan.io/tcp/33015/ws/p2p/12D3KooWNTau7iG4G9cUJSwwt2QJP1W88pUf2SgqsHjRU2RL8pfa", "/dns/boot.metaspan.io/tcp/33016/wss/p2p/12D3KooWNTau7iG4G9cUJSwwt2QJP1W88pUf2SgqsHjRU2RL8pfa", @@ -33,7 +33,8 @@ "/dns/wnd14.rotko.net/tcp/35234/wss/p2p/12D3KooWLK8Zj1uZ46phU3vQwiDVda8tB76S8J26rXZQLHpwWkDJ", "/dns/wnd14.rotko.net/tcp/33234/p2p/12D3KooWLK8Zj1uZ46phU3vQwiDVda8tB76S8J26rXZQLHpwWkDJ", "/dns/ibp-boot-westend.luckyfriday.io/tcp/30333/p2p/12D3KooWDg1YEytdwFFNWroFj6gio4YFsMB3miSbHKgdpJteUMB9", - "/dns/ibp-boot-westend.luckyfriday.io/tcp/30334/wss/p2p/12D3KooWDg1YEytdwFFNWroFj6gio4YFsMB3miSbHKgdpJteUMB9" + "/dns/ibp-boot-westend.luckyfriday.io/tcp/30334/wss/p2p/12D3KooWDg1YEytdwFFNWroFj6gio4YFsMB3miSbHKgdpJteUMB9", + "/dns/westend.bootnode.stkd.io/tcp/30633/wss/p2p/12D3KooWHaQKkJiTPqeNgqDcW7dfYgJxYwT8YqJMtTkueSu6378V" ], "telemetryEndpoints": [ [ diff --git a/polkadot/node/service/src/benchmarking.rs b/polkadot/node/service/src/benchmarking.rs index a0c4d3b04469b1bcf85990d4f6f62922f09bf88a..4dcff2078419c9161ec752dc269f3f6a919748a2 100644 --- a/polkadot/node/service/src/benchmarking.rs +++ b/polkadot/node/service/src/benchmarking.rs @@ -201,6 +201,7 @@ fn westend_sign_call( frame_system::CheckNonce::::from(nonce), frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(0), + frame_metadata_hash_extension::CheckMetadataHash::::new(false), ); let payload = runtime::SignedPayload::from_raw( @@ -215,6 +216,7 @@ fn westend_sign_call( (), (), (), + None, ), ); @@ -253,6 +255,7 @@ fn rococo_sign_call( frame_system::CheckNonce::::from(nonce), frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(0), + frame_metadata_hash_extension::CheckMetadataHash::::new(false), ); let payload = runtime::SignedPayload::from_raw( @@ -267,6 +270,7 @@ fn rococo_sign_call( (), (), (), + None, ), ); diff --git a/polkadot/node/service/src/chain_spec.rs b/polkadot/node/service/src/chain_spec.rs index 1b990af2394b6fba31b0c8ddb2c1839cb2c09fb0..d377a75f1069b52edbcd02a3c73f67d15be3d3a4 100644 --- a/polkadot/node/service/src/chain_spec.rs +++ b/polkadot/node/service/src/chain_spec.rs @@ -16,28 +16,28 @@ //! Polkadot chain configurations. -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; -use grandpa::AuthorityId as GrandpaId; #[cfg(feature = "westend-native")] use pallet_staking::Forcing; use polkadot_primitives::{AccountId, AccountPublic, AssignmentId, ValidatorId}; +use sc_consensus_grandpa::AuthorityId as GrandpaId; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; #[cfg(feature = "westend-native")] -use polkadot_primitives::vstaging::SchedulerParams; +use polkadot_primitives::SchedulerParams; #[cfg(feature = "rococo-native")] use rococo_runtime as rococo; use sc_chain_spec::ChainSpecExtension; #[cfg(any(feature = "westend-native", feature = "rococo-native"))] use sc_chain_spec::ChainType; +#[cfg(any(feature = "westend-native", feature = "rococo-native"))] +use sc_telemetry::TelemetryEndpoints; use serde::{Deserialize, Serialize}; use sp_core::{sr25519, Pair, Public}; use sp_runtime::traits::IdentifyAccount; #[cfg(feature = "westend-native")] use sp_runtime::Perbill; -#[cfg(any(feature = "westend-native", feature = "rococo-native"))] -use telemetry::TelemetryEndpoints; #[cfg(feature = "westend-native")] use westend_runtime as westend; #[cfg(feature = "westend-native")] @@ -70,11 +70,11 @@ pub struct Extensions { } // Generic chain spec, in case when we don't have the native runtime. -pub type GenericChainSpec = service::GenericChainSpec<(), Extensions>; +pub type GenericChainSpec = sc_service::GenericChainSpec; /// The `ChainSpec` parameterized for the westend runtime. #[cfg(feature = "westend-native")] -pub type WestendChainSpec = service::GenericChainSpec<(), Extensions>; +pub type WestendChainSpec = sc_service::GenericChainSpec; /// The `ChainSpec` parameterized for the westend runtime. // Dummy chain spec, but that is fine when we don't have the native runtime. @@ -83,7 +83,7 @@ pub type WestendChainSpec = GenericChainSpec; /// The `ChainSpec` parameterized for the rococo runtime. #[cfg(feature = "rococo-native")] -pub type RococoChainSpec = service::GenericChainSpec<(), Extensions>; +pub type RococoChainSpec = sc_service::GenericChainSpec; /// The `ChainSpec` parameterized for the rococo runtime. // Dummy chain spec, but that is fine when we don't have the native runtime. @@ -658,7 +658,8 @@ fn westend_local_testnet_genesis() -> serde_json::Value { #[cfg(feature = "westend-native")] pub fn westend_local_testnet_config() -> Result { Ok(WestendChainSpec::builder( - westend::WASM_BINARY.ok_or("Westend development wasm not available")?, + westend::fast_runtime_binary::WASM_BINARY + .ok_or("Westend development wasm not available")?, Default::default(), ) .with_name("Westend Local Testnet") diff --git a/polkadot/node/service/src/fake_runtime_api.rs b/polkadot/node/service/src/fake_runtime_api.rs index 5c889552a6ae4b7708c0afb7511447fb518f8a9a..cdef39d5bdf1805d1066fdeba9cb09f0037261b1 100644 --- a/polkadot/node/service/src/fake_runtime_api.rs +++ b/polkadot/node/service/src/fake_runtime_api.rs @@ -19,8 +19,6 @@ //! These are used to provide a type that implements these runtime APIs without requiring to import //! the native runtimes. -use beefy_primitives::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}; -use grandpa_primitives::AuthorityId as GrandpaId; use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo}; use polkadot_primitives::{ runtime_api, slashing, AccountId, AuthorityDiscoveryId, Balance, Block, BlockNumber, @@ -30,6 +28,8 @@ use polkadot_primitives::{ ScrapedOnChainVotes, SessionIndex, SessionInfo, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, }; +use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}; +use sp_consensus_grandpa::AuthorityId as GrandpaId; use sp_core::OpaqueMetadata; use sp_runtime::{ @@ -232,30 +232,55 @@ sp_api::impl_runtime_apis! { } } - impl beefy_primitives::BeefyApi for Runtime { + impl sp_consensus_beefy::BeefyApi for Runtime { fn beefy_genesis() -> Option { unimplemented!() } - fn validator_set() -> Option> { + fn validator_set() -> Option> { unimplemented!() } - fn submit_report_equivocation_unsigned_extrinsic( - _: beefy_primitives::DoubleVotingProof< + fn submit_report_double_voting_unsigned_extrinsic( + _: sp_consensus_beefy::DoubleVotingProof< BlockNumber, BeefyId, BeefySignature, >, - _: beefy_primitives::OpaqueKeyOwnershipProof, + _: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + unimplemented!() + } + + fn submit_report_fork_voting_unsigned_extrinsic( + _: sp_consensus_beefy::ForkVotingProof< + ::Header, + BeefyId, + sp_runtime::OpaqueValue + >, + _: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + unimplemented!() + } + + fn submit_report_future_block_voting_unsigned_extrinsic( + _: sp_consensus_beefy::FutureBlockVotingProof, + _: sp_consensus_beefy::OpaqueKeyOwnershipProof, ) -> Option<()> { unimplemented!() } fn generate_key_ownership_proof( - _: beefy_primitives::ValidatorSetId, + _: sp_consensus_beefy::ValidatorSetId, _: BeefyId, - ) -> Option { + ) -> Option { + unimplemented!() + } + + fn generate_ancestry_proof( + _: BlockNumber, + _: Option, + ) -> Option { unimplemented!() } } @@ -272,11 +297,11 @@ sp_api::impl_runtime_apis! { fn generate_proof( _: Vec, _: Option, - ) -> Result<(Vec, sp_mmr_primitives::Proof), sp_mmr_primitives::Error> { + ) -> Result<(Vec, sp_mmr_primitives::LeafProof), sp_mmr_primitives::Error> { unimplemented!() } - fn verify_proof(_: Vec, _: sp_mmr_primitives::Proof) + fn verify_proof(_: Vec, _: sp_mmr_primitives::LeafProof) -> Result<(), sp_mmr_primitives::Error> { unimplemented!() @@ -285,35 +310,35 @@ sp_api::impl_runtime_apis! { fn verify_proof_stateless( _: Hash, _: Vec, - _: sp_mmr_primitives::Proof + _: sp_mmr_primitives::LeafProof ) -> Result<(), sp_mmr_primitives::Error> { unimplemented!() } } - impl grandpa_primitives::GrandpaApi for Runtime { + impl sp_consensus_grandpa::GrandpaApi for Runtime { fn grandpa_authorities() -> Vec<(GrandpaId, u64)> { unimplemented!() } - fn current_set_id() -> grandpa_primitives::SetId { + fn current_set_id() -> sp_consensus_grandpa::SetId { unimplemented!() } fn submit_report_equivocation_unsigned_extrinsic( - _: grandpa_primitives::EquivocationProof< + _: sp_consensus_grandpa::EquivocationProof< ::Hash, sp_runtime::traits::NumberFor, >, - _: grandpa_primitives::OpaqueKeyOwnershipProof, + _: sp_consensus_grandpa::OpaqueKeyOwnershipProof, ) -> Option<()> { unimplemented!() } fn generate_key_ownership_proof( - _: grandpa_primitives::SetId, - _: grandpa_primitives::AuthorityId, - ) -> Option { + _: sp_consensus_grandpa::SetId, + _: sp_consensus_grandpa::AuthorityId, + ) -> Option { unimplemented!() } } @@ -398,30 +423,30 @@ sp_api::impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { - fn query_acceptable_payment_assets(_: xcm::Version) -> Result, xcm_fee_payment_runtime_api::fees::Error> { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { + fn query_acceptable_payment_assets(_: xcm::Version) -> Result, xcm_runtime_apis::fees::Error> { unimplemented!() } - fn query_weight_to_asset_fee(_: Weight, _: VersionedAssetId) -> Result { + fn query_weight_to_asset_fee(_: Weight, _: VersionedAssetId) -> Result { unimplemented!() } - fn query_xcm_weight(_: VersionedXcm<()>) -> Result { + fn query_xcm_weight(_: VersionedXcm<()>) -> Result { unimplemented!() } - fn query_delivery_fees(_: VersionedLocation, _: VersionedXcm<()>) -> Result { + fn query_delivery_fees(_: VersionedLocation, _: VersionedXcm<()>) -> Result { unimplemented!() } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(_: ::Extrinsic) -> Result, xcm_fee_payment_runtime_api::dry_run::Error> { + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(_: (), _: ()) -> Result, xcm_runtime_apis::dry_run::Error> { unimplemented!() } - fn dry_run_xcm(_: VersionedLocation, _: VersionedXcm<()>) -> Result, xcm_fee_payment_runtime_api::dry_run::Error> { + fn dry_run_xcm(_: VersionedLocation, _: VersionedXcm<()>) -> Result, xcm_runtime_apis::dry_run::Error> { unimplemented!() } } diff --git a/polkadot/node/service/src/grandpa_support.rs b/polkadot/node/service/src/grandpa_support.rs index 729dbfde5c76b850dd1b76bd9195de5066d551bc..c85d5eb32b192e99189a5c1fae6c233dd2a51aaa 100644 --- a/polkadot/node/service/src/grandpa_support.rs +++ b/polkadot/node/service/src/grandpa_support.rs @@ -64,7 +64,7 @@ where /// w3f validators and randomly selected validators from the latest session (at /// #1500988). #[cfg(feature = "full-node")] -pub(crate) fn kusama_hard_forks() -> Vec> { +pub(crate) fn kusama_hard_forks() -> Vec> { use sp_core::crypto::Ss58Codec; use std::str::FromStr; @@ -141,7 +141,7 @@ pub(crate) fn kusama_hard_forks() -> Vec> { .into_iter() .map(|address| { ( - grandpa_primitives::AuthorityId::from_ss58check(address) + sp_consensus_grandpa::AuthorityId::from_ss58check(address) .expect("hard fork authority addresses are static and they should be carefully defined; qed."), 1, ) @@ -154,7 +154,7 @@ pub(crate) fn kusama_hard_forks() -> Vec> { let hash = Hash::from_str(hash) .expect("hard fork hashes are static and they should be carefully defined; qed."); - grandpa::AuthoritySetHardFork { + sc_consensus_grandpa::AuthoritySetHardFork { set_id, block: (hash, number), authorities: authorities.clone(), diff --git a/polkadot/node/service/src/lib.rs b/polkadot/node/service/src/lib.rs index 665533e9bc70a9173a5a9f6ff106657de07f859f..a907d310c10529ffc91056e8fbb5b100f557bbcb 100644 --- a/polkadot/node/service/src/lib.rs +++ b/polkadot/node/service/src/lib.rs @@ -41,7 +41,6 @@ mod tests; #[cfg(feature = "full-node")] use { - grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider}, gum::info, polkadot_node_core_approval_voting::{ self as approval_voting_subsystem, Config as ApprovalVotingConfig, @@ -58,6 +57,7 @@ use { request_response::ReqProtocolNames, }, sc_client_api::BlockBackend, + sc_consensus_grandpa::{self, FinalityProofProvider as GrandpaFinalityProofProvider}, sc_transaction_pool_api::OffchainTransactionPoolFactory, sp_core::traits::SpawnNamed, }; @@ -82,14 +82,13 @@ use std::{collections::HashMap, path::PathBuf, sync::Arc, time::Duration}; use prometheus_endpoint::Registry; #[cfg(feature = "full-node")] -use service::KeystoreContainer; -use service::RpcHandlers; -use telemetry::TelemetryWorker; +use sc_service::KeystoreContainer; +use sc_service::RpcHandlers; +use sc_telemetry::TelemetryWorker; #[cfg(feature = "full-node")] -use telemetry::{Telemetry, TelemetryWorkerHandle}; +use sc_telemetry::{Telemetry, TelemetryWorkerHandle}; pub use chain_spec::{GenericChainSpec, RococoChainSpec, WestendChainSpec}; -pub use consensus_common::{Proposal, SelectChain}; use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE; use mmr_gadget::MmrGadget; use polkadot_node_subsystem_types::DefaultSubsystemClient; @@ -98,12 +97,14 @@ pub use sc_client_api::{Backend, CallExecutor}; pub use sc_consensus::{BlockImport, LongestChain}; pub use sc_executor::NativeExecutionDispatch; use sc_executor::{HeapAllocStrategy, WasmExecutor, DEFAULT_HEAP_ALLOC_STRATEGY}; -pub use service::{ +pub use sc_service::{ config::{DatabaseSource, PrometheusConfig}, - ChainSpec, Configuration, Error as SubstrateServiceError, PruningMode, Role, RuntimeGenesis, - TFullBackend, TFullCallExecutor, TFullClient, TaskManager, TransactionPoolOptions, + ChainSpec, Configuration, Error as SubstrateServiceError, PruningMode, Role, TFullBackend, + TFullCallExecutor, TFullClient, TaskManager, TransactionPoolOptions, }; pub use sp_api::{ApiRef, ConstructRuntimeApi, Core as CoreApi, ProvideRuntimeApi}; +pub use sp_consensus::{Proposal, SelectChain}; +use sp_consensus_beefy::ecdsa_crypto; pub use sp_runtime::{ generic, traits::{self as runtime_traits, BlakeTwo256, Block as BlockT, Header as HeaderT, NumberFor}, @@ -117,10 +118,10 @@ pub use {westend_runtime, westend_runtime_constants}; pub use fake_runtime_api::{GetLastTimestamp, RuntimeApi}; #[cfg(feature = "full-node")] -pub type FullBackend = service::TFullBackend; +pub type FullBackend = sc_service::TFullBackend; #[cfg(feature = "full-node")] -pub type FullClient = service::TFullClient< +pub type FullClient = sc_service::TFullClient< Block, RuntimeApi, WasmExecutor<(sp_io::SubstrateHostFunctions, frame_benchmarking::benchmarking::HostFunctions)>, @@ -209,7 +210,7 @@ pub enum Error { Blockchain(#[from] sp_blockchain::Error), #[error(transparent)] - Consensus(#[from] consensus_common::Error), + Consensus(#[from] sp_consensus::Error), #[error("Failed to create an overseer")] Overseer(#[from] polkadot_overseer::SubsystemError), @@ -218,7 +219,7 @@ pub enum Error { Prometheus(#[from] prometheus_endpoint::PrometheusError), #[error(transparent)] - Telemetry(#[from] telemetry::Error), + Telemetry(#[from] sc_telemetry::Error), #[error(transparent)] Jaeger(#[from] polkadot_node_subsystem::jaeger::JaegerError), @@ -392,10 +393,16 @@ fn jaeger_launch_collector_with_agent( type FullSelectChain = relay_chain_selection::SelectRelayChain; #[cfg(feature = "full-node")] type FullGrandpaBlockImport = - grandpa::GrandpaBlockImport; + sc_consensus_grandpa::GrandpaBlockImport; #[cfg(feature = "full-node")] -type FullBeefyBlockImport = - beefy::import::BeefyBlockImport; +type FullBeefyBlockImport = + sc_consensus_beefy::import::BeefyBlockImport< + Block, + FullBackend, + FullClient, + InnerBlockImport, + AuthorityId, + >; #[cfg(feature = "full-node")] struct Basics { @@ -416,7 +423,7 @@ fn new_partial_basics( .telemetry_endpoints .clone() .filter(|x| !x.is_empty()) - .map(move |endpoints| -> Result<_, telemetry::Error> { + .map(move |endpoints| -> Result<_, sc_telemetry::Error> { let (worker, mut worker_handle) = if let Some(worker_handle) = telemetry_worker_handle { (None, worker_handle) } else { @@ -442,7 +449,7 @@ fn new_partial_basics( .build(); let (client, backend, keystore_container, task_manager) = - service::new_full_parts::( + sc_service::new_full_parts::( &config, telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()), executor, @@ -471,7 +478,7 @@ fn new_partial( Basics { task_manager, backend, client, keystore_container, telemetry }: Basics, select_chain: ChainSelection, ) -> Result< - service::PartialComponents< + sc_service::PartialComponents< FullClient, FullBackend, ChainSelection, @@ -479,20 +486,22 @@ fn new_partial( sc_transaction_pool::FullPool, ( impl Fn( - polkadot_rpc::DenyUnsafe, polkadot_rpc::SubscriptionTaskExecutor, ) -> Result, ( - babe::BabeBlockImport< + sc_consensus_babe::BabeBlockImport< Block, FullClient, - FullBeefyBlockImport>, + FullBeefyBlockImport< + FullGrandpaBlockImport, + ecdsa_crypto::AuthorityId, + >, >, - grandpa::LinkHalf, - babe::BabeLink, - beefy::BeefyVoterLinks, + sc_consensus_grandpa::LinkHalf, + sc_consensus_babe::BabeLink, + sc_consensus_beefy::BeefyVoterLinks, ), - grandpa::SharedVoterState, + sc_consensus_grandpa::SharedVoterState, sp_consensus_babe::SlotDuration, Option, ), @@ -516,55 +525,57 @@ where Vec::new() }; - let (grandpa_block_import, grandpa_link) = grandpa::block_import_with_authority_set_hard_forks( - client.clone(), - GRANDPA_JUSTIFICATION_PERIOD, - &(client.clone() as Arc<_>), - select_chain.clone(), - grandpa_hard_forks, - telemetry.as_ref().map(|x| x.handle()), - )?; + let (grandpa_block_import, grandpa_link) = + sc_consensus_grandpa::block_import_with_authority_set_hard_forks( + client.clone(), + GRANDPA_JUSTIFICATION_PERIOD, + &(client.clone() as Arc<_>), + select_chain.clone(), + grandpa_hard_forks, + telemetry.as_ref().map(|x| x.handle()), + )?; let justification_import = grandpa_block_import.clone(); let (beefy_block_import, beefy_voter_links, beefy_rpc_links) = - beefy::beefy_block_import_and_links( + sc_consensus_beefy::beefy_block_import_and_links( grandpa_block_import, backend.clone(), client.clone(), config.prometheus_registry().cloned(), ); - let babe_config = babe::configuration(&*client)?; + let babe_config = sc_consensus_babe::configuration(&*client)?; let (block_import, babe_link) = - babe::block_import(babe_config.clone(), beefy_block_import, client.clone())?; + sc_consensus_babe::block_import(babe_config.clone(), beefy_block_import, client.clone())?; let slot_duration = babe_link.config().slot_duration(); - let (import_queue, babe_worker_handle) = babe::import_queue(babe::ImportQueueParams { - link: babe_link.clone(), - block_import: block_import.clone(), - justification_import: Some(Box::new(justification_import)), - client: client.clone(), - select_chain: select_chain.clone(), - create_inherent_data_providers: move |_, ()| async move { - let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); + let (import_queue, babe_worker_handle) = + sc_consensus_babe::import_queue(sc_consensus_babe::ImportQueueParams { + link: babe_link.clone(), + block_import: block_import.clone(), + justification_import: Some(Box::new(justification_import)), + client: client.clone(), + select_chain: select_chain.clone(), + create_inherent_data_providers: move |_, ()| async move { + let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); - let slot = + let slot = sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration( *timestamp, slot_duration, ); - Ok((slot, timestamp)) - }, - spawner: &task_manager.spawn_essential_handle(), - registry: config.prometheus_registry(), - telemetry: telemetry.as_ref().map(|x| x.handle()), - offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()), - })?; + Ok((slot, timestamp)) + }, + spawner: &task_manager.spawn_essential_handle(), + registry: config.prometheus_registry(), + telemetry: telemetry.as_ref().map(|x| x.handle()), + offchain_tx_pool_factory: OffchainTransactionPoolFactory::new(transaction_pool.clone()), + })?; let justification_stream = grandpa_link.justification_stream(); let shared_authority_set = grandpa_link.shared_authority_set().clone(); - let shared_voter_state = grandpa::SharedVoterState::empty(); + let shared_voter_state = sc_consensus_grandpa::SharedVoterState::empty(); let finality_proof_provider = GrandpaFinalityProofProvider::new_for_service( backend.clone(), Some(shared_authority_set.clone()), @@ -581,15 +592,13 @@ where let chain_spec = config.chain_spec.cloned_box(); let backend = backend.clone(); - move |deny_unsafe, - subscription_executor: polkadot_rpc::SubscriptionTaskExecutor| - -> Result { + move |subscription_executor: polkadot_rpc::SubscriptionTaskExecutor| + -> Result { let deps = polkadot_rpc::FullDeps { client: client.clone(), pool: transaction_pool.clone(), select_chain: select_chain.clone(), chain_spec: chain_spec.cloned_box(), - deny_unsafe, babe: polkadot_rpc::BabeDeps { babe_worker_handle: babe_worker_handle.clone(), keystore: keystore.clone(), @@ -601,7 +610,7 @@ where subscription_executor: subscription_executor.clone(), finality_provider: finality_proof_provider.clone(), }, - beefy: polkadot_rpc::BeefyDeps { + beefy: polkadot_rpc::BeefyDeps:: { beefy_finality_proof_stream: beefy_rpc_links.from_voter_justif_stream.clone(), beefy_best_block_stream: beefy_rpc_links.from_voter_best_beefy_stream.clone(), subscription_executor, @@ -613,7 +622,7 @@ where } }; - Ok(service::PartialComponents { + Ok(sc_service::PartialComponents { client, backend, task_manager, @@ -750,8 +759,9 @@ pub fn new_full< prepare_workers_hard_max_num, }: NewFullParams, ) -> Result { + use polkadot_availability_recovery::FETCH_CHUNKS_THRESHOLD; use polkadot_node_network_protocol::request_response::IncomingRequest; - use sc_network_sync::WarpSyncParams; + use sc_network_sync::WarpSyncConfig; let is_offchain_indexing_enabled = config.offchain_worker.indexing_enabled; let role = config.role.clone(); @@ -807,7 +817,7 @@ pub fn new_full< SelectRelayChain::new_longest_chain(basics.backend.clone()) }; - let service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> { + let sc_service::PartialComponents::<_, _, SelectRelayChain<_>, _, _, _> { client, backend, mut task_manager, @@ -825,8 +835,10 @@ pub fn new_full< let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht; let auth_disc_public_addresses = config.network.public_addresses.clone(); - let mut net_config = - sc_network::config::FullNetworkConfiguration::<_, _, Network>::new(&config.network); + let mut net_config = sc_network::config::FullNetworkConfiguration::<_, _, Network>::new( + &config.network, + config.prometheus_config.as_ref().map(|cfg| cfg.registry.clone()), + ); let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); let peer_store_handle = net_config.peer_store_handle(); @@ -834,9 +846,10 @@ pub fn new_full< // Note: GrandPa is pushed before the Polkadot-specific protocols. This doesn't change // anything in terms of behaviour, but makes the logs more consistent with the other // Substrate nodes. - let grandpa_protocol_name = grandpa::protocol_standard_name(&genesis_hash, &config.chain_spec); + let grandpa_protocol_name = + sc_consensus_grandpa::protocol_standard_name(&genesis_hash, &config.chain_spec); let (grandpa_protocol_config, grandpa_notification_service) = - grandpa::grandpa_peers_set_config::<_, Network>( + sc_consensus_grandpa::grandpa_peers_set_config::<_, Network>( grandpa_protocol_name.clone(), metrics.clone(), Arc::clone(&peer_store_handle), @@ -844,21 +857,19 @@ pub fn new_full< net_config.add_notification_protocol(grandpa_protocol_config); let beefy_gossip_proto_name = - beefy::gossip_protocol_name(&genesis_hash, config.chain_spec.fork_id()); + sc_consensus_beefy::gossip_protocol_name(&genesis_hash, config.chain_spec.fork_id()); // `beefy_on_demand_justifications_handler` is given to `beefy-gadget` task to be run, // while `beefy_req_resp_cfg` is added to `config.network.request_response_protocols`. let (beefy_on_demand_justifications_handler, beefy_req_resp_cfg) = - beefy::communication::request_response::BeefyJustifsRequestHandler::new::<_, Network>( - &genesis_hash, - config.chain_spec.fork_id(), - client.clone(), - prometheus_registry.clone(), - ); + sc_consensus_beefy::communication::request_response::BeefyJustifsRequestHandler::new::< + _, + Network, + >(&genesis_hash, config.chain_spec.fork_id(), client.clone(), prometheus_registry.clone()); let beefy_notification_service = match enable_beefy { false => None, true => { let (beefy_notification_config, beefy_notification_service) = - beefy::communication::beefy_peers_set_config::<_, Network>( + sc_consensus_beefy::communication::beefy_peers_set_config::<_, Network>( beefy_gossip_proto_name.clone(), metrics.clone(), Arc::clone(&peer_store_handle), @@ -914,7 +925,10 @@ pub fn new_full< let (pov_req_receiver, cfg) = IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names); net_config.add_request_response_protocol(cfg); - let (chunk_req_receiver, cfg) = + let (chunk_req_v1_receiver, cfg) = + IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names); + net_config.add_request_response_protocol(cfg); + let (chunk_req_v2_receiver, cfg) = IncomingRequest::get_config_receiver::<_, Network>(&req_protocol_names); net_config.add_request_response_protocol(cfg); @@ -924,7 +938,7 @@ pub fn new_full< Vec::new() }; - let warp_sync = Arc::new(grandpa::warp_proof::NetworkProvider::new( + let warp_sync = Arc::new(sc_consensus_grandpa::warp_proof::NetworkProvider::new( backend.clone(), import_setup.1.shared_authority_set().clone(), grandpa_hard_forks, @@ -988,24 +1002,31 @@ pub fn new_full< stagnant_check_interval: Default::default(), stagnant_check_mode: chain_selection_subsystem::StagnantCheckMode::PruneOnly, }; + + // Kusama + testnets get a higher threshold, we are conservative on Polkadot for now. + let fetch_chunks_threshold = + if config.chain_spec.is_polkadot() { None } else { Some(FETCH_CHUNKS_THRESHOLD) }; + Some(ExtendedOverseerGenArgs { keystore, parachains_db, candidate_validation_config, availability_config: AVAILABILITY_CONFIG, pov_req_receiver, - chunk_req_receiver, + chunk_req_v1_receiver, + chunk_req_v2_receiver, statement_req_receiver, candidate_req_v2_receiver, approval_voting_config, dispute_req_receiver, dispute_coordinator_config, chain_selection_config, + fetch_chunks_threshold, }) }; let (network, system_rpc_tx, tx_handler_controller, network_starter, sync_service) = - service::build_network(service::BuildNetworkParams { + sc_service::build_network(sc_service::BuildNetworkParams { config: &config, net_config, client: client.clone(), @@ -1013,7 +1034,7 @@ pub fn new_full< spawn_handle: task_manager.spawn_handle(), import_queue, block_announce_validator_builder: None, - warp_sync_params: Some(WarpSyncParams::WithProvider(warp_sync)), + warp_sync_config: Some(WarpSyncConfig::WithProvider(warp_sync)), block_relay: None, metrics, })?; @@ -1041,7 +1062,7 @@ pub fn new_full< ); } - let rpc_handlers = service::spawn_tasks(service::SpawnTasksParams { + let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams { config, backend: backend.clone(), client: client.clone(), @@ -1137,7 +1158,7 @@ pub fn new_full< let overseer_handle = if let Some(authority_discovery_service) = authority_discovery_service { let (overseer, overseer_handle) = overseer_gen - .generate::>( + .generate::>( overseer_connector, OverseerGenArgs { runtime_client, @@ -1209,7 +1230,7 @@ pub fn new_full< let overseer_handle = overseer_handle.as_ref().ok_or(Error::AuthoritiesRequireRealOverseer)?.clone(); let slot_duration = babe_link.config().slot_duration(); - let babe_config = babe::BabeParams { + let babe_config = sc_consensus_babe::BabeParams { keystore: keystore_container.keystore(), client: client.clone(), select_chain, @@ -1243,12 +1264,12 @@ pub fn new_full< force_authoring, backoff_authoring_blocks, babe_link, - block_proposal_slot_portion: babe::SlotProportion::new(2f32 / 3f32), + block_proposal_slot_portion: sc_consensus_babe::SlotProportion::new(2f32 / 3f32), max_block_proposal_slot_portion: None, telemetry: telemetry.as_ref().map(|x| x.handle()), }; - let babe = babe::start_babe(babe_config)?; + let babe = sc_consensus_babe::start_babe(babe_config)?; task_manager.spawn_essential_handle().spawn_blocking("babe", None, babe); } @@ -1259,7 +1280,7 @@ pub fn new_full< // beefy is enabled if its notification service exists if let Some(notification_service) = beefy_notification_service { let justifications_protocol_name = beefy_on_demand_justifications_handler.protocol_name(); - let network_params = beefy::BeefyNetworkParams { + let network_params = sc_consensus_beefy::BeefyNetworkParams { network: Arc::new(network.clone()), sync: sync_service.clone(), gossip_protocol_name: beefy_gossip_proto_name, @@ -1267,8 +1288,8 @@ pub fn new_full< notification_service, _phantom: core::marker::PhantomData::, }; - let payload_provider = beefy_primitives::mmr::MmrRootProvider::new(client.clone()); - let beefy_params = beefy::BeefyParams { + let payload_provider = sp_consensus_beefy::mmr::MmrRootProvider::new(client.clone()); + let beefy_params = sc_consensus_beefy::BeefyParams { client: client.clone(), backend: backend.clone(), payload_provider, @@ -1282,7 +1303,16 @@ pub fn new_full< is_authority: role.is_authority(), }; - let gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params); + let gadget = sc_consensus_beefy::start_beefy_gadget::< + _, + _, + _, + _, + _, + _, + _, + ecdsa_crypto::AuthorityId, + >(beefy_params); // BEEFY is part of consensus, if it fails we'll bring the node down with it to make sure it // is noticed. @@ -1303,7 +1333,7 @@ pub fn new_full< ); } - let config = grandpa::Config { + let config = sc_consensus_grandpa::Config { // FIXME substrate#1578 make this available through chainspec // Grandpa performance can be improved a bit by tuning this parameter, see: // https://github.com/paritytech/polkadot/issues/5464 @@ -1326,17 +1356,18 @@ pub fn new_full< // provide better guarantees of block and vote data availability than // the observer. - let mut voting_rules_builder = grandpa::VotingRulesBuilder::default(); + let mut voting_rules_builder = sc_consensus_grandpa::VotingRulesBuilder::default(); #[cfg(not(feature = "malus"))] let _malus_finality_delay = None; if let Some(delay) = _malus_finality_delay { info!(?delay, "Enabling malus finality delay",); - voting_rules_builder = voting_rules_builder.add(grandpa::BeforeBestBlockBy(delay)); + voting_rules_builder = + voting_rules_builder.add(sc_consensus_grandpa::BeforeBestBlockBy(delay)); }; - let grandpa_config = grandpa::GrandpaParams { + let grandpa_config = sc_consensus_grandpa::GrandpaParams { config, link: link_half, network: network.clone(), @@ -1352,7 +1383,7 @@ pub fn new_full< task_manager.spawn_essential_handle().spawn_blocking( "grandpa-voter", None, - grandpa::run_grandpa_voter(grandpa_config)?, + sc_consensus_grandpa::run_grandpa_voter(grandpa_config)?, ); } @@ -1381,7 +1412,7 @@ macro_rules! chain_ops { // use the longest chain selection, since there is no overseer available let chain_selection = LongestChain::new(basics.backend.clone()); - let service::PartialComponents { client, backend, import_queue, task_manager, .. } = + let sc_service::PartialComponents { client, backend, import_queue, task_manager, .. } = new_partial::>(&mut config, basics, chain_selection)?; Ok((client, backend, import_queue, task_manager)) }}; @@ -1394,7 +1425,7 @@ pub fn new_chain_ops( jaeger_agent: Option, ) -> Result<(Arc, Arc, sc_consensus::BasicQueue, TaskManager), Error> { - config.keystore = service::config::KeystoreConfig::InMemory; + config.keystore = sc_service::config::KeystoreConfig::InMemory; if config.chain_spec.is_rococo() || config.chain_spec.is_wococo() || @@ -1472,8 +1503,8 @@ pub fn revert_backend( revert_approval_voting(parachains_db.clone(), hash)?; revert_chain_selection(parachains_db, hash)?; // Revert Substrate consensus related components - babe::revert(client.clone(), backend, blocks)?; - grandpa::revert(client, blocks)?; + sc_consensus_babe::revert(client.clone(), backend, blocks)?; + sc_consensus_grandpa::revert(client, blocks)?; Ok(()) } @@ -1502,7 +1533,7 @@ fn revert_approval_voting(db: Arc, hash: Hash) -> sp_blockchain::R config, db, Arc::new(sc_keystore::LocalKeystore::in_memory()), - Box::new(consensus_common::NoNetwork), + Box::new(sp_consensus::NoNetwork), approval_voting_subsystem::Metrics::default(), ); diff --git a/polkadot/node/service/src/overseer.rs b/polkadot/node/service/src/overseer.rs index 26b1446bf515afa342bd53c6237a87e7e750022d..add5d239364dfa8b66aaa33cc825512a59b244f4 100644 --- a/polkadot/node/service/src/overseer.rs +++ b/polkadot/node/service/src/overseer.rs @@ -82,7 +82,7 @@ where /// Underlying network service implementation. pub network_service: Arc, /// Underlying syncing service implementation. - pub sync_service: Arc, + pub sync_service: Arc, /// Underlying authority discovery service. pub authority_discovery_service: AuthorityDiscoveryService, /// Collations request receiver for network protocol v1. @@ -119,8 +119,10 @@ pub struct ExtendedOverseerGenArgs { pub availability_config: AvailabilityConfig, /// POV request receiver. pub pov_req_receiver: IncomingRequestReceiver, - /// Erasure chunks request receiver. - pub chunk_req_receiver: IncomingRequestReceiver, + /// Erasure chunk request v1 receiver. + pub chunk_req_v1_receiver: IncomingRequestReceiver, + /// Erasure chunk request v2 receiver. + pub chunk_req_v2_receiver: IncomingRequestReceiver, /// Receiver for incoming large statement requests. pub statement_req_receiver: IncomingRequestReceiver, /// Receiver for incoming candidate requests. @@ -133,6 +135,10 @@ pub struct ExtendedOverseerGenArgs { pub dispute_coordinator_config: DisputeCoordinatorConfig, /// Configuration for the chain selection subsystem. pub chain_selection_config: ChainSelectionConfig, + /// Optional availability recovery fetch chunks threshold. If PoV size size is lower + /// than the value put in here we always try to recovery availability from backers. + /// The presence of this parameter here is needed to have different values per chain. + pub fetch_chunks_threshold: Option, } /// Obtain a prepared validator `Overseer`, that is initialized with all default values. @@ -159,13 +165,15 @@ pub fn validator_overseer_builder( candidate_validation_config, availability_config, pov_req_receiver, - chunk_req_receiver, + chunk_req_v1_receiver, + chunk_req_v2_receiver, statement_req_receiver, candidate_req_v2_receiver, approval_voting_config, dispute_req_receiver, dispute_coordinator_config, chain_selection_config, + fetch_chunks_threshold, }: ExtendedOverseerGenArgs, ) -> Result< InitializedOverseerBuilder< @@ -221,7 +229,7 @@ where network_service.clone(), authority_discovery_service.clone(), network_bridge_metrics.clone(), - req_protocol_names, + req_protocol_names.clone(), peerset_protocol_names.clone(), notification_sinks.clone(), )) @@ -236,11 +244,18 @@ where )) .availability_distribution(AvailabilityDistributionSubsystem::new( keystore.clone(), - IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver }, + IncomingRequestReceivers { + pov_req_receiver, + chunk_req_v1_receiver, + chunk_req_v2_receiver, + }, + req_protocol_names.clone(), Metrics::register(registry)?, )) - .availability_recovery(AvailabilityRecoverySubsystem::with_chunks_if_pov_large( + .availability_recovery(AvailabilityRecoverySubsystem::for_validator( + fetch_chunks_threshold, available_data_req_receiver, + &req_protocol_names, Metrics::register(registry)?, )) .availability_store(AvailabilityStoreSubsystem::new( @@ -260,6 +275,7 @@ where )) .candidate_validation(CandidateValidationSubsystem::with_config( candidate_validation_config, + keystore.clone(), Metrics::register(registry)?, // candidate-validation metrics Metrics::register(registry)?, // validation host metrics )) @@ -385,7 +401,7 @@ pub fn collator_overseer_builder( DummySubsystem, DummySubsystem, DummySubsystem, - ProspectiveParachainsSubsystem, + DummySubsystem, >, Error, > @@ -406,7 +422,7 @@ where network_service.clone(), authority_discovery_service.clone(), network_bridge_metrics.clone(), - req_protocol_names, + req_protocol_names.clone(), peerset_protocol_names.clone(), notification_sinks.clone(), )) @@ -421,7 +437,9 @@ where )) .availability_distribution(DummySubsystem) .availability_recovery(AvailabilityRecoverySubsystem::for_collator( + None, available_data_req_receiver, + &req_protocol_names, Metrics::register(registry)?, )) .availability_store(DummySubsystem) @@ -462,7 +480,7 @@ where .dispute_coordinator(DummySubsystem) .dispute_distribution(DummySubsystem) .chain_selection(DummySubsystem) - .prospective_parachains(ProspectiveParachainsSubsystem::new(Metrics::register(registry)?)) + .prospective_parachains(DummySubsystem) .activation_external_listeners(Default::default()) .span_per_active_leaf(Default::default()) .active_leaves(Default::default()) diff --git a/polkadot/node/service/src/parachains_db/upgrade.rs b/polkadot/node/service/src/parachains_db/upgrade.rs index 4d7370859609d5559eb9f3b440bb6b4ee28cddff..808acf04b4e704d4a5e5c91556d8aac1524cc545 100644 --- a/polkadot/node/service/src/parachains_db/upgrade.rs +++ b/polkadot/node/service/src/parachains_db/upgrade.rs @@ -463,7 +463,7 @@ mod tests { v3::migration_helpers::{v1_to_latest_sanity_check, v2_fill_test_data}, }; use polkadot_node_subsystem_util::database::kvdb_impl::DbAdapter; - use test_helpers::dummy_candidate_receipt; + use polkadot_primitives_test_helpers::dummy_candidate_receipt; #[test] fn test_paritydb_migrate_0_to_1() { diff --git a/polkadot/node/service/src/relay_chain_selection.rs b/polkadot/node/service/src/relay_chain_selection.rs index c5546c34bdba6b2ca42a6bf2a5fc12f06be6e39a..c0b1ce8b0ebe1e38db56c3692ca473d7b31d13c4 100644 --- a/polkadot/node/service/src/relay_chain_selection.rs +++ b/polkadot/node/service/src/relay_chain_selection.rs @@ -36,7 +36,6 @@ #![cfg(feature = "full-node")] use super::{HeaderProvider, HeaderProviderProvider}; -use consensus_common::{Error as ConsensusError, SelectChain}; use futures::channel::oneshot; use polkadot_node_primitives::MAX_FINALITY_LAG as PRIMITIVES_MAX_FINALITY_LAG; use polkadot_node_subsystem::messages::{ @@ -46,9 +45,10 @@ use polkadot_node_subsystem::messages::{ use polkadot_node_subsystem_util::metrics::{self, prometheus}; use polkadot_overseer::{AllMessages, Handle}; use polkadot_primitives::{Block as PolkadotBlock, BlockNumber, Hash, Header as PolkadotHeader}; +use sp_consensus::{Error as ConsensusError, SelectChain}; use std::sync::Arc; -pub use service::SpawnTaskHandle; +pub use sc_service::SpawnTaskHandle; /// The maximum amount of unfinalized blocks we are willing to allow due to approval checking /// or disputes. diff --git a/polkadot/node/service/src/tests.rs b/polkadot/node/service/src/tests.rs index 26c8083185d84e9f18c27bfbc00779fce6a0b91e..195432bcb75d84a3fa1a5428efdb2d50fd76a910 100644 --- a/polkadot/node/service/src/tests.rs +++ b/polkadot/node/service/src/tests.rs @@ -19,7 +19,6 @@ use super::{relay_chain_selection::*, *}; use futures::channel::oneshot::Receiver; use polkadot_node_primitives::approval::v2::VrfSignature; use polkadot_node_subsystem::messages::{AllMessages, BlockDescription}; -use polkadot_node_subsystem_test_helpers as test_helpers; use polkadot_node_subsystem_util::TimeoutExt; use polkadot_test_client::Sr25519Keyring; use sp_consensus_babe::{ @@ -46,7 +45,8 @@ use polkadot_primitives::{Block, BlockNumber, Hash, Header}; use polkadot_node_subsystem_test_helpers::TestSubsystemSender; use polkadot_overseer::{SubsystemContext, SubsystemSender}; -type VirtualOverseer = test_helpers::TestSubsystemContextHandle; +type VirtualOverseer = + polkadot_node_subsystem_test_helpers::TestSubsystemContextHandle; #[async_trait::async_trait] impl OverseerHandleT for TestSubsystemSender { @@ -70,13 +70,11 @@ fn test_harness>( case_vars: CaseVars, test: impl FnOnce(TestHarness) -> T, ) { - let _ = env_logger::builder() - .is_test(true) - .filter_level(log::LevelFilter::Trace) - .try_init(); + sp_tracing::init_for_tests(); let pool = TaskExecutor::new(); - let (mut context, virtual_overseer) = test_helpers::make_subsystem_context(pool); + let (mut context, virtual_overseer) = + polkadot_node_subsystem_test_helpers::make_subsystem_context(pool); let (finality_target_tx, finality_target_rx) = oneshot::channel::>(); diff --git a/polkadot/node/subsystem-bench/Cargo.toml b/polkadot/node/subsystem-bench/Cargo.toml index e56efbf825429e9f7461fd9453289f5df68b9b6c..ae798cf2640a727d36c79a56019337792a1485b6 100644 --- a/polkadot/node/subsystem-bench/Cargo.toml +++ b/polkadot/node/subsystem-bench/Cargo.toml @@ -19,75 +19,85 @@ path = "src/cli/subsystem-bench.rs" # Prevent rustdoc error. Already documented from top-level Cargo.toml. doc = false + [dependencies] -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-node-subsystem-util = { path = "../subsystem-util" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-primitives = { path = "../../primitives" } -polkadot-node-network-protocol = { path = "../network/protocol" } -polkadot-availability-recovery = { path = "../network/availability-recovery", features = ["subsystem-benchmarks"] } -polkadot-availability-distribution = { path = "../network/availability-distribution" } -polkadot-node-core-av-store = { path = "../core/av-store" } -polkadot-node-core-chain-api = { path = "../core/chain-api" } -polkadot-availability-bitfield-distribution = { path = "../network/bitfield-distribution" } -color-eyre = { version = "0.6.1", default-features = false } -polkadot-overseer = { path = "../overseer" } -colored = "2.0.4" -assert_matches = "1.5" -async-trait = "0.1.79" -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sc-keystore = { path = "../../../substrate/client/keystore" } -sp-core = { path = "../../../substrate/primitives/core" } -clap = { version = "4.5.3", features = ["derive"] } -futures = "0.3.30" -futures-timer = "3.0.2" -bincode = "1.3.3" -sha1 = "0.10.6" -hex = "0.4.3" -gum = { package = "tracing-gum", path = "../gum" } -polkadot-erasure-coding = { package = "polkadot-erasure-coding", path = "../../erasure-coding" } +tikv-jemallocator = { features = ["profiling", "unprefixed_malloc_on_supported_platforms"], workspace = true, optional = true } +jemalloc_pprof = { workspace = true, optional = true } +polkadot-service = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-availability-recovery = { features = ["subsystem-benchmarks"], workspace = true, default-features = true } +polkadot-availability-distribution = { workspace = true, default-features = true } +polkadot-statement-distribution = { workspace = true, default-features = true } +polkadot-node-core-av-store = { workspace = true, default-features = true } +polkadot-node-core-chain-api = { workspace = true, default-features = true } +polkadot-availability-bitfield-distribution = { workspace = true, default-features = true } +color-eyre = { workspace = true } +polkadot-overseer = { workspace = true, default-features = true } +colored = { workspace = true } +assert_matches = { workspace = true } +async-trait = { workspace = true } +sp-keystore = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +clap = { features = ["derive"], workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +bincode = { workspace = true } +sha1 = { workspace = true } +hex = { workspace = true, default-features = true } +gum = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } log = { workspace = true, default-features = true } -env_logger = "0.11" -rand = "0.8.5" +sp-tracing = { workspace = true } +rand = { workspace = true, default-features = true } # `rand` only supports uniform distribution, we need normal distribution for latency. -rand_distr = "0.4.3" -bitvec = "1.0.1" -kvdb-memorydb = "0.13.0" +rand_distr = { workspace = true } +bitvec = { workspace = true, default-features = true } +kvdb-memorydb = { workspace = true } -parity-scale-codec = { version = "3.6.1", features = ["derive", "std"] } -tokio = { version = "1.24.2", features = ["parking_lot", "rt-multi-thread"] } -clap-num = "1.0.2" -polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" } -sc-network = { path = "../../../substrate/client/network" } -sc-network-types = { path = "../../../substrate/client/network/types" } -sc-service = { path = "../../../substrate/client/service" } -sp-consensus = { path = "../../../substrate/primitives/consensus/common" } -polkadot-node-metrics = { path = "../metrics" } -itertools = "0.11" -polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" } -prometheus_endpoint = { package = "substrate-prometheus-endpoint", path = "../../../substrate/utils/prometheus" } -prometheus = { version = "0.13.0", default-features = false } +codec = { features = ["derive", "std"], workspace = true, default-features = true } +tokio = { features = ["parking_lot", "rt-multi-thread"], workspace = true, default-features = true } +clap-num = { workspace = true } +polkadot-node-subsystem-test-helpers = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +itertools = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +prometheus-endpoint = { workspace = true, default-features = true } +prometheus = { workspace = true } serde = { workspace = true, default-features = true } serde_yaml = { workspace = true } serde_json = { workspace = true } -polkadot-node-core-approval-voting = { path = "../core/approval-voting" } -polkadot-approval-distribution = { path = "../network/approval-distribution" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-timestamp = { path = "../../../substrate/primitives/timestamp" } +polkadot-node-core-approval-voting = { workspace = true, default-features = true } +polkadot-approval-distribution = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-timestamp = { workspace = true, default-features = true } -schnorrkel = { version = "0.11.4", default-features = false } +schnorrkel = { workspace = true } # rand_core should match schnorrkel -rand_core = "0.6.2" -rand_chacha = { version = "0.3.1" } -paste = "1.0.14" -orchestra = { version = "0.3.5", default-features = false, features = ["futures_channel"] } -pyroscope = "0.5.7" -pyroscope_pprofrs = "0.2.7" +rand_core = { workspace = true } +rand_chacha = { workspace = true, default-features = true } +paste = { workspace = true, default-features = true } +orchestra = { features = ["futures_channel"], workspace = true } +pyroscope = { workspace = true } +pyroscope_pprofrs = { workspace = true } +strum = { features = ["derive"], workspace = true, default-features = true } [features] default = [] +memprofile = [ + "dep:jemalloc_pprof", + "dep:tikv-jemallocator", +] diff --git a/polkadot/node/subsystem-bench/README.md b/polkadot/node/subsystem-bench/README.md index 228fba41c46cce48a2a4bda96e869f6abcba1c44..8d20f1f49c0e705098d0e45a962623be58488f68 100644 --- a/polkadot/node/subsystem-bench/README.md +++ b/polkadot/node/subsystem-bench/README.md @@ -260,6 +260,41 @@ This file is best interpreted with `cg_annotate --auto=yes cachegrind.out.` For finer profiling of cache misses, better use `perf` on a bare-metal machine. +### Profile memory usage using jemalloc + +Bellow you can find instructions how to setup and run profiling with jemalloc, this is complementary +with using other memory profiling tools like: . + +#### Prerequisites + +Install tooling with: + +``` +sudo apt install libjemalloc-dev graphviz +``` + +#### Generate memory usage snapshots + +Memory usage can be profiled by running any subsystem benchmark with `--features memprofile`, e.g: + +``` +RUSTFLAGS=-g cargo run -p polkadot-subsystem-bench --release --features memprofile -- polkadot/node/subsystem-bench/examples/approvals_throughput.yaml +``` + +#### Interpret the results + +After the benchmark ran the memory usage snapshots can be found in `/tmp/subsystem-bench*`, to extract the information +from a snapshot you can use `jeprof` like this: + +``` +jeprof --text PATH_TO_EXECUTABLE_WITH_DEBUG_SYMBOLS /tmp/subsystem-bench.1222895.199.i199.heap > statistics.txt +``` + +Useful links: + +- Tutorial: +- Jemalloc configuration options: + ## Create new test objectives This tool is intended to make it easy to write new test objectives that focus individual subsystems, diff --git a/polkadot/node/subsystem-bench/examples/approvals_no_shows.yaml b/polkadot/node/subsystem-bench/examples/approvals_no_shows.yaml index 146da57d44c4aaf973e13c886a357028cdbe3559..cae1a30914da78c32a54ad035b8870f3a4412548 100644 --- a/polkadot/node/subsystem-bench/examples/approvals_no_shows.yaml +++ b/polkadot/node/subsystem-bench/examples/approvals_no_shows.yaml @@ -16,3 +16,5 @@ TestConfiguration: peer_bandwidth: 524288000000 bandwidth: 524288000000 num_blocks: 10 + connectivity: 100 + latency: null diff --git a/polkadot/node/subsystem-bench/examples/approvals_throughput.yaml b/polkadot/node/subsystem-bench/examples/approvals_throughput.yaml index 6b17e62c20aa3f69153fb596d1a303a2e0320ddd..7edb48e302a46b464e86d5b3535ab71d1585a408 100644 --- a/polkadot/node/subsystem-bench/examples/approvals_throughput.yaml +++ b/polkadot/node/subsystem-bench/examples/approvals_throughput.yaml @@ -16,3 +16,5 @@ TestConfiguration: peer_bandwidth: 524288000000 bandwidth: 524288000000 num_blocks: 10 + connectivity: 100 + latency: null diff --git a/polkadot/node/subsystem-bench/examples/approvals_throughput_best_case.yaml b/polkadot/node/subsystem-bench/examples/approvals_throughput_best_case.yaml index e946c28e8ef5d4e38736ffc21e56d8b1c6cd0ddc..7c24f50e6af5531ab652e838f362733f0fda6707 100644 --- a/polkadot/node/subsystem-bench/examples/approvals_throughput_best_case.yaml +++ b/polkadot/node/subsystem-bench/examples/approvals_throughput_best_case.yaml @@ -16,3 +16,6 @@ TestConfiguration: peer_bandwidth: 524288000000 bandwidth: 524288000000 num_blocks: 10 + connectivity: 100 + latency: null + diff --git a/polkadot/node/subsystem-bench/examples/approvals_throughput_no_optimisations_enabled.yaml b/polkadot/node/subsystem-bench/examples/approvals_throughput_no_optimisations_enabled.yaml index 8f4b050e72f27dd4b5bb0c52bd49162cd0bb83ec..fe2402faeccdc11f82ef10d7ff8618c8cbbd30c8 100644 --- a/polkadot/node/subsystem-bench/examples/approvals_throughput_no_optimisations_enabled.yaml +++ b/polkadot/node/subsystem-bench/examples/approvals_throughput_no_optimisations_enabled.yaml @@ -16,3 +16,6 @@ TestConfiguration: peer_bandwidth: 524288000000 bandwidth: 524288000000 num_blocks: 10 + connectivity: 100 + latency: null + diff --git a/polkadot/node/subsystem-bench/examples/availability_read.yaml b/polkadot/node/subsystem-bench/examples/availability_read.yaml index 82355b0e2973aaff490a5c2d3ed54d37c61430de..263a6988242e22c4c6f947dbd472a34167ef7453 100644 --- a/polkadot/node/subsystem-bench/examples/availability_read.yaml +++ b/polkadot/node/subsystem-bench/examples/availability_read.yaml @@ -1,8 +1,8 @@ TestConfiguration: # Test 1 - objective: !DataAvailabilityRead - fetch_from_backers: true - n_validators: 300 + strategy: FullFromBackers + n_validators: 500 n_cores: 20 min_pov_size: 5120 max_pov_size: 5120 @@ -16,7 +16,7 @@ TestConfiguration: # Test 2 - objective: !DataAvailabilityRead - fetch_from_backers: true + strategy: FullFromBackers n_validators: 500 n_cores: 20 min_pov_size: 5120 @@ -31,7 +31,7 @@ TestConfiguration: # Test 3 - objective: !DataAvailabilityRead - fetch_from_backers: true + strategy: FullFromBackers n_validators: 1000 n_cores: 20 min_pov_size: 5120 diff --git a/polkadot/node/subsystem-bench/examples/statement_distribution.yaml b/polkadot/node/subsystem-bench/examples/statement_distribution.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e86669ffefc356430c6ce4aa0ccd2ed5fca77474 --- /dev/null +++ b/polkadot/node/subsystem-bench/examples/statement_distribution.yaml @@ -0,0 +1,5 @@ +TestConfiguration: +- objective: StatementDistribution + num_blocks: 10 + n_cores: 100 + n_validators: 500 diff --git a/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs b/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs index 10953b6c7839d8ea2a4e0396a4ee37b9875828e9..0f68b905b4ca880aada73c3996bef9ed8d804b60 100644 --- a/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs +++ b/polkadot/node/subsystem-bench/src/cli/subsystem-bench.rs @@ -20,7 +20,7 @@ use clap::Parser; use color_eyre::eyre; use colored::Colorize; -use polkadot_subsystem_bench::{approval, availability, configuration}; +use polkadot_subsystem_bench::{approval, availability, configuration, statement}; use pyroscope::PyroscopeAgent; use pyroscope_pprofrs::{pprof_backend, PprofConfig}; use serde::{Deserialize, Serialize}; @@ -40,6 +40,8 @@ pub enum TestObjective { DataAvailabilityWrite, /// Benchmark the approval-voting and approval-distribution subsystems. ApprovalVoting(approval::ApprovalsOptions), + // Benchmark the statement-distribution subsystem + StatementDistribution, } impl std::fmt::Display for TestObjective { @@ -51,6 +53,7 @@ impl std::fmt::Display for TestObjective { Self::DataAvailabilityRead(_) => "DataAvailabilityRead", Self::DataAvailabilityWrite => "DataAvailabilityWrite", Self::ApprovalVoting(_) => "ApprovalVoting", + Self::StatementDistribution => "StatementDistribution", } ) } @@ -142,11 +145,8 @@ impl BenchCli { availability::TestDataAvailability::Read(opts), true, ); - env.runtime().block_on(availability::benchmark_availability_read( - &benchmark_name, - &mut env, - &state, - )) + env.runtime() + .block_on(availability::benchmark_availability_read(&mut env, &state)) }, TestObjective::DataAvailabilityWrite => { let state = availability::TestState::new(&test_config); @@ -155,23 +155,22 @@ impl BenchCli { availability::TestDataAvailability::Write, true, ); - env.runtime().block_on(availability::benchmark_availability_write( - &benchmark_name, - &mut env, - &state, - )) + env.runtime() + .block_on(availability::benchmark_availability_write(&mut env, &state)) }, TestObjective::ApprovalVoting(ref options) => { let (mut env, state) = approval::prepare_test(test_config.clone(), options.clone(), true); - env.runtime().block_on(approval::bench_approvals( - &benchmark_name, - &mut env, - state, - )) + env.runtime().block_on(approval::bench_approvals(&mut env, state)) + }, + TestObjective::StatementDistribution => { + let state = statement::TestState::new(&test_config); + let (mut env, _protocol_config) = statement::prepare_test(&state, true); + env.runtime() + .block_on(statement::benchmark_statement_distribution(&mut env, &state)) }, }; - println!("{}", usage); + println!("\n{}\n{}", benchmark_name.purple(), usage); } if let Some(agent_running) = agent_running { @@ -183,16 +182,20 @@ impl BenchCli { } } +#[cfg(feature = "memprofile")] +#[global_allocator] +static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc; + +#[cfg(feature = "memprofile")] +#[allow(non_upper_case_globals)] +#[export_name = "malloc_conf"] +// See https://jemalloc.net/jemalloc.3.html for more information on the configuration options. +pub static malloc_conf: &[u8] = + b"prof:true,prof_active:true,lg_prof_interval:30,lg_prof_sample:21,prof_prefix:/tmp/subsystem-bench\0"; + fn main() -> eyre::Result<()> { color_eyre::install()?; - env_logger::builder() - .filter(Some("hyper"), log::LevelFilter::Info) - // Avoid `Terminating due to subsystem exit subsystem` warnings - .filter(Some("polkadot_overseer"), log::LevelFilter::Error) - .filter(None, log::LevelFilter::Info) - .format_timestamp_millis() - .try_init() - .unwrap(); + sp_tracing::try_init_simple(); let cli: BenchCli = BenchCli::parse(); cli.launch()?; diff --git a/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs b/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs index e4a6c207970febc06fc364237e8f277728ec905e..6d3e7dd92db151d067c9385dfdb4d39419152b76 100644 --- a/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs +++ b/polkadot/node/subsystem-bench/src/lib/approval/message_generator.rs @@ -25,9 +25,9 @@ use crate::{ mock::runtime_api::session_info_for_peers, NODE_UNDER_TEST, }; +use codec::Encode; use futures::SinkExt; use itertools::Itertools; -use parity_scale_codec::Encode; use polkadot_node_core_approval_voting::{ criteria::{compute_assignments, Config}, time::tranche_to_tick, diff --git a/polkadot/node/subsystem-bench/src/lib/approval/mod.rs b/polkadot/node/subsystem-bench/src/lib/approval/mod.rs index 6ac0776d2d35a496be7737987988a68fd854d956..404df2f8c65365e66d8bf318ce8c33ba08c5b3b6 100644 --- a/polkadot/node/subsystem-bench/src/lib/approval/mod.rs +++ b/polkadot/node/subsystem-bench/src/lib/approval/mod.rs @@ -28,9 +28,11 @@ use crate::{ dummy_builder, environment::{TestEnvironment, TestEnvironmentDependencies, MAX_TIME_OF_FLIGHT}, mock::{ + availability_recovery::MockAvailabilityRecovery, + candidate_validation::MockCandidateValidation, chain_api::{ChainApiState, MockChainApi}, network_bridge::{MockNetworkBridgeRx, MockNetworkBridgeTx}, - runtime_api::MockRuntimeApi, + runtime_api::{MockRuntimeApi, MockRuntimeApiCoreState}, AlwaysSupportsParachains, TestSyncOracle, }, network::{ @@ -40,12 +42,12 @@ use crate::{ usage::BenchmarkUsage, NODE_UNDER_TEST, }; +use codec::{Decode, Encode}; use colored::Colorize; use futures::channel::oneshot; use itertools::Itertools; use orchestra::TimeoutExt; use overseer::{metrics::Metrics as OverseerMetrics, MetricsTrait}; -use parity_scale_codec::{Decode, Encode}; use polkadot_approval_distribution::ApprovalDistribution; use polkadot_node_core_approval_voting::{ time::{slot_number_to_tick, tick_to_slot_number, Clock, ClockExt, SystemClock}, @@ -59,15 +61,17 @@ use polkadot_node_subsystem_types::messages::{ApprovalDistributionMessage, Appro use polkadot_node_subsystem_util::metrics::Metrics; use polkadot_overseer::Handle as OverseerHandleReal; use polkadot_primitives::{ - BlockNumber, CandidateEvent, CandidateIndex, CandidateReceipt, Hash, Header, Slot, - ValidatorIndex, + BlockNumber, CandidateEvent, CandidateIndex, CandidateReceipt, Hash, Header, Slot, ValidatorId, + ValidatorIndex, ASSIGNMENT_KEY_TYPE_ID, }; use prometheus::Registry; use sc_keystore::LocalKeystore; use sc_service::SpawnTaskHandle; use serde::{Deserialize, Serialize}; +use sp_application_crypto::AppCrypto; use sp_consensus_babe::Epoch as BabeEpoch; use sp_core::H256; +use sp_keystore::Keystore; use std::{ cmp::max, collections::{HashMap, HashSet}, @@ -465,8 +469,9 @@ impl ApprovalTestState { } } +#[async_trait::async_trait] impl HandleNetworkMessage for ApprovalTestState { - fn handle( + async fn handle( &self, _message: crate::network::NetworkMessage, _node_sender: &mut futures::channel::mpsc::UnboundedSender, @@ -696,12 +701,12 @@ impl PeerMessageProducer { .expect("We can't handle unknown peers") .clone(); - self.network - .send_message_from_peer( - &peer_authority_id, - protocol_v3::ValidationProtocol::ApprovalDistribution(message.msg).into(), - ) - .unwrap_or_else(|_| panic!("Network should be up and running {:?}", sent_by)); + if let Err(err) = self.network.send_message_from_peer( + &peer_authority_id, + protocol_v3::ValidationProtocol::ApprovalDistribution(message.msg).into(), + ) { + gum::warn!(target: LOG_TARGET, ?sent_by, ?err, "Validator can not send message"); + } } // Queues a message to be sent by the peer identified by the `sent_by` value. @@ -784,6 +789,18 @@ fn build_overseer( let db: polkadot_node_subsystem_util::database::kvdb_impl::DbAdapter = polkadot_node_subsystem_util::database::kvdb_impl::DbAdapter::new(db, &[]); let keystore = LocalKeystore::in_memory(); + keystore + .sr25519_generate_new( + ASSIGNMENT_KEY_TYPE_ID, + Some(state.test_authorities.key_seeds.get(NODE_UNDER_TEST as usize).unwrap().as_str()), + ) + .unwrap(); + keystore + .sr25519_generate_new( + ValidatorId::ID, + Some(state.test_authorities.key_seeds.get(NODE_UNDER_TEST as usize).unwrap().as_str()), + ) + .unwrap(); let system_clock = PastSystemClock::new(SystemClock {}, state.delta_tick_from_generated.clone()); @@ -807,6 +824,7 @@ fn build_overseer( state.candidate_events_by_block(), Some(state.babe_epoch.clone()), 1, + MockRuntimeApiCoreState::Occupied, ); let mock_tx_bridge = MockNetworkBridgeTx::new( network.clone(), @@ -822,7 +840,9 @@ fn build_overseer( .replace_chain_selection(|_| mock_chain_selection) .replace_runtime_api(|_| mock_runtime_api) .replace_network_bridge_tx(|_| mock_tx_bridge) - .replace_network_bridge_rx(|_| mock_rx_bridge); + .replace_network_bridge_rx(|_| mock_rx_bridge) + .replace_availability_recovery(|_| MockAvailabilityRecovery::new()) + .replace_candidate_validation(|_| MockCandidateValidation::new()); let (overseer, raw_handle) = dummy.build_with_connector(overseer_connector).expect("Should not fail"); @@ -886,7 +906,6 @@ fn prepare_test_inner( } pub async fn bench_approvals( - benchmark_name: &str, env: &mut TestEnvironment, mut state: ApprovalTestState, ) -> BenchmarkUsage { @@ -898,12 +917,11 @@ pub async fn bench_approvals( env.registry().clone(), ) .await; - bench_approvals_run(benchmark_name, env, state, producer_rx).await + bench_approvals_run(env, state, producer_rx).await } /// Runs the approval benchmark. pub async fn bench_approvals_run( - benchmark_name: &str, env: &mut TestEnvironment, state: ApprovalTestState, producer_rx: oneshot::Receiver<()>, @@ -915,7 +933,9 @@ pub async fn bench_approvals_run( // First create the initialization messages that make sure that then node under // tests receives notifications about the topology used and the connected peers. - let mut initialization_messages = env.network().generate_peer_connected(); + let mut initialization_messages = env.network().generate_peer_connected(|e| { + AllMessages::ApprovalDistribution(ApprovalDistributionMessage::NetworkBridgeUpdate(e)) + }); initialization_messages.extend(generate_new_session_topology( &state.test_authorities, ValidatorIndex(NODE_UNDER_TEST), @@ -985,11 +1005,12 @@ pub async fn bench_approvals_run( "polkadot_parachain_subsystem_bounded_received", Some(("subsystem_name", "approval-distribution-subsystem")), |value| { - gum::info!(target: LOG_TARGET, ?value, ?at_least_messages, "Waiting metric"); + gum::debug!(target: LOG_TARGET, ?value, ?at_least_messages, "Waiting metric"); value >= at_least_messages as f64 }, ) .await; + gum::info!("Requesting approval votes ms"); for info in &state.blocks { @@ -1029,7 +1050,7 @@ pub async fn bench_approvals_run( "polkadot_parachain_subsystem_bounded_received", Some(("subsystem_name", "approval-distribution-subsystem")), |value| { - gum::info!(target: LOG_TARGET, ?value, ?at_least_messages, "Waiting metric"); + gum::debug!(target: LOG_TARGET, ?value, ?at_least_messages, "Waiting metric"); value >= at_least_messages as f64 }, ) @@ -1068,5 +1089,5 @@ pub async fn bench_approvals_run( state.total_unique_messages.load(std::sync::atomic::Ordering::SeqCst) ); - env.collect_resource_usage(benchmark_name, &["approval-distribution", "approval-voting"]) + env.collect_resource_usage(&["approval-distribution", "approval-voting"]) } diff --git a/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs b/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs index 9641b62a94d8a8612cd394b5964fd66eb1d6a0b4..d23c2552b8b37f51273545763e8275dd637af14a 100644 --- a/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs +++ b/polkadot/node/subsystem-bench/src/lib/approval/test_message.rs @@ -18,8 +18,8 @@ use crate::{ approval::{ApprovalsOptions, BlockTestData, CandidateTestData}, configuration::TestAuthorities, }; +use codec::{Decode, Encode}; use itertools::Itertools; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_network_protocol::v3 as protocol_v3; use polkadot_primitives::{CandidateIndex, Hash, ValidatorIndex}; use sc_network_types::PeerId; diff --git a/polkadot/node/subsystem-bench/src/lib/availability/mod.rs b/polkadot/node/subsystem-bench/src/lib/availability/mod.rs index 5b93c3d862de683ea35dde9f0a9e313b1a77ad4d..32dc8ae2c8dca329df20277111ef79a036a82bb2 100644 --- a/polkadot/node/subsystem-bench/src/lib/availability/mod.rs +++ b/polkadot/node/subsystem-bench/src/lib/availability/mod.rs @@ -17,12 +17,14 @@ use crate::{ availability::av_store_helpers::new_av_store, dummy_builder, - environment::{TestEnvironment, TestEnvironmentDependencies, GENESIS_HASH}, + environment::{TestEnvironment, TestEnvironmentDependencies}, mock::{ - av_store::{self, MockAvailabilityStore, NetworkAvailabilityState}, + av_store::{MockAvailabilityStore, NetworkAvailabilityState}, chain_api::{ChainApiState, MockChainApi}, network_bridge::{self, MockNetworkBridgeRx, MockNetworkBridgeTx}, - runtime_api::{self, MockRuntimeApi}, + runtime_api::{ + node_features_with_chunk_mapping_enabled, MockRuntimeApi, MockRuntimeApiCoreState, + }, AlwaysSupportsParachains, }, network::new_network, @@ -30,16 +32,17 @@ use crate::{ }; use colored::Colorize; use futures::{channel::oneshot, stream::FuturesUnordered, StreamExt}; -use parity_scale_codec::Encode; + +use codec::Encode; use polkadot_availability_bitfield_distribution::BitfieldDistribution; use polkadot_availability_distribution::{ AvailabilityDistributionSubsystem, IncomingRequestReceivers, }; -use polkadot_availability_recovery::AvailabilityRecoverySubsystem; +use polkadot_availability_recovery::{AvailabilityRecoverySubsystem, RecoveryStrategyKind}; use polkadot_node_core_av_store::AvailabilityStoreSubsystem; use polkadot_node_metrics::metrics::Metrics; use polkadot_node_network_protocol::{ - request_response::{IncomingRequest, ReqProtocolNames}, + request_response::{v1, v2, IncomingRequest}, OurView, }; use polkadot_node_subsystem::{ @@ -51,12 +54,13 @@ use polkadot_node_subsystem_types::{ Span, }; use polkadot_overseer::{metrics::Metrics as OverseerMetrics, Handle as OverseerHandle}; -use polkadot_primitives::{Block, GroupIndex, Hash}; +use polkadot_primitives::{Block, CoreIndex, GroupIndex, Hash}; use sc_network::request_responses::{IncomingRequest as RawIncomingRequest, ProtocolConfig}; +use std::{ops::Sub, sync::Arc, time::Instant}; +use strum::Display; use sc_service::SpawnTaskHandle; use serde::{Deserialize, Serialize}; -use std::{ops::Sub, sync::Arc, time::Instant}; pub use test_state::TestState; mod av_store_helpers; @@ -64,15 +68,26 @@ mod test_state; const LOG_TARGET: &str = "subsystem-bench::availability"; +#[derive(clap::ValueEnum, Clone, Copy, Debug, PartialEq, Serialize, Deserialize, Display)] +#[value(rename_all = "kebab-case")] +#[strum(serialize_all = "kebab-case")] +pub enum Strategy { + /// Regular random chunk recovery. This is also the fallback for the next strategies. + Chunks, + /// Recovery from systematic chunks. Much faster than regular chunk recovery becasue it avoid + /// doing the reed-solomon reconstruction. + Systematic, + /// Fetch the full availability datafrom backers first. Saves CPU as we don't need to + /// re-construct from chunks. Typically this is only faster if nodes have enough bandwidth. + FullFromBackers, +} + #[derive(Debug, Clone, Serialize, Deserialize, clap::Parser)] #[clap(rename_all = "kebab-case")] #[allow(missing_docs)] pub struct DataAvailabilityReadOptions { - #[clap(short, long, default_value_t = false)] - /// Turbo boost AD Read by fetching the full availability datafrom backers first. Saves CPU as - /// we don't need to re-construct from chunks. Typically this is only faster if nodes have - /// enough bandwidth. - pub fetch_from_backers: bool, + #[clap(short, long, default_value_t = Strategy::Systematic)] + pub strategy: Strategy, } pub enum TestDataAvailability { @@ -84,7 +99,7 @@ fn build_overseer_for_availability_read( spawn_task_handle: SpawnTaskHandle, runtime_api: MockRuntimeApi, av_store: MockAvailabilityStore, - network_bridge: (MockNetworkBridgeTx, MockNetworkBridgeRx), + (network_bridge_tx, network_bridge_rx): (MockNetworkBridgeTx, MockNetworkBridgeRx), availability_recovery: AvailabilityRecoverySubsystem, dependencies: &TestEnvironmentDependencies, ) -> (Overseer, AlwaysSupportsParachains>, OverseerHandle) { @@ -95,8 +110,8 @@ fn build_overseer_for_availability_read( let builder = dummy .replace_runtime_api(|_| runtime_api) .replace_availability_store(|_| av_store) - .replace_network_bridge_tx(|_| network_bridge.0) - .replace_network_bridge_rx(|_| network_bridge.1) + .replace_network_bridge_tx(|_| network_bridge_tx) + .replace_network_bridge_rx(|_| network_bridge_rx) .replace_availability_recovery(|_| availability_recovery); let (overseer, raw_handle) = @@ -109,7 +124,7 @@ fn build_overseer_for_availability_read( fn build_overseer_for_availability_write( spawn_task_handle: SpawnTaskHandle, runtime_api: MockRuntimeApi, - network_bridge: (MockNetworkBridgeTx, MockNetworkBridgeRx), + (network_bridge_tx, network_bridge_rx): (MockNetworkBridgeTx, MockNetworkBridgeRx), availability_distribution: AvailabilityDistributionSubsystem, chain_api: MockChainApi, availability_store: AvailabilityStoreSubsystem, @@ -123,8 +138,8 @@ fn build_overseer_for_availability_write( let builder = dummy .replace_runtime_api(|_| runtime_api) .replace_availability_store(|_| availability_store) - .replace_network_bridge_tx(|_| network_bridge.0) - .replace_network_bridge_rx(|_| network_bridge.1) + .replace_network_bridge_tx(|_| network_bridge_tx) + .replace_network_bridge_rx(|_| network_bridge_rx) .replace_chain_api(|_| chain_api) .replace_bitfield_distribution(|_| bitfield_distribution) // This is needed to test own chunk recovery for `n_cores`. @@ -142,10 +157,14 @@ pub fn prepare_test( with_prometheus_endpoint: bool, ) -> (TestEnvironment, Vec) { let dependencies = TestEnvironmentDependencies::default(); + let availability_state = NetworkAvailabilityState { candidate_hashes: state.candidate_hashes.clone(), + candidate_hash_to_core_index: state.candidate_hash_to_core_index.clone(), available_data: state.available_data.clone(), chunks: state.chunks.clone(), + chunk_indices: state.chunk_indices.clone(), + req_protocol_names: state.req_protocol_names.clone(), }; let mut req_cfgs = Vec::new(); @@ -153,20 +172,31 @@ pub fn prepare_test( let (collation_req_receiver, collation_req_cfg) = IncomingRequest::get_config_receiver::< Block, sc_network::NetworkWorker, - >(&ReqProtocolNames::new(GENESIS_HASH, None)); + >(&state.req_protocol_names); req_cfgs.push(collation_req_cfg); let (pov_req_receiver, pov_req_cfg) = IncomingRequest::get_config_receiver::< Block, sc_network::NetworkWorker, - >(&ReqProtocolNames::new(GENESIS_HASH, None)); - - let (chunk_req_receiver, chunk_req_cfg) = IncomingRequest::get_config_receiver::< - Block, - sc_network::NetworkWorker, - >(&ReqProtocolNames::new(GENESIS_HASH, None)); + >(&state.req_protocol_names); req_cfgs.push(pov_req_cfg); + let (chunk_req_v1_receiver, chunk_req_v1_cfg) = + IncomingRequest::::get_config_receiver::< + Block, + sc_network::NetworkWorker, + >(&state.req_protocol_names); + + // We won't use v1 chunk fetching requests, but we need to keep the inbound queue alive. + // Otherwise, av-distribution subsystem will terminate. + std::mem::forget(chunk_req_v1_cfg); + + let (chunk_req_v2_receiver, chunk_req_v2_cfg) = + IncomingRequest::::get_config_receiver::< + Block, + sc_network::NetworkWorker, + >(&state.req_protocol_names); + let (network, network_interface, network_receiver) = new_network( &state.config, &dependencies, @@ -180,37 +210,48 @@ pub fn prepare_test( state.test_authorities.clone(), ); let network_bridge_rx = - network_bridge::MockNetworkBridgeRx::new(network_receiver, Some(chunk_req_cfg)); + network_bridge::MockNetworkBridgeRx::new(network_receiver, Some(chunk_req_v2_cfg)); - let runtime_api = runtime_api::MockRuntimeApi::new( + let runtime_api = MockRuntimeApi::new( state.config.clone(), state.test_authorities.clone(), state.candidate_receipts.clone(), Default::default(), Default::default(), 0, + MockRuntimeApiCoreState::Occupied, ); let (overseer, overseer_handle) = match &mode { TestDataAvailability::Read(options) => { - let use_fast_path = options.fetch_from_backers; - - let subsystem = if use_fast_path { - AvailabilityRecoverySubsystem::with_fast_path( + let subsystem = match options.strategy { + Strategy::FullFromBackers => + AvailabilityRecoverySubsystem::with_recovery_strategy_kind( + collation_req_receiver, + &state.req_protocol_names, + Metrics::try_register(&dependencies.registry).unwrap(), + RecoveryStrategyKind::BackersFirstAlways, + ), + Strategy::Chunks => AvailabilityRecoverySubsystem::with_recovery_strategy_kind( collation_req_receiver, + &state.req_protocol_names, Metrics::try_register(&dependencies.registry).unwrap(), - ) - } else { - AvailabilityRecoverySubsystem::with_chunks_only( + RecoveryStrategyKind::ChunksAlways, + ), + Strategy::Systematic => AvailabilityRecoverySubsystem::with_recovery_strategy_kind( collation_req_receiver, + &state.req_protocol_names, Metrics::try_register(&dependencies.registry).unwrap(), - ) + RecoveryStrategyKind::SystematicChunks, + ), }; // Use a mocked av-store. - let av_store = av_store::MockAvailabilityStore::new( + let av_store = MockAvailabilityStore::new( state.chunks.clone(), + state.chunk_indices.clone(), state.candidate_hashes.clone(), + state.candidate_hash_to_core_index.clone(), ); build_overseer_for_availability_read( @@ -225,7 +266,12 @@ pub fn prepare_test( TestDataAvailability::Write => { let availability_distribution = AvailabilityDistributionSubsystem::new( state.test_authorities.keyring.keystore(), - IncomingRequestReceivers { pov_req_receiver, chunk_req_receiver }, + IncomingRequestReceivers { + pov_req_receiver, + chunk_req_v1_receiver, + chunk_req_v2_receiver, + }, + state.req_protocol_names.clone(), Metrics::try_register(&dependencies.registry).unwrap(), ); @@ -261,7 +307,6 @@ pub fn prepare_test( } pub async fn benchmark_availability_read( - benchmark_name: &str, env: &mut TestEnvironment, state: &TestState, ) -> BenchmarkUsage { @@ -295,6 +340,7 @@ pub async fn benchmark_availability_read( Some(GroupIndex( candidate_num as u32 % (std::cmp::max(5, config.n_cores) / 5) as u32, )), + Some(*state.candidate_hash_to_core_index.get(&candidate.hash()).unwrap()), tx, ), ); @@ -326,11 +372,10 @@ pub async fn benchmark_availability_read( ); env.stop().await; - env.collect_resource_usage(benchmark_name, &["availability-recovery"]) + env.collect_resource_usage(&["availability-recovery"]) } pub async fn benchmark_availability_write( - benchmark_name: &str, env: &mut TestEnvironment, state: &TestState, ) -> BenchmarkUsage { @@ -340,7 +385,7 @@ pub async fn benchmark_availability_write( env.metrics().set_n_cores(config.n_cores); gum::info!(target: LOG_TARGET, "Seeding availability store with candidates ..."); - for backed_candidate in state.backed_candidates.clone() { + for (core_index, backed_candidate) in state.backed_candidates.clone().into_iter().enumerate() { let candidate_index = *state.candidate_hashes.get(&backed_candidate.hash()).unwrap(); let available_data = state.available_data[candidate_index].clone(); let (tx, rx) = oneshot::channel(); @@ -351,6 +396,8 @@ pub async fn benchmark_availability_write( available_data, expected_erasure_root: backed_candidate.descriptor().erasure_root, tx, + core_index: CoreIndex(core_index as u32), + node_features: node_features_with_chunk_mapping_enabled(), }, )) .await; @@ -459,8 +506,9 @@ pub async fn benchmark_availability_write( ); env.stop().await; - env.collect_resource_usage( - benchmark_name, - &["availability-distribution", "bitfield-distribution", "availability-store"], - ) + env.collect_resource_usage(&[ + "availability-distribution", + "bitfield-distribution", + "availability-store", + ]) } diff --git a/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs b/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs index c328ffedf916e1ae9ce7fcd05e25750e01dc7506..173b23f6b76e41b925eea27133cf726d07a0f67c 100644 --- a/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs +++ b/polkadot/node/subsystem-bench/src/lib/availability/test_state.rs @@ -14,22 +14,28 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use crate::configuration::{TestAuthorities, TestConfiguration}; +use crate::{ + configuration::{TestAuthorities, TestConfiguration}, + environment::GENESIS_HASH, + mock::runtime_api::node_features_with_chunk_mapping_enabled, +}; use bitvec::bitvec; +use codec::Encode; use colored::Colorize; use itertools::Itertools; -use parity_scale_codec::Encode; use polkadot_node_network_protocol::{ - request_response::v1::ChunkFetchingRequest, Versioned, VersionedValidationProtocol, + request_response::{v2::ChunkFetchingRequest, ReqProtocolNames}, + Versioned, VersionedValidationProtocol, }; use polkadot_node_primitives::{AvailableData, BlockData, ErasureChunk, PoV}; use polkadot_node_subsystem_test_helpers::{ derive_erasure_chunks_with_proofs_and_root, mock::new_block_import_info, }; +use polkadot_node_subsystem_util::availability_chunks::availability_chunk_indices; use polkadot_overseer::BlockInfo; use polkadot_primitives::{ - AvailabilityBitfield, BlockNumber, CandidateHash, CandidateReceipt, Hash, HeadData, Header, - PersistedValidationData, Signed, SigningContext, ValidatorIndex, + AvailabilityBitfield, BlockNumber, CandidateHash, CandidateReceipt, ChunkIndex, CoreIndex, + Hash, HeadData, Header, PersistedValidationData, Signed, SigningContext, ValidatorIndex, }; use polkadot_primitives_test_helpers::{dummy_candidate_receipt, dummy_hash}; use sp_core::H256; @@ -49,14 +55,20 @@ pub struct TestState { pub pov_size_to_candidate: HashMap, // Map from generated candidate hashes to candidate index in `available_data` and `chunks`. pub candidate_hashes: HashMap, + // Map from candidate hash to occupied core index. + pub candidate_hash_to_core_index: HashMap, // Per candidate index receipts. pub candidate_receipt_templates: Vec, // Per candidate index `AvailableData` pub available_data: Vec, - // Per candiadte index chunks + // Per candidate index chunks pub chunks: Vec>, + // Per-core ValidatorIndex -> ChunkIndex mapping + pub chunk_indices: Vec>, // Per relay chain block - candidate backed by our backing group pub backed_candidates: Vec, + // Request protcol names + pub req_protocol_names: ReqProtocolNames, // Relay chain block infos pub block_infos: Vec, // Chung fetching requests for backed candidates @@ -89,6 +101,9 @@ impl TestState { candidate_receipts: Default::default(), block_headers: Default::default(), test_authorities: config.generate_authorities(), + req_protocol_names: ReqProtocolNames::new(GENESIS_HASH, None), + chunk_indices: Default::default(), + candidate_hash_to_core_index: Default::default(), }; // we use it for all candidates. @@ -99,6 +114,17 @@ impl TestState { relay_parent_storage_root: Default::default(), }; + test_state.chunk_indices = (0..config.n_cores) + .map(|core_index| { + availability_chunk_indices( + Some(&node_features_with_chunk_mapping_enabled()), + config.n_validators, + CoreIndex(core_index as u32), + ) + .unwrap() + }) + .collect(); + // For each unique pov we create a candidate receipt. for (index, pov_size) in config.pov_sizes().iter().cloned().unique().enumerate() { gum::info!(target: LOG_TARGET, index, pov_size, "{}", "Generating template candidate".bright_blue()); @@ -167,6 +193,11 @@ impl TestState { // Store the new candidate in the state test_state.candidate_hashes.insert(candidate_receipt.hash(), candidate_index); + let core_index = (index % config.n_cores) as u32; + test_state + .candidate_hash_to_core_index + .insert(candidate_receipt.hash(), core_index.into()); + gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_receipt.hash(), "new candidate"); candidate_receipt diff --git a/polkadot/node/subsystem-bench/src/lib/configuration.rs b/polkadot/node/subsystem-bench/src/lib/configuration.rs index 1e0efb72a7dff163898bcf6974ce9bc048bfa086..f614a5e552a803f0a6e2d2475efc5a824b64e9a2 100644 --- a/polkadot/node/subsystem-bench/src/lib/configuration.rs +++ b/polkadot/node/subsystem-bench/src/lib/configuration.rs @@ -18,12 +18,13 @@ use crate::keyring::Keyring; use itertools::Itertools; -use polkadot_primitives::{AssignmentId, AuthorityDiscoveryId, ValidatorId}; +use polkadot_primitives::{AssignmentId, AuthorityDiscoveryId, ValidatorId, ValidatorPair}; use rand::thread_rng; use rand_distr::{Distribution, Normal, Uniform}; use sc_network_types::PeerId; use serde::{Deserialize, Serialize}; use sp_consensus_babe::AuthorityId; +use sp_core::Pair; use std::collections::HashMap; /// Peer networking latency configuration. @@ -89,6 +90,15 @@ fn default_n_delay_tranches() -> usize { fn default_no_show_slots() -> usize { 3 } +fn default_minimum_backing_votes() -> u32 { + 2 +} +fn default_max_candidate_depth() -> u32 { + 3 +} +fn default_allowed_ancestry_len() -> u32 { + 2 +} /// The test input parameters #[derive(Clone, Debug, Serialize, Deserialize)] @@ -137,6 +147,15 @@ pub struct TestConfiguration { pub connectivity: usize, /// Number of blocks to run the test for pub num_blocks: usize, + /// Number of minimum backing votes + #[serde(default = "default_minimum_backing_votes")] + pub minimum_backing_votes: u32, + /// Async Backing max_candidate_depth + #[serde(default = "default_max_candidate_depth")] + pub max_candidate_depth: u32, + /// Async Backing allowed_ancestry_len + #[serde(default = "default_allowed_ancestry_len")] + pub allowed_ancestry_len: u32, } impl Default for TestConfiguration { @@ -158,6 +177,9 @@ impl Default for TestConfiguration { latency: default_peer_latency(), connectivity: default_connectivity(), num_blocks: Default::default(), + minimum_backing_votes: default_minimum_backing_votes(), + max_candidate_depth: default_max_candidate_depth(), + allowed_ancestry_len: default_allowed_ancestry_len(), } } } @@ -208,6 +230,11 @@ impl TestConfiguration { .map(|(peer_id, authority_id)| (*peer_id, authority_id.clone())) .collect(); + let validator_pairs = key_seeds + .iter() + .map(|seed| ValidatorPair::from_string_with_seed(seed, None).unwrap().0) + .collect(); + TestAuthorities { keyring, validator_public, @@ -217,6 +244,7 @@ impl TestConfiguration { validator_assignment_id, key_seeds, peer_id_to_authority, + validator_pairs, } } } @@ -246,6 +274,7 @@ pub struct TestAuthorities { pub key_seeds: Vec, pub peer_ids: Vec, pub peer_id_to_authority: HashMap, + pub validator_pairs: Vec, } /// Sample latency (in milliseconds) from a normal distribution with parameters diff --git a/polkadot/node/subsystem-bench/src/lib/environment.rs b/polkadot/node/subsystem-bench/src/lib/environment.rs index 42955d0302232f35e387a044e34a0c7d665512e8..a63f90da50b3aabcacca38874d723e7166173842 100644 --- a/polkadot/node/subsystem-bench/src/lib/environment.rs +++ b/polkadot/node/subsystem-bench/src/lib/environment.rs @@ -351,13 +351,8 @@ impl TestEnvironment { } } - pub fn collect_resource_usage( - &self, - benchmark_name: &str, - subsystems_under_test: &[&str], - ) -> BenchmarkUsage { + pub fn collect_resource_usage(&self, subsystems_under_test: &[&str]) -> BenchmarkUsage { BenchmarkUsage { - benchmark_name: benchmark_name.to_string(), network_usage: self.network_usage(), cpu_usage: self.cpu_usage(subsystems_under_test), } diff --git a/polkadot/node/subsystem-bench/src/lib/lib.rs b/polkadot/node/subsystem-bench/src/lib/lib.rs index ef2724abc98920c79d8dd9d94f97bed32b0ab8e2..e18227af8be349debc38043529bd1649c67e1c56 100644 --- a/polkadot/node/subsystem-bench/src/lib/lib.rs +++ b/polkadot/node/subsystem-bench/src/lib/lib.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -// The validator index that represent the node that is under test. +// The validator index that represents the node that is under test. pub const NODE_UNDER_TEST: u32 = 0; pub mod approval; @@ -25,5 +25,6 @@ pub(crate) mod environment; pub(crate) mod keyring; pub(crate) mod mock; pub(crate) mod network; +pub mod statement; pub mod usage; pub mod utils; diff --git a/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs b/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs index fba33523be85dbfd241bc1fcf42d8f8069ebf95c..7586e848ab4756bbcbb4a2d8f74cc2325477f58d 100644 --- a/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs +++ b/polkadot/node/subsystem-bench/src/lib/mock/av_store.rs @@ -17,10 +17,10 @@ //! A generic av store subsystem mockup suitable to be used in benchmarks. use crate::network::{HandleNetworkMessage, NetworkMessage}; +use codec::Encode; use futures::{channel::oneshot, FutureExt}; -use parity_scale_codec::Encode; use polkadot_node_network_protocol::request_response::{ - v1::{AvailableDataFetchingResponse, ChunkFetchingResponse, ChunkResponse}, + v1::AvailableDataFetchingResponse, v2::ChunkFetchingResponse, Protocol, ReqProtocolNames, Requests, }; use polkadot_node_primitives::{AvailableData, ErasureChunk}; @@ -28,13 +28,14 @@ use polkadot_node_subsystem::{ messages::AvailabilityStoreMessage, overseer, SpawnedSubsystem, SubsystemError, }; use polkadot_node_subsystem_types::OverseerSignal; -use polkadot_primitives::CandidateHash; -use sc_network::ProtocolName; +use polkadot_primitives::{CandidateHash, ChunkIndex, CoreIndex, ValidatorIndex}; use std::collections::HashMap; pub struct AvailabilityStoreState { candidate_hashes: HashMap, chunks: Vec>, + chunk_indices: Vec>, + candidate_hash_to_core_index: HashMap, } const LOG_TARGET: &str = "subsystem-bench::av-store-mock"; @@ -43,21 +44,25 @@ const LOG_TARGET: &str = "subsystem-bench::av-store-mock"; /// used in a test. #[derive(Clone)] pub struct NetworkAvailabilityState { + pub req_protocol_names: ReqProtocolNames, pub candidate_hashes: HashMap, pub available_data: Vec, pub chunks: Vec>, + pub chunk_indices: Vec>, + pub candidate_hash_to_core_index: HashMap, } // Implement access to the state. +#[async_trait::async_trait] impl HandleNetworkMessage for NetworkAvailabilityState { - fn handle( + async fn handle( &self, message: NetworkMessage, _node_sender: &mut futures::channel::mpsc::UnboundedSender, ) -> Option { match message { NetworkMessage::RequestFromNode(peer, request) => match request { - Requests::ChunkFetchingV1(outgoing_request) => { + Requests::ChunkFetching(outgoing_request) => { gum::debug!(target: LOG_TARGET, request = ?outgoing_request, "Received `RequestFromNode`"); let validator_index: usize = outgoing_request.payload.index.0 as usize; let candidate_hash = outgoing_request.payload.candidate_hash; @@ -68,11 +73,22 @@ impl HandleNetworkMessage for NetworkAvailabilityState { .expect("candidate was generated previously; qed"); gum::warn!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index"); - let chunk: ChunkResponse = - self.chunks.get(*candidate_index).unwrap()[validator_index].clone().into(); + let candidate_chunks = self.chunks.get(*candidate_index).unwrap(); + let chunk_indices = self + .chunk_indices + .get( + self.candidate_hash_to_core_index.get(&candidate_hash).unwrap().0 + as usize, + ) + .unwrap(); + + let chunk = candidate_chunks + .get(chunk_indices.get(validator_index).unwrap().0 as usize) + .unwrap(); + let response = Ok(( - ChunkFetchingResponse::from(Some(chunk)).encode(), - ProtocolName::Static("dummy"), + ChunkFetchingResponse::from(Some(chunk.clone())).encode(), + self.req_protocol_names.get_name(Protocol::ChunkFetchingV2), )); if let Err(err) = outgoing_request.pending_response.send(response) { @@ -93,7 +109,7 @@ impl HandleNetworkMessage for NetworkAvailabilityState { let response = Ok(( AvailableDataFetchingResponse::from(Some(available_data)).encode(), - ProtocolName::Static("dummy"), + self.req_protocol_names.get_name(Protocol::AvailableDataFetchingV1), )); outgoing_request .pending_response @@ -118,16 +134,25 @@ pub struct MockAvailabilityStore { impl MockAvailabilityStore { pub fn new( chunks: Vec>, + chunk_indices: Vec>, candidate_hashes: HashMap, + candidate_hash_to_core_index: HashMap, ) -> MockAvailabilityStore { - Self { state: AvailabilityStoreState { chunks, candidate_hashes } } + Self { + state: AvailabilityStoreState { + chunks, + candidate_hashes, + chunk_indices, + candidate_hash_to_core_index, + }, + } } async fn respond_to_query_all_request( &self, candidate_hash: CandidateHash, - send_chunk: impl Fn(usize) -> bool, - tx: oneshot::Sender>, + send_chunk: impl Fn(ValidatorIndex) -> bool, + tx: oneshot::Sender>, ) { let candidate_index = self .state @@ -136,15 +161,27 @@ impl MockAvailabilityStore { .expect("candidate was generated previously; qed"); gum::debug!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index"); - let v = self - .state - .chunks - .get(*candidate_index) - .unwrap() - .iter() - .filter(|c| send_chunk(c.index.0 as usize)) - .cloned() - .collect(); + let n_validators = self.state.chunks[0].len(); + let candidate_chunks = self.state.chunks.get(*candidate_index).unwrap(); + let core_index = self.state.candidate_hash_to_core_index.get(&candidate_hash).unwrap(); + // We'll likely only send our chunk, so use capacity 1. + let mut v = Vec::with_capacity(1); + + for validator_index in 0..n_validators { + if !send_chunk(ValidatorIndex(validator_index as u32)) { + continue; + } + let chunk_index = self + .state + .chunk_indices + .get(core_index.0 as usize) + .unwrap() + .get(validator_index) + .unwrap(); + + let chunk = candidate_chunks.get(chunk_index.0 as usize).unwrap().clone(); + v.push((ValidatorIndex(validator_index as u32), chunk.clone())); + } let _ = tx.send(v); } @@ -181,8 +218,12 @@ impl MockAvailabilityStore { AvailabilityStoreMessage::QueryAllChunks(candidate_hash, tx) => { // We always have our own chunk. gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_hash, "Responding to QueryAllChunks"); - self.respond_to_query_all_request(candidate_hash, |index| index == 0, tx) - .await; + self.respond_to_query_all_request( + candidate_hash, + |index| index == 0.into(), + tx, + ) + .await; }, AvailabilityStoreMessage::QueryChunkSize(candidate_hash, tx) => { gum::debug!(target: LOG_TARGET, candidate_hash = ?candidate_hash, "Responding to QueryChunkSize"); @@ -194,12 +235,29 @@ impl MockAvailabilityStore { .expect("candidate was generated previously; qed"); gum::debug!(target: LOG_TARGET, ?candidate_hash, candidate_index, "Candidate mapped to index"); - let chunk_size = - self.state.chunks.get(*candidate_index).unwrap()[0].encoded_size(); + let chunk_size = self + .state + .chunks + .get(*candidate_index) + .unwrap() + .first() + .unwrap() + .encoded_size(); let _ = tx.send(Some(chunk_size)); }, - AvailabilityStoreMessage::StoreChunk { candidate_hash, chunk, tx } => { - gum::debug!(target: LOG_TARGET, chunk_index = ?chunk.index ,candidate_hash = ?candidate_hash, "Responding to StoreChunk"); + AvailabilityStoreMessage::StoreChunk { + candidate_hash, + chunk, + tx, + validator_index, + } => { + gum::debug!( + target: LOG_TARGET, + chunk_index = ?chunk.index, + validator_index = ?validator_index, + candidate_hash = ?candidate_hash, + "Responding to StoreChunk" + ); let _ = tx.send(Ok(())); }, _ => { diff --git a/polkadot/node/subsystem-bench/src/lib/mock/availability_recovery.rs b/polkadot/node/subsystem-bench/src/lib/mock/availability_recovery.rs new file mode 100644 index 0000000000000000000000000000000000000000..713226de6ad8ebda3f675398278b19d90e9e7a29 --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/mock/availability_recovery.rs @@ -0,0 +1,73 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! A generic mock availability recovery suitable to be used in benchmarks. + +use std::sync::Arc; + +use futures::FutureExt; +use polkadot_node_primitives::{AvailableData, BlockData, PoV}; +use polkadot_node_subsystem::{ + messages::AvailabilityRecoveryMessage, overseer, SpawnedSubsystem, SubsystemError, +}; +use polkadot_node_subsystem_types::OverseerSignal; +use polkadot_primitives::{Hash, HeadData, PersistedValidationData}; + +pub struct MockAvailabilityRecovery {} + +impl MockAvailabilityRecovery { + pub fn new() -> Self { + Self {} + } +} + +#[overseer::subsystem(AvailabilityRecovery, error=SubsystemError, prefix=self::overseer)] +impl MockAvailabilityRecovery { + fn start(self, ctx: Context) -> SpawnedSubsystem { + let future = self.run(ctx).map(|_| Ok(())).boxed(); + + SpawnedSubsystem { name: "test-environment", future } + } +} + +#[overseer::contextbounds(AvailabilityRecovery, prefix = self::overseer)] +impl MockAvailabilityRecovery { + async fn run(self, mut ctx: Context) { + loop { + let msg = ctx.recv().await.expect("Overseer never fails us"); + match msg { + orchestra::FromOrchestra::Signal(signal) => + if signal == OverseerSignal::Conclude { + return + }, + orchestra::FromOrchestra::Communication { msg } => match msg { + AvailabilityRecoveryMessage::RecoverAvailableData(_, _, _, _, tx) => { + let available_data = AvailableData { + pov: Arc::new(PoV { block_data: BlockData(Vec::new()) }), + validation_data: PersistedValidationData { + parent_head: HeadData(Vec::new()), + relay_parent_number: 0, + relay_parent_storage_root: Hash::default(), + max_pov_size: 2, + }, + }; + tx.send(Ok(available_data)).unwrap(); + }, + }, + } + } + } +} diff --git a/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs b/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs new file mode 100644 index 0000000000000000000000000000000000000000..51494016e185e5e04f00c264eb341bf25d8991dd --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/mock/candidate_backing.rs @@ -0,0 +1,171 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! A generic candidate backing subsystem mockup suitable to be used in benchmarks. + +use crate::{configuration::TestConfiguration, NODE_UNDER_TEST}; +use futures::FutureExt; +use polkadot_node_primitives::{SignedFullStatementWithPVD, Statement, StatementWithPVD}; +use polkadot_node_subsystem::{ + messages::CandidateBackingMessage, overseer, SpawnedSubsystem, SubsystemError, +}; +use polkadot_node_subsystem_types::OverseerSignal; +use polkadot_primitives::{ + CandidateHash, Hash, PersistedValidationData, SigningContext, ValidatorIndex, ValidatorPair, +}; +use sp_core::Pair; +use std::collections::HashMap; + +const LOG_TARGET: &str = "subsystem-bench::candidate-backing-mock"; + +struct MockCandidateBackingState { + pair: ValidatorPair, + pvd: PersistedValidationData, + own_backing_group: Vec, +} + +pub struct MockCandidateBacking { + config: TestConfiguration, + state: MockCandidateBackingState, +} + +impl MockCandidateBacking { + pub fn new( + config: TestConfiguration, + pair: ValidatorPair, + pvd: PersistedValidationData, + own_backing_group: Vec, + ) -> Self { + Self { config, state: MockCandidateBackingState { pair, pvd, own_backing_group } } + } + + fn handle_statement( + &self, + relay_parent: Hash, + statement: SignedFullStatementWithPVD, + statements_tracker: &mut HashMap, + ) -> Vec { + let mut messages = vec![]; + let validator_id = statement.validator_index(); + let is_own_backing_group = self.state.own_backing_group.contains(&validator_id); + + match statement.payload() { + StatementWithPVD::Seconded(receipt, _pvd) => { + let candidate_hash = receipt.hash(); + statements_tracker + .entry(candidate_hash) + .and_modify(|v| { + *v += 1; + }) + .or_insert(1); + + let statements_received_count = *statements_tracker.get(&candidate_hash).unwrap(); + if statements_received_count == (self.config.minimum_backing_votes - 1) && + is_own_backing_group + { + let statement = Statement::Valid(candidate_hash); + let context = SigningContext { parent_hash: relay_parent, session_index: 0 }; + let payload = statement.to_compact().signing_payload(&context); + let message = + polkadot_node_subsystem::messages::StatementDistributionMessage::Share( + relay_parent, + SignedFullStatementWithPVD::new( + statement.supply_pvd(self.state.pvd.clone()), + ValidatorIndex(NODE_UNDER_TEST), + self.state.pair.sign(&payload[..]), + &context, + &self.state.pair.public(), + ) + .unwrap(), + ); + messages.push(message); + } + + if statements_received_count == self.config.minimum_backing_votes { + let message = + polkadot_node_subsystem::messages::StatementDistributionMessage::Backed( + candidate_hash, + ); + messages.push(message); + } + }, + StatementWithPVD::Valid(candidate_hash) => { + statements_tracker + .entry(*candidate_hash) + .and_modify(|v| { + *v += 1; + }) + .or_insert(1); + + let statements_received_count = *statements_tracker.get(candidate_hash).unwrap(); + if statements_received_count == self.config.minimum_backing_votes { + let message = + polkadot_node_subsystem::messages::StatementDistributionMessage::Backed( + *candidate_hash, + ); + messages.push(message); + } + }, + } + + messages + } +} + +#[overseer::subsystem(CandidateBacking, error=SubsystemError, prefix=self::overseer)] +impl MockCandidateBacking { + fn start(self, ctx: Context) -> SpawnedSubsystem { + let future = self.run(ctx).map(|_| Ok(())).boxed(); + + SpawnedSubsystem { name: "test-environment", future } + } +} + +#[overseer::contextbounds(CandidateBacking, prefix = self::overseer)] +impl MockCandidateBacking { + async fn run(self, mut ctx: Context) { + let mut statements_tracker: HashMap = Default::default(); + + loop { + let msg = ctx.recv().await.expect("Overseer never fails us"); + match msg { + orchestra::FromOrchestra::Signal(signal) => + if signal == OverseerSignal::Conclude { + return + }, + orchestra::FromOrchestra::Communication { msg } => { + gum::trace!(target: LOG_TARGET, msg=?msg, "recv message"); + + match msg { + CandidateBackingMessage::Statement(relay_parent, statement) => { + let messages = self.handle_statement( + relay_parent, + statement, + &mut statements_tracker, + ); + for message in messages { + ctx.send_message(message).await; + } + }, + _ => { + unimplemented!("Unexpected candidate-backing message") + }, + } + }, + } + } + } +} diff --git a/polkadot/node/subsystem-bench/src/lib/mock/candidate_validation.rs b/polkadot/node/subsystem-bench/src/lib/mock/candidate_validation.rs new file mode 100644 index 0000000000000000000000000000000000000000..941fac2a38c6c7fecaa16bd21d81310d4f6de488 --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/mock/candidate_validation.rs @@ -0,0 +1,74 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! A generic mock candidate validation subsystem suitable for using in benchmarks, it +//! is responding with candidate valid for every request. + +use futures::FutureExt; +use polkadot_node_primitives::ValidationResult; +use polkadot_node_subsystem::{ + messages::CandidateValidationMessage, overseer, SpawnedSubsystem, SubsystemError, +}; +use polkadot_node_subsystem_types::OverseerSignal; +use polkadot_primitives::{CandidateCommitments, Hash, HeadData, PersistedValidationData}; + +pub struct MockCandidateValidation {} + +impl MockCandidateValidation { + pub fn new() -> Self { + Self {} + } +} + +#[overseer::subsystem(CandidateValidation, error=SubsystemError, prefix=self::overseer)] +impl MockCandidateValidation { + fn start(self, ctx: Context) -> SpawnedSubsystem { + let future = self.run(ctx).map(|_| Ok(())).boxed(); + + SpawnedSubsystem { name: "test-environment", future } + } +} + +#[overseer::contextbounds(CandidateValidation, prefix = self::overseer)] +impl MockCandidateValidation { + async fn run(self, mut ctx: Context) { + loop { + let msg = ctx.recv().await.expect("Overseer never fails us"); + match msg { + orchestra::FromOrchestra::Signal(signal) => + if signal == OverseerSignal::Conclude { + return + }, + orchestra::FromOrchestra::Communication { msg } => match msg { + CandidateValidationMessage::ValidateFromExhaustive { + response_sender, .. + } => response_sender + .send(Ok(ValidationResult::Valid( + CandidateCommitments::default(), + PersistedValidationData { + parent_head: HeadData(Vec::new()), + relay_parent_number: 0, + relay_parent_storage_root: Hash::default(), + max_pov_size: 2, + }, + ))) + .unwrap(), + _ => unimplemented!("Unexpected chain-api message"), + }, + } + } + } +} diff --git a/polkadot/node/subsystem-bench/src/lib/mock/mod.rs b/polkadot/node/subsystem-bench/src/lib/mock/mod.rs index 6dda9a47d398f3e6e952cd054bce9769e8942e70..da4ac05e33b7c9af76ab6804961a53cfbe68f9b0 100644 --- a/polkadot/node/subsystem-bench/src/lib/mock/mod.rs +++ b/polkadot/node/subsystem-bench/src/lib/mock/mod.rs @@ -19,9 +19,13 @@ use polkadot_node_subsystem_types::Hash; use sp_consensus::SyncOracle; pub mod av_store; +pub mod availability_recovery; +pub mod candidate_backing; +pub mod candidate_validation; pub mod chain_api; pub mod dummy; pub mod network_bridge; +pub mod prospective_parachains; pub mod runtime_api; pub struct AlwaysSupportsParachains {} diff --git a/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs b/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs index ec66ad4e279c217f7510d4c09def128f41fbffe5..d70953926d130eabc7be096cab71ff59d6e91bc8 100644 --- a/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs +++ b/polkadot/node/subsystem-bench/src/lib/mock/network_bridge.rs @@ -27,14 +27,19 @@ use polkadot_node_subsystem::{ messages::NetworkBridgeTxMessage, overseer, SpawnedSubsystem, SubsystemError, }; use polkadot_node_subsystem_types::{ - messages::{ApprovalDistributionMessage, BitfieldDistributionMessage, NetworkBridgeEvent}, + messages::{ + ApprovalDistributionMessage, BitfieldDistributionMessage, NetworkBridgeEvent, + StatementDistributionMessage, + }, OverseerSignal, }; use sc_network::{request_responses::ProtocolConfig, RequestFailure}; const LOG_TARGET: &str = "subsystem-bench::network-bridge"; -const CHUNK_REQ_PROTOCOL_NAME_V1: &str = - "/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_chunk/1"; +const ALLOWED_PROTOCOLS: &[&str] = &[ + "/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_chunk/2", + "/ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/req_attested_candidate/2", +]; /// A mock of the network bridge tx subsystem. pub struct MockNetworkBridgeTx { @@ -106,8 +111,15 @@ impl MockNetworkBridgeTx { NetworkBridgeTxMessage::SendRequests(requests, _if_disconnected) => { for request in requests { gum::debug!(target: LOG_TARGET, request = ?request, "Processing request"); - let peer_id = - request.authority_id().expect("all nodes are authorities").clone(); + let peer_id = match request.authority_id() { + Some(v) => v.clone(), + None => self + .test_authorities + .peer_id_to_authority + .get(request.peer_id().expect("Should exist")) + .expect("Should exist") + .clone(), + }; if !self.network.is_peer_connected(&peer_id) { // Attempting to send a request to a disconnected peer. @@ -141,7 +153,23 @@ impl MockNetworkBridgeTx { .expect("Should not fail"); } }, - _ => unimplemented!("Unexpected network bridge message"), + NetworkBridgeTxMessage::SendValidationMessages(messages) => { + for (peers, message) in messages { + for peer in peers { + self.to_network_interface + .unbounded_send(NetworkMessage::MessageFromNode( + self.test_authorities + .peer_id_to_authority + .get(&peer) + .unwrap() + .clone(), + message.clone(), + )) + .expect("Should not fail"); + } + } + }, + message => unimplemented!("Unexpected network bridge message {:?}", message), }, } } @@ -175,13 +203,20 @@ impl MockNetworkBridgeRx { ApprovalDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(peer_id, polkadot_node_network_protocol::Versioned::V3(msg))) ).await; } + Versioned::V3( + polkadot_node_network_protocol::v3::ValidationProtocol::StatementDistribution(msg) + ) => { + ctx.send_message( + StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage(peer_id, polkadot_node_network_protocol::Versioned::V3(msg))) + ).await; + } _ => { unimplemented!("We only talk v2 network protocol") }, }, NetworkMessage::RequestFromPeer(request) => { if let Some(protocol) = self.chunk_request_sender.as_mut() { - assert_eq!(&*protocol.name, CHUNK_REQ_PROTOCOL_NAME_V1); + assert!(ALLOWED_PROTOCOLS.contains(&&*protocol.name)); if let Some(inbound_queue) = protocol.inbound_queue.as_ref() { inbound_queue .send(request) diff --git a/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs b/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs new file mode 100644 index 0000000000000000000000000000000000000000..8a865af21a073aefe55b85b37e7ccd091e8a2f0f --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/mock/prospective_parachains.rs @@ -0,0 +1,74 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! A generic prospective parachains subsystem mockup suitable to be used in benchmarks. + +use futures::FutureExt; +use polkadot_node_subsystem::{ + messages::ProspectiveParachainsMessage, overseer, SpawnedSubsystem, SubsystemError, +}; +use polkadot_node_subsystem_types::OverseerSignal; +use polkadot_primitives::Hash; + +pub struct MockProspectiveParachains {} + +impl MockProspectiveParachains { + pub fn new() -> Self { + Self {} + } +} + +#[overseer::subsystem(ProspectiveParachains, error=SubsystemError, prefix=self::overseer)] +impl MockProspectiveParachains { + fn start(self, ctx: Context) -> SpawnedSubsystem { + let future = self.run(ctx).map(|_| Ok(())).boxed(); + + SpawnedSubsystem { name: "test-environment", future } + } +} + +#[overseer::contextbounds(ProspectiveParachains, prefix = self::overseer)] +impl MockProspectiveParachains { + async fn run(self, mut ctx: Context) { + loop { + let msg = ctx.recv().await.expect("Overseer never fails us"); + match msg { + orchestra::FromOrchestra::Signal(signal) => + if signal == OverseerSignal::Conclude { + return + }, + orchestra::FromOrchestra::Communication { msg } => match msg { + ProspectiveParachainsMessage::GetMinimumRelayParents(_relay_parent, tx) => { + tx.send(vec![]).unwrap(); + }, + ProspectiveParachainsMessage::GetHypotheticalMembership(req, tx) => { + tx.send( + req.candidates + .iter() + .cloned() + .map(|candidate| (candidate, vec![Hash::repeat_byte(0)])) + .collect(), + ) + .unwrap(); + }, + _ => { + unimplemented!("Unexpected chain-api message") + }, + }, + } + } + } +} diff --git a/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs b/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs index b73d61321cd3b274915dda37233c1945240c2b11..61523de1f1b502600d4e8208021e7a3ddf345e3c 100644 --- a/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs +++ b/polkadot/node/subsystem-bench/src/lib/mock/runtime_api.rs @@ -26,8 +26,9 @@ use polkadot_node_subsystem::{ }; use polkadot_node_subsystem_types::OverseerSignal; use polkadot_primitives::{ - CandidateEvent, CandidateReceipt, CoreState, GroupIndex, IndexedVec, NodeFeatures, - OccupiedCore, SessionIndex, SessionInfo, ValidatorIndex, + node_features, ApprovalVotingParams, AsyncBackingParams, CandidateEvent, CandidateReceipt, + CoreState, GroupIndex, GroupRotationInfo, IndexedVec, NodeFeatures, OccupiedCore, + ScheduledCore, SessionIndex, SessionInfo, ValidationCode, ValidatorIndex, }; use sp_consensus_babe::Epoch as BabeEpoch; use sp_core::H256; @@ -40,6 +41,8 @@ const LOG_TARGET: &str = "subsystem-bench::runtime-api-mock"; pub struct RuntimeApiState { // All authorities in the test, authorities: TestAuthorities, + // Node features state in the runtime + node_features: NodeFeatures, // Candidate hashes per block candidate_hashes: HashMap>, // Included candidates per bock @@ -49,11 +52,20 @@ pub struct RuntimeApiState { session_index: SessionIndex, } +#[derive(Clone)] +pub enum MockRuntimeApiCoreState { + Occupied, + Scheduled, + #[allow(dead_code)] + Free, +} + /// A mocked `runtime-api` subsystem. #[derive(Clone)] pub struct MockRuntimeApi { state: RuntimeApiState, config: TestConfiguration, + core_state: MockRuntimeApiCoreState, } impl MockRuntimeApi { @@ -64,7 +76,11 @@ impl MockRuntimeApi { included_candidates: HashMap>, babe_epoch: Option, session_index: SessionIndex, + core_state: MockRuntimeApiCoreState, ) -> MockRuntimeApi { + // Enable chunk mapping feature to make systematic av-recovery possible. + let node_features = node_features_with_chunk_mapping_enabled(); + Self { state: RuntimeApiState { authorities, @@ -72,8 +88,10 @@ impl MockRuntimeApi { included_candidates, babe_epoch, session_index, + node_features, }, config, + core_state, } } @@ -156,15 +174,15 @@ impl MockRuntimeApi { }, RuntimeApiMessage::Request( _block_hash, - RuntimeApiRequest::SessionExecutorParams(_session_index, sender), + RuntimeApiRequest::NodeFeatures(_session_index, sender), ) => { - let _ = sender.send(Ok(Some(Default::default()))); + let _ = sender.send(Ok(self.state.node_features.clone())); }, RuntimeApiMessage::Request( - _request, - RuntimeApiRequest::NodeFeatures(_session_index, sender), + _block_hash, + RuntimeApiRequest::SessionExecutorParams(_session_index, sender), ) => { - let _ = sender.send(Ok(NodeFeatures::EMPTY)); + let _ = sender.send(Ok(Some(Default::default()))); }, RuntimeApiMessage::Request( _block_hash, @@ -198,16 +216,26 @@ impl MockRuntimeApi { // Ensure test breaks if badly configured. assert!(index < validator_group_count); - CoreState::Occupied(OccupiedCore { - next_up_on_available: None, - occupied_since: 0, - time_out_at: 0, - next_up_on_time_out: None, - availability: BitVec::default(), - group_responsible: GroupIndex(index as u32), - candidate_hash: candidate_receipt.hash(), - candidate_descriptor: candidate_receipt.descriptor.clone(), - }) + use MockRuntimeApiCoreState::*; + match self.core_state { + Occupied => CoreState::Occupied(OccupiedCore { + next_up_on_available: None, + occupied_since: 0, + time_out_at: 0, + next_up_on_time_out: None, + availability: BitVec::default(), + group_responsible: GroupIndex(index as u32), + candidate_hash: candidate_receipt.hash(), + candidate_descriptor: candidate_receipt + .descriptor + .clone(), + }), + Scheduled => CoreState::Scheduled(ScheduledCore { + para_id: (index + 1).into(), + collator: None, + }), + Free => todo!(), + } }) .collect::>(); @@ -223,6 +251,59 @@ impl MockRuntimeApi { .clone() .expect("Babe epoch unpopulated"))); }, + RuntimeApiMessage::Request( + _block_hash, + RuntimeApiRequest::AsyncBackingParams(sender), + ) => { + let _ = sender.send(Ok(AsyncBackingParams { + max_candidate_depth: self.config.max_candidate_depth, + allowed_ancestry_len: self.config.allowed_ancestry_len, + })); + }, + RuntimeApiMessage::Request(_parent, RuntimeApiRequest::Version(tx)) => { + tx.send(Ok(RuntimeApiRequest::DISABLED_VALIDATORS_RUNTIME_REQUIREMENT)) + .unwrap(); + }, + RuntimeApiMessage::Request( + _parent, + RuntimeApiRequest::DisabledValidators(tx), + ) => { + tx.send(Ok(vec![])).unwrap(); + }, + RuntimeApiMessage::Request( + _parent, + RuntimeApiRequest::MinimumBackingVotes(_session_index, tx), + ) => { + tx.send(Ok(self.config.minimum_backing_votes)).unwrap(); + }, + RuntimeApiMessage::Request( + _parent, + RuntimeApiRequest::ValidatorGroups(tx), + ) => { + let groups = self.session_info().validator_groups.to_vec(); + let group_rotation_info = GroupRotationInfo { + session_start_block: 1, + group_rotation_frequency: 12, + now: 1, + }; + tx.send(Ok((groups, group_rotation_info))).unwrap(); + }, + RuntimeApiMessage::Request( + _parent, + RuntimeApiRequest::ValidationCodeByHash(_, tx), + ) => { + let validation_code = ValidationCode(Vec::new()); + if let Err(err) = tx.send(Ok(Some(validation_code))) { + gum::error!(target: LOG_TARGET, ?err, "validation code wasn't received"); + } + }, + RuntimeApiMessage::Request( + _parent, + RuntimeApiRequest::ApprovalVotingParams(_, tx), + ) => + if let Err(err) = tx.send(Ok(ApprovalVotingParams::default())) { + gum::error!(target: LOG_TARGET, ?err, "Voting params weren't received"); + }, // Long term TODO: implement more as needed. message => { unimplemented!("Unexpected runtime-api message: {:?}", message) @@ -233,3 +314,10 @@ impl MockRuntimeApi { } } } + +pub fn node_features_with_chunk_mapping_enabled() -> NodeFeatures { + let mut node_features = NodeFeatures::new(); + node_features.resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false); + node_features.set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true); + node_features +} diff --git a/polkadot/node/subsystem-bench/src/lib/network.rs b/polkadot/node/subsystem-bench/src/lib/network.rs index 9bf2415e5a864a9c4512350b9387b6c172b37114..331dd7d25156675c6866a153b3a3fac3e3988256 100644 --- a/polkadot/node/subsystem-bench/src/lib/network.rs +++ b/polkadot/node/subsystem-bench/src/lib/network.rs @@ -38,6 +38,7 @@ use crate::{ environment::TestEnvironmentDependencies, NODE_UNDER_TEST, }; +use codec::Encode; use colored::Colorize; use futures::{ channel::{ @@ -51,13 +52,13 @@ use futures::{ }; use itertools::Itertools; use net_protocol::{ - peer_set::{ProtocolVersion, ValidationVersion}, + peer_set::ValidationVersion, request_response::{Recipient, Requests, ResponseSender}, - ObservedRole, VersionedValidationProtocol, + ObservedRole, VersionedValidationProtocol, View, }; -use parity_scale_codec::Encode; use polkadot_node_network_protocol::{self as net_protocol, Versioned}; -use polkadot_node_subsystem_types::messages::{ApprovalDistributionMessage, NetworkBridgeEvent}; +use polkadot_node_subsystem::messages::StatementDistributionMessage; +use polkadot_node_subsystem_types::messages::NetworkBridgeEvent; use polkadot_node_subsystem_util::metrics::prometheus::{ self, CounterVec, Opts, PrometheusError, Registry, }; @@ -437,6 +438,7 @@ pub struct EmulatedPeerHandle { /// Send actions to be performed by the peer. actions_tx: UnboundedSender, peer_id: PeerId, + authority_id: AuthorityDiscoveryId, } impl EmulatedPeerHandle { @@ -496,29 +498,31 @@ impl EmulatedPeer { } /// Interceptor pattern for handling messages. +#[async_trait::async_trait] pub trait HandleNetworkMessage { /// Returns `None` if the message was handled, or the `message` /// otherwise. /// /// `node_sender` allows sending of messages to the node in response /// to the handled message. - fn handle( + async fn handle( &self, message: NetworkMessage, node_sender: &mut UnboundedSender, ) -> Option; } +#[async_trait::async_trait] impl HandleNetworkMessage for Arc where - T: HandleNetworkMessage, + T: HandleNetworkMessage + Sync + Send, { - fn handle( + async fn handle( &self, message: NetworkMessage, node_sender: &mut UnboundedSender, ) -> Option { - self.as_ref().handle(message, node_sender) + T::handle(self, message, node_sender).await } } @@ -551,7 +555,7 @@ async fn emulated_peer_loop( for handler in handlers.iter() { // The check below guarantees that message is always `Some`: we are still // inside the loop. - message = handler.handle(message.unwrap(), &mut to_network_interface); + message = handler.handle(message.unwrap(), &mut to_network_interface).await; if message.is_none() { break } @@ -613,6 +617,7 @@ async fn emulated_peer_loop( } /// Creates a new peer emulator task and returns a handle to it. +#[allow(clippy::too_many_arguments)] pub fn new_peer( bandwidth: usize, spawn_task_handle: SpawnTaskHandle, @@ -621,6 +626,7 @@ pub fn new_peer( to_network_interface: UnboundedSender, latency_ms: usize, peer_id: PeerId, + authority_id: AuthorityDiscoveryId, ) -> EmulatedPeerHandle { let (messages_tx, messages_rx) = mpsc::unbounded::(); let (actions_tx, actions_rx) = mpsc::unbounded::(); @@ -649,7 +655,7 @@ pub fn new_peer( .boxed(), ); - EmulatedPeerHandle { messages_tx, actions_tx, peer_id } + EmulatedPeerHandle { messages_tx, actions_tx, peer_id, authority_id } } /// Book keeping of sent and received bytes. @@ -714,6 +720,18 @@ impl Peer { Peer::Disconnected(ref emulator) => emulator, } } + + pub fn authority_id(&self) -> AuthorityDiscoveryId { + match self { + Peer::Connected(handle) | Peer::Disconnected(handle) => handle.authority_id.clone(), + } + } + + pub fn peer_id(&self) -> PeerId { + match self { + Peer::Connected(handle) | Peer::Disconnected(handle) => handle.peer_id, + } + } } /// A ha emulated network implementation. @@ -728,21 +746,34 @@ pub struct NetworkEmulatorHandle { } impl NetworkEmulatorHandle { + pub fn generate_statement_distribution_peer_view_change(&self, view: View) -> Vec { + self.peers + .iter() + .filter(|peer| peer.is_connected()) + .map(|peer| { + AllMessages::StatementDistribution( + StatementDistributionMessage::NetworkBridgeUpdate( + NetworkBridgeEvent::PeerViewChange(peer.peer_id(), view.clone()), + ), + ) + }) + .collect_vec() + } + /// Generates peer_connected messages for all peers in `test_authorities` - pub fn generate_peer_connected(&self) -> Vec { + pub fn generate_peer_connected(&self, mapper: F) -> Vec + where + F: Fn(NetworkBridgeEvent) -> AllMessages, + { self.peers .iter() .filter(|peer| peer.is_connected()) .map(|peer| { - let network = NetworkBridgeEvent::PeerConnected( + mapper(NetworkBridgeEvent::PeerConnected( peer.handle().peer_id, - ObservedRole::Full, - ProtocolVersion::from(ValidationVersion::V3), - None, - ); - - AllMessages::ApprovalDistribution(ApprovalDistributionMessage::NetworkBridgeUpdate( - network, + ObservedRole::Authority, + ValidationVersion::V3.into(), + Some(vec![peer.authority_id()].into_iter().collect()), )) }) .collect_vec() @@ -772,7 +803,7 @@ pub fn new_network( let (stats, mut peers): (_, Vec<_>) = (0..n_peers) .zip(authorities.validator_authority_id.clone()) .map(|(peer_index, authority_id)| { - validator_authority_id_mapping.insert(authority_id, peer_index); + validator_authority_id_mapping.insert(authority_id.clone(), peer_index); let stats = Arc::new(PeerEmulatorStats::new(peer_index, metrics.clone())); ( stats.clone(), @@ -784,6 +815,7 @@ pub fn new_network( to_network_interface.clone(), random_latency(config.latency.as_ref()), *authorities.peer_ids.get(peer_index).unwrap(), + authority_id, )), ) }) @@ -971,6 +1003,8 @@ impl Metrics { pub trait RequestExt { /// Get the authority id if any from the request. fn authority_id(&self) -> Option<&AuthorityDiscoveryId>; + /// Get the peer id if any from the request. + fn peer_id(&self) -> Option<&PeerId>; /// Consume self and return the response sender. fn into_response_sender(self) -> ResponseSender; /// Allows to change the `ResponseSender` in place. @@ -982,7 +1016,7 @@ pub trait RequestExt { impl RequestExt for Requests { fn authority_id(&self) -> Option<&AuthorityDiscoveryId> { match self { - Requests::ChunkFetchingV1(request) => { + Requests::ChunkFetching(request) => { if let Recipient::Authority(authority_id) = &request.peer { Some(authority_id) } else { @@ -996,15 +1030,29 @@ impl RequestExt for Requests { None } }, + // Requested by PeerId + Requests::AttestedCandidateV2(_) => None, request => { unimplemented!("RequestAuthority not implemented for {:?}", request) }, } } + fn peer_id(&self) -> Option<&PeerId> { + match self { + Requests::AttestedCandidateV2(request) => match &request.peer { + Recipient::Authority(_) => None, + Recipient::Peer(peer_id) => Some(peer_id), + }, + request => { + unimplemented!("peer_id() is not implemented for {:?}", request) + }, + } + } + fn into_response_sender(self) -> ResponseSender { match self { - Requests::ChunkFetchingV1(outgoing_request) => outgoing_request.pending_response, + Requests::ChunkFetching(outgoing_request) => outgoing_request.pending_response, Requests::AvailableDataFetchingV1(outgoing_request) => outgoing_request.pending_response, _ => unimplemented!("unsupported request type"), @@ -1014,10 +1062,12 @@ impl RequestExt for Requests { /// Swaps the `ResponseSender` and returns the previous value. fn swap_response_sender(&mut self, new_sender: ResponseSender) -> ResponseSender { match self { - Requests::ChunkFetchingV1(outgoing_request) => + Requests::ChunkFetching(outgoing_request) => std::mem::replace(&mut outgoing_request.pending_response, new_sender), Requests::AvailableDataFetchingV1(outgoing_request) => std::mem::replace(&mut outgoing_request.pending_response, new_sender), + Requests::AttestedCandidateV2(outgoing_request) => + std::mem::replace(&mut outgoing_request.pending_response, new_sender), _ => unimplemented!("unsupported request type"), } } @@ -1025,9 +1075,11 @@ impl RequestExt for Requests { /// Returns the size in bytes of the request payload. fn size(&self) -> usize { match self { - Requests::ChunkFetchingV1(outgoing_request) => outgoing_request.payload.encoded_size(), + Requests::ChunkFetching(outgoing_request) => outgoing_request.payload.encoded_size(), Requests::AvailableDataFetchingV1(outgoing_request) => outgoing_request.payload.encoded_size(), + Requests::AttestedCandidateV2(outgoing_request) => + outgoing_request.payload.encoded_size(), _ => unimplemented!("received an unexpected request"), } } diff --git a/polkadot/node/subsystem-bench/src/lib/statement/mod.rs b/polkadot/node/subsystem-bench/src/lib/statement/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bd47505f56aeabc201f0d57bec57fa6a3f3380d4 --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/statement/mod.rs @@ -0,0 +1,449 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use crate::{ + configuration::TestAuthorities, + dummy_builder, + environment::{TestEnvironment, TestEnvironmentDependencies, GENESIS_HASH}, + mock::{ + candidate_backing::MockCandidateBacking, + chain_api::{ChainApiState, MockChainApi}, + network_bridge::{MockNetworkBridgeRx, MockNetworkBridgeTx}, + prospective_parachains::MockProspectiveParachains, + runtime_api::{MockRuntimeApi, MockRuntimeApiCoreState}, + AlwaysSupportsParachains, + }, + network::{new_network, NetworkEmulatorHandle, NetworkInterface, NetworkInterfaceReceiver}, + usage::BenchmarkUsage, + NODE_UNDER_TEST, +}; +use bitvec::vec::BitVec; +use colored::Colorize; +use itertools::Itertools; +use polkadot_node_metrics::metrics::Metrics; +use polkadot_node_network_protocol::{ + grid_topology::{SessionGridTopology, TopologyPeerInfo}, + request_response::{IncomingRequest, ReqProtocolNames}, + v3::{self, BackedCandidateManifest, StatementFilter}, + view, Versioned, View, +}; +use polkadot_node_subsystem::messages::{ + network_bridge_event::NewGossipTopology, AllMessages, NetworkBridgeEvent, + StatementDistributionMessage, +}; +use polkadot_overseer::{ + Handle as OverseerHandle, Overseer, OverseerConnector, OverseerMetrics, SpawnGlue, +}; +use polkadot_primitives::{ + AuthorityDiscoveryId, Block, GroupIndex, Hash, Id, ValidatorId, ValidatorIndex, +}; +use polkadot_statement_distribution::StatementDistributionSubsystem; +use rand::SeedableRng; +use sc_keystore::LocalKeystore; +use sc_network::request_responses::ProtocolConfig; +use sc_network_types::PeerId; +use sc_service::SpawnTaskHandle; +use sp_keystore::{Keystore, KeystorePtr}; +use sp_runtime::RuntimeAppPublic; +use std::{ + sync::{atomic::Ordering, Arc}, + time::{Duration, Instant}, +}; +pub use test_state::TestState; + +mod test_state; + +const LOG_TARGET: &str = "subsystem-bench::statement"; + +pub fn make_keystore() -> KeystorePtr { + let keystore: KeystorePtr = Arc::new(LocalKeystore::in_memory()); + Keystore::sr25519_generate_new(&*keystore, ValidatorId::ID, Some("//Node0")) + .expect("Insert key into keystore"); + Keystore::sr25519_generate_new(&*keystore, AuthorityDiscoveryId::ID, Some("//Node0")) + .expect("Insert key into keystore"); + keystore +} + +fn build_overseer( + state: &TestState, + network: NetworkEmulatorHandle, + network_interface: NetworkInterface, + network_receiver: NetworkInterfaceReceiver, + dependencies: &TestEnvironmentDependencies, +) -> ( + Overseer, AlwaysSupportsParachains>, + OverseerHandle, + Vec, +) { + let overseer_connector = OverseerConnector::with_event_capacity(64000); + let overseer_metrics = OverseerMetrics::try_register(&dependencies.registry).unwrap(); + let spawn_task_handle = dependencies.task_manager.spawn_handle(); + let mock_runtime_api = MockRuntimeApi::new( + state.config.clone(), + state.test_authorities.clone(), + state.candidate_receipts.clone(), + Default::default(), + Default::default(), + 0, + MockRuntimeApiCoreState::Scheduled, + ); + let chain_api_state = ChainApiState { block_headers: state.block_headers.clone() }; + let mock_chain_api = MockChainApi::new(chain_api_state); + let mock_prospective_parachains = MockProspectiveParachains::new(); + let mock_candidate_backing = MockCandidateBacking::new( + state.config.clone(), + state + .test_authorities + .validator_pairs + .get(NODE_UNDER_TEST as usize) + .unwrap() + .clone(), + state.pvd.clone(), + state.own_backing_group.clone(), + ); + let (statement_req_receiver, statement_req_cfg) = IncomingRequest::get_config_receiver::< + Block, + sc_network::NetworkWorker, + >(&ReqProtocolNames::new(GENESIS_HASH, None)); + let (candidate_req_receiver, candidate_req_cfg) = IncomingRequest::get_config_receiver::< + Block, + sc_network::NetworkWorker, + >(&ReqProtocolNames::new(GENESIS_HASH, None)); + let keystore = make_keystore(); + let subsystem = StatementDistributionSubsystem::new( + keystore.clone(), + statement_req_receiver, + candidate_req_receiver, + Metrics::try_register(&dependencies.registry).unwrap(), + rand::rngs::StdRng::from_entropy(), + ); + let network_bridge_tx = MockNetworkBridgeTx::new( + network, + network_interface.subsystem_sender(), + state.test_authorities.clone(), + ); + let network_bridge_rx = MockNetworkBridgeRx::new(network_receiver, Some(candidate_req_cfg)); + + let dummy = dummy_builder!(spawn_task_handle, overseer_metrics) + .replace_runtime_api(|_| mock_runtime_api) + .replace_chain_api(|_| mock_chain_api) + .replace_prospective_parachains(|_| mock_prospective_parachains) + .replace_candidate_backing(|_| mock_candidate_backing) + .replace_statement_distribution(|_| subsystem) + .replace_network_bridge_tx(|_| network_bridge_tx) + .replace_network_bridge_rx(|_| network_bridge_rx); + let (overseer, raw_handle) = dummy.build_with_connector(overseer_connector).unwrap(); + let overseer_handle = OverseerHandle::new(raw_handle); + + (overseer, overseer_handle, vec![statement_req_cfg]) +} + +pub fn prepare_test( + state: &TestState, + with_prometheus_endpoint: bool, +) -> (TestEnvironment, Vec) { + let dependencies = TestEnvironmentDependencies::default(); + let (network, network_interface, network_receiver) = new_network( + &state.config, + &dependencies, + &state.test_authorities, + vec![Arc::new(state.clone())], + ); + let (overseer, overseer_handle, cfg) = + build_overseer(state, network.clone(), network_interface, network_receiver, &dependencies); + + ( + TestEnvironment::new( + dependencies, + state.config.clone(), + network, + overseer, + overseer_handle, + state.test_authorities.clone(), + with_prometheus_endpoint, + ), + cfg, + ) +} + +pub fn generate_peer_view_change(block_hash: Hash, peer_id: PeerId) -> AllMessages { + let network = NetworkBridgeEvent::PeerViewChange(peer_id, View::new([block_hash], 0)); + + AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate(network)) +} + +pub fn generate_new_session_topology( + topology: &SessionGridTopology, + test_node: ValidatorIndex, +) -> Vec { + let event = NetworkBridgeEvent::NewGossipTopology(NewGossipTopology { + session: 0, + topology: topology.clone(), + local_index: Some(test_node), + }); + vec![AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate( + event, + ))] +} + +/// Generates a topology to be used for this benchmark. +pub fn generate_topology(test_authorities: &TestAuthorities) -> SessionGridTopology { + let keyrings = test_authorities + .validator_authority_id + .clone() + .into_iter() + .zip(test_authorities.peer_ids.clone()) + .collect_vec(); + + let topology = keyrings + .clone() + .into_iter() + .enumerate() + .map(|(index, (discovery_id, peer_id))| TopologyPeerInfo { + peer_ids: vec![peer_id], + validator_index: ValidatorIndex(index as u32), + discovery_id, + }) + .collect_vec(); + let shuffled = (0..keyrings.len()).collect_vec(); + + SessionGridTopology::new(shuffled, topology) +} + +pub async fn benchmark_statement_distribution( + env: &mut TestEnvironment, + state: &TestState, +) -> BenchmarkUsage { + state.reset_trackers(); + + let connected_validators = state + .test_authorities + .validator_authority_id + .iter() + .enumerate() + .filter_map(|(i, id)| if env.network().is_peer_connected(id) { Some(i) } else { None }) + .collect_vec(); + let seconding_validator_in_own_backing_group = state + .own_backing_group + .iter() + .find(|v| connected_validators.contains(&(v.0 as usize))) + .unwrap() + .to_owned(); + + let config = env.config().clone(); + let groups = state.session_info.validator_groups.clone(); + let own_backing_group_index = groups + .iter() + .position(|group| group.iter().any(|v| v.0 == NODE_UNDER_TEST)) + .unwrap(); + + env.metrics().set_n_validators(config.n_validators); + env.metrics().set_n_cores(config.n_cores); + + let topology = generate_topology(&state.test_authorities); + let peer_connected_messages = env.network().generate_peer_connected(|e| { + AllMessages::StatementDistribution(StatementDistributionMessage::NetworkBridgeUpdate(e)) + }); + let new_session_topology_messages = + generate_new_session_topology(&topology, ValidatorIndex(NODE_UNDER_TEST)); + for message in peer_connected_messages.into_iter().chain(new_session_topology_messages) { + env.send_message(message).await; + } + + let test_start = Instant::now(); + let mut candidates_advertised = 0; + for block_info in state.block_infos.iter() { + let block_num = block_info.number as usize; + gum::info!(target: LOG_TARGET, "Current block {}/{} {:?}", block_num, config.num_blocks, block_info.hash); + env.metrics().set_current_block(block_num); + env.import_block(block_info.clone()).await; + + for peer_view_change in env + .network() + .generate_statement_distribution_peer_view_change(view![block_info.hash]) + { + env.send_message(peer_view_change).await; + } + + let seconding_peer_id = *state + .test_authorities + .peer_ids + .get(seconding_validator_in_own_backing_group.0 as usize) + .unwrap(); + let candidate = state.candidate_receipts.get(&block_info.hash).unwrap().first().unwrap(); + let candidate_hash = candidate.hash(); + let statement = state + .statements + .get(&candidate_hash) + .unwrap() + .get(seconding_validator_in_own_backing_group.0 as usize) + .unwrap() + .clone(); + let message = AllMessages::StatementDistribution( + StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage( + seconding_peer_id, + Versioned::V3(v3::StatementDistributionMessage::Statement( + block_info.hash, + statement, + )), + )), + ); + env.send_message(message).await; + + let max_messages_per_candidate = state.config.max_candidate_depth + 1; + // One was just sent for the own backing group + let mut messages_tracker = (0..groups.len()) + .map(|i| if i == own_backing_group_index { max_messages_per_candidate } else { 0 }) + .collect_vec(); + + let neighbors = + topology.compute_grid_neighbors_for(ValidatorIndex(NODE_UNDER_TEST)).unwrap(); + let connected_neighbors_x = neighbors + .validator_indices_x + .iter() + .filter(|&v| connected_validators.contains(&(v.0 as usize))) + .cloned() + .collect_vec(); + let connected_neighbors_y = neighbors + .validator_indices_y + .iter() + .filter(|&v| connected_validators.contains(&(v.0 as usize))) + .cloned() + .collect_vec(); + let one_hop_peers_and_groups = connected_neighbors_x + .iter() + .chain(connected_neighbors_y.iter()) + .map(|validator_index| { + let peer_id = + *state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap(); + let group_index = + groups.iter().position(|group| group.contains(validator_index)).unwrap(); + (peer_id, group_index) + }) + .collect_vec(); + let two_hop_x_peers_and_groups = connected_neighbors_x + .iter() + .flat_map(|validator_index| { + let peer_id = + *state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap(); + topology + .compute_grid_neighbors_for(*validator_index) + .unwrap() + .validator_indices_y + .iter() + .map(|validator_neighbor| { + let group_index = groups + .iter() + .position(|group| group.contains(validator_neighbor)) + .unwrap(); + (peer_id, group_index) + }) + .collect_vec() + }) + .collect_vec(); + let two_hop_y_peers_and_groups = connected_neighbors_y + .iter() + .flat_map(|validator_index| { + let peer_id = + *state.test_authorities.peer_ids.get(validator_index.0 as usize).unwrap(); + topology + .compute_grid_neighbors_for(*validator_index) + .unwrap() + .validator_indices_x + .iter() + .map(|validator_neighbor| { + let group_index = groups + .iter() + .position(|group| group.contains(validator_neighbor)) + .unwrap(); + (peer_id, group_index) + }) + .collect_vec() + }) + .collect_vec(); + + for (seconding_peer_id, group_index) in one_hop_peers_and_groups + .into_iter() + .chain(two_hop_x_peers_and_groups) + .chain(two_hop_y_peers_and_groups) + { + let messages_sent_count = messages_tracker.get_mut(group_index).unwrap(); + if *messages_sent_count == max_messages_per_candidate { + continue + } + *messages_sent_count += 1; + + let candidate_hash = state + .candidate_receipts + .get(&block_info.hash) + .unwrap() + .get(group_index) + .unwrap() + .hash(); + let manifest = BackedCandidateManifest { + relay_parent: block_info.hash, + candidate_hash, + group_index: GroupIndex(group_index as u32), + para_id: Id::new(group_index as u32 + 1), + parent_head_data_hash: state.pvd.parent_head.hash(), + statement_knowledge: StatementFilter { + seconded_in_group: BitVec::from_iter( + groups.get(GroupIndex(group_index as u32)).unwrap().iter().map(|_| true), + ), + validated_in_group: BitVec::from_iter( + groups.get(GroupIndex(group_index as u32)).unwrap().iter().map(|_| false), + ), + }, + }; + let message = AllMessages::StatementDistribution( + StatementDistributionMessage::NetworkBridgeUpdate(NetworkBridgeEvent::PeerMessage( + seconding_peer_id, + Versioned::V3(v3::StatementDistributionMessage::BackedCandidateManifest( + manifest, + )), + )), + ); + env.send_message(message).await; + } + + candidates_advertised += messages_tracker.iter().filter(|&&v| v > 0).collect_vec().len(); + + loop { + let manifests_count = state + .manifests_tracker + .values() + .filter(|v| v.load(Ordering::SeqCst)) + .collect::>() + .len(); + gum::debug!(target: LOG_TARGET, "{}/{} manifest exchanges", manifests_count, candidates_advertised); + + if manifests_count == candidates_advertised { + break; + } + tokio::time::sleep(Duration::from_millis(50)).await; + } + } + + let duration: u128 = test_start.elapsed().as_millis(); + gum::info!(target: LOG_TARGET, "All blocks processed in {}", format!("{:?}ms", duration).cyan()); + gum::info!(target: LOG_TARGET, + "Avg block time: {}", + format!("{} ms", test_start.elapsed().as_millis() / env.config().num_blocks as u128).red() + ); + + env.stop().await; + env.collect_resource_usage(&["statement-distribution"]) +} diff --git a/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs b/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs new file mode 100644 index 0000000000000000000000000000000000000000..88b5e8b76b6252dfb470c38d344b60246008fd97 --- /dev/null +++ b/polkadot/node/subsystem-bench/src/lib/statement/test_state.rs @@ -0,0 +1,436 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use crate::{ + configuration::{TestAuthorities, TestConfiguration}, + mock::runtime_api::session_info_for_peers, + network::{HandleNetworkMessage, NetworkMessage}, + NODE_UNDER_TEST, +}; +use bitvec::vec::BitVec; +use codec::{Decode, Encode}; +use futures::channel::oneshot; +use itertools::Itertools; +use polkadot_node_network_protocol::{ + request_response::{ + v2::{AttestedCandidateRequest, AttestedCandidateResponse}, + Requests, + }, + v3::{ + BackedCandidateAcknowledgement, StatementDistributionMessage, StatementFilter, + ValidationProtocol, + }, + Versioned, +}; +use polkadot_node_primitives::{AvailableData, BlockData, PoV}; +use polkadot_node_subsystem_test_helpers::{ + derive_erasure_chunks_with_proofs_and_root, mock::new_block_import_info, +}; +use polkadot_overseer::BlockInfo; +use polkadot_primitives::{ + BlockNumber, CandidateHash, CandidateReceipt, CommittedCandidateReceipt, CompactStatement, + Hash, Header, Id, PersistedValidationData, SessionInfo, SignedStatement, SigningContext, + UncheckedSigned, ValidatorIndex, ValidatorPair, +}; +use polkadot_primitives_test_helpers::{ + dummy_committed_candidate_receipt, dummy_hash, dummy_head_data, dummy_pvd, +}; +use sc_network::{config::IncomingRequest, ProtocolName}; +use sp_core::{Pair, H256}; +use std::{ + collections::HashMap, + sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }, +}; + +#[derive(Clone)] +pub struct TestState { + // Full test config + pub config: TestConfiguration, + // Authority keys for the network emulation. + pub test_authorities: TestAuthorities, + // Relay chain block infos + pub block_infos: Vec, + // Map from generated candidate receipts + pub candidate_receipts: HashMap>, + // Map from generated commited candidate receipts + pub commited_candidate_receipts: HashMap>, + // PersistedValidationData, we use one for all candidates + pub pvd: PersistedValidationData, + // Relay chain block headers + pub block_headers: HashMap, + // Session info + pub session_info: SessionInfo, + // Pregenerated statements + pub statements: HashMap>>, + // Indices in the backing group where the node under test is + pub own_backing_group: Vec, + // Tracks how many statements we received for a candidates + pub statements_tracker: HashMap>>, + // Tracks if manifest exchange happened + pub manifests_tracker: HashMap>, +} + +impl TestState { + pub fn new(config: &TestConfiguration) -> Self { + let test_authorities = config.generate_authorities(); + let session_info = session_info_for_peers(config, &test_authorities); + let own_backing_group = session_info + .validator_groups + .iter() + .find(|g| g.contains(&ValidatorIndex(NODE_UNDER_TEST))) + .unwrap() + .clone(); + let mut state = Self { + config: config.clone(), + test_authorities, + block_infos: (1..=config.num_blocks).map(generate_block_info).collect(), + candidate_receipts: Default::default(), + commited_candidate_receipts: Default::default(), + pvd: dummy_pvd(dummy_head_data(), 0), + block_headers: Default::default(), + statements_tracker: Default::default(), + manifests_tracker: Default::default(), + session_info, + own_backing_group, + statements: Default::default(), + }; + + state.block_headers = state.block_infos.iter().map(generate_block_header).collect(); + + // For each unique pov we create a candidate receipt. + let pov_sizes = Vec::from(config.pov_sizes()); // For n_cores + let pov_size_to_candidate = generate_pov_size_to_candidate(&pov_sizes); + let receipt_templates = + generate_receipt_templates(&pov_size_to_candidate, config.n_validators, &state.pvd); + + for block_info in state.block_infos.iter() { + for core_idx in 0..config.n_cores { + let pov_size = pov_sizes.get(core_idx).expect("This is a cycle; qed"); + let candidate_index = + *pov_size_to_candidate.get(pov_size).expect("pov_size always exists; qed"); + let mut receipt = receipt_templates[candidate_index].clone(); + receipt.descriptor.para_id = Id::new(core_idx as u32 + 1); + receipt.descriptor.relay_parent = block_info.hash; + + state.candidate_receipts.entry(block_info.hash).or_default().push( + CandidateReceipt { + descriptor: receipt.descriptor.clone(), + commitments_hash: receipt.commitments.hash(), + }, + ); + state.statements_tracker.entry(receipt.hash()).or_default().extend( + (0..config.n_validators) + .map(|_| Arc::new(AtomicBool::new(false))) + .collect_vec(), + ); + state.manifests_tracker.insert(receipt.hash(), Arc::new(AtomicBool::new(false))); + state + .commited_candidate_receipts + .entry(block_info.hash) + .or_default() + .push(receipt); + } + } + + let groups = state.session_info.validator_groups.clone(); + + for block_info in state.block_infos.iter() { + for (index, group) in groups.iter().enumerate() { + let candidate = + state.candidate_receipts.get(&block_info.hash).unwrap().get(index).unwrap(); + let statements = group + .iter() + .map(|&v| { + sign_statement( + CompactStatement::Seconded(candidate.hash()), + block_info.hash, + v, + state.test_authorities.validator_pairs.get(v.0 as usize).unwrap(), + ) + }) + .collect_vec(); + state.statements.insert(candidate.hash(), statements); + } + } + + state + } + + pub fn reset_trackers(&self) { + self.statements_tracker.values().for_each(|v| { + v.iter() + .enumerate() + .for_each(|(index, v)| v.as_ref().store(index <= 1, Ordering::SeqCst)) + }); + self.manifests_tracker + .values() + .for_each(|v| v.as_ref().store(false, Ordering::SeqCst)); + } +} + +fn sign_statement( + statement: CompactStatement, + relay_parent: H256, + validator_index: ValidatorIndex, + pair: &ValidatorPair, +) -> UncheckedSigned { + let context = SigningContext { parent_hash: relay_parent, session_index: 0 }; + let payload = statement.signing_payload(&context); + + SignedStatement::new( + statement, + validator_index, + pair.sign(&payload[..]), + &context, + &pair.public(), + ) + .unwrap() + .as_unchecked() + .to_owned() +} + +fn generate_block_info(block_num: usize) -> BlockInfo { + new_block_import_info(Hash::repeat_byte(block_num as u8), block_num as BlockNumber) +} + +fn generate_block_header(info: &BlockInfo) -> (H256, Header) { + ( + info.hash, + Header { + digest: Default::default(), + number: info.number, + parent_hash: info.parent_hash, + extrinsics_root: Default::default(), + state_root: Default::default(), + }, + ) +} + +fn generate_pov_size_to_candidate(pov_sizes: &[usize]) -> HashMap { + pov_sizes + .iter() + .cloned() + .unique() + .enumerate() + .map(|(index, pov_size)| (pov_size, index)) + .collect() +} + +fn generate_receipt_templates( + pov_size_to_candidate: &HashMap, + n_validators: usize, + pvd: &PersistedValidationData, +) -> Vec { + pov_size_to_candidate + .iter() + .map(|(&pov_size, &index)| { + let mut receipt = dummy_committed_candidate_receipt(dummy_hash()); + let (_, erasure_root) = derive_erasure_chunks_with_proofs_and_root( + n_validators, + &AvailableData { + validation_data: pvd.clone(), + pov: Arc::new(PoV { block_data: BlockData(vec![index as u8; pov_size]) }), + }, + |_, _| {}, + ); + receipt.descriptor.persisted_validation_data_hash = pvd.hash(); + receipt.descriptor.erasure_root = erasure_root; + receipt + }) + .collect() +} + +#[async_trait::async_trait] +impl HandleNetworkMessage for TestState { + async fn handle( + &self, + message: NetworkMessage, + node_sender: &mut futures::channel::mpsc::UnboundedSender, + ) -> Option { + match message { + NetworkMessage::RequestFromNode(_authority_id, Requests::AttestedCandidateV2(req)) => { + let payload = req.payload; + let candidate_receipt = self + .commited_candidate_receipts + .values() + .flatten() + .find(|v| v.hash() == payload.candidate_hash) + .unwrap() + .clone(); + let persisted_validation_data = self.pvd.clone(); + let statements = self.statements.get(&payload.candidate_hash).unwrap().clone(); + let res = AttestedCandidateResponse { + candidate_receipt, + persisted_validation_data, + statements, + }; + let _ = req.pending_response.send(Ok((res.encode(), ProtocolName::from("")))); + None + }, + NetworkMessage::MessageFromNode( + authority_id, + Versioned::V3(ValidationProtocol::StatementDistribution( + StatementDistributionMessage::Statement(relay_parent, statement), + )), + ) => { + let index = self + .test_authorities + .validator_authority_id + .iter() + .position(|v| v == &authority_id) + .unwrap(); + let candidate_hash = *statement.unchecked_payload().candidate_hash(); + + let statements_sent_count = self + .statements_tracker + .get(&candidate_hash) + .unwrap() + .get(index) + .unwrap() + .as_ref(); + if statements_sent_count.load(Ordering::SeqCst) { + return None + } else { + statements_sent_count.store(true, Ordering::SeqCst); + } + + let group_statements = self.statements.get(&candidate_hash).unwrap(); + if !group_statements.iter().any(|s| s.unchecked_validator_index().0 == index as u32) + { + return None + } + + let statement = CompactStatement::Valid(candidate_hash); + let context = SigningContext { parent_hash: relay_parent, session_index: 0 }; + let payload = statement.signing_payload(&context); + let pair = self.test_authorities.validator_pairs.get(index).unwrap(); + let signature = pair.sign(&payload[..]); + let statement = SignedStatement::new( + statement, + ValidatorIndex(index as u32), + signature, + &context, + &pair.public(), + ) + .unwrap() + .as_unchecked() + .to_owned(); + + node_sender + .start_send(NetworkMessage::MessageFromPeer( + *self.test_authorities.peer_ids.get(index).unwrap(), + Versioned::V3(ValidationProtocol::StatementDistribution( + StatementDistributionMessage::Statement(relay_parent, statement), + )), + )) + .unwrap(); + None + }, + NetworkMessage::MessageFromNode( + authority_id, + Versioned::V3(ValidationProtocol::StatementDistribution( + StatementDistributionMessage::BackedCandidateManifest(manifest), + )), + ) => { + let index = self + .test_authorities + .validator_authority_id + .iter() + .position(|v| v == &authority_id) + .unwrap(); + let backing_group = + self.session_info.validator_groups.get(manifest.group_index).unwrap(); + let group_size = backing_group.len(); + let is_own_backing_group = backing_group.contains(&ValidatorIndex(NODE_UNDER_TEST)); + let mut seconded_in_group = + BitVec::from_iter((0..group_size).map(|_| !is_own_backing_group)); + let mut validated_in_group = BitVec::from_iter((0..group_size).map(|_| false)); + + if is_own_backing_group { + let (pending_response, response_receiver) = oneshot::channel(); + let peer_id = self.test_authorities.peer_ids.get(index).unwrap().to_owned(); + node_sender + .start_send(NetworkMessage::RequestFromPeer(IncomingRequest { + peer: peer_id, + payload: AttestedCandidateRequest { + candidate_hash: manifest.candidate_hash, + mask: StatementFilter::blank(self.own_backing_group.len()), + } + .encode(), + pending_response, + })) + .unwrap(); + + let response = response_receiver.await.unwrap(); + let response = + AttestedCandidateResponse::decode(&mut response.result.unwrap().as_ref()) + .unwrap(); + + for statement in response.statements { + let validator_index = statement.unchecked_validator_index(); + let position_in_group = + backing_group.iter().position(|v| *v == validator_index).unwrap(); + match statement.unchecked_payload() { + CompactStatement::Seconded(_) => + seconded_in_group.set(position_in_group, true), + CompactStatement::Valid(_) => + validated_in_group.set(position_in_group, true), + } + } + } + + let ack = BackedCandidateAcknowledgement { + candidate_hash: manifest.candidate_hash, + statement_knowledge: StatementFilter { seconded_in_group, validated_in_group }, + }; + node_sender + .start_send(NetworkMessage::MessageFromPeer( + *self.test_authorities.peer_ids.get(index).unwrap(), + Versioned::V3(ValidationProtocol::StatementDistribution( + StatementDistributionMessage::BackedCandidateKnown(ack), + )), + )) + .unwrap(); + + self.manifests_tracker + .get(&manifest.candidate_hash) + .unwrap() + .as_ref() + .store(true, Ordering::SeqCst); + + None + }, + NetworkMessage::MessageFromNode( + _authority_id, + Versioned::V3(ValidationProtocol::StatementDistribution( + StatementDistributionMessage::BackedCandidateKnown(ack), + )), + ) => { + self.manifests_tracker + .get(&ack.candidate_hash) + .unwrap() + .as_ref() + .store(true, Ordering::SeqCst); + + None + }, + _ => Some(message), + } + } +} diff --git a/polkadot/node/subsystem-bench/src/lib/usage.rs b/polkadot/node/subsystem-bench/src/lib/usage.rs index bfaac3265a2e3741aaa2fa4811785bd90e8ea016..883e9aa7ad0a0cec210ef49ccd7542f17d7256ee 100644 --- a/polkadot/node/subsystem-bench/src/lib/usage.rs +++ b/polkadot/node/subsystem-bench/src/lib/usage.rs @@ -23,7 +23,6 @@ use std::collections::HashMap; #[derive(Debug, Serialize, Deserialize, Clone)] pub struct BenchmarkUsage { - pub benchmark_name: String, pub network_usage: Vec, pub cpu_usage: Vec, } @@ -32,8 +31,7 @@ impl std::fmt::Display for BenchmarkUsage { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { write!( f, - "\n{}\n\n{}\n{}\n\n{}\n{}\n", - self.benchmark_name.purple(), + "\n{}\n{}\n\n{}\n{}\n", format!("{:<32}{:>12}{:>12}", "Network usage, KiB", "total", "per block").blue(), self.network_usage .iter() @@ -59,18 +57,17 @@ impl BenchmarkUsage { let all_cpu_usage: Vec<&ResourceUsage> = usages.iter().flat_map(|v| &v.cpu_usage).collect(); Self { - benchmark_name: usages.first().map(|v| v.benchmark_name.clone()).unwrap_or_default(), network_usage: ResourceUsage::average_by_resource_name(&all_network_usages), cpu_usage: ResourceUsage::average_by_resource_name(&all_cpu_usage), } } pub fn check_network_usage(&self, checks: &[ResourceUsageCheck]) -> Vec { - check_usage(&self.benchmark_name, &self.network_usage, checks) + check_usage(&self.network_usage, checks) } pub fn check_cpu_usage(&self, checks: &[ResourceUsageCheck]) -> Vec { - check_usage(&self.benchmark_name, &self.cpu_usage, checks) + check_usage(&self.cpu_usage, checks) } pub fn cpu_usage_diff(&self, other: &Self, resource_name: &str) -> Option { @@ -105,18 +102,8 @@ impl BenchmarkUsage { } } -fn check_usage( - benchmark_name: &str, - usage: &[ResourceUsage], - checks: &[ResourceUsageCheck], -) -> Vec { - checks - .iter() - .filter_map(|check| { - check_resource_usage(usage, check) - .map(|message| format!("{}: {}", benchmark_name, message)) - }) - .collect() +fn check_usage(usage: &[ResourceUsage], checks: &[ResourceUsageCheck]) -> Vec { + checks.iter().filter_map(|check| check_resource_usage(usage, check)).collect() } fn check_resource_usage( diff --git a/polkadot/node/subsystem-test-helpers/Cargo.toml b/polkadot/node/subsystem-test-helpers/Cargo.toml index 57678e8e8d4a1057ec843f097c2cd9811f33a6bb..d3229291673c6da0b1ba12d6983c678ed2d5a343 100644 --- a/polkadot/node/subsystem-test-helpers/Cargo.toml +++ b/polkadot/node/subsystem-test-helpers/Cargo.toml @@ -11,19 +11,19 @@ license.workspace = true workspace = true [dependencies] -async-trait = "0.1.79" -futures = "0.3.30" -parking_lot = "0.12.1" -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-erasure-coding = { path = "../../erasure-coding" } -polkadot-node-subsystem-util = { path = "../subsystem-util" } -polkadot-primitives = { path = "../../primitives" } -polkadot-node-primitives = { path = "../primitives" } +async-trait = { workspace = true } +futures = { workspace = true } +parking_lot = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-subsystem-util = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } -sc-client-api = { path = "../../../substrate/client/api" } -sc-utils = { path = "../../../substrate/client/utils" } -sp-core = { path = "../../../substrate/primitives/core" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sc-keystore = { path = "../../../substrate/client/keystore" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" } +sc-client-api = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } diff --git a/polkadot/node/subsystem-test-helpers/src/lib.rs b/polkadot/node/subsystem-test-helpers/src/lib.rs index 6c1ac86c4507b798e4270b7c52e97a4dad74b64c..bdb0647fee6f5aec1dd6322b68c9a38f6e493b98 100644 --- a/polkadot/node/subsystem-test-helpers/src/lib.rs +++ b/polkadot/node/subsystem-test-helpers/src/lib.rs @@ -25,7 +25,7 @@ use polkadot_node_subsystem::{ SubsystemError, SubsystemResult, TrySendError, }; use polkadot_node_subsystem_util::TimeoutExt; -use polkadot_primitives::{Hash, ValidatorIndex}; +use polkadot_primitives::{ChunkIndex, Hash}; use futures::{channel::mpsc, poll, prelude::*}; use parking_lot::Mutex; @@ -36,7 +36,7 @@ use std::{ convert::Infallible, future::Future, pin::Pin, - sync::Arc, + sync::{atomic::AtomicUsize, Arc}, task::{Context, Poll, Waker}, time::Duration, }; @@ -146,12 +146,13 @@ pub fn single_item_sink() -> (SingleItemSink, SingleItemStream) { #[derive(Clone)] pub struct TestSubsystemSender { tx: mpsc::UnboundedSender, + message_counter: MessageCounter, } /// Construct a sender/receiver pair. pub fn sender_receiver() -> (TestSubsystemSender, mpsc::UnboundedReceiver) { let (tx, rx) = mpsc::unbounded(); - (TestSubsystemSender { tx }, rx) + (TestSubsystemSender { tx, message_counter: MessageCounter::default() }, rx) } #[async_trait::async_trait] @@ -161,6 +162,11 @@ where OutgoingMessage: Send + 'static, { async fn send_message(&mut self, msg: OutgoingMessage) { + self.send_message_with_priority::(msg).await; + } + + async fn send_message_with_priority(&mut self, msg: OutgoingMessage) { + self.message_counter.increment(P::priority()); self.tx.send(msg.into()).await.expect("test overseer no longer live"); } @@ -168,6 +174,14 @@ where &mut self, msg: OutgoingMessage, ) -> Result<(), TrySendError> { + self.try_send_message_with_priority::(msg) + } + + fn try_send_message_with_priority( + &mut self, + msg: OutgoingMessage, + ) -> Result<(), TrySendError> { + self.message_counter.increment(P::priority()); self.tx.unbounded_send(msg.into()).expect("test overseer no longer live"); Ok(()) } @@ -277,6 +291,9 @@ pub struct TestSubsystemContextHandle { /// Direct access to the receiver. pub rx: mpsc::UnboundedReceiver, + + /// Message counter over subsystems. + pub message_counter: MessageCounter, } impl TestSubsystemContextHandle { @@ -322,6 +339,34 @@ pub fn make_subsystem_context( make_buffered_subsystem_context(spawner, 0) } +/// Message counter over subsystems. +#[derive(Default, Clone)] +pub struct MessageCounter { + total: Arc, + with_high_priority: Arc, +} + +impl MessageCounter { + /// Increment the message counter. + pub fn increment(&mut self, priority_level: overseer::PriorityLevel) { + self.total.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + if matches!(priority_level, overseer::PriorityLevel::High) { + self.with_high_priority.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + } + } + + /// Reset the message counter. + pub fn reset(&mut self) { + self.total.store(0, std::sync::atomic::Ordering::SeqCst); + self.with_high_priority.store(0, std::sync::atomic::Ordering::SeqCst); + } + + /// Get the messages with high priority count. + pub fn with_high_priority(&self) -> usize { + self.with_high_priority.load(std::sync::atomic::Ordering::SeqCst) + } +} + /// Make a test subsystem context with buffered overseer channel. Some tests (e.g. /// `dispute-coordinator`) create too many parallel operations and deadlock unless /// the channel is buffered. Usually `buffer_size=1` is enough. @@ -331,15 +376,23 @@ pub fn make_buffered_subsystem_context( ) -> (TestSubsystemContext>, TestSubsystemContextHandle) { let (overseer_tx, overseer_rx) = mpsc::channel(buffer_size); let (all_messages_tx, all_messages_rx) = mpsc::unbounded(); + let message_counter = MessageCounter::default(); ( TestSubsystemContext { - tx: TestSubsystemSender { tx: all_messages_tx }, + tx: TestSubsystemSender { + tx: all_messages_tx, + message_counter: message_counter.clone(), + }, rx: overseer_rx, spawn: SpawnGlue(spawner), message_buffer: VecDeque::new(), }, - TestSubsystemContextHandle { tx: overseer_tx, rx: all_messages_rx }, + TestSubsystemContextHandle { + tx: overseer_tx, + rx: all_messages_rx, + message_counter: message_counter.clone(), + }, ) } @@ -487,7 +540,7 @@ pub fn derive_erasure_chunks_with_proofs_and_root( .enumerate() .map(|(index, (proof, chunk))| ErasureChunk { chunk: chunk.to_vec(), - index: ValidatorIndex(index as _), + index: ChunkIndex(index as _), proof: Proof::try_from(proof).unwrap(), }) .collect::>(); diff --git a/polkadot/node/subsystem-types/Cargo.toml b/polkadot/node/subsystem-types/Cargo.toml index 93dd43c5dbfc495ff92fa76f28e3ad80992b8a6a..c8fc324699e1754cb0d476a97ef29c8fea4ede74 100644 --- a/polkadot/node/subsystem-types/Cargo.toml +++ b/polkadot/node/subsystem-types/Cargo.toml @@ -10,25 +10,26 @@ license.workspace = true workspace = true [dependencies] -derive_more = "0.99.17" -futures = "0.3.30" -polkadot-primitives = { path = "../../primitives" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-node-network-protocol = { path = "../network/protocol" } -polkadot-statement-table = { path = "../../statement-table" } -polkadot-node-jaeger = { path = "../jaeger" } -orchestra = { version = "0.3.5", default-features = false, features = ["futures_channel"] } -sc-network = { path = "../../../substrate/client/network" } -sc-network-types = { path = "../../../substrate/client/network/types" } -sp-api = { path = "../../../substrate/primitives/api" } -sp-blockchain = { path = "../../../substrate/primitives/blockchain" } -sp-consensus-babe = { path = "../../../substrate/primitives/consensus/babe" } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-authority-discovery = { path = "../../../substrate/primitives/authority-discovery" } -sc-client-api = { path = "../../../substrate/client/api" } -sc-transaction-pool-api = { path = "../../../substrate/client/transaction-pool/api" } -smallvec = "1.8.0" -substrate-prometheus-endpoint = { path = "../../../substrate/utils/prometheus" } +derive_more = { workspace = true, default-features = true } +fatality = { workspace = true } +futures = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-statement-table = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } +orchestra = { features = ["futures_channel"], workspace = true } +sc-network = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +smallvec = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } thiserror = { workspace = true } -async-trait = "0.1.79" -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } +async-trait = { workspace = true } +bitvec = { features = ["alloc"], workspace = true } diff --git a/polkadot/node/subsystem-types/src/errors.rs b/polkadot/node/subsystem-types/src/errors.rs index 44136362a69efa0ba316413cc9f78d834b5c3e9f..8e1b515c8db0acc4ff30727ed0986c6322d941ce 100644 --- a/polkadot/node/subsystem-types/src/errors.rs +++ b/polkadot/node/subsystem-types/src/errors.rs @@ -18,6 +18,7 @@ use crate::JaegerError; use ::orchestra::OrchestraError as OverseerError; +use fatality::fatality; /// A description of an error causing the runtime API request to be unservable. #[derive(thiserror::Error, Debug, Clone)] @@ -68,32 +69,21 @@ impl core::fmt::Display for ChainApiError { impl std::error::Error for ChainApiError {} /// An error that may happen during Availability Recovery process. -#[derive(PartialEq, Debug, Clone)] +#[derive(PartialEq, Clone)] +#[fatality(splitable)] +#[allow(missing_docs)] pub enum RecoveryError { - /// A chunk is recovered but is invalid. + #[error("Invalid data")] Invalid, - /// A requested chunk is unavailable. + #[error("Data is unavailable")] Unavailable, - /// Erasure task channel closed, usually means node is shutting down. + #[fatal] + #[error("Erasure task channel closed")] ChannelClosed, } -impl std::fmt::Display for RecoveryError { - fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> { - let msg = match self { - RecoveryError::Invalid => "Invalid", - RecoveryError::Unavailable => "Unavailable", - RecoveryError::ChannelClosed => "ChannelClosed", - }; - - write!(f, "{}", msg) - } -} - -impl std::error::Error for RecoveryError {} - /// An error type that describes faults that may happen /// /// These are: @@ -117,7 +107,7 @@ pub enum SubsystemError { Infallible(#[from] std::convert::Infallible), #[error(transparent)] - Prometheus(#[from] substrate_prometheus_endpoint::PrometheusError), + Prometheus(#[from] prometheus_endpoint::PrometheusError), #[error(transparent)] Jaeger(#[from] JaegerError), diff --git a/polkadot/node/subsystem-types/src/messages.rs b/polkadot/node/subsystem-types/src/messages.rs index e75d80395c4ba0371b58ce1383db2a1f364eaad8..d067ca468011d6f196efef42b012f6c8f1459cb7 100644 --- a/polkadot/node/subsystem-types/src/messages.rs +++ b/polkadot/node/subsystem-types/src/messages.rs @@ -43,13 +43,13 @@ use polkadot_node_primitives::{ }; use polkadot_primitives::{ async_backing, slashing, ApprovalVotingParams, AuthorityDiscoveryId, BackedCandidate, - BlockNumber, CandidateEvent, CandidateHash, CandidateIndex, CandidateReceipt, CollatorId, - CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams, GroupIndex, - GroupRotationInfo, Hash, HeadData, Header as BlockHeader, Id as ParaId, InboundDownwardMessage, - InboundHrmpMessage, MultiDisputeStatementSet, NodeFeatures, OccupiedCoreAssumption, - PersistedValidationData, PvfCheckStatement, PvfExecKind, SessionIndex, SessionInfo, - SignedAvailabilityBitfield, SignedAvailabilityBitfields, ValidationCode, ValidationCodeHash, - ValidatorId, ValidatorIndex, ValidatorSignature, + BlockNumber, CandidateCommitments, CandidateEvent, CandidateHash, CandidateIndex, + CandidateReceipt, CollatorId, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, + ExecutorParams, GroupIndex, GroupRotationInfo, Hash, HeadData, Header as BlockHeader, + Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, MultiDisputeStatementSet, + NodeFeatures, OccupiedCoreAssumption, PersistedValidationData, PvfCheckStatement, PvfExecKind, + SessionIndex, SessionInfo, SignedAvailabilityBitfield, SignedAvailabilityBitfields, + ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, }; use polkadot_statement_table::v2::Misbehavior; use std::{ @@ -62,7 +62,7 @@ pub mod network_bridge_event; pub use network_bridge_event::NetworkBridgeEvent; /// A request to the candidate backing subsystem to check whether -/// there exists vacant membership in some fragment tree. +/// we can second this candidate. #[derive(Debug, Copy, Clone)] pub struct CanSecondRequest { /// Para id of the candidate. @@ -85,15 +85,17 @@ pub enum CandidateBackingMessage { /// candidates of the same para that follow it in the input vector. In other words, assuming /// candidates are supplied in dependency order, we must ensure that this dependency order is /// preserved. - GetBackedCandidates( + GetBackableCandidates( HashMap>, oneshot::Sender>>, ), /// Request the subsystem to check whether it's allowed to second given candidate. - /// The rule is to only fetch collations that are either built on top of the root - /// of some fragment tree or have a parent node which represents backed candidate. + /// The rule is to only fetch collations that can either be directly chained to any + /// FragmentChain in the view or there is at least one FragmentChain where this candidate is a + /// potentially unconnected candidate (we predict that it may become connected to a + /// FragmentChain in the future). /// - /// Always responses with `false` if async backing is disabled for candidate's relay + /// Always responds with `false` if async backing is disabled for candidate's relay /// parent. CanSecond(CanSecondRequest, oneshot::Sender), /// Note that the Candidate Backing subsystem should second the given candidate in the context @@ -244,13 +246,6 @@ pub enum CollatorProtocolMessage { /// /// The hash is the relay parent. Seconded(Hash, SignedFullStatement), - /// The candidate received enough validity votes from the backing group. - Backed { - /// Candidate's para id. - para_id: ParaId, - /// Hash of the para head generated by candidate. - para_head: Hash, - }, } impl Default for CollatorProtocolMessage { @@ -449,6 +444,16 @@ pub enum NetworkBridgeTxMessage { /// The peer set we want the connection on. peer_set: PeerSet, }, + + /// Extends the known validators set with new peers we already know the `Multiaddrs`, this is + /// usually needed for validators that change their address mid-session. It is usually called + /// after a ConnectToResolvedValidators at the beginning of the session. + AddToResolvedValidators { + /// Each entry corresponds to the addresses of an already resolved validator. + validator_addrs: Vec>, + /// The peer set we want the connection on. + peer_set: PeerSet, + }, } /// Availability Distribution Message. @@ -485,6 +490,8 @@ pub enum AvailabilityRecoveryMessage { CandidateReceipt, SessionIndex, Option, // Optional backing group to request from first. + Option, /* A `CoreIndex` needs to be specified for the recovery process to + * prefer systematic chunk recovery. */ oneshot::Sender>, ), } @@ -520,7 +527,7 @@ pub enum AvailabilityStoreMessage { QueryChunkSize(CandidateHash, oneshot::Sender>), /// Query all chunks that we have for the given candidate hash. - QueryAllChunks(CandidateHash, oneshot::Sender>), + QueryAllChunks(CandidateHash, oneshot::Sender>), /// Query whether an `ErasureChunk` exists within the AV Store. /// @@ -535,6 +542,8 @@ pub enum AvailabilityStoreMessage { StoreChunk { /// A hash of the candidate this chunk belongs to. candidate_hash: CandidateHash, + /// Validator index. May not be equal to the chunk index. + validator_index: ValidatorIndex, /// The chunk itself. chunk: ErasureChunk, /// Sending side of the channel to send result to. @@ -554,6 +563,11 @@ pub enum AvailabilityStoreMessage { available_data: AvailableData, /// Erasure root we expect to get after chunking. expected_erasure_root: Hash, + /// Core index where the candidate was backed. + core_index: CoreIndex, + /// Node features at the candidate relay parent. Used for computing the validator->chunk + /// mapping. + node_features: NodeFeatures, /// Sending side of the channel to send result to. tx: oneshot::Sender>, }, @@ -1023,9 +1037,9 @@ pub enum GossipSupportMessage { NetworkBridgeUpdate(NetworkBridgeEvent), } -/// Request introduction of a candidate into the prospective parachains subsystem. +/// Request introduction of a seconded candidate into the prospective parachains subsystem. #[derive(Debug, PartialEq, Eq, Clone)] -pub struct IntroduceCandidateRequest { +pub struct IntroduceSecondedCandidateRequest { /// The para-id of the candidate. pub candidate_para: ParaId, /// The candidate receipt itself. @@ -1034,7 +1048,7 @@ pub struct IntroduceCandidateRequest { pub persisted_validation_data: PersistedValidationData, } -/// A hypothetical candidate to be evaluated for frontier membership +/// A hypothetical candidate to be evaluated for potential/actual membership /// in the prospective parachains subsystem. /// /// Hypothetical candidates are either complete or incomplete. @@ -1103,21 +1117,53 @@ impl HypotheticalCandidate { candidate_relay_parent, } } + + /// Get the output head data hash, if the candidate is complete. + pub fn output_head_data_hash(&self) -> Option { + match *self { + HypotheticalCandidate::Complete { ref receipt, .. } => + Some(receipt.descriptor.para_head), + HypotheticalCandidate::Incomplete { .. } => None, + } + } + + /// Get the candidate commitments, if the candidate is complete. + pub fn commitments(&self) -> Option<&CandidateCommitments> { + match *self { + HypotheticalCandidate::Complete { ref receipt, .. } => Some(&receipt.commitments), + HypotheticalCandidate::Incomplete { .. } => None, + } + } + + /// Get the persisted validation data, if the candidate is complete. + pub fn persisted_validation_data(&self) -> Option<&PersistedValidationData> { + match *self { + HypotheticalCandidate::Complete { ref persisted_validation_data, .. } => + Some(persisted_validation_data), + HypotheticalCandidate::Incomplete { .. } => None, + } + } + + /// Get the validation code hash, if the candidate is complete. + pub fn validation_code_hash(&self) -> Option<&ValidationCodeHash> { + match *self { + HypotheticalCandidate::Complete { ref receipt, .. } => + Some(&receipt.descriptor.validation_code_hash), + HypotheticalCandidate::Incomplete { .. } => None, + } + } } /// Request specifying which candidates are either already included -/// or might be included in the hypothetical frontier of fragment trees -/// under a given active leaf. +/// or might become included in fragment chain under a given active leaf (or any active leaf if +/// `fragment_chain_relay_parent` is `None`). #[derive(Debug, PartialEq, Eq, Clone)] -pub struct HypotheticalFrontierRequest { +pub struct HypotheticalMembershipRequest { /// Candidates, in arbitrary order, which should be checked for - /// possible membership in fragment trees. + /// hypothetical/actual membership in fragment chains. pub candidates: Vec, - /// Either a specific fragment tree to check, otherwise all. - pub fragment_tree_relay_parent: Option, - /// Only return membership if all candidates in the path from the - /// root are backed. - pub backed_in_path_only: bool, + /// Either a specific fragment chain to check, otherwise all. + pub fragment_chain_relay_parent: Option, } /// A request for the persisted validation data stored in the prospective @@ -1156,9 +1202,9 @@ impl ParentHeadData { } } -/// Indicates the relay-parents whose fragment tree a candidate -/// is present in and the depths of that tree the candidate is present in. -pub type FragmentTreeMembership = Vec<(Hash, Vec)>; +/// Indicates the relay-parents whose fragment chain a candidate +/// is present in or can be added in (right now or in the future). +pub type HypotheticalMembership = Vec; /// A collection of ancestor candidates of a parachain. pub type Ancestors = HashSet; @@ -1166,15 +1212,11 @@ pub type Ancestors = HashSet; /// Messages sent to the Prospective Parachains subsystem. #[derive(Debug)] pub enum ProspectiveParachainsMessage { - /// Inform the Prospective Parachains Subsystem of a new candidate. + /// Inform the Prospective Parachains Subsystem of a new seconded candidate. /// - /// The response sender accepts the candidate membership, which is the existing - /// membership of the candidate if it was already known. - IntroduceCandidate(IntroduceCandidateRequest, oneshot::Sender), - /// Inform the Prospective Parachains Subsystem that a previously introduced candidate - /// has been seconded. This requires that the candidate was successfully introduced in - /// the past. - CandidateSeconded(ParaId, CandidateHash), + /// The response sender returns false if the candidate was rejected by prospective parachains, + /// true otherwise (if it was accepted or already present) + IntroduceSecondedCandidate(IntroduceSecondedCandidateRequest, oneshot::Sender), /// Inform the Prospective Parachains Subsystem that a previously introduced candidate /// has been backed. This requires that the candidate was successfully introduced in /// the past. @@ -1193,23 +1235,29 @@ pub enum ProspectiveParachainsMessage { Ancestors, oneshot::Sender>, ), - /// Get the hypothetical frontier membership of candidates with the given properties - /// under the specified active leaves' fragment trees. + /// Get the hypothetical or actual membership of candidates with the given properties + /// under the specified active leave's fragment chain. + /// + /// For each candidate, we return a vector of leaves where the candidate is present or could be + /// added. "Could be added" either means that the candidate can be added to the chain right now + /// or could be added in the future (we may not have its ancestors yet). + /// Note that even if we think it could be added in the future, we may find out that it was + /// invalid, as time passes. + /// If an active leaf is not in the vector, it means that there's no + /// chance this candidate will become valid under that leaf in the future. /// - /// For any candidate which is already known, this returns the depths the candidate - /// occupies. - GetHypotheticalFrontier( - HypotheticalFrontierRequest, - oneshot::Sender>, + /// If `fragment_chain_relay_parent` in the request is `Some()`, the return vector can only + /// contain this relay parent (or none). + GetHypotheticalMembership( + HypotheticalMembershipRequest, + oneshot::Sender>, ), - /// Get the membership of the candidate in all fragment trees. - GetTreeMembership(ParaId, CandidateHash, oneshot::Sender), - /// Get the minimum accepted relay-parent number for each para in the fragment tree + /// Get the minimum accepted relay-parent number for each para in the fragment chain /// for the given relay-chain block hash. /// /// That is, if the block hash is known and is an active leaf, this returns the /// minimum relay-parent block number in the same branch of the relay chain which - /// is accepted in the fragment tree for each para-id. + /// is accepted in the fragment chain for each para-id. /// /// If the block hash is not an active leaf, this will return an empty vector. /// @@ -1219,8 +1267,10 @@ pub enum ProspectiveParachainsMessage { /// Para-IDs are returned in no particular order. GetMinimumRelayParents(Hash, oneshot::Sender>), /// Get the validation data of some prospective candidate. The candidate doesn't need - /// to be part of any fragment tree, but this only succeeds if the parent head-data and - /// relay-parent are part of some fragment tree. + /// to be part of any fragment chain, but this only succeeds if the parent head-data and + /// relay-parent are part of the `CandidateStorage` (meaning that it's a candidate which is + /// part of some fragment chain or which prospective-parachains predicted will become part of + /// some fragment chain). GetProspectiveValidationData( ProspectiveValidationDataRequest, oneshot::Sender>, diff --git a/polkadot/node/subsystem-util/Cargo.toml b/polkadot/node/subsystem-util/Cargo.toml index cb93ad75d20b1487bae29759dd92b4d2a5ff8502..a7157d1b5b7f46627665fb96d97f28c95fb105ec 100644 --- a/polkadot/node/subsystem-util/Cargo.toml +++ b/polkadot/node/subsystem-util/Cargo.toml @@ -10,46 +10,46 @@ license.workspace = true workspace = true [dependencies] -async-trait = "0.1.79" -futures = "0.3.30" -futures-channel = "0.3.23" -itertools = "0.11" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -parking_lot = "0.12.1" -pin-project = "1.0.9" -rand = "0.8.5" +async-trait = { workspace = true } +futures = { workspace = true } +futures-channel = { workspace = true } +itertools = { workspace = true } +codec = { features = ["derive"], workspace = true } +parking_lot = { workspace = true, default-features = true } +pin-project = { workspace = true } +rand = { workspace = true, default-features = true } thiserror = { workspace = true } -fatality = "0.0.6" -gum = { package = "tracing-gum", path = "../gum" } -derive_more = "0.99.17" -schnellru = "0.2.1" +fatality = { workspace = true } +gum = { workspace = true, default-features = true } +derive_more = { workspace = true, default-features = true } +schnellru = { workspace = true } -polkadot-node-subsystem = { path = "../subsystem" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-node-jaeger = { path = "../jaeger" } -polkadot-node-metrics = { path = "../metrics" } -polkadot-node-network-protocol = { path = "../network/protocol" } -polkadot-primitives = { path = "../../primitives" } -polkadot-node-primitives = { path = "../primitives" } -polkadot-overseer = { path = "../overseer" } -metered = { package = "prioritized-metered-channel", version = "0.6.1", default-features = false, features = ["futures_channel"] } +polkadot-erasure-coding = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } +polkadot-node-metrics = { workspace = true, default-features = true } +polkadot-node-network-protocol = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-overseer = { workspace = true, default-features = true } +metered = { features = ["futures_channel"], workspace = true } -sp-core = { path = "../../../substrate/primitives/core" } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sc-client-api = { path = "../../../substrate/client/api" } +sp-core = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } -kvdb = "0.13.0" -parity-db = { version = "0.4.12" } +kvdb = { workspace = true } +parity-db = { workspace = true } [dev-dependencies] -assert_matches = "1.4.0" -env_logger = "0.11" -futures = { version = "0.3.30", features = ["thread-pool"] } +assert_matches = { workspace = true } +futures = { features = ["thread-pool"], workspace = true } log = { workspace = true, default-features = true } -polkadot-node-subsystem-test-helpers = { path = "../subsystem-test-helpers" } -lazy_static = "1.4.0" -polkadot-primitives-test-helpers = { path = "../../primitives/test-helpers" } -kvdb-shared-tests = "0.11.0" -tempfile = "3.1.0" -kvdb-memorydb = "0.13.0" +polkadot-node-subsystem-test-helpers = { workspace = true } +lazy_static = { workspace = true } +polkadot-primitives-test-helpers = { workspace = true } +kvdb-shared-tests = { workspace = true } +tempfile = { workspace = true } +kvdb-memorydb = { workspace = true } diff --git a/polkadot/node/subsystem-util/src/availability_chunks.rs b/polkadot/node/subsystem-util/src/availability_chunks.rs new file mode 100644 index 0000000000000000000000000000000000000000..651dd3633cfcc386a1244dea59f1c04a670def9d --- /dev/null +++ b/polkadot/node/subsystem-util/src/availability_chunks.rs @@ -0,0 +1,227 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use polkadot_erasure_coding::systematic_recovery_threshold; +use polkadot_primitives::{node_features, ChunkIndex, CoreIndex, NodeFeatures, ValidatorIndex}; + +/// Compute the per-validator availability chunk index. +/// WARNING: THIS FUNCTION IS CRITICAL TO PARACHAIN CONSENSUS. +/// Any modification to the output of the function needs to be coordinated via the runtime. +/// It's best to use minimal/no external dependencies. +pub fn availability_chunk_index( + maybe_node_features: Option<&NodeFeatures>, + n_validators: usize, + core_index: CoreIndex, + validator_index: ValidatorIndex, +) -> Result { + if let Some(features) = maybe_node_features { + if let Some(&true) = features + .get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8)) + .as_deref() + { + let systematic_threshold = systematic_recovery_threshold(n_validators)? as u32; + let core_start_pos = core_index.0 * systematic_threshold; + + return Ok(ChunkIndex((core_start_pos + validator_index.0) % n_validators as u32)) + } + } + + Ok(validator_index.into()) +} + +/// Compute the per-core availability chunk indices. Returns a Vec which maps ValidatorIndex to +/// ChunkIndex for a given availability core index +/// WARNING: THIS FUNCTION IS CRITICAL TO PARACHAIN CONSENSUS. +/// Any modification to the output of the function needs to be coordinated via the +/// runtime. It's best to use minimal/no external dependencies. +pub fn availability_chunk_indices( + maybe_node_features: Option<&NodeFeatures>, + n_validators: usize, + core_index: CoreIndex, +) -> Result, polkadot_erasure_coding::Error> { + let identity = (0..n_validators).map(|index| ChunkIndex(index as u32)); + if let Some(features) = maybe_node_features { + if let Some(&true) = features + .get(usize::from(node_features::FeatureIndex::AvailabilityChunkMapping as u8)) + .as_deref() + { + let systematic_threshold = systematic_recovery_threshold(n_validators)? as u32; + let core_start_pos = core_index.0 * systematic_threshold; + + return Ok(identity + .into_iter() + .cycle() + .skip(core_start_pos as usize) + .take(n_validators) + .collect()) + } + } + + Ok(identity.collect()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::collections::HashSet; + + pub fn node_features_with_mapping_enabled() -> NodeFeatures { + let mut node_features = NodeFeatures::new(); + node_features + .resize(node_features::FeatureIndex::AvailabilityChunkMapping as usize + 1, false); + node_features + .set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, true); + node_features + } + + pub fn node_features_with_other_bits_enabled() -> NodeFeatures { + let mut node_features = NodeFeatures::new(); + node_features.resize(node_features::FeatureIndex::FirstUnassigned as usize + 1, true); + node_features + .set(node_features::FeatureIndex::AvailabilityChunkMapping as u8 as usize, false); + node_features + } + + #[test] + fn test_availability_chunk_indices() { + let n_validators = 20u32; + let n_cores = 15u32; + + // If the mapping feature is not enabled, it should always be the identity vector. + { + for node_features in + [None, Some(NodeFeatures::EMPTY), Some(node_features_with_other_bits_enabled())] + { + for core_index in 0..n_cores { + let indices = availability_chunk_indices( + node_features.as_ref(), + n_validators as usize, + CoreIndex(core_index), + ) + .unwrap(); + + for validator_index in 0..n_validators { + assert_eq!( + indices[validator_index as usize], + availability_chunk_index( + node_features.as_ref(), + n_validators as usize, + CoreIndex(core_index), + ValidatorIndex(validator_index) + ) + .unwrap() + ) + } + + assert_eq!( + indices, + (0..n_validators).map(|i| ChunkIndex(i)).collect::>() + ); + } + } + } + + // Test when mapping feature is enabled. + { + let node_features = node_features_with_mapping_enabled(); + let mut previous_indices = None; + + for core_index in 0..n_cores { + let indices = availability_chunk_indices( + Some(&node_features), + n_validators as usize, + CoreIndex(core_index), + ) + .unwrap(); + + for validator_index in 0..n_validators { + assert_eq!( + indices[validator_index as usize], + availability_chunk_index( + Some(&node_features), + n_validators as usize, + CoreIndex(core_index), + ValidatorIndex(validator_index) + ) + .unwrap() + ) + } + + // Check that it's not equal to the previous core's indices. + if let Some(previous_indices) = previous_indices { + assert_ne!(previous_indices, indices); + } + + previous_indices = Some(indices.clone()); + + // Check that it's indeed a permutation. + assert_eq!( + (0..n_validators).map(|i| ChunkIndex(i)).collect::>(), + indices.into_iter().collect::>() + ); + } + } + } + + #[test] + // This is just a dummy test that checks the mapping against some hardcoded outputs, to prevent + // accidental changes to the algorithms. + fn prevent_changes_to_mapping() { + let n_validators = 7; + let node_features = node_features_with_mapping_enabled(); + + assert_eq!( + availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(0)) + .unwrap() + .into_iter() + .map(|i| i.0) + .collect::>(), + vec![0, 1, 2, 3, 4, 5, 6] + ); + assert_eq!( + availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(1)) + .unwrap() + .into_iter() + .map(|i| i.0) + .collect::>(), + vec![2, 3, 4, 5, 6, 0, 1] + ); + assert_eq!( + availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(2)) + .unwrap() + .into_iter() + .map(|i| i.0) + .collect::>(), + vec![4, 5, 6, 0, 1, 2, 3] + ); + assert_eq!( + availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(3)) + .unwrap() + .into_iter() + .map(|i| i.0) + .collect::>(), + vec![6, 0, 1, 2, 3, 4, 5] + ); + assert_eq!( + availability_chunk_indices(Some(&node_features), n_validators, CoreIndex(4)) + .unwrap() + .into_iter() + .map(|i| i.0) + .collect::>(), + vec![1, 2, 3, 4, 5, 6, 0] + ); + } +} diff --git a/polkadot/node/subsystem-util/src/backing_implicit_view.rs b/polkadot/node/subsystem-util/src/backing_implicit_view.rs index a14536a17666c8e2d9183755e3579990f6185113..a805ef8165e5fe108cf292c4eff04bf8d0f7e486 100644 --- a/polkadot/node/subsystem-util/src/backing_implicit_view.rs +++ b/polkadot/node/subsystem-util/src/backing_implicit_view.rs @@ -17,23 +17,46 @@ use futures::channel::oneshot; use polkadot_node_subsystem::{ errors::ChainApiError, - messages::{ChainApiMessage, ProspectiveParachainsMessage}, + messages::{ChainApiMessage, ProspectiveParachainsMessage, RuntimeApiMessage}, SubsystemSender, }; use polkadot_primitives::{BlockNumber, Hash, Id as ParaId}; use std::collections::HashMap; +use crate::{ + inclusion_emulator::RelayChainBlockInfo, + request_session_index_for_child, + runtime::{self, prospective_parachains_mode, recv_runtime, ProspectiveParachainsMode}, +}; + // Always aim to retain 1 block before the active leaves. const MINIMUM_RETAIN_LENGTH: BlockNumber = 2; /// Handles the implicit view of the relay chain derived from the immediate view, which /// is composed of active leaves, and the minimum relay-parents allowed for /// candidates of various parachains at those leaves. -#[derive(Default, Clone)] +#[derive(Clone)] pub struct View { leaves: HashMap, block_info_storage: HashMap, + collating_for: Option, +} + +impl View { + /// Create a new empty view. + /// If `collating_for` is `Some`, the node is a collator and is only interested in the allowed + /// relay parents of a single paraid. When this is true, prospective-parachains is no longer + /// queried. + pub fn new(collating_for: Option) -> Self { + Self { leaves: Default::default(), block_info_storage: Default::default(), collating_for } + } +} + +impl Default for View { + fn default() -> Self { + Self::new(None) + } } // Minimum relay parents implicitly relative to a particular block. @@ -99,6 +122,26 @@ struct BlockInfo { parent_hash: Hash, } +/// Information about a relay-chain block, to be used when calling this module from prospective +/// parachains. +#[derive(Debug, Clone, PartialEq)] +pub struct BlockInfoProspectiveParachains { + /// The hash of the relay-chain block. + pub hash: Hash, + /// The hash of the parent relay-chain block. + pub parent_hash: Hash, + /// The number of the relay-chain block. + pub number: BlockNumber, + /// The storage-root of the relay-chain block. + pub storage_root: Hash, +} + +impl From for RelayChainBlockInfo { + fn from(value: BlockInfoProspectiveParachains) -> Self { + Self { hash: value.hash, number: value.number, storage_root: value.storage_root } + } +} + impl View { /// Get an iterator over active leaves in the view. pub fn leaves(&self) -> impl Iterator { @@ -106,15 +149,13 @@ impl View { } /// Activate a leaf in the view. - /// This will request the minimum relay parents from the - /// Prospective Parachains subsystem for each leaf and will load headers in the ancestry of each - /// leaf in the view as needed. These are the 'implicit ancestors' of the leaf. + /// This will request the minimum relay parents the leaf and will load headers in the + /// ancestry of the leaf as needed. These are the 'implicit ancestors' of the leaf. /// /// To maximize reuse of outdated leaves, it's best to activate new leaves before /// deactivating old ones. /// - /// This returns a list of para-ids which are relevant to the leaf, - /// and the allowed relay parents for these paras under this leaf can be + /// The allowed relay parents for the relevant paras under this leaf can be /// queried with [`View::known_allowed_relay_parents_under`]. /// /// No-op for known leaves. @@ -122,10 +163,11 @@ impl View { &mut self, sender: &mut Sender, leaf_hash: Hash, - ) -> Result, FetchError> + ) -> Result<(), FetchError> where - Sender: SubsystemSender, - Sender: SubsystemSender, + Sender: SubsystemSender + + SubsystemSender + + SubsystemSender, { if self.leaves.contains_key(&leaf_hash) { return Err(FetchError::AlreadyKnown) @@ -135,6 +177,7 @@ impl View { leaf_hash, &mut self.block_info_storage, &mut *sender, + self.collating_for, ) .await; @@ -150,12 +193,67 @@ impl View { self.leaves.insert(leaf_hash, ActiveLeafPruningInfo { retain_minimum }); - Ok(fetched.relevant_paras) + Ok(()) }, Err(e) => Err(e), } } + /// Activate a leaf in the view. To be used by the prospective parachains subsystem. + /// + /// This will not request any additional data, as prospective parachains already provides all + /// the required info. + /// NOTE: using `activate_leaf` instead of this function will result in a + /// deadlock, as it calls prospective-parachains under the hood. + /// + /// No-op for known leaves. + pub fn activate_leaf_from_prospective_parachains( + &mut self, + leaf: BlockInfoProspectiveParachains, + ancestors: &[BlockInfoProspectiveParachains], + ) { + if self.leaves.contains_key(&leaf.hash) { + return + } + + // Retain at least `MINIMUM_RETAIN_LENGTH` blocks in storage. + // This helps to avoid Chain API calls when activating leaves in the + // same chain. + let retain_minimum = std::cmp::min( + ancestors.last().map(|a| a.number).unwrap_or(0), + leaf.number.saturating_sub(MINIMUM_RETAIN_LENGTH), + ); + + self.leaves.insert(leaf.hash, ActiveLeafPruningInfo { retain_minimum }); + let mut allowed_relay_parents = AllowedRelayParents { + allowed_relay_parents_contiguous: Vec::with_capacity(ancestors.len()), + // In this case, initialise this to an empty map, as prospective parachains already has + // this data and it won't query the implicit view for it. + minimum_relay_parents: HashMap::new(), + }; + + for ancestor in ancestors { + self.block_info_storage.insert( + ancestor.hash, + BlockInfo { + block_number: ancestor.number, + maybe_allowed_relay_parents: None, + parent_hash: ancestor.parent_hash, + }, + ); + allowed_relay_parents.allowed_relay_parents_contiguous.push(ancestor.hash); + } + + self.block_info_storage.insert( + leaf.hash, + BlockInfo { + block_number: leaf.number, + maybe_allowed_relay_parents: Some(allowed_relay_parents), + parent_hash: leaf.parent_hash, + }, + ); + } + /// Deactivate a leaf in the view. This prunes any outdated implicit ancestors as well. /// /// Returns hashes of blocks pruned from storage. @@ -249,6 +347,10 @@ pub enum FetchError { /// Request to the Chain API subsystem failed. #[error("The chain API subsystem was unavailable")] ChainApiUnavailable, + + /// Request to the runtime API failed. + #[error("Runtime API error: {0}")] + RuntimeApi(#[from] runtime::Error), } /// Reasons a block header might have been unavailable. @@ -265,30 +367,92 @@ pub enum BlockHeaderUnavailableReason { struct FetchSummary { minimum_ancestor_number: BlockNumber, leaf_number: BlockNumber, - relevant_paras: Vec, } -async fn fetch_fresh_leaf_and_insert_ancestry( +// Request the min relay parents from prospective-parachains. +async fn fetch_min_relay_parents_from_prospective_parachains< + Sender: SubsystemSender, +>( leaf_hash: Hash, - block_info_storage: &mut HashMap, sender: &mut Sender, -) -> Result +) -> Result, FetchError> { + let (tx, rx) = oneshot::channel(); + sender + .send_message(ProspectiveParachainsMessage::GetMinimumRelayParents(leaf_hash, tx)) + .await; + + rx.await.map_err(|_| FetchError::ProspectiveParachainsUnavailable) +} + +// Request the min relay parent for the purposes of a collator, directly using ChainApi (where +// prospective-parachains is not available). +async fn fetch_min_relay_parents_for_collator( + leaf_hash: Hash, + leaf_number: BlockNumber, + sender: &mut Sender, +) -> Result, FetchError> where - Sender: SubsystemSender, - Sender: SubsystemSender, + Sender: SubsystemSender + + SubsystemSender + + SubsystemSender, { - let min_relay_parents_raw = { - let (tx, rx) = oneshot::channel(); - sender - .send_message(ProspectiveParachainsMessage::GetMinimumRelayParents(leaf_hash, tx)) - .await; + let Ok(ProspectiveParachainsMode::Enabled { allowed_ancestry_len, .. }) = + prospective_parachains_mode(sender, leaf_hash).await + else { + // This should never happen, leaves that don't have prospective parachains mode enabled + // should not use implicit view. + return Ok(None) + }; - match rx.await { - Ok(m) => m, - Err(_) => return Err(FetchError::ProspectiveParachainsUnavailable), + // Fetch the session of the leaf. We must make sure that we stop at the ancestor which has a + // different session index. + let required_session = + recv_runtime(request_session_index_for_child(leaf_hash, sender).await).await?; + + let mut min = leaf_number; + + // Fetch the ancestors, up to allowed_ancestry_len. + let (tx, rx) = oneshot::channel(); + sender + .send_message(ChainApiMessage::Ancestors { + hash: leaf_hash, + k: allowed_ancestry_len, + response_channel: tx, + }) + .await; + let hashes = rx + .await + .map_err(|_| FetchError::ChainApiUnavailable)? + .map_err(|err| FetchError::ChainApiError(leaf_hash, err))?; + + for hash in hashes { + // The relay chain cannot accept blocks backed from previous sessions, with + // potentially previous validators. This is a technical limitation we need to + // respect here. + let session = recv_runtime(request_session_index_for_child(hash, sender).await).await?; + + if session == required_session { + // We should never underflow here, the ChainAPI stops at genesis block. + min = min.saturating_sub(1); + } else { + break } - }; + } + + Ok(Some(min)) +} +async fn fetch_fresh_leaf_and_insert_ancestry( + leaf_hash: Hash, + block_info_storage: &mut HashMap, + sender: &mut Sender, + collating_for: Option, +) -> Result +where + Sender: SubsystemSender + + SubsystemSender + + SubsystemSender, +{ let leaf_header = { let (tx, rx) = oneshot::channel(); sender.send_message(ChainApiMessage::BlockHeader(leaf_hash, tx)).await; @@ -313,8 +477,18 @@ where } }; - let min_min = min_relay_parents_raw.iter().map(|x| x.1).min().unwrap_or(leaf_header.number); - let relevant_paras = min_relay_parents_raw.iter().map(|x| x.0).collect(); + // If the node is a collator, bypass prospective-parachains. We're only interested in the one + // paraid and the subsystem is not present. + let min_relay_parents = if let Some(para_id) = collating_for { + fetch_min_relay_parents_for_collator(leaf_hash, leaf_header.number, sender) + .await? + .map(|x| vec![(para_id, x)]) + .unwrap_or_default() + } else { + fetch_min_relay_parents_from_prospective_parachains(leaf_hash, sender).await? + }; + + let min_min = min_relay_parents.iter().map(|x| x.1).min().unwrap_or(leaf_header.number); let expected_ancestry_len = (leaf_header.number.saturating_sub(min_min) as usize) + 1; let ancestry = if leaf_header.number > 0 { @@ -380,14 +554,11 @@ where vec![leaf_hash] }; - let fetched_ancestry = FetchSummary { - minimum_ancestor_number: min_min, - leaf_number: leaf_header.number, - relevant_paras, - }; + let fetched_ancestry = + FetchSummary { minimum_ancestor_number: min_min, leaf_number: leaf_header.number }; let allowed_relay_parents = AllowedRelayParents { - minimum_relay_parents: min_relay_parents_raw.iter().cloned().collect(), + minimum_relay_parents: min_relay_parents.into_iter().collect(), allowed_relay_parents_contiguous: ancestry, }; @@ -408,12 +579,12 @@ mod tests { use crate::TimeoutExt; use assert_matches::assert_matches; use futures::future::{join, FutureExt}; - use polkadot_node_subsystem::AllMessages; + use polkadot_node_subsystem::{messages::RuntimeApiRequest, AllMessages}; use polkadot_node_subsystem_test_helpers::{ make_subsystem_context, TestSubsystemContextHandle, }; use polkadot_overseer::SubsystemContext; - use polkadot_primitives::Header; + use polkadot_primitives::{AsyncBackingParams, Header}; use sp_core::testing::TaskExecutor; use std::time::Duration; @@ -514,6 +685,71 @@ mod tests { ); } + async fn assert_async_backing_params_request( + virtual_overseer: &mut VirtualOverseer, + leaf: Hash, + params: AsyncBackingParams, + ) { + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + leaf_hash, + RuntimeApiRequest::AsyncBackingParams( + tx + ) + ) + ) => { + assert_eq!(leaf, leaf_hash, "received unexpected leaf hash"); + tx.send(Ok(params)).unwrap(); + } + ); + } + + async fn assert_session_index_request( + virtual_overseer: &mut VirtualOverseer, + leaf: Hash, + session: u32, + ) { + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::RuntimeApi( + RuntimeApiMessage::Request( + leaf_hash, + RuntimeApiRequest::SessionIndexForChild( + tx + ) + ) + ) => { + assert_eq!(leaf, leaf_hash, "received unexpected leaf hash"); + tx.send(Ok(session)).unwrap(); + } + ); + } + + async fn assert_ancestors_request( + virtual_overseer: &mut VirtualOverseer, + leaf: Hash, + expected_ancestor_len: u32, + response: Vec, + ) { + assert_matches!( + overseer_recv(virtual_overseer).await, + AllMessages::ChainApi( + ChainApiMessage::Ancestors { + hash: leaf_hash, + k, + response_channel: tx + } + ) => { + assert_eq!(leaf, leaf_hash, "received unexpected leaf hash"); + assert_eq!(k, expected_ancestor_len as usize); + + tx.send(Ok(response)).unwrap(); + } + ); + } + #[test] fn construct_fresh_view() { let pool = TaskExecutor::new(); @@ -521,6 +757,8 @@ mod tests { let mut view = View::default(); + assert_eq!(view.collating_for, None); + // Chain B. const PARA_A_MIN_PARENT: u32 = 4; const PARA_B_MIN_PARENT: u32 = 3; @@ -528,15 +766,17 @@ mod tests { let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT), (PARA_B, PARA_B_MIN_PARENT)]; let leaf = CHAIN_B.last().unwrap(); + let leaf_idx = CHAIN_B.len() - 1; let min_min_idx = (PARA_B_MIN_PARENT - GENESIS_NUMBER - 1) as usize; let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| { - let paras = res.expect("`activate_leaf` timed out").unwrap(); - assert_eq!(paras, vec![PARA_A, PARA_B]); + res.expect("`activate_leaf` timed out").unwrap(); }); let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[leaf_idx..]).await; assert_min_relay_parents_request(&mut ctx_handle, leaf, prospective_response).await; - assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..]).await; + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..leaf_idx]) + .await; }; futures::executor::block_on(join(fut, overseer_fut)); @@ -558,6 +798,11 @@ mod tests { allowed_relay_parents.allowed_relay_parents_contiguous, expected_ancestry ); + + assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..])); + assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..(PARA_A_MIN_PARENT - 1) as usize])); + assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)), Some(&expected_ancestry[..])); + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty()); } ); @@ -566,18 +811,188 @@ mod tests { let prospective_response = vec![(PARA_C, PARA_C_MIN_PARENT)]; let leaf = CHAIN_A.last().unwrap(); let blocks = [&[GENESIS_HASH], CHAIN_A].concat(); + let leaf_idx = blocks.len() - 1; let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| { - let paras = res.expect("`activate_leaf` timed out").unwrap(); - assert_eq!(paras, vec![PARA_C]); + res.expect("`activate_leaf` timed out").unwrap(); }); let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[leaf_idx..]).await; assert_min_relay_parents_request(&mut ctx_handle, leaf, prospective_response).await; - assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks).await; + assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[..leaf_idx]).await; }; futures::executor::block_on(join(fut, overseer_fut)); assert_eq!(view.leaves.len(), 2); + + let leaf_info = + view.block_info_storage.get(leaf).expect("block must be present in storage"); + assert_matches!( + leaf_info.maybe_allowed_relay_parents, + Some(ref allowed_relay_parents) => { + assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_C], GENESIS_NUMBER); + let expected_ancestry: Vec = + blocks[..].iter().rev().copied().collect(); + assert_eq!( + allowed_relay_parents.allowed_relay_parents_contiguous, + expected_ancestry + ); + + assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..])); + assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)), Some(&expected_ancestry[..])); + + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)).unwrap().is_empty()); + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty()); + } + ); + } + + #[test] + fn construct_fresh_view_single_para() { + let pool = TaskExecutor::new(); + let (mut ctx, mut ctx_handle) = make_subsystem_context::(pool); + + let mut view = View::new(Some(PARA_A)); + + assert_eq!(view.collating_for, Some(PARA_A)); + + // Chain B. + const PARA_A_MIN_PARENT: u32 = 4; + + let current_session = 2; + + let leaf = CHAIN_B.last().unwrap(); + let leaf_idx = CHAIN_B.len() - 1; + let min_min_idx = (PARA_A_MIN_PARENT - GENESIS_NUMBER - 1) as usize; + + let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| { + res.expect("`activate_leaf` timed out").unwrap(); + }); + let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[leaf_idx..]).await; + + assert_async_backing_params_request( + &mut ctx_handle, + *leaf, + AsyncBackingParams { + max_candidate_depth: 0, + allowed_ancestry_len: PARA_A_MIN_PARENT, + }, + ) + .await; + + assert_session_index_request(&mut ctx_handle, *leaf, current_session).await; + + assert_ancestors_request( + &mut ctx_handle, + *leaf, + PARA_A_MIN_PARENT, + CHAIN_B[min_min_idx..leaf_idx].iter().copied().rev().collect(), + ) + .await; + + for hash in CHAIN_B[min_min_idx..leaf_idx].into_iter().rev() { + assert_session_index_request(&mut ctx_handle, *hash, current_session).await; + } + + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_min_idx..leaf_idx]) + .await; + }; + futures::executor::block_on(join(fut, overseer_fut)); + + for i in min_min_idx..(CHAIN_B.len() - 1) { + // No allowed relay parents constructed for ancestry. + assert!(view.known_allowed_relay_parents_under(&CHAIN_B[i], None).is_none()); + } + + let leaf_info = + view.block_info_storage.get(leaf).expect("block must be present in storage"); + assert_matches!( + leaf_info.maybe_allowed_relay_parents, + Some(ref allowed_relay_parents) => { + assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_A], PARA_A_MIN_PARENT); + let expected_ancestry: Vec = + CHAIN_B[min_min_idx..].iter().rev().copied().collect(); + assert_eq!( + allowed_relay_parents.allowed_relay_parents_contiguous, + expected_ancestry + ); + + assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..])); + assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..])); + + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty()); + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty()); + } + ); + + // Suppose the whole test chain A is allowed up to genesis for para A, but the genesis block + // is in a different session. + let leaf = CHAIN_A.last().unwrap(); + let blocks = [&[GENESIS_HASH], CHAIN_A].concat(); + let leaf_idx = blocks.len() - 1; + + let fut = view.activate_leaf(ctx.sender(), *leaf).timeout(TIMEOUT).map(|res| { + res.expect("`activate_leaf` timed out").unwrap(); + }); + + let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[leaf_idx..]).await; + + assert_async_backing_params_request( + &mut ctx_handle, + *leaf, + AsyncBackingParams { + max_candidate_depth: 0, + allowed_ancestry_len: blocks.len() as u32, + }, + ) + .await; + + assert_session_index_request(&mut ctx_handle, *leaf, current_session).await; + + assert_ancestors_request( + &mut ctx_handle, + *leaf, + blocks.len() as u32, + blocks[..leaf_idx].iter().rev().copied().collect(), + ) + .await; + + for hash in blocks[1..leaf_idx].into_iter().rev() { + assert_session_index_request(&mut ctx_handle, *hash, current_session).await; + } + + assert_session_index_request(&mut ctx_handle, GENESIS_HASH, 0).await; + + // We won't request for the genesis block + assert_block_header_requests(&mut ctx_handle, CHAIN_A, &blocks[1..leaf_idx]).await; + }; + + futures::executor::block_on(join(fut, overseer_fut)); + + assert_eq!(view.leaves.len(), 2); + + let leaf_info = + view.block_info_storage.get(leaf).expect("block must be present in storage"); + assert_matches!( + leaf_info.maybe_allowed_relay_parents, + Some(ref allowed_relay_parents) => { + assert_eq!(allowed_relay_parents.minimum_relay_parents[&PARA_A], 1); + let expected_ancestry: Vec = + CHAIN_A[..].iter().rev().copied().collect(); + assert_eq!( + allowed_relay_parents.allowed_relay_parents_contiguous, + expected_ancestry + ); + + assert_eq!(view.known_allowed_relay_parents_under(&leaf, None), Some(&expected_ancestry[..])); + assert_eq!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_A)), Some(&expected_ancestry[..])); + + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_B)).unwrap().is_empty()); + assert!(view.known_allowed_relay_parents_under(&leaf, Some(PARA_C)).unwrap().is_empty()); + } + ); } #[test] @@ -595,15 +1010,20 @@ mod tests { let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT)]; let fut = view.activate_leaf(ctx.sender(), leaf_a).timeout(TIMEOUT).map(|res| { - let paras = res.expect("`activate_leaf` timed out").unwrap(); - assert_eq!(paras, vec![PARA_A]); + res.expect("`activate_leaf` timed out").unwrap(); }); let overseer_fut = async { + assert_block_header_requests( + &mut ctx_handle, + CHAIN_B, + &CHAIN_B[(leaf_a_number - 1)..leaf_a_number], + ) + .await; assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await; assert_block_header_requests( &mut ctx_handle, CHAIN_B, - &CHAIN_B[min_min_idx..leaf_a_number], + &CHAIN_B[min_min_idx..(leaf_a_number - 1)], ) .await; }; @@ -617,15 +1037,20 @@ mod tests { let prospective_response = vec![(PARA_B, PARA_B_MIN_PARENT)]; let fut = view.activate_leaf(ctx.sender(), leaf_b).timeout(TIMEOUT).map(|res| { - let paras = res.expect("`activate_leaf` timed out").unwrap(); - assert_eq!(paras, vec![PARA_B]); + res.expect("`activate_leaf` timed out").unwrap(); }); let overseer_fut = async { + assert_block_header_requests( + &mut ctx_handle, + CHAIN_B, + &CHAIN_B[(leaf_b_number - 1)..leaf_b_number], + ) + .await; assert_min_relay_parents_request(&mut ctx_handle, &leaf_b, prospective_response).await; assert_block_header_requests( &mut ctx_handle, CHAIN_B, - &CHAIN_B[leaf_a_number..leaf_b_number], // Note the expected range. + &CHAIN_B[leaf_a_number..(leaf_b_number - 1)], // Note the expected range. ) .await; }; @@ -665,13 +1090,15 @@ mod tests { .timeout(TIMEOUT) .map(|res| res.unwrap().unwrap()); let overseer_fut = async { - assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await; assert_block_header_requests( &mut ctx_handle, CHAIN_B, - &CHAIN_B[min_a_idx..=leaf_a_idx], + &CHAIN_B[leaf_a_idx..(leaf_a_idx + 1)], ) .await; + assert_min_relay_parents_request(&mut ctx_handle, &leaf_a, prospective_response).await; + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &CHAIN_B[min_a_idx..leaf_a_idx]) + .await; }; futures::executor::block_on(join(fut, overseer_fut)); @@ -689,8 +1116,11 @@ mod tests { .timeout(TIMEOUT) .map(|res| res.expect("`activate_leaf` timed out").unwrap()); let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &blocks[(blocks.len() - 1)..]) + .await; assert_min_relay_parents_request(&mut ctx_handle, &leaf_b, prospective_response).await; - assert_block_header_requests(&mut ctx_handle, CHAIN_B, blocks).await; + assert_block_header_requests(&mut ctx_handle, CHAIN_B, &blocks[..(blocks.len() - 1)]) + .await; }; futures::executor::block_on(join(fut, overseer_fut)); @@ -721,19 +1151,18 @@ mod tests { let prospective_response = vec![(PARA_A, PARA_A_MIN_PARENT)]; let fut = view.activate_leaf(ctx.sender(), GENESIS_HASH).timeout(TIMEOUT).map(|res| { - let paras = res.expect("`activate_leaf` timed out").unwrap(); - assert_eq!(paras, vec![PARA_A]); + res.expect("`activate_leaf` timed out").unwrap(); }); let overseer_fut = async { + assert_block_header_requests(&mut ctx_handle, &[GENESIS_HASH], &[GENESIS_HASH]).await; assert_min_relay_parents_request(&mut ctx_handle, &GENESIS_HASH, prospective_response) .await; - assert_block_header_requests(&mut ctx_handle, &[GENESIS_HASH], &[GENESIS_HASH]).await; }; futures::executor::block_on(join(fut, overseer_fut)); assert_matches!( view.known_allowed_relay_parents_under(&GENESIS_HASH, None), - Some(hashes) if !hashes.is_empty() + Some(hashes) if hashes == &[GENESIS_HASH] ); } } diff --git a/polkadot/node/subsystem-util/src/inclusion_emulator/mod.rs b/polkadot/node/subsystem-util/src/inclusion_emulator/mod.rs index d38d838fedefac643253528ab99d0035eeae55da..0c3b40743495c0d219b79a1a3e19f915a1c59fed 100644 --- a/polkadot/node/subsystem-util/src/inclusion_emulator/mod.rs +++ b/polkadot/node/subsystem-util/src/inclusion_emulator/mod.rs @@ -39,8 +39,8 @@ /// /// # Usage /// -/// It's expected that the users of this module will be building up trees of -/// [`Fragment`]s and consistently pruning and adding to the tree. +/// It's expected that the users of this module will be building up chains or trees of +/// [`Fragment`]s and consistently pruning and adding to them. /// /// ## Operating Constraints /// @@ -54,72 +54,39 @@ /// make an intelligent prediction about what might be accepted in the future based on /// prior fragments that also exist off-chain. /// -/// ## Fragment Trees +/// ## Fragment Chains /// -/// As the relay-chain grows, some predictions come true and others come false. -/// And new predictions get made. These three changes correspond distinctly to the -/// 3 primary operations on fragment trees. -/// -/// A fragment tree is a mental model for thinking about a forking series of predictions -/// about a single parachain. There may be one or more fragment trees per parachain. -/// -/// In expectation, most parachains will have a plausibly-unique authorship method which means -/// that they should really be much closer to fragment-chains, maybe with an occasional fork. -/// -/// Avoiding fragment-tree blowup is beyond the scope of this module. -/// -/// ### Pruning Fragment Trees -/// -/// When the relay-chain advances, we want to compare the new constraints of that relay-parent -/// to the roots of the fragment trees we have. There are 3 cases: -/// -/// 1. The root fragment is still valid under the new constraints. In this case, we do nothing. -/// This is the "prediction still uncertain" case. -/// -/// 2. The root fragment is invalid under the new constraints because it has been subsumed by -/// the relay-chain. In this case, we can discard the root and split & re-root the fragment -/// tree under its descendants and compare to the new constraints again. This is the -/// "prediction came true" case. -/// -/// 3. The root fragment is invalid under the new constraints because a competing parachain -/// block has been included or it would never be accepted for some other reason. In this -/// case we can discard the entire fragment tree. This is the "prediction came false" case. +/// For the sake of this module, we don't care how higher-level code is managing parachain +/// fragments, whether or not they're kept as a chain or tree. In reality, +/// prospective-parachains is maintaining for every active leaf, a chain of the "best" backable +/// candidates and a storage of potential candidates which may be added to this chain in the +/// future. /// -/// This is all a bit of a simplification because it assumes that the relay-chain advances -/// without forks and is finalized instantly. In practice, the set of fragment-trees needs to -/// be observable from the perspective of a few different possible forks of the relay-chain and -/// not pruned too eagerly. -/// -/// Note that the fragments themselves don't need to change and the only thing we care about -/// is whether the predictions they represent are still valid. -/// -/// ### Extending Fragment Trees -/// -/// As predictions fade into the past, new ones should be stacked on top. +/// As the relay-chain grows, some predictions come true and others come false. +/// And new predictions get made. Higher-level code is responsible for adding and pruning the +/// fragments chains. /// -/// Every new relay-chain block is an opportunity to make a new prediction about the future. -/// Higher-level logic should select the leaves of the fragment-trees to build upon or whether -/// to create a new fragment-tree. +/// Avoiding fragment-chain blowup is beyond the scope of this module. Higher-level must ensure +/// proper spam protection. /// /// ### Code Upgrades /// /// Code upgrades are the main place where this emulation fails. The on-chain PVF upgrade /// scheduling logic is very path-dependent and intricate so we just assume that code upgrades -/// can't be initiated and applied within a single fragment-tree. Fragment-trees aren't deep, -/// in practice and code upgrades are fairly rare. So what's likely to happen around code -/// upgrades is that the entire fragment-tree has to get discarded at some point. +/// can't be initiated and applied within a single fragment-chain. Fragment-chains aren't deep, +/// in practice (bounded by a linear function of the the number of cores assigned to a +/// parachain) and code upgrades are fairly rare. So what's likely to happen around code +/// upgrades is that the entire fragment-chain has to get discarded at some point. /// /// That means a few blocks of execution time lost, which is not a big deal for code upgrades /// in practice at most once every few weeks. +use polkadot_node_subsystem::messages::HypotheticalCandidate; use polkadot_primitives::{ async_backing::Constraints as PrimitiveConstraints, BlockNumber, CandidateCommitments, - CollatorId, CollatorSignature, Hash, HeadData, Id as ParaId, PersistedValidationData, - UpgradeRestriction, ValidationCodeHash, -}; -use std::{ - borrow::{Borrow, Cow}, - collections::HashMap, + CandidateHash, Hash, HeadData, Id as ParaId, PersistedValidationData, UpgradeRestriction, + ValidationCodeHash, }; +use std::{collections::HashMap, sync::Arc}; /// Constraints on inbound HRMP channels. #[derive(Debug, Clone, PartialEq)] @@ -519,18 +486,13 @@ impl ConstraintModifications { /// The prospective candidate. /// /// This comprises the key information that represent a candidate -/// without pinning it to a particular session. For example, everything -/// to do with the collator's signature and commitments are represented -/// here. But the erasure-root is not. This means that prospective candidates +/// without pinning it to a particular session. For example commitments are +/// represented here. But the erasure-root is not. This means that prospective candidates /// are not correlated to any session in particular. #[derive(Debug, Clone, PartialEq)] -pub struct ProspectiveCandidate<'a> { +pub struct ProspectiveCandidate { /// The commitments to the output of the execution. - pub commitments: Cow<'a, CandidateCommitments>, - /// The collator that created the candidate. - pub collator: CollatorId, - /// The signature of the collator on the payload. - pub collator_signature: CollatorSignature, + pub commitments: CandidateCommitments, /// The persisted validation data used to create the candidate. pub persisted_validation_data: PersistedValidationData, /// The hash of the PoV. @@ -539,32 +501,6 @@ pub struct ProspectiveCandidate<'a> { pub validation_code_hash: ValidationCodeHash, } -impl<'a> ProspectiveCandidate<'a> { - fn into_owned(self) -> ProspectiveCandidate<'static> { - ProspectiveCandidate { commitments: Cow::Owned(self.commitments.into_owned()), ..self } - } - - /// Partially clone the prospective candidate, but borrow the - /// parts which are potentially heavy. - pub fn partial_clone(&self) -> ProspectiveCandidate { - ProspectiveCandidate { - commitments: Cow::Borrowed(self.commitments.borrow()), - collator: self.collator.clone(), - collator_signature: self.collator_signature.clone(), - persisted_validation_data: self.persisted_validation_data.clone(), - pov_hash: self.pov_hash, - validation_code_hash: self.validation_code_hash, - } - } -} - -#[cfg(test)] -impl ProspectiveCandidate<'static> { - fn commitments_mut(&mut self) -> &mut CandidateCommitments { - self.commitments.to_mut() - } -} - /// Kinds of errors with the validity of a fragment. #[derive(Debug, Clone, PartialEq)] pub enum FragmentValidityError { @@ -618,19 +554,19 @@ pub enum FragmentValidityError { /// This is a type which guarantees that the candidate is valid under the /// operating constraints. #[derive(Debug, Clone, PartialEq)] -pub struct Fragment<'a> { +pub struct Fragment { /// The new relay-parent. relay_parent: RelayChainBlockInfo, /// The constraints this fragment is operating under. operating_constraints: Constraints, /// The core information about the prospective candidate. - candidate: ProspectiveCandidate<'a>, + candidate: Arc, /// Modifications to the constraints based on the outputs of /// the candidate. modifications: ConstraintModifications, } -impl<'a> Fragment<'a> { +impl Fragment { /// Create a new fragment. /// /// This fails if the fragment isn't in line with the operating @@ -642,10 +578,29 @@ impl<'a> Fragment<'a> { pub fn new( relay_parent: RelayChainBlockInfo, operating_constraints: Constraints, - candidate: ProspectiveCandidate<'a>, + candidate: Arc, ) -> Result { + let modifications = Self::check_against_constraints( + &relay_parent, + &operating_constraints, + &candidate.commitments, + &candidate.validation_code_hash, + &candidate.persisted_validation_data, + )?; + + Ok(Fragment { relay_parent, operating_constraints, candidate, modifications }) + } + + /// Check the candidate against the operating constrains and return the constraint modifications + /// made by this candidate. + pub fn check_against_constraints( + relay_parent: &RelayChainBlockInfo, + operating_constraints: &Constraints, + commitments: &CandidateCommitments, + validation_code_hash: &ValidationCodeHash, + persisted_validation_data: &PersistedValidationData, + ) -> Result { let modifications = { - let commitments = &candidate.commitments; ConstraintModifications { required_parent: Some(commitments.head_data.clone()), hrmp_watermark: Some({ @@ -689,11 +644,13 @@ impl<'a> Fragment<'a> { validate_against_constraints( &operating_constraints, &relay_parent, - &candidate, + commitments, + persisted_validation_data, + validation_code_hash, &modifications, )?; - Ok(Fragment { relay_parent, operating_constraints, candidate, modifications }) + Ok(modifications) } /// Access the relay parent information. @@ -707,39 +664,27 @@ impl<'a> Fragment<'a> { } /// Access the underlying prospective candidate. - pub fn candidate(&self) -> &ProspectiveCandidate<'a> { + pub fn candidate(&self) -> &ProspectiveCandidate { &self.candidate } + /// Get a cheap ref-counted copy of the underlying prospective candidate. + pub fn candidate_clone(&self) -> Arc { + self.candidate.clone() + } + /// Modifications to constraints based on the outputs of the candidate. pub fn constraint_modifications(&self) -> &ConstraintModifications { &self.modifications } - - /// Convert the fragment into an owned variant. - pub fn into_owned(self) -> Fragment<'static> { - Fragment { candidate: self.candidate.into_owned(), ..self } - } - - /// Validate this fragment against some set of constraints - /// instead of the operating constraints. - pub fn validate_against_constraints( - &self, - constraints: &Constraints, - ) -> Result<(), FragmentValidityError> { - validate_against_constraints( - constraints, - &self.relay_parent, - &self.candidate, - &self.modifications, - ) - } } fn validate_against_constraints( constraints: &Constraints, relay_parent: &RelayChainBlockInfo, - candidate: &ProspectiveCandidate, + commitments: &CandidateCommitments, + persisted_validation_data: &PersistedValidationData, + validation_code_hash: &ValidationCodeHash, modifications: &ConstraintModifications, ) -> Result<(), FragmentValidityError> { let expected_pvd = PersistedValidationData { @@ -749,17 +694,17 @@ fn validate_against_constraints( max_pov_size: constraints.max_pov_size as u32, }; - if expected_pvd != candidate.persisted_validation_data { + if expected_pvd != *persisted_validation_data { return Err(FragmentValidityError::PersistedValidationDataMismatch( expected_pvd, - candidate.persisted_validation_data.clone(), + persisted_validation_data.clone(), )) } - if constraints.validation_code_hash != candidate.validation_code_hash { + if constraints.validation_code_hash != *validation_code_hash { return Err(FragmentValidityError::ValidationCodeMismatch( constraints.validation_code_hash, - candidate.validation_code_hash, + *validation_code_hash, )) } @@ -770,7 +715,7 @@ fn validate_against_constraints( )) } - if candidate.commitments.new_validation_code.is_some() { + if commitments.new_validation_code.is_some() { match constraints.upgrade_restriction { None => {}, Some(UpgradeRestriction::Present) => @@ -778,11 +723,8 @@ fn validate_against_constraints( } } - let announced_code_size = candidate - .commitments - .new_validation_code - .as_ref() - .map_or(0, |code| code.0.len()); + let announced_code_size = + commitments.new_validation_code.as_ref().map_or(0, |code| code.0.len()); if announced_code_size > constraints.max_code_size { return Err(FragmentValidityError::CodeSizeTooLarge( @@ -801,17 +743,17 @@ fn validate_against_constraints( } } - if candidate.commitments.horizontal_messages.len() > constraints.max_hrmp_num_per_candidate { + if commitments.horizontal_messages.len() > constraints.max_hrmp_num_per_candidate { return Err(FragmentValidityError::HrmpMessagesPerCandidateOverflow { messages_allowed: constraints.max_hrmp_num_per_candidate, - messages_submitted: candidate.commitments.horizontal_messages.len(), + messages_submitted: commitments.horizontal_messages.len(), }) } - if candidate.commitments.upward_messages.len() > constraints.max_ump_num_per_candidate { + if commitments.upward_messages.len() > constraints.max_ump_num_per_candidate { return Err(FragmentValidityError::UmpMessagesPerCandidateOverflow { messages_allowed: constraints.max_ump_num_per_candidate, - messages_submitted: candidate.commitments.upward_messages.len(), + messages_submitted: commitments.upward_messages.len(), }) } @@ -820,13 +762,59 @@ fn validate_against_constraints( .map_err(FragmentValidityError::OutputsInvalid) } +/// Trait for a hypothetical or concrete candidate, as needed when assessing the validity of a +/// potential candidate. +pub trait HypotheticalOrConcreteCandidate { + /// Return a reference to the candidate commitments, if present. + fn commitments(&self) -> Option<&CandidateCommitments>; + /// Return a reference to the persisted validation data, if present. + fn persisted_validation_data(&self) -> Option<&PersistedValidationData>; + /// Return a reference to the validation code hash, if present. + fn validation_code_hash(&self) -> Option<&ValidationCodeHash>; + /// Return the parent head hash. + fn parent_head_data_hash(&self) -> Hash; + /// Return the output head hash, if present. + fn output_head_data_hash(&self) -> Option; + /// Return the relay parent hash. + fn relay_parent(&self) -> Hash; + /// Return the candidate hash. + fn candidate_hash(&self) -> CandidateHash; +} + +impl HypotheticalOrConcreteCandidate for HypotheticalCandidate { + fn commitments(&self) -> Option<&CandidateCommitments> { + self.commitments() + } + + fn persisted_validation_data(&self) -> Option<&PersistedValidationData> { + self.persisted_validation_data() + } + + fn validation_code_hash(&self) -> Option<&ValidationCodeHash> { + self.validation_code_hash() + } + + fn parent_head_data_hash(&self) -> Hash { + self.parent_head_data_hash() + } + + fn output_head_data_hash(&self) -> Option { + self.output_head_data_hash() + } + + fn relay_parent(&self) -> Hash { + self.relay_parent() + } + + fn candidate_hash(&self) -> CandidateHash { + self.candidate_hash() + } +} + #[cfg(test)] mod tests { use super::*; - use polkadot_primitives::{ - CollatorPair, HorizontalMessages, OutboundHrmpMessage, ValidationCode, - }; - use sp_application_crypto::Pair; + use polkadot_primitives::{HorizontalMessages, OutboundHrmpMessage, ValidationCode}; #[test] fn stack_modifications() { @@ -1184,23 +1172,16 @@ mod tests { fn make_candidate( constraints: &Constraints, relay_parent: &RelayChainBlockInfo, - ) -> ProspectiveCandidate<'static> { - let collator_pair = CollatorPair::generate().0; - let collator = collator_pair.public(); - - let sig = collator_pair.sign(b"blabla".as_slice()); - + ) -> ProspectiveCandidate { ProspectiveCandidate { - commitments: Cow::Owned(CandidateCommitments { + commitments: CandidateCommitments { upward_messages: Default::default(), horizontal_messages: Default::default(), new_validation_code: None, head_data: HeadData::from(vec![1, 2, 3, 4, 5]), processed_downward_messages: 0, hrmp_watermark: relay_parent.number, - }), - collator, - collator_signature: sig, + }, persisted_validation_data: PersistedValidationData { parent_head: constraints.required_parent.clone(), relay_parent_number: relay_parent.number, @@ -1229,7 +1210,7 @@ mod tests { candidate.validation_code_hash = got_code; assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::ValidationCodeMismatch(expected_code, got_code,)), ) } @@ -1261,7 +1242,7 @@ mod tests { let got_pvd = candidate.persisted_validation_data.clone(); assert_eq!( - Fragment::new(relay_parent_b, constraints, candidate), + Fragment::new(relay_parent_b, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::PersistedValidationDataMismatch(expected_pvd, got_pvd,)), ); } @@ -1278,10 +1259,10 @@ mod tests { let mut candidate = make_candidate(&constraints, &relay_parent); let max_code_size = constraints.max_code_size; - candidate.commitments_mut().new_validation_code = Some(vec![0; max_code_size + 1].into()); + candidate.commitments.new_validation_code = Some(vec![0; max_code_size + 1].into()); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::CodeSizeTooLarge(max_code_size, max_code_size + 1,)), ); } @@ -1298,7 +1279,7 @@ mod tests { let candidate = make_candidate(&constraints, &relay_parent); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::RelayParentTooOld(5, 3,)), ); } @@ -1317,7 +1298,7 @@ mod tests { let max_hrmp = constraints.max_hrmp_num_per_candidate; candidate - .commitments_mut() + .commitments .horizontal_messages .try_extend((0..max_hrmp + 1).map(|i| OutboundHrmpMessage { recipient: ParaId::from(i as u32), @@ -1326,7 +1307,7 @@ mod tests { .unwrap(); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::HrmpMessagesPerCandidateOverflow { messages_allowed: max_hrmp, messages_submitted: max_hrmp + 1, @@ -1346,22 +1327,36 @@ mod tests { let mut candidate = make_candidate(&constraints, &relay_parent); // Empty dmp queue is ok. - assert!(Fragment::new(relay_parent.clone(), constraints.clone(), candidate.clone()).is_ok()); + assert!(Fragment::new( + relay_parent.clone(), + constraints.clone(), + Arc::new(candidate.clone()) + ) + .is_ok()); // Unprocessed message that was sent later is ok. constraints.dmp_remaining_messages = vec![relay_parent.number + 1]; - assert!(Fragment::new(relay_parent.clone(), constraints.clone(), candidate.clone()).is_ok()); + assert!(Fragment::new( + relay_parent.clone(), + constraints.clone(), + Arc::new(candidate.clone()) + ) + .is_ok()); for block_number in 0..=relay_parent.number { constraints.dmp_remaining_messages = vec![block_number]; assert_eq!( - Fragment::new(relay_parent.clone(), constraints.clone(), candidate.clone()), + Fragment::new( + relay_parent.clone(), + constraints.clone(), + Arc::new(candidate.clone()) + ), Err(FragmentValidityError::DmpAdvancementRule), ); } - candidate.commitments.to_mut().processed_downward_messages = 1; - assert!(Fragment::new(relay_parent, constraints, candidate).is_ok()); + candidate.commitments.processed_downward_messages = 1; + assert!(Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())).is_ok()); } #[test] @@ -1379,13 +1374,12 @@ mod tests { candidate .commitments - .to_mut() .upward_messages .try_extend((0..max_ump + 1).map(|i| vec![i as u8])) .unwrap(); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::UmpMessagesPerCandidateOverflow { messages_allowed: max_ump, messages_submitted: max_ump + 1, @@ -1405,10 +1399,10 @@ mod tests { let mut candidate = make_candidate(&constraints, &relay_parent); constraints.upgrade_restriction = Some(UpgradeRestriction::Present); - candidate.commitments_mut().new_validation_code = Some(ValidationCode(vec![1, 2, 3])); + candidate.commitments.new_validation_code = Some(ValidationCode(vec![1, 2, 3])); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::CodeUpgradeRestricted), ); } @@ -1424,23 +1418,23 @@ mod tests { let constraints = make_constraints(); let mut candidate = make_candidate(&constraints, &relay_parent); - candidate.commitments_mut().horizontal_messages = HorizontalMessages::truncate_from(vec![ + candidate.commitments.horizontal_messages = HorizontalMessages::truncate_from(vec![ OutboundHrmpMessage { recipient: ParaId::from(0 as u32), data: vec![1, 2, 3] }, OutboundHrmpMessage { recipient: ParaId::from(0 as u32), data: vec![4, 5, 6] }, ]); assert_eq!( - Fragment::new(relay_parent.clone(), constraints.clone(), candidate.clone()), + Fragment::new(relay_parent.clone(), constraints.clone(), Arc::new(candidate.clone())), Err(FragmentValidityError::HrmpMessagesDescendingOrDuplicate(1)), ); - candidate.commitments_mut().horizontal_messages = HorizontalMessages::truncate_from(vec![ + candidate.commitments.horizontal_messages = HorizontalMessages::truncate_from(vec![ OutboundHrmpMessage { recipient: ParaId::from(1 as u32), data: vec![1, 2, 3] }, OutboundHrmpMessage { recipient: ParaId::from(0 as u32), data: vec![4, 5, 6] }, ]); assert_eq!( - Fragment::new(relay_parent, constraints, candidate), + Fragment::new(relay_parent, constraints, Arc::new(candidate.clone())), Err(FragmentValidityError::HrmpMessagesDescendingOrDuplicate(1)), ); } diff --git a/polkadot/node/subsystem-util/src/lib.rs b/polkadot/node/subsystem-util/src/lib.rs index b93818070a183e43e71f327bcc1770a71fae1cb6..4bab4e80fe509dd9b0d15189773265ac374ccca8 100644 --- a/polkadot/node/subsystem-util/src/lib.rs +++ b/polkadot/node/subsystem-util/src/lib.rs @@ -25,31 +25,31 @@ #![warn(missing_docs)] +pub use overseer::{ + gen::{OrchestraError as OverseerError, Timeout}, + Subsystem, TimeoutExt, +}; use polkadot_node_subsystem::{ errors::{RuntimeApiError, SubsystemError}, messages::{RuntimeApiMessage, RuntimeApiRequest, RuntimeApiSender}, overseer, SubsystemSender, }; -use polkadot_primitives::{async_backing::BackingState, slashing, CoreIndex, ExecutorParams}; - -pub use overseer::{ - gen::{OrchestraError as OverseerError, Timeout}, - Subsystem, TimeoutExt, -}; pub use polkadot_node_metrics::{metrics, Metronome}; +use codec::Encode; use futures::channel::{mpsc, oneshot}; -use parity_scale_codec::Encode; use polkadot_primitives::{ - AsyncBackingParams, AuthorityDiscoveryId, CandidateEvent, CandidateHash, - CommittedCandidateReceipt, CoreState, EncodeAs, GroupIndex, GroupRotationInfo, Hash, - Id as ParaId, OccupiedCoreAssumption, PersistedValidationData, ScrapedOnChainVotes, - SessionIndex, SessionInfo, Signed, SigningContext, ValidationCode, ValidationCodeHash, - ValidatorId, ValidatorIndex, ValidatorSignature, + async_backing::BackingState, slashing, AsyncBackingParams, AuthorityDiscoveryId, + CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, EncodeAs, + ExecutorParams, GroupIndex, GroupRotationInfo, Hash, Id as ParaId, OccupiedCoreAssumption, + PersistedValidationData, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed, + SigningContext, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, + ValidatorSignature, }; pub use rand; +use runtime::get_disabled_validators_with_fallback; use sp_application_crypto::AppCrypto; use sp_core::ByteArray; use sp_keystore::{Error as KeystoreError, KeystorePtr}; @@ -58,19 +58,19 @@ use std::{ time::Duration, }; use thiserror::Error; -use vstaging::get_disabled_validators_with_fallback; +pub use determine_new_blocks::determine_new_blocks; pub use metered; pub use polkadot_node_network_protocol::MIN_GOSSIP_PEERS; -pub use determine_new_blocks::determine_new_blocks; - /// These reexports are required so that external crates can use the `delegated_subsystem` macro /// properly. pub mod reexports { pub use polkadot_overseer::gen::{SpawnedSubsystem, Spawner, Subsystem, SubsystemContext}; } +/// Helpers for the validator->chunk index mapping. +pub mod availability_chunks; /// A utility for managing the implicit view of the relay-chain derived from active /// leaves and the minimum allowed relay-parents that parachain candidates can have /// and be backed in those leaves' children. diff --git a/polkadot/node/subsystem-util/src/runtime/error.rs b/polkadot/node/subsystem-util/src/runtime/error.rs index 8751693b078a6797584ed59a2ebd3c320d87cd78..1111b119e95f5926321f7a09de6af02bcbc4acba 100644 --- a/polkadot/node/subsystem-util/src/runtime/error.rs +++ b/polkadot/node/subsystem-util/src/runtime/error.rs @@ -28,7 +28,7 @@ pub enum Error { /// Runtime API subsystem is down, which means we're shutting down. #[fatal] #[error("Runtime request got canceled")] - RuntimeRequestCanceled(oneshot::Canceled), + RuntimeRequestCanceled(#[from] oneshot::Canceled), /// Some request to the runtime failed. /// For example if we prune a block we're requesting info about. diff --git a/polkadot/node/subsystem-util/src/runtime/mod.rs b/polkadot/node/subsystem-util/src/runtime/mod.rs index 714384b32e37bcbd6ba7f077252fa23f50eac490..2f9d3ed7b4f40cb27e9061bb6fadd4749a4f3173 100644 --- a/polkadot/node/subsystem-util/src/runtime/mod.rs +++ b/polkadot/node/subsystem-util/src/runtime/mod.rs @@ -18,7 +18,7 @@ use schnellru::{ByLength, LruMap}; -use parity_scale_codec::Encode; +use codec::Encode; use sp_application_crypto::AppCrypto; use sp_core::crypto::ByteArray; use sp_keystore::{Keystore, KeystorePtr}; @@ -31,18 +31,21 @@ use polkadot_node_subsystem::{ use polkadot_node_subsystem_types::UnpinHandle; use polkadot_primitives::{ node_features::FeatureIndex, slashing, AsyncBackingParams, CandidateEvent, CandidateHash, - CoreState, EncodeAs, ExecutorParams, GroupIndex, GroupRotationInfo, Hash, IndexedVec, - NodeFeatures, OccupiedCore, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signed, - SigningContext, UncheckedSigned, ValidationCode, ValidationCodeHash, ValidatorId, - ValidatorIndex, LEGACY_MIN_BACKING_VOTES, + CoreIndex, CoreState, EncodeAs, ExecutorParams, GroupIndex, GroupRotationInfo, Hash, + Id as ParaId, IndexedVec, NodeFeatures, OccupiedCore, ScrapedOnChainVotes, SessionIndex, + SessionInfo, Signed, SigningContext, UncheckedSigned, ValidationCode, ValidationCodeHash, + ValidatorId, ValidatorIndex, LEGACY_MIN_BACKING_VOTES, }; +use std::collections::{BTreeMap, VecDeque}; + use crate::{ - request_async_backing_params, request_availability_cores, request_candidate_events, + has_required_runtime, request_async_backing_params, request_availability_cores, + request_candidate_events, request_claim_queue, request_disabled_validators, request_from_runtime, request_key_ownership_proof, request_on_chain_votes, request_session_executor_params, request_session_index_for_child, request_session_info, request_submit_report_dispute_lost, request_unapplied_slashes, request_validation_code_by_hash, - request_validator_groups, vstaging::get_disabled_validators_with_fallback, + request_validator_groups, }; /// Errors that can happen on runtime fetches. @@ -348,7 +351,7 @@ where pub async fn get_occupied_cores( sender: &mut Sender, relay_parent: Hash, -) -> Result> +) -> Result> where Sender: overseer::SubsystemSender, { @@ -356,9 +359,10 @@ where Ok(cores .into_iter() - .filter_map(|core_state| { + .enumerate() + .filter_map(|(core_index, core_state)| { if let CoreState::Occupied(occupied) = core_state { - Some(occupied) + Some((CoreIndex(core_index as u32), occupied)) } else { None } @@ -578,3 +582,98 @@ pub async fn request_node_features( res.map(Some) } } + +/// A snapshot of the runtime claim queue at an arbitrary relay chain block. +#[derive(Default)] +pub struct ClaimQueueSnapshot(pub BTreeMap>); + +impl From>> for ClaimQueueSnapshot { + fn from(claim_queue_snapshot: BTreeMap>) -> Self { + ClaimQueueSnapshot(claim_queue_snapshot) + } +} + +impl ClaimQueueSnapshot { + /// Returns the `ParaId` that has a claim for `core_index` at the specified `depth` in the + /// claim queue. A depth of `0` means the very next block. + pub fn get_claim_for(&self, core_index: CoreIndex, depth: usize) -> Option { + self.0.get(&core_index)?.get(depth).copied() + } + + /// Returns an iterator over all claimed cores and the claiming `ParaId` at the specified + /// `depth` in the claim queue. + pub fn iter_claims_at_depth( + &self, + depth: usize, + ) -> impl Iterator + '_ { + self.0 + .iter() + .filter_map(move |(core_index, paras)| Some((*core_index, *paras.get(depth)?))) + } + + /// Returns an iterator over all claims on the given core. + pub fn iter_claims_for_core( + &self, + core_index: &CoreIndex, + ) -> impl Iterator + '_ { + self.0.get(core_index).map(|c| c.iter()).into_iter().flatten() + } + + /// Returns an iterator over the whole claim queue. + pub fn iter_all_claims(&self) -> impl Iterator)> + '_ { + self.0.iter() + } +} + +// TODO: https://github.com/paritytech/polkadot-sdk/issues/1940 +/// Returns disabled validators list if the runtime supports it. Otherwise logs a debug messages and +/// returns an empty vec. +/// Once runtime ver `DISABLED_VALIDATORS_RUNTIME_REQUIREMENT` is released remove this function and +/// replace all usages with `request_disabled_validators` +pub async fn get_disabled_validators_with_fallback>( + sender: &mut Sender, + relay_parent: Hash, +) -> Result> { + let disabled_validators = if has_required_runtime( + sender, + relay_parent, + RuntimeApiRequest::DISABLED_VALIDATORS_RUNTIME_REQUIREMENT, + ) + .await + { + request_disabled_validators(relay_parent, sender) + .await + .await + .map_err(Error::RuntimeRequestCanceled)?? + } else { + gum::debug!(target: LOG_TARGET, "Runtime doesn't support `DisabledValidators` - continuing with an empty disabled validators set"); + vec![] + }; + + Ok(disabled_validators) +} + +/// Checks if the runtime supports `request_claim_queue` and attempts to fetch the claim queue. +/// Returns `ClaimQueueSnapshot` or `None` if claim queue API is not supported by runtime. +/// Any specific `RuntimeApiError` is bubbled up to the caller. +pub async fn fetch_claim_queue( + sender: &mut impl SubsystemSender, + relay_parent: Hash, +) -> Result> { + if has_required_runtime( + sender, + relay_parent, + RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT, + ) + .await + { + let res = request_claim_queue(relay_parent, sender) + .await + .await + .map_err(Error::RuntimeRequestCanceled)??; + Ok(Some(res.into())) + } else { + gum::trace!(target: LOG_TARGET, "Runtime doesn't support `request_claim_queue`"); + Ok(None) + } +} diff --git a/polkadot/node/subsystem-util/src/vstaging.rs b/polkadot/node/subsystem-util/src/vstaging.rs index b166a54f75c46ebfe4dd8d06af32a3dea3495b7a..b608bb416ff649a56a2aa6ef7131ebf77dcc0b8e 100644 --- a/polkadot/node/subsystem-util/src/vstaging.rs +++ b/polkadot/node/subsystem-util/src/vstaging.rs @@ -18,95 +18,3 @@ //! //! This module is intended to contain common boiler plate code handling unreleased runtime API //! calls. - -use std::collections::{BTreeMap, VecDeque}; - -use polkadot_node_subsystem_types::messages::{RuntimeApiMessage, RuntimeApiRequest}; -use polkadot_overseer::SubsystemSender; -use polkadot_primitives::{CoreIndex, Hash, Id as ParaId, ValidatorIndex}; - -use crate::{has_required_runtime, request_claim_queue, request_disabled_validators, runtime}; - -const LOG_TARGET: &'static str = "parachain::subsystem-util-vstaging"; - -/// A snapshot of the runtime claim queue at an arbitrary relay chain block. -#[derive(Default)] -pub struct ClaimQueueSnapshot(BTreeMap>); - -impl From>> for ClaimQueueSnapshot { - fn from(claim_queue_snapshot: BTreeMap>) -> Self { - ClaimQueueSnapshot(claim_queue_snapshot) - } -} - -impl ClaimQueueSnapshot { - /// Returns the `ParaId` that has a claim for `core_index` at the specified `depth` in the - /// claim queue. A depth of `0` means the very next block. - pub fn get_claim_for(&self, core_index: CoreIndex, depth: usize) -> Option { - self.0.get(&core_index)?.get(depth).copied() - } - - /// Returns an iterator over all claimed cores and the claiming `ParaId` at the specified - /// `depth` in the claim queue. - pub fn iter_claims_at_depth( - &self, - depth: usize, - ) -> impl Iterator + '_ { - self.0 - .iter() - .filter_map(move |(core_index, paras)| Some((*core_index, *paras.get(depth)?))) - } -} - -// TODO: https://github.com/paritytech/polkadot-sdk/issues/1940 -/// Returns disabled validators list if the runtime supports it. Otherwise logs a debug messages and -/// returns an empty vec. -/// Once runtime ver `DISABLED_VALIDATORS_RUNTIME_REQUIREMENT` is released remove this function and -/// replace all usages with `request_disabled_validators` -pub async fn get_disabled_validators_with_fallback>( - sender: &mut Sender, - relay_parent: Hash, -) -> Result, runtime::Error> { - let disabled_validators = if has_required_runtime( - sender, - relay_parent, - RuntimeApiRequest::DISABLED_VALIDATORS_RUNTIME_REQUIREMENT, - ) - .await - { - request_disabled_validators(relay_parent, sender) - .await - .await - .map_err(runtime::Error::RuntimeRequestCanceled)?? - } else { - gum::debug!(target: LOG_TARGET, "Runtime doesn't support `DisabledValidators` - continuing with an empty disabled validators set"); - vec![] - }; - - Ok(disabled_validators) -} - -/// Checks if the runtime supports `request_claim_queue` and attempts to fetch the claim queue. -/// Returns `ClaimQueueSnapshot` or `None` if claim queue API is not supported by runtime. -/// Any specific `RuntimeApiError` is bubbled up to the caller. -pub async fn fetch_claim_queue( - sender: &mut impl SubsystemSender, - relay_parent: Hash, -) -> Result, runtime::Error> { - if has_required_runtime( - sender, - relay_parent, - RuntimeApiRequest::CLAIM_QUEUE_RUNTIME_REQUIREMENT, - ) - .await - { - let res = request_claim_queue(relay_parent, sender) - .await - .await - .map_err(runtime::Error::RuntimeRequestCanceled)??; - Ok(Some(res.into())) - } else { - gum::trace!(target: LOG_TARGET, "Runtime doesn't support `request_claim_queue`"); - Ok(None) - } -} diff --git a/polkadot/node/subsystem/Cargo.toml b/polkadot/node/subsystem/Cargo.toml index c59c1f88e33995aef7578da58e28d086668f14ee..8edfea9e26bf5d2176b672c9d24bb1e0251b33ae 100644 --- a/polkadot/node/subsystem/Cargo.toml +++ b/polkadot/node/subsystem/Cargo.toml @@ -10,6 +10,6 @@ license.workspace = true workspace = true [dependencies] -polkadot-overseer = { path = "../overseer" } -polkadot-node-subsystem-types = { path = "../subsystem-types" } -polkadot-node-jaeger = { path = "../jaeger" } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-node-subsystem-types = { workspace = true, default-features = true } +polkadot-node-jaeger = { workspace = true, default-features = true } diff --git a/polkadot/node/test/client/Cargo.toml b/polkadot/node/test/client/Cargo.toml index 7db00404eb8eca049a6194d19e5e92e66325628c..587af659fbd2dfeb142c4f307ce71a92b0fae35b 100644 --- a/polkadot/node/test/client/Cargo.toml +++ b/polkadot/node/test/client/Cargo.toml @@ -10,35 +10,35 @@ license.workspace = true workspace = true [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } # Polkadot dependencies -polkadot-test-runtime = { path = "../../../runtime/test-runtime" } -polkadot-test-service = { path = "../service" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-node-subsystem = { path = "../../subsystem" } +polkadot-test-runtime = { workspace = true } +polkadot-test-service = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } # Substrate dependencies -substrate-test-client = { path = "../../../../substrate/test-utils/client" } -sc-service = { path = "../../../../substrate/client/service" } -sc-block-builder = { path = "../../../../substrate/client/block-builder" } -sc-consensus = { path = "../../../../substrate/client/consensus/common" } -sc-offchain = { path = "../../../../substrate/client/offchain" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-inherents = { path = "../../../../substrate/primitives/inherents" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-api = { path = "../../../../substrate/primitives/api" } -sp-timestamp = { path = "../../../../substrate/primitives/timestamp" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" } -sp-state-machine = { path = "../../../../substrate/primitives/state-machine" } -sp-io = { path = "../../../../substrate/primitives/io" } -frame-benchmarking = { path = "../../../../substrate/frame/benchmarking" } +substrate-test-client = { workspace = true } +sc-service = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-offchain = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +frame-benchmarking = { workspace = true, default-features = true } [dev-dependencies] -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -futures = "0.3.30" +sp-keyring = { workspace = true, default-features = true } +futures = { workspace = true } [features] runtime-benchmarks = [ diff --git a/polkadot/node/test/client/src/block_builder.rs b/polkadot/node/test/client/src/block_builder.rs index 57e6008917af9cf6a5ceb6d173f680f9d90e5ebb..71bcdaffac4e7e69c7614abe4c51a50bd1e8556e 100644 --- a/polkadot/node/test/client/src/block_builder.rs +++ b/polkadot/node/test/client/src/block_builder.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::Client; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use polkadot_primitives::{Block, InherentData as ParachainsInherentData}; use polkadot_test_runtime::UncheckedExtrinsic; use polkadot_test_service::GetLastTimestamp; diff --git a/polkadot/node/test/client/src/lib.rs b/polkadot/node/test/client/src/lib.rs index 6b205c09f2f3297cb8b53bfb62cc80a1ed25c3a7..498994d9a0a88bdc91b197949f2bcec8c424bdbb 100644 --- a/polkadot/node/test/client/src/lib.rs +++ b/polkadot/node/test/client/src/lib.rs @@ -102,7 +102,7 @@ mod tests { #[test] fn ensure_test_client_can_build_and_import_block() { - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let block_builder = client.init_polkadot_block_builder(); let block = block_builder.build().expect("Finalizes the block").block; @@ -113,7 +113,7 @@ mod tests { #[test] fn ensure_test_client_can_push_extrinsic() { - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let transfer = construct_transfer_extrinsic( &client, diff --git a/polkadot/node/test/service/Cargo.toml b/polkadot/node/test/service/Cargo.toml index 48a206f23c660ca9dbb5e0dd48b1cf0f4835b183..8eb6105f98e2571bab0257694ccac49ae47c2ca9 100644 --- a/polkadot/node/test/service/Cargo.toml +++ b/polkadot/node/test/service/Cargo.toml @@ -10,60 +10,60 @@ license.workspace = true workspace = true [dependencies] -futures = "0.3.30" -hex = "0.4.3" -gum = { package = "tracing-gum", path = "../../gum" } -rand = "0.8.5" +futures = { workspace = true } +hex = { workspace = true, default-features = true } +gum = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -tempfile = "3.2.0" -tokio = "1.37" +tempfile = { workspace = true } +tokio = { workspace = true, default-features = true } # Polkadot dependencies -polkadot-overseer = { path = "../../overseer" } -polkadot-primitives = { path = "../../../primitives" } -polkadot-parachain-primitives = { path = "../../../parachain" } -polkadot-rpc = { path = "../../../rpc" } -polkadot-runtime-common = { path = "../../../runtime/common" } -polkadot-service = { path = "../../service" } -polkadot-node-subsystem = { path = "../../subsystem" } -polkadot-node-primitives = { path = "../../primitives" } -polkadot-test-runtime = { path = "../../../runtime/test-runtime" } -test-runtime-constants = { path = "../../../runtime/test-runtime/constants" } -polkadot-runtime-parachains = { path = "../../../runtime/parachains" } +polkadot-overseer = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-rpc = { workspace = true, default-features = true } +polkadot-runtime-common = { workspace = true, default-features = true } +polkadot-service = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-test-runtime = { workspace = true } +test-runtime-constants = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } # Substrate dependencies -sp-authority-discovery = { path = "../../../../substrate/primitives/authority-discovery" } -sc-authority-discovery = { path = "../../../../substrate/client/authority-discovery" } -babe = { package = "sc-consensus-babe", path = "../../../../substrate/client/consensus/babe" } -babe-primitives = { package = "sp-consensus-babe", path = "../../../../substrate/primitives/consensus/babe" } -consensus_common = { package = "sp-consensus", path = "../../../../substrate/primitives/consensus/common" } -frame-system = { path = "../../../../substrate/frame/system" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../../substrate/client/consensus/grandpa" } -grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../../substrate/primitives/consensus/grandpa" } -inherents = { package = "sp-inherents", path = "../../../../substrate/primitives/inherents" } -pallet-staking = { path = "../../../../substrate/frame/staking" } -pallet-balances = { path = "../../../../substrate/frame/balances" } -pallet-transaction-payment = { path = "../../../../substrate/frame/transaction-payment" } -sc-chain-spec = { path = "../../../../substrate/client/chain-spec" } -sc-cli = { path = "../../../../substrate/client/cli" } -sc-client-api = { path = "../../../../substrate/client/api" } -sc-consensus = { path = "../../../../substrate/client/consensus/common" } -sc-network = { path = "../../../../substrate/client/network" } -sc-tracing = { path = "../../../../substrate/client/tracing" } -sc-transaction-pool = { path = "../../../../substrate/client/transaction-pool" } -sc-service = { path = "../../../../substrate/client/service", default-features = false } -sp-arithmetic = { path = "../../../../substrate/primitives/arithmetic" } -sp-blockchain = { path = "../../../../substrate/primitives/blockchain" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-state-machine = { path = "../../../../substrate/primitives/state-machine" } -substrate-test-client = { path = "../../../../substrate/test-utils/client" } +sp-authority-discovery = { workspace = true, default-features = true } +sc-authority-discovery = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +pallet-staking = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-transaction-payment = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-cli = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-service = { workspace = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +substrate-test-client = { workspace = true } [dev-dependencies] -pallet-balances = { path = "../../../../substrate/frame/balances", default-features = false } -substrate-test-utils = { path = "../../../../substrate/test-utils" } -tokio = { version = "1.37", features = ["macros"] } +pallet-balances = { workspace = true } +substrate-test-utils = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } [features] runtime-metrics = ["polkadot-test-runtime/runtime-metrics"] diff --git a/polkadot/node/test/service/src/chain_spec.rs b/polkadot/node/test/service/src/chain_spec.rs index f14fa9fde58b4426690cd1bd0e16129f095c34ec..8add51b07521f4bbde67009d081b8fec0fd421ee 100644 --- a/polkadot/node/test/service/src/chain_spec.rs +++ b/polkadot/node/test/service/src/chain_spec.rs @@ -16,16 +16,16 @@ //! Chain specifications for the test runtime. -use babe_primitives::AuthorityId as BabeId; -use grandpa::AuthorityId as GrandpaId; use pallet_staking::Forcing; use polkadot_primitives::{ - vstaging::SchedulerParams, AccountId, AssignmentId, ValidatorId, MAX_CODE_SIZE, MAX_POV_SIZE, + AccountId, AssignmentId, SchedulerParams, ValidatorId, MAX_CODE_SIZE, MAX_POV_SIZE, }; use polkadot_service::chain_spec::{get_account_id_from_seed, get_from_seed, Extensions}; use polkadot_test_runtime::BABE_GENESIS_EPOCH_CONFIG; use sc_chain_spec::{ChainSpec, ChainType}; +use sc_consensus_grandpa::AuthorityId as GrandpaId; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; +use sp_consensus_babe::AuthorityId as BabeId; use sp_core::sr25519; use sp_runtime::Perbill; use test_runtime_constants::currency::DOTS; @@ -33,7 +33,7 @@ use test_runtime_constants::currency::DOTS; const DEFAULT_PROTOCOL_ID: &str = "dot"; /// The `ChainSpec` parameterized for polkadot test runtime. -pub type PolkadotChainSpec = sc_service::GenericChainSpec<(), Extensions>; +pub type PolkadotChainSpec = sc_service::GenericChainSpec; /// Returns the properties for the [`PolkadotChainSpec`]. pub fn polkadot_chain_spec_properties() -> serde_json::map::Map { diff --git a/polkadot/node/test/service/src/lib.rs b/polkadot/node/test/service/src/lib.rs index 35156a3a9372b54cf438fe086d3642b8fd55992d..a4e58253bb1706c9face2ded9dbbfb66a93ebb40 100644 --- a/polkadot/node/test/service/src/lib.rs +++ b/polkadot/node/test/service/src/lib.rs @@ -232,7 +232,6 @@ pub fn node_config( announce_block: true, data_path: root, base_path, - informant_output_format: Default::default(), } } diff --git a/polkadot/node/zombienet-backchannel/Cargo.toml b/polkadot/node/zombienet-backchannel/Cargo.toml index 9139c6a4e5e7e90ea9cc529ce375056b475d0e38..a9bf1f5ef093a905de7ca96c515a5a1b2c9cd17b 100644 --- a/polkadot/node/zombienet-backchannel/Cargo.toml +++ b/polkadot/node/zombienet-backchannel/Cargo.toml @@ -12,14 +12,14 @@ license.workspace = true workspace = true [dependencies] -tokio = { version = "1.24.2", default-features = false, features = ["macros", "net", "rt-multi-thread", "sync"] } -url = "2.3.1" -tokio-tungstenite = "0.20.1" -futures-util = "0.3.30" -lazy_static = "1.4.0" -parity-scale-codec = { version = "3.6.1", features = ["derive"] } -reqwest = { version = "0.11", features = ["rustls-tls"], default-features = false } +tokio = { features = ["macros", "net", "rt-multi-thread", "sync"], workspace = true } +url = { workspace = true } +tokio-tungstenite = { workspace = true } +futures-util = { workspace = true, default-features = true } +lazy_static = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +reqwest = { features = ["rustls-tls"], workspace = true } thiserror = { workspace = true } -gum = { package = "tracing-gum", path = "../gum" } +gum = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } diff --git a/polkadot/node/zombienet-backchannel/src/lib.rs b/polkadot/node/zombienet-backchannel/src/lib.rs index fa9218d2d3502af7d55cfead12f5aebe1cb070ef..9068b03399ca5180ec17a03669be3ea25fc3c5db 100644 --- a/polkadot/node/zombienet-backchannel/src/lib.rs +++ b/polkadot/node/zombienet-backchannel/src/lib.rs @@ -19,9 +19,9 @@ //! values in the test specifications, through a bidirectional message passing //! implemented as a `backchannel`. +use codec; use futures_util::{SinkExt, StreamExt}; use lazy_static::lazy_static; -use parity_scale_codec as codec; use serde::{Deserialize, Serialize}; use std::{env, sync::Mutex}; use tokio::sync::broadcast; diff --git a/polkadot/parachain/Cargo.toml b/polkadot/parachain/Cargo.toml index 15eea2addc893ced551edaf2557ff703a455a879..9d0518fd46ade9644af5c21c0a4c5873bfd458e3 100644 --- a/polkadot/parachain/Cargo.toml +++ b/polkadot/parachain/Cargo.toml @@ -13,15 +13,14 @@ workspace = true # note: special care is taken to avoid inclusion of `sp-io` externals when compiling # this crate for WASM. This is critical to avoid forcing all parachain WASM into implementing # various unnecessary Substrate-specific endpoints. -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] } -sp-std = { path = "../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../substrate/primitives/runtime", default-features = false, features = ["serde"] } -sp-core = { path = "../../substrate/primitives/core", default-features = false, features = ["serde"] } -sp-weights = { path = "../../substrate/primitives/weights", default-features = false } -polkadot-core-primitives = { path = "../core-primitives", default-features = false } -derive_more = "0.99.11" -bounded-collections = { version = "0.2.0", default-features = false, features = ["serde"] } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive", "serde"], workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-core = { features = ["serde"], workspace = true } +sp-weights = { workspace = true } +polkadot-core-primitives = { workspace = true } +derive_more = { workspace = true, default-features = true } +bounded-collections = { features = ["serde"], workspace = true } # all optional crates. serde = { features = ["alloc", "derive"], workspace = true } @@ -31,13 +30,12 @@ default = ["std"] wasm-api = [] std = [ "bounded-collections/std", - "parity-scale-codec/std", + "codec/std", "polkadot-core-primitives/std", "scale-info/std", "serde/std", "sp-core/std", "sp-runtime/std", - "sp-std/std", "sp-weights/std", ] runtime-benchmarks = ["sp-runtime/runtime-benchmarks"] diff --git a/polkadot/parachain/src/lib.rs b/polkadot/parachain/src/lib.rs index bd75296bf837128c7b10b8a89a823cb66dc1ca8b..8941b7fbb911e8338972ff37fe3d7231d4841cd2 100644 --- a/polkadot/parachain/src/lib.rs +++ b/polkadot/parachain/src/lib.rs @@ -51,3 +51,5 @@ mod wasm_api; #[cfg(all(not(feature = "std"), feature = "wasm-api"))] pub use wasm_api::*; + +extern crate alloc; diff --git a/polkadot/parachain/src/primitives.rs b/polkadot/parachain/src/primitives.rs index 5a1efdf898217a18972cab8c9ea49a41e5a2280f..c5757928c3fc2f86fdd6ddb779856f0f39db70f7 100644 --- a/polkadot/parachain/src/primitives.rs +++ b/polkadot/parachain/src/primitives.rs @@ -17,10 +17,10 @@ //! Primitive types which are strictly necessary from a parachain-execution point //! of view. -use sp_std::vec::Vec; +use alloc::vec::Vec; use bounded_collections::{BoundedVec, ConstU32}; -use parity_scale_codec::{CompactAs, Decode, Encode, MaxEncodedLen}; +use codec::{CompactAs, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use serde::{Deserialize, Serialize}; use sp_core::{bytes, RuntimeDebug, TypeId}; @@ -89,14 +89,14 @@ impl ValidationCode { #[derive(Clone, Copy, Encode, Decode, Hash, Eq, PartialEq, PartialOrd, Ord, TypeInfo)] pub struct ValidationCodeHash(Hash); -impl sp_std::fmt::Display for ValidationCodeHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Display for ValidationCodeHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { self.0.fmt(f) } } -impl sp_std::fmt::Debug for ValidationCodeHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for ValidationCodeHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{:?}", self.0) } } @@ -119,9 +119,9 @@ impl From<[u8; 32]> for ValidationCodeHash { } } -impl sp_std::fmt::LowerHex for ValidationCodeHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { - sp_std::fmt::LowerHex::fmt(&self.0, f) +impl core::fmt::LowerHex for ValidationCodeHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::LowerHex::fmt(&self.0, f) } } @@ -225,7 +225,7 @@ impl IsSystem for Id { } } -impl sp_std::ops::Add for Id { +impl core::ops::Add for Id { type Output = Self; fn add(self, other: u32) -> Self { @@ -233,7 +233,7 @@ impl sp_std::ops::Add for Id { } } -impl sp_std::ops::Sub for Id { +impl core::ops::Sub for Id { type Output = Self; fn sub(self, other: u32) -> Self { @@ -333,7 +333,19 @@ impl DmpMessageHandler for () { } /// The aggregate XCMP message format. -#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, TypeInfo, RuntimeDebug)] +#[derive( + Copy, + Clone, + Eq, + PartialEq, + Ord, + PartialOrd, + Encode, + Decode, + TypeInfo, + RuntimeDebug, + MaxEncodedLen, +)] pub enum XcmpMessageFormat { /// Encoded `VersionedXcm` messages, all concatenated. ConcatenatedVersionedXcm, diff --git a/polkadot/parachain/src/wasm_api.rs b/polkadot/parachain/src/wasm_api.rs index 981d276af75ca5e06cfb108045d51eeb8cd6e99e..1c557c9ae50584b61b25004880f8aa4f86308d06 100644 --- a/polkadot/parachain/src/wasm_api.rs +++ b/polkadot/parachain/src/wasm_api.rs @@ -22,9 +22,9 @@ /// function's entry point. #[cfg(not(feature = "std"))] pub unsafe fn load_params(params: *const u8, len: usize) -> crate::primitives::ValidationParams { - let mut slice = sp_std::slice::from_raw_parts(params, len); + let mut slice = core::slice::from_raw_parts(params, len); - parity_scale_codec::Decode::decode(&mut slice).expect("Invalid input data") + codec::Decode::decode(&mut slice).expect("Invalid input data") } /// Allocate the validation result in memory, getting the return-pointer back. diff --git a/polkadot/parachain/test-parachains/Cargo.toml b/polkadot/parachain/test-parachains/Cargo.toml index 6acdedf67ff2e4be34da2caa70c572a41f861eca..9f35653f957f3ba8423c5a1e47ca08a05d6bf6c5 100644 --- a/polkadot/parachain/test-parachains/Cargo.toml +++ b/polkadot/parachain/test-parachains/Cargo.toml @@ -11,15 +11,15 @@ publish = false workspace = true [dependencies] -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +tiny-keccak = { features = ["keccak"], workspace = true } +codec = { features = ["derive"], workspace = true } -adder = { package = "test-parachain-adder", path = "adder" } -halt = { package = "test-parachain-halt", path = "halt" } +test-parachain-adder = { workspace = true } +test-parachain-halt = { workspace = true } [dev-dependencies] -sp-core = { path = "../../../substrate/primitives/core" } +sp-core = { workspace = true, default-features = true } [features] default = ["std"] -std = ["adder/std", "halt/std", "parity-scale-codec/std"] +std = ["codec/std", "test-parachain-adder/std", "test-parachain-halt/std"] diff --git a/polkadot/parachain/test-parachains/adder/Cargo.toml b/polkadot/parachain/test-parachains/adder/Cargo.toml index eec19ef788aad510d7ea9ef6d2ab61d7c6aeb8f9..7a150b75d5cdb28a82cdaf9cdeef3cb0c3a4582d 100644 --- a/polkadot/parachain/test-parachains/adder/Cargo.toml +++ b/polkadot/parachain/test-parachains/adder/Cargo.toml @@ -12,18 +12,17 @@ publish = false workspace = true [dependencies] -parachain = { package = "polkadot-parachain-primitives", path = "../..", default-features = false, features = ["wasm-api"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -dlmalloc = { version = "0.2.4", features = ["global"] } +polkadot-parachain-primitives = { features = ["wasm-api"], workspace = true } +codec = { features = ["derive"], workspace = true } +tiny-keccak = { features = ["keccak"], workspace = true } +dlmalloc = { features = ["global"], workspace = true } # We need to make sure the global allocator is disabled until we have support of full substrate externalities -sp-io = { path = "../../../../substrate/primitives/io", default-features = false, features = ["disable_allocator"] } +sp-io = { features = ["disable_allocator"], workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] -std = ["parachain/std", "parity-scale-codec/std", "sp-io/std", "sp-std/std"] +std = ["codec/std", "polkadot-parachain-primitives/std", "sp-io/std"] diff --git a/polkadot/parachain/test-parachains/adder/collator/Cargo.toml b/polkadot/parachain/test-parachains/adder/collator/Cargo.toml index 5a2b5405741446f52e5f1212de2665ab04d350d2..061378a76a82eb8edcf8823d7ee3d43d7d3fc7e9 100644 --- a/polkadot/parachain/test-parachains/adder/collator/Cargo.toml +++ b/polkadot/parachain/test-parachains/adder/collator/Cargo.toml @@ -15,30 +15,30 @@ name = "adder-collator" path = "src/main.rs" [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -clap = { version = "4.5.3", features = ["derive"] } -futures = "0.3.30" -futures-timer = "3.0.2" +codec = { features = ["derive"], workspace = true } +clap = { features = ["derive"], workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -test-parachain-adder = { path = ".." } -polkadot-primitives = { path = "../../../../primitives" } -polkadot-cli = { path = "../../../../cli" } -polkadot-service = { path = "../../../../node/service", features = ["elastic-scaling-experimental", "rococo-native"] } -polkadot-node-primitives = { path = "../../../../node/primitives" } -polkadot-node-subsystem = { path = "../../../../node/subsystem" } +test-parachain-adder = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-cli = { workspace = true, default-features = true } +polkadot-service = { features = ["rococo-native"], workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } -sc-cli = { path = "../../../../../substrate/client/cli" } -sp-core = { path = "../../../../../substrate/primitives/core" } -sc-service = { path = "../../../../../substrate/client/service" } +sc-cli = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } [dev-dependencies] -polkadot-parachain-primitives = { path = "../../.." } -polkadot-test-service = { path = "../../../../node/test/service" } -polkadot-node-core-pvf = { path = "../../../../node/core/pvf", features = ["test-utils"] } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-test-service = { workspace = true } +polkadot-node-core-pvf = { features = ["test-utils"], workspace = true, default-features = true } -substrate-test-utils = { path = "../../../../../substrate/test-utils" } -sc-service = { path = "../../../../../substrate/client/service" } -sp-keyring = { path = "../../../../../substrate/primitives/keyring" } +substrate-test-utils = { workspace = true } +sc-service = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } -tokio = { version = "1.24.2", features = ["macros"] } +tokio = { features = ["macros"], workspace = true, default-features = true } diff --git a/polkadot/parachain/test-parachains/adder/collator/src/lib.rs b/polkadot/parachain/test-parachains/adder/collator/src/lib.rs index c2ba93f389b03d3c3171bc68ad845d373da124f3..daeb8bc915dd613bd83d532406e2c9bfa92af2b0 100644 --- a/polkadot/parachain/test-parachains/adder/collator/src/lib.rs +++ b/polkadot/parachain/test-parachains/adder/collator/src/lib.rs @@ -16,9 +16,9 @@ //! Collator for the adder test parachain. +use codec::{Decode, Encode}; use futures::channel::oneshot; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_primitives::{ Collation, CollationResult, CollationSecondedSignal, CollatorFn, MaybeCompressedPoV, PoV, Statement, diff --git a/polkadot/parachain/test-parachains/adder/src/lib.rs b/polkadot/parachain/test-parachains/adder/src/lib.rs index 4cf1ba8ac971df98142bc04d5deee1add1334fbd..7e8d1bb1e1383fed96525c34ce44eb4c20f9467d 100644 --- a/polkadot/parachain/test-parachains/adder/src/lib.rs +++ b/polkadot/parachain/test-parachains/adder/src/lib.rs @@ -18,7 +18,9 @@ #![no_std] -use parity_scale_codec::{Decode, Encode}; +extern crate alloc; + +use codec::{Decode, Encode}; use tiny_keccak::{Hasher as _, Keccak}; #[cfg(not(feature = "std"))] diff --git a/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs b/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs index 048330437cd7bb4b24e1dc4e1ae3d20c9ea18b65..9c3c77f7350b902b3f99203d2be0f2d675e77274 100644 --- a/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs +++ b/polkadot/parachain/test-parachains/adder/src/wasm_validation.rs @@ -17,14 +17,14 @@ //! WASM validation for adder parachain. use crate::{BlockData, HeadData}; +use alloc::vec::Vec; +use codec::{Decode, Encode}; use core::panic; -use parachain::primitives::{HeadData as GenericHeadData, ValidationResult}; -use parity_scale_codec::{Decode, Encode}; -use sp_std::vec::Vec; +use polkadot_parachain_primitives::primitives::{HeadData as GenericHeadData, ValidationResult}; #[no_mangle] pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 { - let params = unsafe { parachain::load_params(params, len) }; + let params = unsafe { polkadot_parachain_primitives::load_params(params, len) }; let parent_head = HeadData::decode(&mut ¶ms.parent_head.0[..]).expect("invalid parent head format."); @@ -34,13 +34,11 @@ pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 { let parent_hash = crate::keccak256(¶ms.parent_head.0[..]); let new_head = crate::execute(parent_hash, parent_head, &block_data).expect("Executes block"); - parachain::write_result(&ValidationResult { + polkadot_parachain_primitives::write_result(&ValidationResult { head_data: GenericHeadData(new_head.encode()), new_validation_code: None, - upward_messages: sp_std::vec::Vec::new().try_into().expect("empty vec fits into bounds"), - horizontal_messages: sp_std::vec::Vec::new() - .try_into() - .expect("empty vec fits into bounds"), + upward_messages: alloc::vec::Vec::new().try_into().expect("empty vec fits into bounds"), + horizontal_messages: alloc::vec::Vec::new().try_into().expect("empty vec fits into bounds"), processed_downward_messages: 0, hrmp_watermark: params.relay_parent_number, }) diff --git a/polkadot/parachain/test-parachains/halt/Cargo.toml b/polkadot/parachain/test-parachains/halt/Cargo.toml index 1bdd4392ad313dbdcf62d36bd04cab7330fdf3fb..f8272f6ed19681adf3faa57dfac3c4f126db6839 100644 --- a/polkadot/parachain/test-parachains/halt/Cargo.toml +++ b/polkadot/parachain/test-parachains/halt/Cargo.toml @@ -14,8 +14,8 @@ workspace = true [dependencies] [build-dependencies] -substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" } -rustversion = "1.0.6" +substrate-wasm-builder = { workspace = true, default-features = true } +rustversion = { workspace = true } [features] default = ["std"] diff --git a/polkadot/parachain/test-parachains/undying/Cargo.toml b/polkadot/parachain/test-parachains/undying/Cargo.toml index 82ceebcf4eee99f36140908580b41c13b04ea87e..4b2e12ebf435422c713fd2319eee08d9fa45d8dc 100644 --- a/polkadot/parachain/test-parachains/undying/Cargo.toml +++ b/polkadot/parachain/test-parachains/undying/Cargo.toml @@ -12,25 +12,23 @@ license.workspace = true workspace = true [dependencies] -parachain = { package = "polkadot-parachain-primitives", path = "../..", default-features = false, features = ["wasm-api"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sp-std = { path = "../../../../substrate/primitives/std", default-features = false } -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -dlmalloc = { version = "0.2.4", features = ["global"] } +polkadot-parachain-primitives = { features = ["wasm-api"], workspace = true } +codec = { features = ["derive"], workspace = true } +tiny-keccak = { features = ["keccak"], workspace = true } +dlmalloc = { features = ["global"], workspace = true } log = { workspace = true } # We need to make sure the global allocator is disabled until we have support of full substrate externalities -sp-io = { path = "../../../../substrate/primitives/io", default-features = false, features = ["disable_allocator"] } +sp-io = { features = ["disable_allocator"], workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] std = [ + "codec/std", "log/std", - "parachain/std", - "parity-scale-codec/std", + "polkadot-parachain-primitives/std", "sp-io/std", - "sp-std/std", ] diff --git a/polkadot/parachain/test-parachains/undying/collator/Cargo.toml b/polkadot/parachain/test-parachains/undying/collator/Cargo.toml index cacf7304f90a29d39848b80a58159afbbb6cb3e5..5760258c70ea5757f5fda90abbfe5a41e5ee0fb4 100644 --- a/polkadot/parachain/test-parachains/undying/collator/Cargo.toml +++ b/polkadot/parachain/test-parachains/undying/collator/Cargo.toml @@ -15,30 +15,30 @@ name = "undying-collator" path = "src/main.rs" [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -clap = { version = "4.5.3", features = ["derive"] } -futures = "0.3.30" -futures-timer = "3.0.2" +codec = { features = ["derive"], workspace = true } +clap = { features = ["derive"], workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -test-parachain-undying = { path = ".." } -polkadot-primitives = { path = "../../../../primitives" } -polkadot-cli = { path = "../../../../cli" } -polkadot-service = { path = "../../../../node/service", features = ["elastic-scaling-experimental", "rococo-native"] } -polkadot-node-primitives = { path = "../../../../node/primitives" } -polkadot-node-subsystem = { path = "../../../../node/subsystem" } +test-parachain-undying = { workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-cli = { workspace = true, default-features = true } +polkadot-service = { features = ["rococo-native"], workspace = true, default-features = true } +polkadot-node-primitives = { workspace = true, default-features = true } +polkadot-node-subsystem = { workspace = true, default-features = true } -sc-cli = { path = "../../../../../substrate/client/cli" } -sp-core = { path = "../../../../../substrate/primitives/core" } -sc-service = { path = "../../../../../substrate/client/service" } +sc-cli = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sc-service = { workspace = true, default-features = true } [dev-dependencies] -polkadot-parachain-primitives = { path = "../../.." } -polkadot-test-service = { path = "../../../../node/test/service" } -polkadot-node-core-pvf = { path = "../../../../node/core/pvf", features = ["test-utils"] } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-test-service = { workspace = true } +polkadot-node-core-pvf = { features = ["test-utils"], workspace = true, default-features = true } -substrate-test-utils = { path = "../../../../../substrate/test-utils" } -sc-service = { path = "../../../../../substrate/client/service" } -sp-keyring = { path = "../../../../../substrate/primitives/keyring" } +substrate-test-utils = { workspace = true } +sc-service = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } -tokio = { version = "1.24.2", features = ["macros"] } +tokio = { features = ["macros"], workspace = true, default-features = true } diff --git a/polkadot/parachain/test-parachains/undying/collator/src/lib.rs b/polkadot/parachain/test-parachains/undying/collator/src/lib.rs index 3c869233182f8faf98e8855017a0e255d5b43167..920099f4499d4467c1df6e6c6f482d489a0f8d26 100644 --- a/polkadot/parachain/test-parachains/undying/collator/src/lib.rs +++ b/polkadot/parachain/test-parachains/undying/collator/src/lib.rs @@ -16,9 +16,9 @@ //! Collator for the `Undying` test parachain. +use codec::{Decode, Encode}; use futures::channel::oneshot; use futures_timer::Delay; -use parity_scale_codec::{Decode, Encode}; use polkadot_node_primitives::{ maybe_compress_pov, Collation, CollationResult, CollationSecondedSignal, CollatorFn, MaybeCompressedPoV, PoV, Statement, diff --git a/polkadot/parachain/test-parachains/undying/src/lib.rs b/polkadot/parachain/test-parachains/undying/src/lib.rs index abd88726b7fcb42f30f19bee37623f662547a1bf..e4ec7e99346bbef4f3ce2fdb03b6084c053926f8 100644 --- a/polkadot/parachain/test-parachains/undying/src/lib.rs +++ b/polkadot/parachain/test-parachains/undying/src/lib.rs @@ -18,8 +18,10 @@ #![no_std] -use parity_scale_codec::{Decode, Encode}; -use sp_std::vec::Vec; +extern crate alloc; + +use alloc::vec::Vec; +use codec::{Decode, Encode}; use tiny_keccak::{Hasher as _, Keccak}; #[cfg(not(feature = "std"))] diff --git a/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs b/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs index de4a1d7e2329c8ff2c6540abf91f0f3d02a3ed35..46b66aa518e490e117c6d190d52a4d4dc85574d7 100644 --- a/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs +++ b/polkadot/parachain/test-parachains/undying/src/wasm_validation.rs @@ -17,12 +17,12 @@ //! WASM validation for the `Undying` parachain. use crate::{BlockData, HeadData}; -use parachain::primitives::{HeadData as GenericHeadData, ValidationResult}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; +use polkadot_parachain_primitives::primitives::{HeadData as GenericHeadData, ValidationResult}; #[no_mangle] pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 { - let params = unsafe { parachain::load_params(params, len) }; + let params = unsafe { polkadot_parachain_primitives::load_params(params, len) }; let parent_head = HeadData::decode(&mut ¶ms.parent_head.0[..]).expect("invalid parent head format."); @@ -34,11 +34,11 @@ pub extern "C" fn validate_block(params: *const u8, len: usize) -> u64 { let (new_head, _) = crate::execute(parent_hash, parent_head, block_data).expect("Executes block"); - parachain::write_result(&ValidationResult { + polkadot_parachain_primitives::write_result(&ValidationResult { head_data: GenericHeadData(new_head.encode()), new_validation_code: None, - upward_messages: sp_std::vec::Vec::new().try_into().expect("empty vec fits within bounds"), - horizontal_messages: sp_std::vec::Vec::new() + upward_messages: alloc::vec::Vec::new().try_into().expect("empty vec fits within bounds"), + horizontal_messages: alloc::vec::Vec::new() .try_into() .expect("empty vec fits within bounds"), processed_downward_messages: 0, diff --git a/polkadot/primitives/Cargo.toml b/polkadot/primitives/Cargo.toml index 99800afc37fe0133b78dd6f1b7432014b923c0ca..8f7ec314ecffe6d7ca7f1f943a47971b4a1e9558 100644 --- a/polkadot/primitives/Cargo.toml +++ b/polkadot/primitives/Cargo.toml @@ -10,55 +10,53 @@ description = "Shared primitives used by Polkadot runtime" workspace = true [dependencies] -bitvec = { version = "1.0.0", default-features = false, features = ["alloc", "serde"] } -hex-literal = "0.4.1" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["bit-vec", "derive", "serde"] } -log = { workspace = true, default-features = false } +bitvec = { features = ["alloc", "serde"], workspace = true } +hex-literal = { workspace = true, default-features = true } +codec = { features = ["bit-vec", "derive"], workspace = true } +scale-info = { features = ["bit-vec", "derive", "serde"], workspace = true } +log = { workspace = true } serde = { features = ["alloc", "derive"], workspace = true } -application-crypto = { package = "sp-application-crypto", path = "../../substrate/primitives/application-crypto", default-features = false, features = ["serde"] } -inherents = { package = "sp-inherents", path = "../../substrate/primitives/inherents", default-features = false } -primitives = { package = "sp-core", path = "../../substrate/primitives/core", default-features = false } -runtime_primitives = { package = "sp-runtime", path = "../../substrate/primitives/runtime", default-features = false } -sp-api = { path = "../../substrate/primitives/api", default-features = false } -sp-arithmetic = { path = "../../substrate/primitives/arithmetic", default-features = false, features = ["serde"] } -sp-authority-discovery = { path = "../../substrate/primitives/authority-discovery", default-features = false, features = ["serde"] } -sp-consensus-slots = { path = "../../substrate/primitives/consensus/slots", default-features = false, features = ["serde"] } -sp-io = { path = "../../substrate/primitives/io", default-features = false } -sp-keystore = { path = "../../substrate/primitives/keystore", optional = true, default-features = false } -sp-staking = { path = "../../substrate/primitives/staking", default-features = false, features = ["serde"] } -sp-std = { package = "sp-std", path = "../../substrate/primitives/std", default-features = false } +sp-application-crypto = { features = ["serde"], workspace = true } +sp-inherents = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-api = { workspace = true } +sp-arithmetic = { features = ["serde"], workspace = true } +sp-authority-discovery = { features = ["serde"], workspace = true } +sp-consensus-slots = { features = ["serde"], workspace = true } +sp-io = { workspace = true } +sp-keystore = { optional = true, workspace = true } +sp-staking = { features = ["serde"], workspace = true } -polkadot-core-primitives = { path = "../core-primitives", default-features = false } -polkadot-parachain-primitives = { path = "../parachain", default-features = false } +polkadot-core-primitives = { workspace = true } +polkadot-parachain-primitives = { workspace = true } [features] default = ["std"] std = [ - "application-crypto/std", "bitvec/std", - "inherents/std", + "codec/std", "log/std", - "parity-scale-codec/std", "polkadot-core-primitives/std", "polkadot-parachain-primitives/std", - "primitives/std", - "runtime_primitives/std", "scale-info/std", "serde/std", "sp-api/std", + "sp-application-crypto/std", "sp-arithmetic/std", "sp-authority-discovery/std", "sp-consensus-slots/std", + "sp-core/std", + "sp-inherents/std", "sp-io/std", "sp-keystore", "sp-keystore?/std", + "sp-runtime/std", "sp-staking/std", - "sp-std/std", ] runtime-benchmarks = [ "polkadot-parachain-primitives/runtime-benchmarks", - "runtime_primitives/runtime-benchmarks", + "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", ] diff --git a/polkadot/primitives/src/lib.rs b/polkadot/primitives/src/lib.rs index 01f393086a668f43d2e18abc10b4491f54aae2cf..493f9fb5ba92ee66320ad6ead60e5bb1111213b9 100644 --- a/polkadot/primitives/src/lib.rs +++ b/polkadot/primitives/src/lib.rs @@ -19,8 +19,8 @@ #![warn(missing_docs)] #![cfg_attr(not(feature = "std"), no_std)] -// `v6` is currently the latest stable version of the runtime API. -pub mod v7; +// `v11` is currently the latest stable version of the runtime API. +pub mod v8; // The 'staging' version is special - it contains primitives which are // still in development. Once they are considered stable, they will be @@ -31,9 +31,11 @@ pub mod vstaging; // unstable functions. pub mod runtime_api; +extern crate alloc; + // Current primitives not requiring versioning are exported here. // Primitives requiring versioning must not be exported and must be referred by an exact version. -pub use v7::{ +pub use v8::{ async_backing, byzantine_threshold, check_candidate_backing, collator_signature_payload, effective_minimum_backing_votes, executor_params, metric_definitions, node_features, slashing, supermajority_threshold, well_known_keys, AbridgedHostConfiguration, AbridgedHrmpChannel, @@ -41,19 +43,20 @@ pub use v7::{ ApprovalVotingParams, AssignmentId, AsyncBackingParams, AuthorityDiscoveryId, AvailabilityBitfield, BackedCandidate, Balance, BlakeTwo256, Block, BlockId, BlockNumber, CandidateCommitments, CandidateDescriptor, CandidateEvent, CandidateHash, CandidateIndex, - CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CollatorId, - CollatorSignature, CommittedCandidateReceipt, CompactStatement, ConsensusLog, CoreIndex, - CoreState, DisputeState, DisputeStatement, DisputeStatementSet, DownwardMessage, EncodeAs, - ExecutorParam, ExecutorParamError, ExecutorParams, ExecutorParamsHash, ExecutorParamsPrepHash, - ExplicitDisputeStatement, GroupIndex, GroupRotationInfo, Hash, HashT, HeadData, Header, - HorizontalMessages, HrmpChannelId, Id, InboundDownwardMessage, InboundHrmpMessage, IndexedVec, - InherentData, InvalidDisputeStatementKind, Moment, MultiDisputeStatementSet, NodeFeatures, - Nonce, OccupiedCore, OccupiedCoreAssumption, OutboundHrmpMessage, ParathreadClaim, - ParathreadEntry, PersistedValidationData, PvfCheckStatement, PvfExecKind, PvfPrepKind, - RuntimeMetricLabel, RuntimeMetricLabelValue, RuntimeMetricLabelValues, RuntimeMetricLabels, - RuntimeMetricOp, RuntimeMetricUpdate, ScheduledCore, ScrapedOnChainVotes, SessionIndex, - SessionInfo, Signature, Signed, SignedAvailabilityBitfield, SignedAvailabilityBitfields, - SignedStatement, SigningContext, Slot, UncheckedSigned, UncheckedSignedAvailabilityBitfield, + CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, ChunkIndex, + CollatorId, CollatorSignature, CommittedCandidateReceipt, CompactStatement, ConsensusLog, + CoreIndex, CoreState, DisputeState, DisputeStatement, DisputeStatementSet, DownwardMessage, + EncodeAs, ExecutorParam, ExecutorParamError, ExecutorParams, ExecutorParamsHash, + ExecutorParamsPrepHash, ExplicitDisputeStatement, GroupIndex, GroupRotationInfo, Hash, HashT, + HeadData, Header, HorizontalMessages, HrmpChannelId, Id, InboundDownwardMessage, + InboundHrmpMessage, IndexedVec, InherentData, InvalidDisputeStatementKind, Moment, + MultiDisputeStatementSet, NodeFeatures, Nonce, OccupiedCore, OccupiedCoreAssumption, + OutboundHrmpMessage, ParathreadClaim, ParathreadEntry, PersistedValidationData, + PvfCheckStatement, PvfExecKind, PvfPrepKind, RuntimeMetricLabel, RuntimeMetricLabelValue, + RuntimeMetricLabelValues, RuntimeMetricLabels, RuntimeMetricOp, RuntimeMetricUpdate, + ScheduledCore, SchedulerParams, ScrapedOnChainVotes, SessionIndex, SessionInfo, Signature, + Signed, SignedAvailabilityBitfield, SignedAvailabilityBitfields, SignedStatement, + SigningContext, Slot, UncheckedSigned, UncheckedSignedAvailabilityBitfield, UncheckedSignedAvailabilityBitfields, UncheckedSignedStatement, UpgradeGoAhead, UpgradeRestriction, UpwardMessage, ValidDisputeStatementKind, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, ValidityAttestation, @@ -64,4 +67,4 @@ pub use v7::{ }; #[cfg(feature = "std")] -pub use v7::{AssignmentPair, CollatorPair, ValidatorPair}; +pub use v8::{AssignmentPair, CollatorPair, ValidatorPair}; diff --git a/polkadot/primitives/src/runtime_api.rs b/polkadot/primitives/src/runtime_api.rs index 7bd92be35c159db35b3db7b9dd91afcc73eebd81..b4816ad15075dcc8d739259b779bfda1a9b5c84a 100644 --- a/polkadot/primitives/src/runtime_api.rs +++ b/polkadot/primitives/src/runtime_api.rs @@ -121,12 +121,12 @@ use crate::{ SessionIndex, SessionInfo, ValidatorId, ValidatorIndex, ValidatorSignature, }; -use polkadot_core_primitives as pcp; -use polkadot_parachain_primitives::primitives as ppp; -use sp_std::{ +use alloc::{ collections::{btree_map::BTreeMap, vec_deque::VecDeque}, - prelude::*, + vec::Vec, }; +use polkadot_core_primitives as pcp; +use polkadot_parachain_primitives::primitives as ppp; sp_api::decl_runtime_apis! { /// The API for querying the state of parachains on-chain. diff --git a/polkadot/primitives/src/v7/async_backing.rs b/polkadot/primitives/src/v8/async_backing.rs similarity index 98% rename from polkadot/primitives/src/v7/async_backing.rs rename to polkadot/primitives/src/v8/async_backing.rs index 1abe87b6dec433122a6918f2f834a4a8e57817e8..55d436e30de07812d4b1d722a5cbb9a85cc7d1aa 100644 --- a/polkadot/primitives/src/v7/async_backing.rs +++ b/polkadot/primitives/src/v8/async_backing.rs @@ -18,9 +18,10 @@ use super::*; -use parity_scale_codec::{Decode, Encode}; -use primitives::RuntimeDebug; +use alloc::vec::Vec; +use codec::{Decode, Encode}; use scale_info::TypeInfo; +use sp_core::RuntimeDebug; /// Candidate's acceptance limitations for asynchronous backing per relay parent. #[derive( diff --git a/polkadot/primitives/src/v7/executor_params.rs b/polkadot/primitives/src/v8/executor_params.rs similarity index 93% rename from polkadot/primitives/src/v7/executor_params.rs rename to polkadot/primitives/src/v8/executor_params.rs index 918a7f17a7e3ba466bd8e06cb635cfbf2f9df839..bfd42ec30bd39dbaa3299cda634fd0f4743ab2e2 100644 --- a/polkadot/primitives/src/v7/executor_params.rs +++ b/polkadot/primitives/src/v8/executor_params.rs @@ -22,11 +22,12 @@ //! done in `polkadot-node-core-pvf`. use crate::{BlakeTwo256, HashT as _, PvfExecKind, PvfPrepKind}; -use parity_scale_codec::{Decode, Encode}; +use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec}; +use codec::{Decode, Encode}; +use core::{ops::Deref, time::Duration}; use polkadot_core_primitives::Hash; use scale_info::TypeInfo; use serde::{Deserialize, Serialize}; -use sp_std::{collections::btree_map::BTreeMap, ops::Deref, time::Duration, vec, vec::Vec}; /// Default maximum number of wasm values allowed for the stack during execution of a PVF. pub const DEFAULT_LOGICAL_STACK_MAX: u32 = 65536; @@ -134,21 +135,21 @@ impl ExecutorParamsHash { } } -impl sp_std::fmt::Display for ExecutorParamsHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Display for ExecutorParamsHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { self.0.fmt(f) } } -impl sp_std::fmt::Debug for ExecutorParamsHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for ExecutorParamsHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{:?}", self.0) } } -impl sp_std::fmt::LowerHex for ExecutorParamsHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { - sp_std::fmt::LowerHex::fmt(&self.0, f) +impl core::fmt::LowerHex for ExecutorParamsHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::LowerHex::fmt(&self.0, f) } } @@ -159,21 +160,21 @@ impl sp_std::fmt::LowerHex for ExecutorParamsHash { #[derive(Clone, Copy, Encode, Decode, Hash, Eq, PartialEq, PartialOrd, Ord, TypeInfo)] pub struct ExecutorParamsPrepHash(Hash); -impl sp_std::fmt::Display for ExecutorParamsPrepHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Display for ExecutorParamsPrepHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { self.0.fmt(f) } } -impl sp_std::fmt::Debug for ExecutorParamsPrepHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for ExecutorParamsPrepHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "{:?}", self.0) } } -impl sp_std::fmt::LowerHex for ExecutorParamsPrepHash { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { - sp_std::fmt::LowerHex::fmt(&self.0, f) +impl core::fmt::LowerHex for ExecutorParamsPrepHash { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + core::fmt::LowerHex::fmt(&self.0, f) } } diff --git a/polkadot/primitives/src/v7/metrics.rs b/polkadot/primitives/src/v8/metrics.rs similarity index 97% rename from polkadot/primitives/src/v7/metrics.rs rename to polkadot/primitives/src/v8/metrics.rs index 97f7678e437371c47a9fc7d31a58e2c52196e492..1d66c9848a7c4016a86f5ed1eb85e880b35bba91 100644 --- a/polkadot/primitives/src/v7/metrics.rs +++ b/polkadot/primitives/src/v8/metrics.rs @@ -16,8 +16,8 @@ //! Runtime metric primitives. -use parity_scale_codec::{Decode, Encode}; -use sp_std::prelude::*; +use alloc::vec::Vec; +use codec::{Decode, Encode}; /// Runtime metric operations. #[derive(Encode, Decode)] @@ -42,7 +42,7 @@ pub struct RuntimeMetricUpdate { } fn vec_to_str<'a>(v: &'a Vec, default: &'static str) -> &'a str { - return sp_std::str::from_utf8(v).unwrap_or(default) + return alloc::str::from_utf8(v).unwrap_or(default) } impl RuntimeMetricLabels { @@ -99,7 +99,7 @@ pub trait AsStr { impl AsStr for RuntimeMetricLabel { fn as_str(&self) -> Option<&str> { - sp_std::str::from_utf8(&self.0).ok() + alloc::str::from_utf8(&self.0).ok() } } diff --git a/polkadot/primitives/src/v7/mod.rs b/polkadot/primitives/src/v8/mod.rs similarity index 92% rename from polkadot/primitives/src/v7/mod.rs rename to polkadot/primitives/src/v8/mod.rs index 8a059408496c0f87e2d1394beb84263f48c4fbda..b6928e372064621e64dbac2af346491f6bb10afc 100644 --- a/polkadot/primitives/src/v7/mod.rs +++ b/polkadot/primitives/src/v8/mod.rs @@ -16,23 +16,28 @@ //! `V7` Primitives. +use alloc::{ + vec, + vec::{IntoIter, Vec}, +}; use bitvec::{field::BitField, slice::BitSlice, vec::BitVec}; -use parity_scale_codec::{Decode, Encode}; -use scale_info::TypeInfo; -use sp_std::{ +use codec::{Decode, Encode}; +use core::{ marker::PhantomData, - prelude::*, slice::{Iter, IterMut}, - vec::IntoIter, }; +use scale_info::TypeInfo; -use application_crypto::KeyTypeId; -use inherents::InherentIdentifier; -use primitives::RuntimeDebug; -use runtime_primitives::traits::{AppVerify, Header as HeaderT}; -use sp_arithmetic::traits::{BaseArithmetic, Saturating}; +use sp_application_crypto::KeyTypeId; +use sp_arithmetic::{ + traits::{BaseArithmetic, Saturating}, + Perbill, +}; +use sp_core::RuntimeDebug; +use sp_inherents::InherentIdentifier; +use sp_runtime::traits::{AppVerify, Header as HeaderT}; -pub use runtime_primitives::traits::{BlakeTwo256, Hash as HashT}; +pub use sp_runtime::traits::{BlakeTwo256, Hash as HashT}; // Export some core primitives. pub use polkadot_core_primitives::v2::{ @@ -77,7 +82,7 @@ pub const COLLATOR_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"coll"); const LOG_TARGET: &str = "runtime::primitives"; mod collator_app { - use application_crypto::{app_crypto, sr25519}; + use sp_application_crypto::{app_crypto, sr25519}; app_crypto!(sr25519, super::COLLATOR_KEY_TYPE_ID); } @@ -95,7 +100,7 @@ pub type CollatorSignature = collator_app::Signature; pub const PARACHAIN_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"para"); mod validator_app { - use application_crypto::{app_crypto, sr25519}; + use sp_application_crypto::{app_crypto, sr25519}; app_crypto!(sr25519, super::PARACHAIN_KEY_TYPE_ID); } @@ -117,6 +122,34 @@ pub trait TypeIndex { #[cfg_attr(feature = "std", derive(Serialize, Deserialize, Hash))] pub struct ValidatorIndex(pub u32); +/// Index of an availability chunk. +/// +/// The underlying type is identical to `ValidatorIndex`, because +/// the number of chunks will always be equal to the number of validators. +/// However, the chunk index held by a validator may not always be equal to its `ValidatorIndex`, so +/// we use a separate type to make code easier to read. +#[derive(Eq, Ord, PartialEq, PartialOrd, Copy, Clone, Encode, Decode, TypeInfo, RuntimeDebug)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Hash))] +pub struct ChunkIndex(pub u32); + +impl From for ValidatorIndex { + fn from(c_index: ChunkIndex) -> Self { + ValidatorIndex(c_index.0) + } +} + +impl From for ChunkIndex { + fn from(v_index: ValidatorIndex) -> Self { + ChunkIndex(v_index.0) + } +} + +impl From for ChunkIndex { + fn from(n: u32) -> Self { + ChunkIndex(n) + } +} + // We should really get https://github.com/paritytech/polkadot/issues/2403 going .. impl From for ValidatorIndex { fn from(n: u32) -> Self { @@ -130,7 +163,7 @@ impl TypeIndex for ValidatorIndex { } } -application_crypto::with_pair! { +sp_application_crypto::with_pair! { /// A Parachain validator keypair. pub type ValidatorPair = validator_app::Pair; } @@ -144,10 +177,10 @@ pub type ValidatorSignature = validator_app::Signature; /// A declarations of storage keys where an external observer can find some interesting data. pub mod well_known_keys { use super::{HrmpChannelId, Id, WellKnownKey}; + use alloc::vec::Vec; + use codec::Encode as _; use hex_literal::hex; - use parity_scale_codec::Encode as _; use sp_io::hashing::twox_64; - use sp_std::prelude::*; // A note on generating these magic values below: // @@ -415,7 +448,7 @@ pub const LEGACY_MIN_BACKING_VOTES: u32 = 2; // The public key of a keypair used by a validator for determining assignments /// to approve included parachain candidates. mod assignment_app { - use application_crypto::{app_crypto, sr25519}; + use sp_application_crypto::{app_crypto, sr25519}; app_crypto!(sr25519, super::ASSIGNMENT_KEY_TYPE_ID); } @@ -423,7 +456,7 @@ mod assignment_app { /// to approve included parachain candidates. pub type AssignmentId = assignment_app::Public; -application_crypto::with_pair! { +sp_application_crypto::with_pair! { /// The full keypair used by a validator for determining assignments to approve included /// parachain candidates. pub type AssignmentPair = assignment_app::Pair; @@ -589,13 +622,13 @@ impl CommittedCandidateReceipt { } impl PartialOrd for CommittedCandidateReceipt { - fn partial_cmp(&self, other: &Self) -> Option { + fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } impl Ord for CommittedCandidateReceipt { - fn cmp(&self, other: &Self) -> sp_std::cmp::Ordering { + fn cmp(&self, other: &Self) -> core::cmp::Ordering { // TODO: compare signatures or something more sane // https://github.com/paritytech/polkadot/issues/222 self.descriptor() @@ -956,7 +989,7 @@ impl GroupRotationInfo { return GroupIndex(0) } - let cores = sp_std::cmp::min(cores, u32::MAX as usize); + let cores = core::cmp::min(cores, u32::MAX as usize); let blocks_since_start = self.now.saturating_sub(self.session_start_block); let rotations = blocks_since_start / self.group_rotation_frequency; @@ -978,7 +1011,7 @@ impl GroupRotationInfo { return CoreIndex(0) } - let cores = sp_std::cmp::min(cores, u32::MAX as usize); + let cores = core::cmp::min(cores, u32::MAX as usize); let blocks_since_start = self.now.saturating_sub(self.session_start_block); let rotations = blocks_since_start / self.group_rotation_frequency; let rotations = rotations % cores as u32; @@ -1333,7 +1366,7 @@ pub enum UpgradeGoAhead { } /// Consensus engine id for polkadot v1 consensus engine. -pub const POLKADOT_ENGINE_ID: runtime_primitives::ConsensusEngineId = *b"POL1"; +pub const POLKADOT_ENGINE_ID: sp_runtime::ConsensusEngineId = *b"POL1"; /// A consensus log item for polkadot validation. To be used with [`POLKADOT_ENGINE_ID`]. #[derive(Decode, Encode, Clone, PartialEq, Eq)] @@ -1363,18 +1396,18 @@ pub enum ConsensusLog { impl ConsensusLog { /// Attempt to convert a reference to a generic digest item into a consensus log. pub fn from_digest_item( - digest_item: &runtime_primitives::DigestItem, - ) -> Result, parity_scale_codec::Error> { + digest_item: &sp_runtime::DigestItem, + ) -> Result, codec::Error> { match digest_item { - runtime_primitives::DigestItem::Consensus(id, encoded) if id == &POLKADOT_ENGINE_ID => + sp_runtime::DigestItem::Consensus(id, encoded) if id == &POLKADOT_ENGINE_ID => Ok(Some(Self::decode(&mut &encoded[..])?)), _ => Ok(None), } } } -impl From for runtime_primitives::DigestItem { - fn from(c: ConsensusLog) -> runtime_primitives::DigestItem { +impl From for sp_runtime::DigestItem { + fn from(c: ConsensusLog) -> sp_runtime::DigestItem { Self::Consensus(POLKADOT_ENGINE_ID, c.encode()) } } @@ -1724,25 +1757,23 @@ impl From for CompactStatementInner { } } -impl parity_scale_codec::Encode for CompactStatement { +impl codec::Encode for CompactStatement { fn size_hint(&self) -> usize { // magic + discriminant + payload 4 + 1 + 32 } - fn encode_to(&self, dest: &mut T) { + fn encode_to(&self, dest: &mut T) { dest.write(&BACKING_STATEMENT_MAGIC); CompactStatementInner::from(self.clone()).encode_to(dest) } } -impl parity_scale_codec::Decode for CompactStatement { - fn decode( - input: &mut I, - ) -> Result { +impl codec::Decode for CompactStatement { + fn decode(input: &mut I) -> Result { let maybe_magic = <[u8; 4]>::decode(input)?; if maybe_magic != BACKING_STATEMENT_MAGIC { - return Err(parity_scale_codec::Error::from("invalid magic string")) + return Err(codec::Error::from("invalid magic string")) } Ok(match CompactStatementInner::decode(input)? { @@ -1787,6 +1818,14 @@ where self.0.get(index.type_index()) } + /// Returns a mutable reference to an element indexed using `K`. + pub fn get_mut(&mut self, index: K) -> Option<&mut V> + where + K: TypeIndex, + { + self.0.get_mut(index.type_index()) + } + /// Returns number of elements in vector. pub fn len(&self) -> usize { self.0.len() @@ -1836,7 +1875,7 @@ pub fn effective_minimum_backing_votes( group_len: usize, configured_minimum_backing_votes: u32, ) -> usize { - sp_std::cmp::min(group_len, configured_minimum_backing_votes as usize) + core::cmp::min(group_len, configured_minimum_backing_votes as usize) } /// Information about validator sets of a session. @@ -1932,7 +1971,7 @@ impl PvfCheckStatement { pub struct WellKnownKey { /// The raw storage key. pub key: Vec, - _p: sp_std::marker::PhantomData, + _p: core::marker::PhantomData, } impl From> for WellKnownKey { @@ -1951,7 +1990,7 @@ impl WellKnownKey { /// Gets the value or `None` if it does not exist or decoding failed. pub fn get(&self) -> Option { sp_io::storage::get(&self.key) - .and_then(|raw| parity_scale_codec::DecodeAll::decode_all(&mut raw.as_ref()).ok()) + .and_then(|raw| codec::DecodeAll::decode_all(&mut raw.as_ref()).ok()) } } @@ -1989,6 +2028,7 @@ pub mod node_features { /// A feature index used to identify a bit into the node_features array stored /// in the HostConfiguration. #[repr(u8)] + #[derive(Clone, Copy)] pub enum FeatureIndex { /// Tells if tranch0 assignments could be sent in a single certificate. /// Reserved for: `` @@ -1997,10 +2037,95 @@ pub mod node_features { /// The value stored there represents the assumed core index where the candidates /// are backed. This is needed for the elastic scaling MVP. ElasticScalingMVP = 1, + /// Tells if the chunk mapping feature is enabled. + /// Enables the implementation of + /// [RFC-47](https://github.com/polkadot-fellows/RFCs/blob/main/text/0047-assignment-of-availability-chunks.md). + /// Must not be enabled unless all validators and collators have stopped using `req_chunk` + /// protocol version 1. If it is enabled, validators can start systematic chunk recovery. + AvailabilityChunkMapping = 2, + /// Enables node side support of `CoreIndex` committed candidate receipts. + /// See [RFC-103](https://github.com/polkadot-fellows/RFCs/pull/103) for details. + /// Only enable if at least 2/3 of nodes support the feature. + CandidateReceiptV2 = 3, /// First unassigned feature bit. /// Every time a new feature flag is assigned it should take this value. /// and this should be incremented. - FirstUnassigned = 2, + FirstUnassigned = 4, + } +} + +/// Scheduler configuration parameters. All coretime/ondemand parameters are here. +#[derive( + RuntimeDebug, + Copy, + Clone, + PartialEq, + Encode, + Decode, + TypeInfo, + serde::Serialize, + serde::Deserialize, +)] +pub struct SchedulerParams { + /// How often parachain groups should be rotated across parachains. + /// + /// Must be non-zero. + pub group_rotation_frequency: BlockNumber, + /// Availability timeout for a block on a core, measured in blocks. + /// + /// This is the maximum amount of blocks after a core became occupied that validators have time + /// to make the block available. + /// + /// This value only has effect on group rotations. If backers backed something at the end of + /// their rotation, the occupied core affects the backing group that comes afterwards. We limit + /// the effect one backing group can have on the next to `paras_availability_period` blocks. + /// + /// Within a group rotation there is no timeout as backers are only affecting themselves. + /// + /// Must be at least 1. With a value of 1, the previous group will not be able to negatively + /// affect the following group at the expense of a tight availability timeline at group + /// rotation boundaries. + pub paras_availability_period: BlockNumber, + /// The maximum number of validators to have per core. + /// + /// `None` means no maximum. + pub max_validators_per_core: Option, + /// The amount of blocks ahead to schedule paras. + pub lookahead: u32, + /// How many cores are managed by the coretime chain. + pub num_cores: u32, + /// The max number of times a claim can time out in availability. + pub max_availability_timeouts: u32, + /// The maximum queue size of the pay as you go module. + pub on_demand_queue_max_size: u32, + /// The target utilization of the spot price queue in percentages. + pub on_demand_target_queue_utilization: Perbill, + /// How quickly the fee rises in reaction to increased utilization. + /// The lower the number the slower the increase. + pub on_demand_fee_variability: Perbill, + /// The minimum amount needed to claim a slot in the spot pricing queue. + pub on_demand_base_fee: Balance, + /// The number of blocks a claim stays in the scheduler's claim queue before getting cleared. + /// This number should go reasonably higher than the number of blocks in the async backing + /// lookahead. + pub ttl: BlockNumber, +} + +impl> Default for SchedulerParams { + fn default() -> Self { + Self { + group_rotation_frequency: 1u32.into(), + paras_availability_period: 1u32.into(), + max_validators_per_core: Default::default(), + lookahead: 1, + num_cores: Default::default(), + max_availability_timeouts: Default::default(), + on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, + on_demand_target_queue_utilization: Perbill::from_percent(25), + on_demand_fee_variability: Perbill::from_percent(3), + on_demand_base_fee: 10_000_000u128, + ttl: 5u32.into(), + } } } @@ -2008,7 +2133,7 @@ pub mod node_features { mod tests { use super::*; use bitvec::bitvec; - use primitives::sr25519; + use sp_core::sr25519; pub fn dummy_committed_candidate_receipt() -> CommittedCandidateReceipt { let zeros = Hash::zero(); diff --git a/polkadot/primitives/src/v7/signed.rs b/polkadot/primitives/src/v8/signed.rs similarity index 94% rename from polkadot/primitives/src/v7/signed.rs rename to polkadot/primitives/src/v8/signed.rs index 96646d54cbbafbd9c1223a4fe43c5d48d70afaf9..f819b379a30ae2dde68d215daea712c7c28ecbb2 100644 --- a/polkadot/primitives/src/v7/signed.rs +++ b/polkadot/primitives/src/v8/signed.rs @@ -14,17 +14,17 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use scale_info::TypeInfo; +use alloc::vec::Vec; #[cfg(feature = "std")] -use application_crypto::AppCrypto; +use sp_application_crypto::AppCrypto; #[cfg(feature = "std")] use sp_keystore::{Error as KeystoreError, KeystorePtr}; -use sp_std::prelude::Vec; -use primitives::RuntimeDebug; -use runtime_primitives::traits::AppVerify; +use sp_core::RuntimeDebug; +use sp_runtime::traits::AppVerify; use super::{SigningContext, ValidatorId, ValidatorIndex, ValidatorSignature}; @@ -57,7 +57,7 @@ pub struct UncheckedSigned { /// The signature by the validator of the signed payload. signature: ValidatorSignature, /// This ensures the real payload is tracked at the typesystem level. - real_payload: sp_std::marker::PhantomData, + real_payload: core::marker::PhantomData, } impl, RealPayload: Encode> Signed { @@ -163,7 +163,7 @@ impl, RealPayload: Encode> Signed, RealPayload: Encode> Signed, RealPayload: Encode> UncheckedSigned, RealPayload: Encode> UncheckedSigned, validator_index: ValidatorIndex, ) -> Self { - use application_crypto::RuntimeAppPublic; + use sp_application_crypto::RuntimeAppPublic; let data = Self::payload_data(&payload, context); let signature = public.sign(&data).unwrap(); - Self { payload, validator_index, signature, real_payload: sp_std::marker::PhantomData } + Self { payload, validator_index, signature, real_payload: core::marker::PhantomData } } /// Immutably access the signature. @@ -343,7 +343,7 @@ impl From> /// This helper trait ensures that we can encode `Statement` as `CompactStatement`, /// and anything as itself. /// -/// This resembles `parity_scale_codec::EncodeLike`, but it's distinct: +/// This resembles `codec::EncodeLike`, but it's distinct: /// `EncodeLike` is a marker trait which asserts at the typesystem level that /// one type's encoding is a valid encoding for another type. It doesn't /// perform any type conversion when encoding. diff --git a/polkadot/primitives/src/v7/slashing.rs b/polkadot/primitives/src/v8/slashing.rs similarity index 97% rename from polkadot/primitives/src/v7/slashing.rs rename to polkadot/primitives/src/v8/slashing.rs index bcd7d0c2fc4455e2ebf01fab027dbf0618f63dba..148bc1477ff88fd94565d7b834399500f6a1d17e 100644 --- a/polkadot/primitives/src/v7/slashing.rs +++ b/polkadot/primitives/src/v8/slashing.rs @@ -17,9 +17,9 @@ //! Primitives types used for dispute slashing. use crate::{CandidateHash, SessionIndex, ValidatorId, ValidatorIndex}; -use parity_scale_codec::{Decode, Encode}; +use alloc::{collections::btree_map::BTreeMap, vec::Vec}; +use codec::{Decode, Encode}; use scale_info::TypeInfo; -use sp_std::{collections::btree_map::BTreeMap, vec::Vec}; /// The kind of the dispute offence. #[derive(PartialEq, Eq, Clone, Copy, Encode, Decode, TypeInfo, Debug)] diff --git a/polkadot/primitives/src/vstaging/mod.rs b/polkadot/primitives/src/vstaging/mod.rs index 1af73993f640cb8d28bc5145ffb797ab0619d16c..1429b0c326aceef4b9088bd4ddef6828f8dcfbd8 100644 --- a/polkadot/primitives/src/vstaging/mod.rs +++ b/polkadot/primitives/src/vstaging/mod.rs @@ -17,85 +17,3 @@ //! Staging Primitives. // Put any primitives used by staging APIs functions here -use crate::v7::*; -use sp_std::prelude::*; - -use parity_scale_codec::{Decode, Encode}; -use primitives::RuntimeDebug; -use scale_info::TypeInfo; -use sp_arithmetic::Perbill; - -/// Scheduler configuration parameters. All coretime/ondemand parameters are here. -#[derive( - RuntimeDebug, - Copy, - Clone, - PartialEq, - Encode, - Decode, - TypeInfo, - serde::Serialize, - serde::Deserialize, -)] -pub struct SchedulerParams { - /// How often parachain groups should be rotated across parachains. - /// - /// Must be non-zero. - pub group_rotation_frequency: BlockNumber, - /// Availability timeout for a block on a core, measured in blocks. - /// - /// This is the maximum amount of blocks after a core became occupied that validators have time - /// to make the block available. - /// - /// This value only has effect on group rotations. If backers backed something at the end of - /// their rotation, the occupied core affects the backing group that comes afterwards. We limit - /// the effect one backing group can have on the next to `paras_availability_period` blocks. - /// - /// Within a group rotation there is no timeout as backers are only affecting themselves. - /// - /// Must be at least 1. With a value of 1, the previous group will not be able to negatively - /// affect the following group at the expense of a tight availability timeline at group - /// rotation boundaries. - pub paras_availability_period: BlockNumber, - /// The maximum number of validators to have per core. - /// - /// `None` means no maximum. - pub max_validators_per_core: Option, - /// The amount of blocks ahead to schedule paras. - pub lookahead: u32, - /// How many cores are managed by the coretime chain. - pub num_cores: u32, - /// The max number of times a claim can time out in availability. - pub max_availability_timeouts: u32, - /// The maximum queue size of the pay as you go module. - pub on_demand_queue_max_size: u32, - /// The target utilization of the spot price queue in percentages. - pub on_demand_target_queue_utilization: Perbill, - /// How quickly the fee rises in reaction to increased utilization. - /// The lower the number the slower the increase. - pub on_demand_fee_variability: Perbill, - /// The minimum amount needed to claim a slot in the spot pricing queue. - pub on_demand_base_fee: Balance, - /// The number of blocks a claim stays in the scheduler's claim queue before getting cleared. - /// This number should go reasonably higher than the number of blocks in the async backing - /// lookahead. - pub ttl: BlockNumber, -} - -impl> Default for SchedulerParams { - fn default() -> Self { - Self { - group_rotation_frequency: 1u32.into(), - paras_availability_period: 1u32.into(), - max_validators_per_core: Default::default(), - lookahead: 1, - num_cores: Default::default(), - max_availability_timeouts: Default::default(), - on_demand_queue_max_size: ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, - on_demand_target_queue_utilization: Perbill::from_percent(25), - on_demand_fee_variability: Perbill::from_percent(3), - on_demand_base_fee: 10_000_000u128, - ttl: 5u32.into(), - } - } -} diff --git a/polkadot/primitives/test-helpers/Cargo.toml b/polkadot/primitives/test-helpers/Cargo.toml index fab9480cfdeb9876c2556ae78a690775bf16d7a8..a44996ad6ef2dfdbeeea6c75fadb397d500eafec 100644 --- a/polkadot/primitives/test-helpers/Cargo.toml +++ b/polkadot/primitives/test-helpers/Cargo.toml @@ -10,9 +10,9 @@ license.workspace = true workspace = true [dependencies] -sp-keyring = { path = "../../../substrate/primitives/keyring" } -sp-application-crypto = { package = "sp-application-crypto", path = "../../../substrate/primitives/application-crypto", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime" } -sp-core = { path = "../../../substrate/primitives/core", features = ["std"] } -polkadot-primitives = { path = ".." } -rand = "0.8.5" +sp-keyring = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true } +sp-runtime = { workspace = true, default-features = true } +sp-core = { features = ["std"], workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } diff --git a/polkadot/roadmap/implementers-guide/src/SUMMARY.md b/polkadot/roadmap/implementers-guide/src/SUMMARY.md index bb19390c7af4d422dfe62252a7153392c8ef534d..41485e5df8ec1f75bc04a54c5c21ef87a5ef4bb6 100644 --- a/polkadot/roadmap/implementers-guide/src/SUMMARY.md +++ b/polkadot/roadmap/implementers-guide/src/SUMMARY.md @@ -8,6 +8,7 @@ - [Disputes Process](protocol-disputes.md) - [Dispute Flow](disputes-flow.md) - [Chain Selection and Finalization](protocol-chain-selection.md) + - [Validator Disabling](protocol-validator-disabling.md) - [Architecture Overview](architecture.md) - [Messaging Overview](messaging.md) - [PVF Pre-checking](pvf-prechecking.md) diff --git a/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md b/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md index 345b3d2e6970403f3096272cc51f903e0566a22e..9b4082c49e2f003f0b7d0fd317bc2e8ce06580e4 100644 --- a/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md +++ b/polkadot/roadmap/implementers-guide/src/node/approval/approval-voting.md @@ -396,7 +396,7 @@ On receiving an `ApprovedAncestor(Hash, BlockNumber, response_channel)`: * Requires `(SessionIndex, SessionInfo, CandidateReceipt, ValidatorIndex, backing_group, block_hash, candidate_index)` * Extract the public key of the `ValidatorIndex` from the `SessionInfo` for the session. * Issue an `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session_index, Some(backing_group), - response_sender)` +Some(core_index), response_sender)` * Load the historical validation code of the parachain by dispatching a `RuntimeApiRequest::ValidationCodeByHash(descriptor.validation_code_hash)` against the state of `block_hash`. * Spawn a background task with a clone of `background_tx` diff --git a/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md b/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md index c57c4589244e79f6cd54a87f823abc466ed8eb43..5b756080becc05b4804138e64baeac3bfdaf97b8 100644 --- a/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md +++ b/polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md @@ -1,84 +1,108 @@ # Availability Recovery -This subsystem is the inverse of the [Availability Distribution](availability-distribution.md) subsystem: validators -will serve the availability chunks kept in the availability store to nodes who connect to them. And the subsystem will -also implement the other side: the logic for nodes to connect to validators, request availability pieces, and -reconstruct the `AvailableData`. +This subsystem is responsible for recovering the data made available via the +[Availability Distribution](availability-distribution.md) subsystem, neccessary for candidate validation during the +approval/disputes processes. Additionally, it is also being used by collators to recover PoVs in adversarial scenarios +where the other collators of the para are censoring blocks. -This version of the availability recovery subsystem is based off of direct connections to validators. In order to -recover any given `AvailableData`, we must recover at least `f + 1` pieces from validators of the session. Thus, we will -connect to and query randomly chosen validators until we have received `f + 1` pieces. +According to the Polkadot protocol, in order to recover any given `AvailableData`, we generally must recover at least +`f + 1` pieces from validators of the session. Thus, we should connect to and query randomly chosen validators until we +have received `f + 1` pieces. + +In practice, there are various optimisations implemented in this subsystem which avoid querying all chunks from +different validators and/or avoid doing the chunk reconstruction altogether. ## Protocol -`PeerSet`: `Validation` +This version of the availability recovery subsystem is based only on request-response network protocols. Input: -* `NetworkBridgeUpdate(update)` -* `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session, backing_group, response)` +* `AvailabilityRecoveryMessage::RecoverAvailableData(candidate, session, backing_group, core_index, response)` Output: -* `NetworkBridge::SendValidationMessage` -* `NetworkBridge::ReportPeer` -* `AvailabilityStore::QueryChunk` +* `NetworkBridgeMessage::SendRequests` +* `AvailabilityStoreMessage::QueryAllChunks` +* `AvailabilityStoreMessage::QueryAvailableData` +* `AvailabilityStoreMessage::QueryChunkSize` + ## Functionality -We hold a state which tracks the currently ongoing recovery tasks, as well as which request IDs correspond to which -task. A recovery task is a structure encapsulating all recovery tasks with the network necessary to recover the -available data in respect to one candidate. +We hold a state which tracks the currently ongoing recovery tasks. A `RecoveryTask` is a structure encapsulating all +network tasks needed in order to recover the available data in respect to a candidate. + +Each `RecoveryTask` has a collection of ordered recovery strategies to try. ```rust +/// Subsystem state. struct State { - /// Each recovery is implemented as an independent async task, and the handles only supply information about the result. - ongoing_recoveries: FuturesUnordered, - /// A recent block hash for which state should be available. - live_block_hash: Hash, - // An LRU cache of recently recovered data. - availability_lru: LruMap>, + /// Each recovery task is implemented as its own async task, + /// and these handles are for communicating with them. + ongoing_recoveries: FuturesUnordered, + /// A recent block hash for which state should be available. + live_block: (BlockNumber, Hash), + /// An LRU cache of recently recovered data. + availability_lru: LruMap, + /// Cached runtime info. + runtime_info: RuntimeInfo, } -/// This is a future, which concludes either when a response is received from the recovery tasks, -/// or all the `awaiting` channels have closed. -struct RecoveryHandle { - candidate_hash: CandidateHash, - interaction_response: RemoteHandle, - awaiting: Vec>>, -} - -struct Unavailable; -struct Concluded(CandidateHash, Result); - -struct RecoveryTaskParams { - validator_authority_keys: Vec, - validators: Vec, - // The number of pieces needed. - threshold: usize, - candidate_hash: Hash, - erasure_root: Hash, +struct RecoveryParams { + /// Discovery ids of `validators`. + pub validator_authority_keys: Vec, + /// Number of validators. + pub n_validators: usize, + /// The number of regular chunks needed. + pub threshold: usize, + /// The number of systematic chunks needed. + pub systematic_threshold: usize, + /// A hash of the relevant candidate. + pub candidate_hash: CandidateHash, + /// The root of the erasure encoding of the candidate. + pub erasure_root: Hash, + /// Metrics to report. + pub metrics: Metrics, + /// Do not request data from availability-store. Useful for collators. + pub bypass_availability_store: bool, + /// The type of check to perform after available data was recovered. + pub post_recovery_check: PostRecoveryCheck, + /// The blake2-256 hash of the PoV. + pub pov_hash: Hash, + /// Protocol name for ChunkFetchingV1. + pub req_v1_protocol_name: ProtocolName, + /// Protocol name for ChunkFetchingV2. + pub req_v2_protocol_name: ProtocolName, + /// Whether or not chunk mapping is enabled. + pub chunk_mapping_enabled: bool, + /// Channel to the erasure task handler. + pub erasure_task_tx: mpsc::Sender, } -enum RecoveryTask { - RequestFromBackers { - // a random shuffling of the validators from the backing group which indicates the order - // in which we connect to them and request the chunk. - shuffled_backers: Vec, - } - RequestChunksFromValidators { - // a random shuffling of the validators which indicates the order in which we connect to the validators and - // request the chunk from them. - shuffling: Vec, - received_chunks: Map, - requesting_chunks: FuturesUnordered>, - } +pub struct RecoveryTask { + sender: Sender, + params: RecoveryParams, + strategies: VecDeque>>, + state: task::State, } -struct RecoveryTask { - to_subsystems: SubsystemSender, - params: RecoveryTaskParams, - source: Source, +#[async_trait::async_trait] +/// Common trait for runnable recovery strategies. +pub trait RecoveryStrategy: Send { + /// Main entry point of the strategy. + async fn run( + mut self: Box, + state: &mut task::State, + sender: &mut Sender, + common_params: &RecoveryParams, + ) -> Result; + + /// Return the name of the strategy for logging purposes. + fn display_name(&self) -> &'static str; + + /// Return the strategy type for use as a metric label. + fn strategy_type(&self) -> &'static str; } ``` @@ -90,68 +114,71 @@ Ignore `BlockFinalized` signals. On `Conclude`, shut down the subsystem. -#### `AvailabilityRecoveryMessage::RecoverAvailableData(receipt, session, Option, response)` +#### `AvailabilityRecoveryMessage::RecoverAvailableData(...)` -1. Check the `availability_lru` for the candidate and return the data if so. -1. Check if there is already an recovery handle for the request. If so, add the response handle to it. +1. Check the `availability_lru` for the candidate and return the data if present. +1. Check if there is already a recovery handle for the request. If so, add the response handle to it. 1. Otherwise, load the session info for the given session under the state of `live_block_hash`, and initiate a recovery - task with *`launch_recovery_task`*. Add a recovery handle to the state and add the response channel to it. + task with `launch_recovery_task`. Add a recovery handle to the state and add the response channel to it. 1. If the session info is not available, return `RecoveryError::Unavailable` on the response channel. ### Recovery logic -#### `launch_recovery_task(session_index, session_info, candidate_receipt, candidate_hash, Option)` +#### `handle_recover(...) -> Result<()>` -1. Compute the threshold from the session info. It should be `f + 1`, where `n = 3f + k`, where `k in {1, 2, 3}`, and - `n` is the number of validators. -1. Set the various fields of `RecoveryParams` based on the validator lists in `session_info` and information about the - candidate. -1. If the `backing_group_index` is `Some`, start in the `RequestFromBackers` phase with a shuffling of the backing group - validator indices and a `None` requesting value. -1. Otherwise, start in the `RequestChunksFromValidators` source with `received_chunks`,`requesting_chunks`, and - `next_shuffling` all empty. -1. Set the `to_subsystems` sender to be equal to a clone of the `SubsystemContext`'s sender. -1. Initialize `received_chunks` to an empty set, as well as `requesting_chunks`. +Instantiate the appropriate `RecoveryStrategy`es, based on the subsystem configuration, params and session info. +Call `launch_recovery_task()`. -Launch the source as a background task running `run(recovery_task)`. +#### `launch_recovery_task(state, ctx, response_sender, recovery_strategies, params) -> Result<()>` -#### `run(recovery_task) -> Result` +Create the `RecoveryTask` and launch it as a background task running `recovery_task.run()`. -```rust -// How many parallel requests to have going at once. -const N_PARALLEL: usize = 50; -``` +#### `recovery_task.run(mut self) -> Result` + +* Loop: + * Pop a strategy from the queue. If none are left, return `RecoveryError::Unavailable`. + * Run the strategy. + * If the strategy returned successfully or returned `RecoveryError::Invalid`, break the loop. + +### Recovery strategies + +#### `FetchFull` + +This strategy tries requesting the full available data from the validators in the backing group to +which the node is already connected. They are tried one by one in a random order. +It is very performant if there's enough network bandwidth and the backing group is not overloaded. +The costly reed-solomon reconstruction is not needed. + +#### `FetchSystematicChunks` + +Very similar to `FetchChunks` below but requests from the validators that hold the systematic chunks, so that we avoid +reed-solomon reconstruction. Only possible if `node_features::FeatureIndex::AvailabilityChunkMapping` is enabled and +the `core_index` is supplied (currently only for recoveries triggered by approval voting). + +More info in +[RFC-47](https://github.com/polkadot-fellows/RFCs/blob/main/text/0047-assignment-of-availability-chunks.md). + +#### `FetchChunks` + +The least performant strategy but also the most comprehensive one. It's the only one that cannot fail under the +byzantine threshold assumption, so it's always added as the last one in the `recovery_strategies` queue. + +Performs parallel chunk requests to validators. When enough chunks were received, do the reconstruction. +In the worst case, all validators will be tried. + +### Default recovery strategy configuration + +#### For validators + +If the estimated available data size is smaller than a configured constant (currently 1Mib for Polkadot or 4Mib for +other networks), try doing `FetchFull` first. +Next, if the preconditions described in `FetchSystematicChunks` above are met, try systematic recovery. +As a last resort, do `FetchChunks`. + +#### For collators + +Collators currently only use `FetchChunks`, as they only attempt recoveries in rare scenarios. -* Request `AvailabilityStoreMessage::QueryAvailableData`. If it exists, return that. -* If the task contains `RequestFromBackers` - * Loop: - * If the `requesting_pov` is `Some`, poll for updates on it. If it concludes, set `requesting_pov` to `None`. - * If the `requesting_pov` is `None`, take the next backer off the `shuffled_backers`. - * If the backer is `Some`, issue a `NetworkBridgeMessage::Requests` with a network request for the - `AvailableData` and wait for the response. - * If it concludes with a `None` result, return to beginning. - * If it concludes with available data, attempt a re-encoding. - * If it has the correct erasure-root, break and issue a `Ok(available_data)`. - * If it has an incorrect erasure-root, return to beginning. - * Send the result to each member of `awaiting`. - * If the backer is `None`, set the source to `RequestChunksFromValidators` with a random shuffling of validators - and empty `received_chunks`, and `requesting_chunks` and break the loop. - -* If the task contains `RequestChunksFromValidators`: - * Request `AvailabilityStoreMessage::QueryAllChunks`. For each chunk that exists, add it to `received_chunks` and - remote the validator from `shuffling`. - * Loop: - * If `received_chunks + requesting_chunks + shuffling` lengths are less than the threshold, break and return - `Err(Unavailable)`. - * Poll for new updates from `requesting_chunks`. Check merkle proofs of any received chunks. If the request simply - fails due to network issues, insert into the front of `shuffling` to be retried. - * If `received_chunks` has more than `threshold` entries, attempt to recover the data. - * If that fails, return `Err(RecoveryError::Invalid)` - * If correct: - * If re-encoding produces an incorrect erasure-root, break and issue a `Err(RecoveryError::Invalid)`. - * break and issue `Ok(available_data)` - * Send the result to each member of `awaiting`. - * While there are fewer than `N_PARALLEL` entries in `requesting_chunks`, - * Pop the next item from `shuffling`. If it's empty and `requesting_chunks` is empty, return - `Err(RecoveryError::Unavailable)`. - * Issue a `NetworkBridgeMessage::Requests` and wait for the response in `requesting_chunks`. +Moreover, the recovery task is specially configured to not attempt requesting data from the local availability-store +(because it doesn't exist) and to not reencode the data after a succcessful recovery (because it's an expensive check +that is not needed; checking the pov_hash is enough for collators). diff --git a/polkadot/roadmap/implementers-guide/src/node/backing/candidate-backing.md b/polkadot/roadmap/implementers-guide/src/node/backing/candidate-backing.md index 31f8423fe27b275452b84bc8d2486e10b81e1908..0e483f02ec312ae3649b158735dd5872b56eadf7 100644 --- a/polkadot/roadmap/implementers-guide/src/node/backing/candidate-backing.md +++ b/polkadot/roadmap/implementers-guide/src/node/backing/candidate-backing.md @@ -1,5 +1,9 @@ # Candidate Backing +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + The Candidate Backing subsystem ensures every parablock considered for relay block inclusion has been seconded by at least one validator, and approved by a quorum. Parablocks for which not enough validators will assert correctness are discarded. If the block later proves invalid, the initial backers are slashable; this gives Polkadot a rational threat diff --git a/polkadot/roadmap/implementers-guide/src/node/backing/prospective-parachains.md b/polkadot/roadmap/implementers-guide/src/node/backing/prospective-parachains.md index 8f00ff084941cc260dea6a9e76c0ff30d3770caf..61278621cf565c226c2133eb90c0d7e0430c5624 100644 --- a/polkadot/roadmap/implementers-guide/src/node/backing/prospective-parachains.md +++ b/polkadot/roadmap/implementers-guide/src/node/backing/prospective-parachains.md @@ -1,5 +1,9 @@ # Prospective Parachains +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + ## Overview **Purpose:** Tracks and handles prospective parachain fragments and informs @@ -98,15 +102,11 @@ prospective validation data. This is unlikely to change. hashes. - Sent by the Provisioner when requesting backable candidates, when selecting candidates for a given relay-parent. -- `ProspectiveParachainsMessage::GetHypotheticalFrontier` +- `ProspectiveParachainsMessage::GetHypotheticalMembership` - Gets the hypothetical frontier membership of candidates with the given properties under the specified active leaves' fragment trees. - Sent by the Backing Subsystem when sanity-checking whether a candidate can be seconded based on its hypothetical frontiers. -- `ProspectiveParachainsMessage::GetTreeMembership` - - Gets the membership of the candidate in all fragment trees. - - Sent by the Backing Subsystem when it needs to update the candidates - seconded at various depths under new active leaves. - `ProspectiveParachainsMessage::GetMinimumRelayParents` - Gets the minimum accepted relay-parent number for each para in the fragment tree for the given relay-chain block hash. diff --git a/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md b/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md index e6e597c531787f46ced0a6f9e38e05817f2323d7..ce2ff3ca9139dc67ffd8aafa613a5fbde9f40448 100644 --- a/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md +++ b/polkadot/roadmap/implementers-guide/src/node/backing/statement-distribution.md @@ -130,23 +130,9 @@ accept statements from it. Filtering out of statements from disabled validators on the node side is purely an optimization, as it will be done in the runtime as well. -Because we use the state of the active leaves to -check whether a validator is disabled instead of the relay parent, the notion -of being disabled is inherently racy: -- the responder has learned about the disabled validator before the requester -- the receiver has witnessed the disabled validator after sending the request - -We could have sent a manifest to a peer, then received information about -disabling, and then receive a request. This can break an invariant of the grid -mode: -- the response is required to indicate quorum - -Due to the above, there should be no response at all for grid requests when -the backing threshold is no longer met as a result of disabled validators. -In addition to that, we add disabled validators to the request's unwanted -mask. This ensures that the sender will not send statements from disabled -validators (at least from the perspective of the receiver at the moment of the -request). This doesn't fully avoid race conditions, but tries to minimize them. +We use the state of the relay parent to check whether a validator is disabled +to avoid race conditions and ensure that disabling works well in the presense +of re-enabling. ## Messages @@ -194,7 +180,7 @@ request). This doesn't fully avoid race conditions, but tries to minimize them. - Reports a peer (either good or bad). - `CandidateBackingMessage::Statement` - Note a validator's statement about a particular candidate. -- `ProspectiveParachainsMessage::GetHypotheticalFrontier` +- `ProspectiveParachainsMessage::GetHypotheticalMembership` - Gets the hypothetical frontier membership of candidates under active leaves' fragment trees. - `NetworkBridgeTxMessage::SendRequests` - Sends requests, initiating the request/response protocol. @@ -211,9 +197,9 @@ We also have a request/response protocol because validators do not eagerly send - Requests are queued up with `RequestManager::get_or_insert`. - Done as needed, when handling incoming manifests/statements. - `RequestManager::dispatch_requests` sends any queued-up requests. - - Calls `RequestManager::next_request` to completion. - - Creates the `OutgoingRequest`, saves the receiver in `RequestManager::pending_responses`. - - Does nothing if we have more responses pending than the limit of parallel requests. + - Calls `RequestManager::next_request` to completion. + - Creates the `OutgoingRequest`, saves the receiver in `RequestManager::pending_responses`. + - Does nothing if we have more responses pending than the limit of parallel requests. 2. Peer diff --git a/polkadot/roadmap/implementers-guide/src/node/collators/collator-protocol.md b/polkadot/roadmap/implementers-guide/src/node/collators/collator-protocol.md index 1fed671170c7c42f6de97dead0e53200ef5d675f..432d9ab69bab99297b51fb5af285e7636e8b90ae 100644 --- a/polkadot/roadmap/implementers-guide/src/node/collators/collator-protocol.md +++ b/polkadot/roadmap/implementers-guide/src/node/collators/collator-protocol.md @@ -1,5 +1,9 @@ # Collator Protocol +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + The Collator Protocol implements the network protocol by which collators and validators communicate. It is used by collators to distribute collations to validators and used by validators to accept collations by collators. diff --git a/polkadot/roadmap/implementers-guide/src/node/utility/provisioner.md b/polkadot/roadmap/implementers-guide/src/node/utility/provisioner.md index b017259da8c0863e47deb87e916076d20ed95996..64727d39fabe0dee80e047a1444894733c827014 100644 --- a/polkadot/roadmap/implementers-guide/src/node/utility/provisioner.md +++ b/polkadot/roadmap/implementers-guide/src/node/utility/provisioner.md @@ -1,5 +1,9 @@ # Provisioner +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + Relay chain block authorship authority is governed by BABE and is beyond the scope of the Overseer and the rest of the subsystems. That said, ultimately the block author needs to select a set of backable parachain candidates and other consensus data, and assemble a block from them. This subsystem is responsible for providing the necessary data to all diff --git a/polkadot/roadmap/implementers-guide/src/protocol-disputes.md b/polkadot/roadmap/implementers-guide/src/protocol-disputes.md index 2a4082cc07f92aa99425e9e708ec2e90117c02c5..922cc3c3e2b56836d804f9decd8c2be44e7a7fd4 100644 --- a/polkadot/roadmap/implementers-guide/src/protocol-disputes.md +++ b/polkadot/roadmap/implementers-guide/src/protocol-disputes.md @@ -8,9 +8,9 @@ All parachain blocks that end up in the finalized relay chain should be valid. T only backed, but not included. We have two primary components for ensuring that nothing invalid ends up in the finalized relay chain: - * Approval Checking, as described [here](./protocol-approval.md) and implemented according to the [Approval - Voting](node/approval/approval-voting.md) subsystem. This protocol can be shown to prevent invalid parachain blocks - from making their way into the finalized relay chain as long as the amount of attempts are limited. + * Approval Checking, as described [here](./protocol-approval.md) and implemented accordingly in the [Approval +Voting](node/approval/approval-voting.md) subsystem. This protocol can be shown to prevent invalid parachain blocks +from making their way into the finalized relay chain as long as the amount of attempts are limited. * Disputes, this protocol, which ensures that each attempt to include something bad is caught, and the offending validators are punished. Disputes differ from backing and approval process (and can not be part of those) in that a dispute is independent of a particular fork, while both backing and approval operate on particular forks. This diff --git a/polkadot/roadmap/implementers-guide/src/protocol-validator-disabling.md b/polkadot/roadmap/implementers-guide/src/protocol-validator-disabling.md new file mode 100644 index 0000000000000000000000000000000000000000..9fd44c00fa0a1c9ba7f5bb0d5abd54bdc55b8e4e --- /dev/null +++ b/polkadot/roadmap/implementers-guide/src/protocol-validator-disabling.md @@ -0,0 +1,437 @@ +# Validator Disabling + +## Background + +As established in the [approval process](protocol-approval.md) dealing with bad parablocks is a three step process: + +1. Detection +1. Escalation +1. Consequences + +The main system responsible for dispensing **consequences** for malicious actors is the [dispute +system](protocol-disputes.md) which eventually dispenses slash events. The slashes itself can be dispensed quickly (a +matter of blocks) but for an extra layer of auditing all slashes are deferred for 27 days (in Polkadot/Kusama) which +gives time for Governance to investigate and potentially alter the punishment. Dispute concluding by itself does not +immediately remove the validator from the active validator set. + +> **Note:** \ +> There was an additional mechanism of automatically chilling the validator which removed their intent to participate in +> the next election, but the removed validator could simply re-register his intent to validate. + +There is a need to have a more immediate way to deal with malicious validators. This is where the validator disabling +comes in. It is focused on dispensing **low latency** consequences for malicious actors. It is important to note that +the validator disabling is not a replacement for the dispute or slashing systems. It is a complementary system that is +focused on lighter but immediate consequences usually in the form of restricted validator privileges. + +The primary goals are: +- Eliminate or minimize cases where attackers can get free attempts at attacking the network +- Eliminate or minimize the risks of honest nodes being pushed out of consensus when getting unjustly slashed (defense + in depth) + +The above two goals are generally at odds so a careful balance has to be struck between them. We will achieve them by +sacrificing some **liveness** in favor of **soundness** when the network is under stress. Maintaining some liveness but +absolute soundness is paramount. + +> **Note:** \ +> Liveness = Valid candidates can go through (at a decent pace) \ +> Security = Invalid candidates cannot go through (or are statistically very improbable) + +Side goals are: +- Reduce the damages to honest nodes that had a fault which might cause repeated slashes +- Reduce liveness impact of individual malicious attackers + +## System Overview + +High level assumptions and goals of the validator disabling system that will be further discussed in the following +sections: + +1. If validator gets slashed (even 0%) we mark them as disabled in the runtime and on the node side. +1. We only disable up to byzantine threshold of the validators. +1. If there are more offenders than byzantine threshold disable only the highest offenders. (Some might get re-enabled.) +1. Disablement lasts for 1 era. +1. Disabled validators remain in the active validator set but have some limited permissions. +1. Disabled validators can get re-elected. +1. Disabled validators can participate in approval checking. +1. Disabled validators can participate in GRANDPA/BEEFY, but equivocations cause disablement. +1. Disabled validators cannot author blocks. +1. Disabled validators cannot back candidates. +1. Disabled validators cannot initiate disputes, but their votes are still counted if a dispute occurs. +1. Disabled validators making dispute statements no-show in approval checking. + +


+ +# Risks + +## Risks of NOT having validator disabling + +Assume that if an offense is committed a slash is deposited but the perpetrator can still act normally. He will be +slashed 100% with a long delay (slash deferral duration which is 27 days). This is akin to the current design. + +A simple argument for disabling is that if someone is already slashed 100% and they have nothing to lose they could +cause harm to the network and should be silenced. + +What harm could they cause? + +**1. Liveness attacks:** + +- 1.1. Break sharding (with mass no-shows or mass disputes): It forces everyone to do all the work which affects + liveness but doesn't kill it completely. The chain can progress at a slow rate. + +- 1.2. Mass invalid candidate backing: Spawns a lot of worthless work that needs to be done but it is bounded by backing + numbers. Honest backers will still back valid candidates and that cannot be stopped. Honest block authors will + eventually select valid candidates and even if disputed they will win and progress the chain. + +**2. Soundness attacks:** + +- 2.1. The best and possibly only way to affect soundness is by getting lucky in the approval process. If by chance all + approval voters would be malicious, the attackers could get a single invalid candidate through. Their chances would be + relatively low but in general this risk has to be taken seriously as it significantly reduces the safety buffer around + approval checking. + +> **Note:** With 30 approvals needed chance that a malicious candidate going through is around 4\*10^-15. Assuming +> attackers can back invalid candidates on 50 cores for 48 hours straight and only those candidates get included it +> still gives a 7\*10^-9 chance of success which is still relatively small considering the cost (all malicious stake +> slashed). + +Attacks 1.2 and 2.1 should generally be pretty futile as a solo attacker while 1.1 could be possible with mass disputes +even from a single attacker. Nevertheless whatever the attack vector within the old system the attackers would get +*eventually* get slashed and pushed out of the active validator set but they had plenty of time to wreck havoc. + +## Risks of having validator disabling + +Assume we fully push out validator when they commit offenses. + +The primary risk behind having any sort of disabling is that it is a double-edged sword that in case of any dispute bugs +or sources of PVF non-determinism could disable honest nodes or be abused by attackers to specifically silence honest +nodes. + +Validators being pushed out of the validator set are an issue because that can greatly skew the numbers game in approval +checking (% for 30-ish malicious in a row). + +There are also censorship or liveness issues if backing is suddenly dominated by malicious nodes but in general even if +some honest blocks get backed liveness should be preserved. + +> **Note:** It is worth noting that is is fundamentally a defense in depth strategy because if we assume disputes are +> perfect it should not be a real concern. In reality disputes and determinism are difficult to get right, and +> non-determinism and happen so defense in depth is crucial when handling those subsystems. + +


+ +# Risks Mitigation + +## Addressing the risks of having validator disabling + +One safety measure is bounding the disabled number to 1/3 ([**Point 2.**](#system-overview)) or to be exact the +byzantine threshold. If for any reason more than 1/3 of validators are getting disabled it means that some part of the +protocol failed or there is more than 1/3 malicious nodes which breaks the assumptions. + +Even in such a dire situation where more than 1/3 got disabled the most likely scenario is a non-determinism bug or +sacrifice attack bug. Those attacks generally cause minor slashes to multiple honest nodes. In such a case the situation +could be salvaged by prioritizing highest offenders for disabling ([**Point 3.**](#system-overview)). + +> **Note:** \ +> System can be launched with re-enabling and will still provide some security improvements. Re-enabling will be +> launched in an upgrade after the initial deployment. + +Fully pushing out offending validator out of the validator set it too risky in case of a dispute bug, non-determinism or +sacrifice attacks. Main issue lies in skewing the numbers in approval checking so instead of fully blocking disabled +nodes a different approach can be taken - one were only some functionalities are disabled ([**Point +5.**](#system-overview)). Once of those functionalities can be approval voting which as pointed above is so crucial that +even in a disabled state nodes should be able to participate in it ([**Point 7.**](#system-overview)). + +> **Note:** \ +> Approval Checking statement are implicitly valid. Sending a statement for an invalid candidate is a part of the +> dispute logic which we did not yet discuss. For now we only allow nodes to state that a candidate is valid or remain +> silent. But this solves the main risk of disabling. + +Because we capped the number of disabled nodes to 1/3 there will always be at least 1/3 honest nodes to participate in +backing so liveness should be preserved. That means that backing **COULD** be safely disabled for disabled nodes +([**Point 10.**](#system-overview)). + + +## Addressing the risks of NOT having validator disabling + +To determine if backing **SHOULD** be disabled the attack vector of 1.2 (Mass invalid candidate backing) and 2.1 +(Getting lucky in approval voting) need to be considered. In both of those cases having extra backed malicious +candidates gives attackers extra chances to get lucky in approval checking. The solution is to not allow for backing in +disablement. ([**Point 10.**](#system-overview)) + +The attack vector 1.1 (Break sharding) requires a bit more nuance. If we assume that the attacker is a single entity and +that he can get a lot of disputes through he could potentially incredibly easily break sharding. This generally points +into the direction of disallowing that during disablement ([**Point 11.**](#system-overview)). + +This might seem like an issue because it takes away the escalation privileges of disabled approval checkers but this is +NOT true. By issuing a dispute statement those nodes remain silent in approval checking because they skip their approval +statement and thus will count as a no-show. This will create a mini escalation for that particular candidate. This means +that disabled nodes maintain just enough escalation that they can protect soundness (same argument as soundness +protection during a DoS attack on approval checking) but they lose their extreme escalation privilege which are only +given to flawlessly performing nodes ([**Point 12.**](#system-overview)). + +As a defense in depth measure dispute statements from disabled validators count toward confirming disputes (byzantine +threshold needed to confirm). If a dispute is confirmed everyone participates in it. This protects us from situations +where due to a bug more than byzantine threshold of validators would be disabled. + +> **Note:** \ +> The way this behavior is achieved easily in implementation is that honest nodes note down dispute statements from +> disabled validators just like they would for normal nodes, but they do not release their own dispute statements unless +> the dispute is confirmed already. This simply stops the escalation process of disputes. + +

+ +# Disabling Duration + +## Context + +A crucial point to understand is that as of the time of writing all slashing events as alluded to in the begging are +delayed for 27 days before being executed. This is primarily because it gives governance enough time to investigate and +potentially intervene. For that duration when the slash is pending the stake is locked and cannot be moved. Time to +unbond you stake is 28 days which ensures that the stake will eventually be slashed before being withdrawn. + +## Design + +A few options for the duration of disablement were considered: +- 1 epoch (4h in Polkadot) +- 1 era (24h in Polkadot) +- 2-26 eras +- 27 eras + +1 epoch is a short period and between a few epochs the validator will most likely be exactly the same. It is also very +difficult to fix any local node issues for honest validator in such a short time so the chance for a repeated offense is +high. + +1 era gives a bit more time to fix any minor issues. Additionally, it guarantees a validator set change at so many of +the currently disabled validator might no longer be present anyway. It also gives the time for the validator to chill +themselves if they have identified a cause and want to spend more time fixing it. ([**Point 4.**](#system-overview)) + +Higher values could be considered and the main arguments for those are based around the fact that it reduces the number +of repeated attacks that will be allowed before the slash execution. Generally 1 attack per era for 27 eras resulting in +27 attacks at most should not compromise our safety assumptions. Although this direction could be further explored and +might be parametrized for governance to decide. + +


+ +# Economic consequences of Disablement + +Disablement is generally a form of punishment and that will be reflected in the rewards at the end of an era. A disabled +validator will not receive any rewards for backing or block authoring. which will reduce its profits. + +That means that the opportunity cost of being disabled is a punishment by itself and thus it can be used for some cases +where a minor punishment is needed. Current implementation was using 0% slashes to mark nodes for chilling and similar +approach of 0% slashes can be used to mark validators for disablement. ([**Point 1.**](#system-overview)) 0% slashes +could for instance be used to punish approval checkers voting invalid on valid candidates. + +Anything higher than 0% will of course also lead to a disablement. + +> **Notes:** \ +> Alternative designs incorporating disabling proportional to offenses were explored but they were deemed too complex +> and not worth the effort. Main issue with those is that proportional disabling would cause back and forth between +> disabled and enabled which complicated tracking the state of disabled validators and messes with optimistic node +> optimizations. Main benefits were that minor slashes will be barely disabled which has nice properties against +> sacrifice attacks. + +


+ +# Redundancy + +Some systems can be greatly simplified or outright removed thanks to the above changes. This leads to reduced complexity +around the systems that were hard to reason about and were sources of potential bugs or new attack vectors. + +## Automatic Chilling + +Chilling is process of a validator dropping theirs intent to validate. This removes them from the upcoming NPoS +elections and effectively pushes them out of the validator set as quickly as of the next era (or 2 era in case of late +offenses). All nominators of that validator were also getting unsubscribed from that validator. Validator could +re-register their intent to validate at any time. The intent behind this logic was to protect honest stakes from +repeated slashes caused by unnoticed bugs. It would give time for validators to fix their issue before continuing as a +validator. + +Chilling had a myriad of problems. It assumes that validators and nominators remain very active and monitor everything. +If a validator got slashed he was getting automatically chilled and his nominators were getting unsubscribed. This was +an issue because of minor non-malicious slashes due to node operator mistakes or small bugs. Validators got those bugs +fixed quickly and were reimbursed but nominator had to manually re-subscribe to the validator, which they often +postponed for very lengthy amounts of time most likely due to simply not checking their stake. **This forced +unsubscribing of nominators was later disabled.** + +Automatic chilling was achieving its goals in ideal scenarios (no attackers, no lazy nominators) but it opened new +vulnerabilities for attackers. The biggest issue was that chilling in case of honest node slashes could lead to honest +validators being quickly pushed out of the next validator set within the next era. This retains the validator set size +but gives an edge to attackers as they can more easily win slots in the NPoS election. + +Disabling allows for punishment that limits the damages malicious actors can cause without having to resort to kicking +them out of the validator set. This protects us from the edge case of honest validators getting quickly pushed out of +the set by slashes. ([**Point 6.**](#system-overview)) + +> **Notes:** \ +> As long as honest slashes absolutely cannot occur automatic chilling is a sensible and desirable. This means it could +> be re-enabled once PolkaVM introduces deterministic gas metering. Then best of both worlds could be achieved. + +## Forcing New Era + +Previous implementation of disabling had some limited mechanisms allowing for validators disablement and if too many +were disabled forcing a new era (new election). Frame staking pallet offered the ability to force a new era but it was +also deemed unsafe as it could be abused and compromised the security of the network for instance by weakening the +randomness used throughout the protocol. + +


+ +# Other types of slashing + +Above slashes were specifically referring to slashing events coming from disputes against candidates, but in Polkadot +other types of offenses exist for example GRANDPA equivocations or block authoring offenses. Question is if the above +defined design can handle those offenses. + +## GRANDPA/BEEFY Offenses + +The main offences for GRANDPA/BEEFY are equivocations. It is not a very serious offense and some nodes committing do not +endanger the system and performance is barely affected. If more than byzantine threshold of nodes equivocate it is a +catastrophic failure potentially resulting in 2 finalized blocks on the same height in the case of GRANDPA. + +Honest nodes generally should not commit those offenses so the goal of protecting them does not apply here. + +> **Note:** \ +> A validator running multiple nodes with the same identity might equivocate. Doing that is highly not advised but it +> has happened before. + +It's not a game of chance so giving attackers extra chances does not compromise soundness. Also it requires a +supermajority of honest nodes to successfully finalize blocks so any disabling of honest nodes from GRANDPA might +compromise liveness. + +Best approach is to allow disabled nodes to participate in GRANDPA/BEEFY as normal and as mentioned before +GRANDPA/BABE/BEEFY equivocations should not happen to honest nodes so we can safely disable the offenders. Additionally +the slashes for singular equivocations will be very low so those offenders would easily get re-enabled in the case of +more serious offenders showing up. ([**Point 8.**](#system-overview)) + +## Block Authoring Offenses (BABE Equivocations) + +Even if all honest nodes are disabled in Block Authoring (BA) liveness is generally preserved. At least 50% of blocks +produced should still be honest. Soundness wise disabled nodes can create a decent amount of wasted work by creating bad +blocks but they only get to do it in bounded amounts. + +Disabling in BA is not a requirement as both liveness and soundness are preserved but it is the current default behavior +as well as it offers a bit less wasted work. + +Offenses in BA just like in backing can be caused by faulty PVFs or bugs. They might happen to honest nodes and +disabling here while not a requirement can also ensure that this node does not repeat the offense as it might not be +trusted with it's PVF anymore. + +Both points above don't present significant risks when disabling so the default behavior is to disable in BA and because +of offenses in BA. ([**Point 9.**](#system-overview)) This filters out honest faulty nodes as well as protects from some +attackers. + +


+ +# Extra Design Considerations + +## Disabling vs Accumulating Slashes + +Instant disabling generally allows us to remove the need for accumulating slashes. It is a more immediate punishment and +it is a more lenient punishment for honest nodes. + +The current architecture of using max slashing can be used and it works around the problems of delaying the slash for a +long period. + +An alternative design with immediate slashing and acclimating slashing could relevant to other systems but it goes +against the governance auditing mechanisms so it's not be suitable for Polkadot. + +## Disabling vs Getting Pushed Out of NPoS Elections + +Validator disabling and getting forced ouf of NPoS elections (1 era) due to slashes are actually very similar processes +in terms of outcomes but there are some differences: + +- **latency** (next few blocks for validator disabling and 27 days for getting pushed out organically) +- **pool restriction** (validator disabling could effectively lower the number of active validators during an era if we + fully disable) +- **granularity** (validator disabling could remove only a portion of validator privileges instead of all) + +Granularity is particularly crucial in the final design as only a few select functions are disabled while others remain. + +## Enabling Approval Voter Slashes + +The original Polkadot 1.0 design describes that all validators on the loosing side of the dispute are slashed. In the +current system only the backers are slashed and any approval voters on the wrong side will not be slashed. This creates +some undesirable incentives: + +- Lazy approval checkers (approvals yay`ing everything) +- Spammy approval checkers (approval voters nay`ing everything) + +Initially those slashes were disabled to reduce the complexity and to minimize the risk surface in case the system +malfunctioned. This is especially risky in case any nondeterministic bugs are present in the system. Once validator +re-enabling is launched approval voter slashes can be re-instated. Numbers need to be further explored but slashes +between 0-2% are reasonable. 0% would still disable which with the opportunity cost consideration should be enough. + + > **Note:** \ +> Spammy approval checkers are in fact not a big issue as a side effect of the offchain-disabling introduced by the +> Defense Against Past-Era Dispute Spam (**Node**) [#2225](https://github.com/paritytech/polkadot-sdk/issues/2225). It +> makes it so all validators loosing a dispute are locally disabled and ignored for dispute initiation so it effectively +> silences spammers. They can still no-show but the damage is minimized. + + +## Interaction with all types of misbehaviors + +With re-enabling in place and potentially approval voter slashes enabled the overall misbehaviour-punishment system can +be as highlighted in the table below: + +|Misbehaviour |Slash % |Onchain Disabling |Offchain Disabling |Chilling |Reputation Costs | +|------------ |------- |----------------- |------------------ |-------- |----------------- | +|Backing Invalid |100% |Yes (High Prio) |Yes (High Prio) |No |No | +|ForInvalid Vote |2% |Yes (Mid Prio) |Yes (Mid Prio) |No |No | +|AgainstValid Vote |0% |Yes (Low Prio) |Yes (Low Prio) |No |No | +|GRANDPA / BABE / BEEFY Equivocations |0.01-100% |Yes (Varying Prio) |No |No |No | +|Seconded + Valid Equivocation |- |No |No |No |No | +|Double Seconded Equivocation |- |No |No |No |Yes | + + +*Ignoring AURA offences. + +**There are some other misbehaviour types handled in rep only (DoS prevention etc) but they are not relevant to this strategy. + +*** BEEFY will soon introduce new slash types so this strategy table will need to be revised but no major changes are expected. + +


+ +# Implementation + +Implementation of the above design covers a few additional areas that allow for node-side optimizations. + +## Core Features + +1. Disabled Validators Tracking (**Runtime**) [#2950](https://github.com/paritytech/polkadot-sdk/issues/2950) + - Expose a ``disabled_validators`` map through a Runtime API +1. Enforce Backing Disabling (**Runtime**) [#1592](https://github.com/paritytech/polkadot-sdk/issues/1592) + - Filter out votes from ``disabled_validators`` in ``BackedCandidates`` in ``process_inherent_data`` +1. Substrate Byzantine Threshold (BZT) as Limit for Disabling + [#1963](https://github.com/paritytech/polkadot-sdk/issues/1963) + - Can be parametrized but default to BZT + - Disable only up to 1/3 of validators +1. Respect Disabling in Backing Statement Distribution (**Node**) + [#1591](https://github.com/paritytech/polkadot-sdk/issues/1951) + - This is an optimization as in the end it would get filtered in the runtime anyway + - Filter out backing statements coming from ``disabled_validators`` +1. Respect Disablement in Backing (**Node**) [#2951](https://github.com/paritytech/polkadot-sdk/issues/2951) + - This is an optimization as in the end it would get filtered in the runtime anyway + - Don't start backing new candidates when disabled + - Don't react to backing requests when disabled +1. Stop Automatic Chilling of Offenders [#1962](https://github.com/paritytech/polkadot-sdk/issues/1962) + - Chilling still persists as a state but is no longer automatically applied on offenses +1. Respect Disabling in Dispute Participation (**Node**) [#2225](https://github.com/paritytech/polkadot-sdk/issues/2225) + - Receive dispute statements from ``disabled_validators`` but do not release own statements + - Ensure dispute confirmation when BZT statements from disabled +1. Remove Liveness Slashes [#1964](https://github.com/paritytech/polkadot-sdk/issues/1964) + - Remove liveness slashes from the system + - The are other incentives to be online and they could be abused to attack the system +1. Defense Against Past-Era Dispute Spam (**Node**) [#2225](https://github.com/paritytech/polkadot-sdk/issues/2225) + - This is needed because runtime cannot disable validators which it no longer knows about + - Add a node-side parallel store of ``disabled_validators`` + - Add new disabled validators to node-side store when they loose a dispute in any leaf in scope + - Runtime ``disabled_validators`` always have priority over node-side ``disabled_validators`` + - Respect the BZT threshold + > **Note:** \ + > An alternative design here was considered where instead of tracking new incoming leaves a relay parent is used. + > This would guarantee determinism as different nodes can see different leaves, but this approach was leaving too + > wide of a window because of Async-Backing. Relay Parent could have been significantly in the past and it would + > give a lot of time for past session disputes to be spammed. +1. Do not block finality for "disabled" disputes [#3358](https://github.com/paritytech/polkadot-sdk/pull/3358) + - Emergency fix to not block finality for disputes initiated only by disabled validators +1. Re-enable small offender when approaching BZT (**Runtime**) #TODO + - When BZT limit is reached and there are more offenders to be disabled re-enable the smallest offenders to disable + the biggest ones diff --git a/polkadot/roadmap/implementers-guide/src/runtime/inclusion.md b/polkadot/roadmap/implementers-guide/src/runtime/inclusion.md index 0700a781d426324c2c35e72628caa65b577ef979..5031433cf5a1d7a5517458d5f0a5b31a024c4d49 100644 --- a/polkadot/roadmap/implementers-guide/src/runtime/inclusion.md +++ b/polkadot/roadmap/implementers-guide/src/runtime/inclusion.md @@ -1,5 +1,9 @@ # Inclusion Pallet +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + The inclusion module is responsible for inclusion and availability of scheduled parachains. It also manages the UMP dispatch queue of each parachain. diff --git a/polkadot/roadmap/implementers-guide/src/runtime/parainherent.md b/polkadot/roadmap/implementers-guide/src/runtime/parainherent.md index 7972c706b9ee1ebce2132a49ccf62a194d6c1e58..f21e1a59c1a4c0a9e05ae41361f5d7d9fa216378 100644 --- a/polkadot/roadmap/implementers-guide/src/runtime/parainherent.md +++ b/polkadot/roadmap/implementers-guide/src/runtime/parainherent.md @@ -1,5 +1,9 @@ # `ParaInherent` +> NOTE: This module has suffered changes for the elastic scaling implementation. As a result, parts of this document may +be out of date and will be updated at a later time. Issue tracking the update: +https://github.com/paritytech/polkadot-sdk/issues/3699 + This module is responsible for providing all data given to the runtime by the block author to the various parachains modules. The entry-point is mandatory, in that it must be invoked exactly once within every block, and it is also "inherent", in that it is provided with no origin by the block author. The data within it carries its own diff --git a/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md b/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md index 083ed2b6feac9ed6d27c44bc2267744dd49fffd1..be1e71666ad20626711e23f828820155746cbb68 100644 --- a/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md +++ b/polkadot/roadmap/implementers-guide/src/runtime/scheduler.md @@ -1,7 +1,7 @@ # Scheduler Pallet > TODO: this section is still heavily under construction. key questions about availability cores and validator -> assignment are still open and the flow of the the section may be contradictory or inconsistent +> assignment are still open and the flow of the section may be contradictory or inconsistent The Scheduler module is responsible for two main tasks: diff --git a/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md b/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md index e011afb97089aaf59d685b8d4bf9998d21390146..c82d89d2d8799eff6a68b49bdb01ee15bbe43d84 100644 --- a/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md +++ b/polkadot/roadmap/implementers-guide/src/types/overseer-protocol.md @@ -238,6 +238,9 @@ enum AvailabilityRecoveryMessage { CandidateReceipt, SessionIndex, Option, // Backing validator group to request the data directly from. + Option, /* A `CoreIndex` needs to be specified for the recovery process to + * prefer systematic chunk recovery. This is the core that the candidate + * was occupying while pending availability. */ ResponseChannel>, ), } diff --git a/polkadot/rpc/Cargo.toml b/polkadot/rpc/Cargo.toml index 5af5e63b175380f7e695deb973ea48df52c326e4..d01528d4dee07d2d1d5ae59f5dac6a61e60fb197 100644 --- a/polkadot/rpc/Cargo.toml +++ b/polkadot/rpc/Cargo.toml @@ -10,29 +10,31 @@ description = "Polkadot specific RPC functionality." workspace = true [dependencies] -jsonrpsee = { version = "0.22", features = ["server"] } -polkadot-primitives = { path = "../primitives" } -sc-client-api = { path = "../../substrate/client/api" } -sp-blockchain = { path = "../../substrate/primitives/blockchain" } -sp-keystore = { path = "../../substrate/primitives/keystore" } -sp-runtime = { path = "../../substrate/primitives/runtime" } -sp-api = { path = "../../substrate/primitives/api" } -sp-consensus = { path = "../../substrate/primitives/consensus/common" } -sp-consensus-babe = { path = "../../substrate/primitives/consensus/babe" } -sc-chain-spec = { path = "../../substrate/client/chain-spec" } -sc-rpc = { path = "../../substrate/client/rpc" } -sc-rpc-spec-v2 = { path = "../../substrate/client/rpc-spec-v2" } -sc-consensus-babe = { path = "../../substrate/client/consensus/babe" } -sc-consensus-babe-rpc = { path = "../../substrate/client/consensus/babe/rpc" } -sc-consensus-beefy = { path = "../../substrate/client/consensus/beefy" } -sc-consensus-beefy-rpc = { path = "../../substrate/client/consensus/beefy/rpc" } -sc-consensus-epochs = { path = "../../substrate/client/consensus/epochs" } -sc-consensus-grandpa = { path = "../../substrate/client/consensus/grandpa" } -sc-consensus-grandpa-rpc = { path = "../../substrate/client/consensus/grandpa/rpc" } -sc-sync-state-rpc = { path = "../../substrate/client/sync-state-rpc" } -txpool-api = { package = "sc-transaction-pool-api", path = "../../substrate/client/transaction-pool/api" } -frame-rpc-system = { package = "substrate-frame-rpc-system", path = "../../substrate/utils/frame/rpc/system" } -mmr-rpc = { path = "../../substrate/client/merkle-mountain-range/rpc" } -pallet-transaction-payment-rpc = { path = "../../substrate/frame/transaction-payment/rpc" } -sp-block-builder = { path = "../../substrate/primitives/block-builder" } -substrate-state-trie-migration-rpc = { path = "../../substrate/utils/frame/rpc/state-trie-migration-rpc" } +jsonrpsee = { features = ["server"], workspace = true } +polkadot-primitives = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sc-rpc-spec-v2 = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-babe-rpc = { workspace = true, default-features = true } +sc-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-beefy-rpc = { workspace = true, default-features = true } +sc-consensus-epochs = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sc-consensus-grandpa-rpc = { workspace = true, default-features = true } +sc-sync-state-rpc = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +substrate-frame-rpc-system = { workspace = true, default-features = true } +mmr-rpc = { workspace = true, default-features = true } +pallet-transaction-payment-rpc = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +substrate-state-trie-migration-rpc = { workspace = true, default-features = true } diff --git a/polkadot/rpc/src/lib.rs b/polkadot/rpc/src/lib.rs index 4455efd3b5337be85fb975f368af9475b20b0b89..0007df908e2bff5136bfb16fbff33a19b304ba98 100644 --- a/polkadot/rpc/src/lib.rs +++ b/polkadot/rpc/src/lib.rs @@ -27,14 +27,16 @@ use sc_consensus_beefy::communication::notification::{ BeefyBestBlockStream, BeefyVersionedFinalityProofStream, }; use sc_consensus_grandpa::FinalityProofProvider; -pub use sc_rpc::{DenyUnsafe, SubscriptionTaskExecutor}; +pub use sc_rpc::SubscriptionTaskExecutor; +use sc_transaction_pool_api::TransactionPool; use sp_api::ProvideRuntimeApi; +use sp_application_crypto::RuntimeAppPublic; use sp_block_builder::BlockBuilder; use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; use sp_consensus::SelectChain; use sp_consensus_babe::BabeApi; +use sp_consensus_beefy::AuthorityIdBound; use sp_keystore::KeystorePtr; -use txpool_api::TransactionPool; /// A type representing all RPC extensions. pub type RpcExtension = RpcModule<()>; @@ -62,9 +64,9 @@ pub struct GrandpaDeps { } /// Dependencies for BEEFY -pub struct BeefyDeps { +pub struct BeefyDeps { /// Receives notifications about finality proof events from BEEFY. - pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream, + pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream, /// Receives notifications about best block events from BEEFY. pub beefy_best_block_stream: BeefyBestBlockStream, /// Executor to drive the subscription manager in the BEEFY RPC handler. @@ -72,7 +74,7 @@ pub struct BeefyDeps { } /// Full client dependencies -pub struct FullDeps { +pub struct FullDeps { /// The client instance to use. pub client: Arc, /// Transaction pool instance. @@ -81,21 +83,25 @@ pub struct FullDeps { pub select_chain: SC, /// A copy of the chain spec. pub chain_spec: Box, - /// Whether to deny unsafe calls - pub deny_unsafe: DenyUnsafe, /// BABE specific dependencies. pub babe: BabeDeps, /// GRANDPA specific dependencies. pub grandpa: GrandpaDeps, /// BEEFY specific dependencies. - pub beefy: BeefyDeps, + pub beefy: BeefyDeps, /// Backend used by the node. pub backend: Arc, } /// Instantiate all RPC extensions. -pub fn create_full( - FullDeps { client, pool, select_chain, chain_spec, deny_unsafe, babe, grandpa, beefy, backend } : FullDeps, +pub fn create_full( + FullDeps { client, pool, select_chain, chain_spec, babe, grandpa, beefy, backend }: FullDeps< + C, + P, + SC, + B, + AuthorityId, + >, ) -> Result> where C: ProvideRuntimeApi @@ -105,7 +111,7 @@ where + Send + Sync + 'static, - C::Api: frame_rpc_system::AccountNonceApi, + C::Api: substrate_frame_rpc_system::AccountNonceApi, C::Api: mmr_rpc::MmrRuntimeApi::Hash, BlockNumber>, C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, C::Api: BabeApi, @@ -114,15 +120,16 @@ where SC: SelectChain + 'static, B: sc_client_api::Backend + Send + Sync + 'static, B::State: sc_client_api::StateBackend>, + AuthorityId: AuthorityIdBound, + ::Signature: Send + Sync, { - use frame_rpc_system::{System, SystemApiServer}; use mmr_rpc::{Mmr, MmrApiServer}; use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; use sc_consensus_babe_rpc::{Babe, BabeApiServer}; use sc_consensus_beefy_rpc::{Beefy, BeefyApiServer}; use sc_consensus_grandpa_rpc::{Grandpa, GrandpaApiServer}; - use sc_rpc_spec_v2::chain_spec::{ChainSpec, ChainSpecApiServer}; use sc_sync_state_rpc::{SyncState, SyncStateApiServer}; + use substrate_frame_rpc_system::{System, SystemApiServer}; use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer}; let mut io = RpcModule::new(()); @@ -135,13 +142,8 @@ where finality_provider, } = grandpa; - let chain_name = chain_spec.name().to_string(); - let genesis_hash = client.hash(0).ok().flatten().expect("Genesis block exists; qed"); - let properties = chain_spec.properties(); - - io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?; - io.merge(StateMigration::new(client.clone(), backend.clone(), deny_unsafe).into_rpc())?; - io.merge(System::new(client.clone(), pool.clone(), deny_unsafe).into_rpc())?; + io.merge(StateMigration::new(client.clone(), backend.clone()).into_rpc())?; + io.merge(System::new(client.clone(), pool.clone()).into_rpc())?; io.merge(TransactionPayment::new(client.clone()).into_rpc())?; io.merge( Mmr::new( @@ -153,8 +155,7 @@ where .into_rpc(), )?; io.merge( - Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain, deny_unsafe) - .into_rpc(), + Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain).into_rpc(), )?; io.merge( Grandpa::new( @@ -171,7 +172,7 @@ where )?; io.merge( - Beefy::::new( + Beefy::::new( beefy.beefy_finality_proof_stream, beefy.beefy_best_block_stream, beefy.subscription_executor, diff --git a/polkadot/runtime/common/Cargo.toml b/polkadot/runtime/common/Cargo.toml index 4219a7e7b0dcb57c50a5e709d0695dfa723b582a..cda6f3240dd2e4e6460471372a5536fa8cc2307d 100644 --- a/polkadot/runtime/common/Cargo.toml +++ b/polkadot/runtime/common/Cargo.toml @@ -10,77 +10,76 @@ license.workspace = true workspace = true [dependencies] -impl-trait-for-tuples = "0.2.2" -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +impl-trait-for-tuples = { workspace = true } +bitvec = { features = ["alloc"], workspace = true } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -rustc-hex = { version = "2.1.0", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +rustc-hex = { workspace = true } +scale-info = { features = ["derive"], workspace = true } serde = { features = ["alloc"], workspace = true } serde_derive = { workspace = true } -static_assertions = "1.1.0" +static_assertions = { workspace = true, default-features = true } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false } -sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false, features = ["serde"] } -sp-core = { path = "../../../substrate/primitives/core", default-features = false, features = ["serde"] } -sp-npos-elections = { path = "../../../substrate/primitives/npos-elections", default-features = false, features = ["serde"] } +sp-api = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-session = { workspace = true } +sp-staking = { features = ["serde"], workspace = true } +sp-core = { features = ["serde"], workspace = true } +sp-npos-elections = { features = ["serde"], workspace = true } -pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-broker = { path = "../../../substrate/frame/broker", default-features = false } -pallet-fast-unstake = { path = "../../../substrate/frame/fast-unstake", default-features = false } -pallet-identity = { path = "../../../substrate/frame/identity", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -pallet-staking = { path = "../../../substrate/frame/staking", default-features = false } -pallet-staking-reward-fn = { path = "../../../substrate/frame/staking/reward-fn", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-vesting = { path = "../../../substrate/frame/vesting", default-features = false } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false } -pallet-treasury = { path = "../../../substrate/frame/treasury", default-features = false } -pallet-asset-rate = { path = "../../../substrate/frame/asset-rate", default-features = false, optional = true } -pallet-election-provider-multi-phase = { path = "../../../substrate/frame/election-provider-multi-phase", default-features = false } -frame-election-provider-support = { path = "../../../substrate/frame/election-provider-support", default-features = false } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-broker = { workspace = true } +pallet-fast-unstake = { workspace = true } +pallet-identity = { workspace = true } +pallet-session = { workspace = true } +frame-support = { workspace = true } +pallet-staking = { workspace = true } +pallet-staking-reward-fn = { workspace = true } +frame-system = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-vesting = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-treasury = { workspace = true } +pallet-asset-rate = { optional = true, workspace = true } +pallet-election-provider-multi-phase = { workspace = true } +frame-election-provider-support = { workspace = true } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -pallet-babe = { path = "../../../substrate/frame/babe", default-features = false, optional = true } +frame-benchmarking = { optional = true, workspace = true } +pallet-babe = { optional = true, workspace = true } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } -libsecp256k1 = { version = "0.7.0", default-features = false } -runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false } +polkadot-primitives = { workspace = true } +libsecp256k1 = { workspace = true } +polkadot-runtime-parachains = { workspace = true } -slot-range-helper = { path = "slot_range_helper", default-features = false } -xcm = { package = "staging-xcm", path = "../../xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false, optional = true } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm/xcm-builder", default-features = false } +slot-range-helper = { workspace = true } +xcm = { workspace = true } +xcm-executor = { optional = true, workspace = true } +xcm-builder = { workspace = true } [dev-dependencies] -hex-literal = "0.4.1" -frame-support-test = { path = "../../../substrate/frame/support/test" } -pallet-babe = { path = "../../../substrate/frame/babe" } -pallet-treasury = { path = "../../../substrate/frame/treasury" } -sp-keystore = { path = "../../../substrate/primitives/keystore" } -sp-keyring = { path = "../../../substrate/primitives/keyring" } +hex-literal = { workspace = true, default-features = true } +frame-support-test = { workspace = true } +pallet-babe = { workspace = true, default-features = true } +pallet-treasury = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -libsecp256k1 = "0.7.0" -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" } +libsecp256k1 = { workspace = true, default-features = true } +polkadot-primitives-test-helpers = { workspace = true } [features] default = ["std"] no_std = [] std = [ "bitvec/std", + "codec/std", "frame-benchmarking?/std", "frame-election-provider-support/std", "frame-support/std", "frame-system/std", - "inherents/std", "libsecp256k1/std", "log/std", "pallet-asset-rate?/std", @@ -97,21 +96,20 @@ std = [ "pallet-transaction-payment/std", "pallet-treasury/std", "pallet-vesting/std", - "parity-scale-codec/std", - "primitives/std", - "runtime-parachains/std", + "polkadot-primitives/std", + "polkadot-runtime-parachains/std", "rustc-hex/std", "scale-info/std", "serde/std", "slot-range-helper/std", "sp-api/std", "sp-core/std", + "sp-inherents/std", "sp-io/std", "sp-npos-elections/std", "sp-runtime/std", "sp-session/std", "sp-staking/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", @@ -134,8 +132,8 @@ runtime-benchmarks = [ "pallet-timestamp/runtime-benchmarks", "pallet-treasury/runtime-benchmarks", "pallet-vesting/runtime-benchmarks", - "primitives/runtime-benchmarks", - "runtime-parachains/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", + "polkadot-runtime-parachains/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", "xcm-builder/runtime-benchmarks", @@ -160,6 +158,6 @@ try-runtime = [ "pallet-transaction-payment/try-runtime", "pallet-treasury/try-runtime", "pallet-vesting/try-runtime", - "runtime-parachains/try-runtime", + "polkadot-runtime-parachains/try-runtime", "sp-runtime/try-runtime", ] diff --git a/polkadot/runtime/common/slot_range_helper/Cargo.toml b/polkadot/runtime/common/slot_range_helper/Cargo.toml index cacafd8ed3b746d35b5b064ca3d6662b313f8b86..02810b75283f8babda0de26fc91e16b6ac493669 100644 --- a/polkadot/runtime/common/slot_range_helper/Cargo.toml +++ b/polkadot/runtime/common/slot_range_helper/Cargo.toml @@ -10,12 +10,11 @@ description = "Helper crate for generating slot ranges for the Polkadot runtime. workspace = true [dependencies] -paste = "1.0" -enumn = "0.1.12" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sp-std = { package = "sp-std", path = "../../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +paste = { workspace = true, default-features = true } +enumn = { workspace = true } +codec = { features = ["derive"], workspace = true } +sp-runtime = { workspace = true } [features] default = ["std"] -std = ["parity-scale-codec/std", "sp-runtime/std", "sp-std/std"] +std = ["codec/std", "sp-runtime/std"] diff --git a/polkadot/runtime/common/slot_range_helper/src/lib.rs b/polkadot/runtime/common/slot_range_helper/src/lib.rs index bbe5b61ae1f3af6fd4a316ed4202942ba52e3264..0dd893a284f3c657761d870f05dab40fa13b2d3d 100644 --- a/polkadot/runtime/common/slot_range_helper/src/lib.rs +++ b/polkadot/runtime/common/slot_range_helper/src/lib.rs @@ -18,11 +18,11 @@ #![cfg_attr(not(feature = "std"), no_std)] +pub use codec::{Decode, Encode}; +pub use core::{ops::Add, result}; pub use enumn::N; -pub use parity_scale_codec::{Decode, Encode}; pub use paste; pub use sp_runtime::traits::CheckedSub; -pub use sp_std::{ops::Add, result}; /// This macro generates a `SlotRange` enum of arbitrary length for use in the Slot Auction /// mechanism on Polkadot. diff --git a/polkadot/runtime/common/src/assigned_slots/benchmarking.rs b/polkadot/runtime/common/src/assigned_slots/benchmarking.rs index 61638fe6cabfce76d4323e65a1983e18fae22ffc..882bfa051c8307b32a45161db11f60e283d670e1 100644 --- a/polkadot/runtime/common/src/assigned_slots/benchmarking.rs +++ b/polkadot/runtime/common/src/assigned_slots/benchmarking.rs @@ -22,7 +22,7 @@ use super::*; use frame_benchmarking::v2::*; use frame_support::assert_ok; use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin}; -use primitives::Id as ParaId; +use polkadot_primitives::Id as ParaId; use sp_runtime::traits::Bounded; type CurrencyOf = <::Leaser as Leaser>>::Currency; diff --git a/polkadot/runtime/common/src/assigned_slots/migration.rs b/polkadot/runtime/common/src/assigned_slots/migration.rs index b52509bbdf498a7bc9b03be6b4432326d894211b..c13ee0c572dd6eab8c285da04caa76f7a5c8d38a 100644 --- a/polkadot/runtime/common/src/assigned_slots/migration.rs +++ b/polkadot/runtime/common/src/assigned_slots/migration.rs @@ -18,13 +18,13 @@ use super::{Config, MaxPermanentSlots, MaxTemporarySlots, Pallet, LOG_TARGET}; use frame_support::traits::{Get, GetStorageVersion, UncheckedOnRuntimeUpgrade}; #[cfg(feature = "try-runtime")] -use frame_support::ensure; +use alloc::vec::Vec; #[cfg(feature = "try-runtime")] -use sp_std::vec::Vec; +use frame_support::ensure; pub mod v1 { use super::*; - pub struct VersionUncheckedMigrateToV1(sp_std::marker::PhantomData); + pub struct VersionUncheckedMigrateToV1(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV1 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { diff --git a/polkadot/runtime/common/src/assigned_slots/mod.rs b/polkadot/runtime/common/src/assigned_slots/mod.rs index 9b24b99cfbe2a2f1d06fc842f798a6232077e2fb..dd39789e10cfdbb481615f728b6cd223ec64f037 100644 --- a/polkadot/runtime/common/src/assigned_slots/mod.rs +++ b/polkadot/runtime/common/src/assigned_slots/mod.rs @@ -30,18 +30,18 @@ use crate::{ slots::{self, Pallet as Slots, WeightInfo as SlotsWeightInfo}, traits::{LeaseError, Leaser, Registrar}, }; +use alloc::vec::Vec; +use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::{pallet_prelude::*, traits::Currency}; use frame_system::pallet_prelude::*; pub use pallet::*; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; -use primitives::Id as ParaId; -use runtime_parachains::{ +use polkadot_primitives::Id as ParaId; +use polkadot_runtime_parachains::{ configuration, paras::{self}, }; use scale_info::TypeInfo; use sp_runtime::traits::{One, Saturating, Zero}; -use sp_std::prelude::*; const LOG_TARGET: &str = "runtime::assigned_slots"; @@ -428,7 +428,8 @@ pub mod pallet { // Force downgrade to on-demand parachain (if needed) before end of lease period if is_parachain { - if let Err(err) = runtime_parachains::schedule_parachain_downgrade::(id) { + if let Err(err) = polkadot_runtime_parachains::schedule_parachain_downgrade::(id) + { // Treat failed downgrade as warning .. slot lease has been cleared, // so the parachain will be downgraded anyway by the slots pallet // at the end of the lease period . @@ -630,12 +631,12 @@ mod tests { use super::*; use crate::{assigned_slots, mock::TestRegistrar, slots}; - use ::test_helpers::{dummy_head_data, dummy_validation_code}; use frame_support::{assert_noop, assert_ok, derive_impl, parameter_types}; use frame_system::EnsureRoot; use pallet_balances; - use primitives::BlockNumber; - use runtime_parachains::{ + use polkadot_primitives::BlockNumber; + use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code}; + use polkadot_runtime_parachains::{ configuration as parachains_configuration, paras as parachains_paras, shared as parachains_shared, }; @@ -671,10 +672,6 @@ mod tests { type OverarchingCall = RuntimeCall; } - parameter_types! { - pub const BlockHashCount: u32 = 250; - } - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type BaseCallFilter = frame_support::traits::Everything; @@ -689,7 +686,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type DbWeight = (); type Version = (); type PalletInfo = PalletInfo; @@ -702,24 +698,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } impl parachains_configuration::Config for Test { diff --git a/polkadot/runtime/common/src/auctions.rs b/polkadot/runtime/common/src/auctions.rs index aa4caac96f154b43f60fb4aa0dc45b9017aff1d9..78f20d918bab52b11eccc076070f67a76b95e3de 100644 --- a/polkadot/runtime/common/src/auctions.rs +++ b/polkadot/runtime/common/src/auctions.rs @@ -22,6 +22,9 @@ use crate::{ slot_range::SlotRange, traits::{AuctionStatus, Auctioneer, LeaseError, Leaser, Registrar}, }; +use alloc::{vec, vec::Vec}; +use codec::Decode; +use core::mem::swap; use frame_support::{ dispatch::DispatchResult, ensure, @@ -30,10 +33,8 @@ use frame_support::{ }; use frame_system::pallet_prelude::BlockNumberFor; pub use pallet::*; -use parity_scale_codec::Decode; -use primitives::Id as ParaId; +use polkadot_primitives::Id as ParaId; use sp_runtime::traits::{CheckedSub, One, Saturating, Zero}; -use sp_std::{mem::swap, prelude::*}; type CurrencyOf = <::Leaser as Leaser>>::Currency; type BalanceOf = <<::Leaser as Leaser>>::Currency as Currency< @@ -671,15 +672,15 @@ impl Pallet { mod tests { use super::*; use crate::{auctions, mock::TestRegistrar}; - use ::test_helpers::{dummy_hash, dummy_head_data, dummy_validation_code}; use frame_support::{ assert_noop, assert_ok, assert_storage_noop, derive_impl, ord_parameter_types, parameter_types, - traits::{ConstU32, EitherOfDiverse, OnFinalize, OnInitialize}, + traits::{EitherOfDiverse, OnFinalize, OnInitialize}, }; use frame_system::{EnsureRoot, EnsureSignedBy}; use pallet_balances; - use primitives::{BlockNumber, Id as ParaId}; + use polkadot_primitives::{BlockNumber, Id as ParaId}; + use polkadot_primitives_test_helpers::{dummy_hash, dummy_head_data, dummy_validation_code}; use sp_core::H256; use sp_runtime::{ traits::{BlakeTwo256, IdentityLookup}, @@ -699,10 +700,6 @@ mod tests { } ); - parameter_types! { - pub const BlockHashCount: u32 = 250; - } - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type BaseCallFilter = frame_support::traits::Everything; @@ -718,7 +715,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -730,25 +726,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - pub const MaxReserves: u32 = 50; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } #[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Debug)] @@ -1431,7 +1411,8 @@ mod tests { #[test] fn initialize_winners_in_ending_period_works() { new_test_ext().execute_with(|| { - assert_eq!(::ExistentialDeposit::get(), 1); + let ed: u64 = ::ExistentialDeposit::get(); + assert_eq!(ed, 1); run_to_block(1); assert_ok!(Auctions::new_auction(RuntimeOrigin::signed(6), 9, 1)); let para_1 = ParaId::from(1_u32); @@ -1544,7 +1525,8 @@ mod tests { #[test] fn less_winning_samples_work() { new_test_ext().execute_with(|| { - assert_eq!(::ExistentialDeposit::get(), 1); + let ed: u64 = ::ExistentialDeposit::get(); + assert_eq!(ed, 1); EndingPeriod::set(30); SampleLength::set(10); @@ -1733,7 +1715,7 @@ mod benchmarking { traits::{EnsureOrigin, OnInitialize}, }; use frame_system::RawOrigin; - use runtime_parachains::paras; + use polkadot_runtime_parachains::paras; use sp_runtime::{traits::Bounded, SaturatedConversion}; use frame_benchmarking::{account, benchmarks, whitelisted_caller, BenchmarkError}; diff --git a/polkadot/runtime/common/src/claims.rs b/polkadot/runtime/common/src/claims.rs index 8407c7f0dda9d9567d0f4283fbc9999c5b0f0a7d..162bf01c38432f95ba25216478205c4046448c98 100644 --- a/polkadot/runtime/common/src/claims.rs +++ b/polkadot/runtime/common/src/claims.rs @@ -16,6 +16,11 @@ //! Pallet to process claims from Ethereum addresses. +#[cfg(not(feature = "std"))] +use alloc::{format, string::String}; +use alloc::{vec, vec::Vec}; +use codec::{Decode, Encode}; +use core::fmt::Debug; use frame_support::{ ensure, traits::{Currency, Get, IsSubType, VestingSchedule}, @@ -23,8 +28,7 @@ use frame_support::{ DefaultNoBound, }; pub use pallet::*; -use parity_scale_codec::{Decode, Encode}; -use primitives::ValidityError; +use polkadot_primitives::ValidityError; use scale_info::TypeInfo; use serde::{self, Deserialize, Deserializer, Serialize, Serializer}; use sp_io::{crypto::secp256k1_ecdsa_recover, hashing::keccak_256}; @@ -35,9 +39,6 @@ use sp_runtime::{ }, RuntimeDebug, }; -#[cfg(not(feature = "std"))] -use sp_std::alloc::{format, string::String}; -use sp_std::{fmt::Debug, prelude::*}; type CurrencyOf = <::VestingSchedule as VestingSchedule< ::AccountId, @@ -150,8 +151,8 @@ impl PartialEq for EcdsaSignature { } } -impl sp_std::fmt::Debug for EcdsaSignature { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for EcdsaSignature { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { write!(f, "EcdsaSignature({:?})", &self.0[..]) } } @@ -596,12 +597,12 @@ where ::RuntimeCall: IsSubType>, { #[cfg(feature = "std")] - fn fmt(&self, f: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { write!(f, "PrevalidateAttests") } #[cfg(not(feature = "std"))] - fn fmt(&self, _: &mut sp_std::fmt::Formatter) -> sp_std::fmt::Result { + fn fmt(&self, _: &mut core::fmt::Formatter) -> core::fmt::Result { Ok(()) } } @@ -612,7 +613,7 @@ where { /// Create new `SignedExtension` to check runtime version. pub fn new() -> Self { - Self(sp_std::marker::PhantomData) + Self(core::marker::PhantomData) } } @@ -699,7 +700,7 @@ mod tests { use hex_literal::hex; use secp_utils::*; - use parity_scale_codec::Encode; + use codec::Encode; // The testing primitives are very useful for avoiding having to work with signatures // or public keys. `u64` is used as the `AccountId` and no `Signature`s are required. use crate::claims; @@ -708,7 +709,7 @@ mod tests { assert_err, assert_noop, assert_ok, derive_impl, dispatch::{GetDispatchInfo, Pays}, ord_parameter_types, parameter_types, - traits::{ConstU32, ExistenceRequirement, WithdrawReasons}, + traits::{ExistenceRequirement, WithdrawReasons}, }; use pallet_balances; use sp_runtime::{ @@ -738,24 +739,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } parameter_types! { diff --git a/polkadot/runtime/common/src/crowdloan/migration.rs b/polkadot/runtime/common/src/crowdloan/migration.rs index 3afd6b3fbc94b5b30bad162cfcf8236a029b77da..0ee3872a366ea1baf90e44f61f6ac1662b022dfd 100644 --- a/polkadot/runtime/common/src/crowdloan/migration.rs +++ b/polkadot/runtime/common/src/crowdloan/migration.rs @@ -21,7 +21,7 @@ use frame_support::{ Twox64Concat, }; -pub struct MigrateToTrackInactiveV2(sp_std::marker::PhantomData); +pub struct MigrateToTrackInactiveV2(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToTrackInactiveV2 { fn on_runtime_upgrade() -> Weight { let on_chain_version = Pallet::::on_chain_storage_version(); diff --git a/polkadot/runtime/common/src/crowdloan/mod.rs b/polkadot/runtime/common/src/crowdloan/mod.rs index 477530467fa105d93b41569d851b5699aadc09b0..8cf288197e3dd56085f96c928ae6a5b7f79a2a86 100644 --- a/polkadot/runtime/common/src/crowdloan/mod.rs +++ b/polkadot/runtime/common/src/crowdloan/mod.rs @@ -55,6 +55,8 @@ use crate::{ slot_range::SlotRange, traits::{Auctioneer, Registrar}, }; +use alloc::{vec, vec::Vec}; +use codec::{Decode, Encode}; use frame_support::{ ensure, pallet_prelude::{DispatchResult, Weight}, @@ -68,8 +70,7 @@ use frame_support::{ }; use frame_system::pallet_prelude::BlockNumberFor; pub use pallet::*; -use parity_scale_codec::{Decode, Encode}; -use primitives::Id as ParaId; +use polkadot_primitives::Id as ParaId; use scale_info::TypeInfo; use sp_runtime::{ traits::{ @@ -77,7 +78,6 @@ use sp_runtime::{ }, MultiSignature, MultiSigner, RuntimeDebug, }; -use sp_std::vec::Vec; type CurrencyOf = <::Auctioneer as Auctioneer>>::Currency; type LeasePeriodOf = <::Auctioneer as Auctioneer>>::LeasePeriod; @@ -832,16 +832,16 @@ impl Pallet { impl crate::traits::OnSwap for Pallet { fn on_swap(one: ParaId, other: ParaId) { - Funds::::mutate(one, |x| Funds::::mutate(other, |y| sp_std::mem::swap(x, y))) + Funds::::mutate(one, |x| Funds::::mutate(other, |y| core::mem::swap(x, y))) } } #[cfg(any(feature = "runtime-benchmarks", test))] mod crypto { + use alloc::vec::Vec; use sp_core::ed25519; use sp_io::crypto::{ed25519_generate, ed25519_sign}; use sp_runtime::{MultiSignature, MultiSigner}; - use sp_std::vec::Vec; pub fn create_ed25519_pubkey(seed: Vec) -> MultiSigner { ed25519_generate(0.into(), Some(seed)).into() @@ -860,9 +860,9 @@ mod tests { use frame_support::{ assert_noop, assert_ok, derive_impl, parameter_types, - traits::{ConstU32, OnFinalize, OnInitialize}, + traits::{OnFinalize, OnInitialize}, }; - use primitives::Id as ParaId; + use polkadot_primitives::Id as ParaId; use sp_core::H256; use std::{cell::RefCell, collections::BTreeMap, sync::Arc}; // The testing primitives are very useful for avoiding having to work with signatures @@ -872,7 +872,7 @@ mod tests { mock::TestRegistrar, traits::{AuctionStatus, OnSwap}, }; - use ::test_helpers::{dummy_head_data, dummy_validation_code}; + use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code}; use sp_keystore::{testing::MemoryKeystore, KeystoreExt}; use sp_runtime::{ traits::{BlakeTwo256, IdentityLookup, TrailingZeroInput}, @@ -890,10 +890,6 @@ mod tests { } ); - parameter_types! { - pub const BlockHashCount: u32 = 250; - } - type BlockNumber = u64; #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] @@ -911,7 +907,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -923,24 +918,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } #[derive(Copy, Clone, Eq, PartialEq, Debug)] @@ -985,7 +965,7 @@ mod tests { let fund = Funds::::get(para).unwrap(); let account_id = Crowdloan::fund_account_id(fund.fund_index); if winner { - let ed = ::ExistentialDeposit::get(); + let ed: u64 = ::ExistentialDeposit::get(); let free_balance = Balances::free_balance(&account_id); Balances::reserve(&account_id, free_balance - ed) .expect("should be able to reserve free balance minus ED"); @@ -1820,7 +1800,8 @@ mod tests { #[test] fn withdraw_from_finished_works() { new_test_ext().execute_with(|| { - assert_eq!(::ExistentialDeposit::get(), 1); + let ed: u64 = ::ExistentialDeposit::get(); + assert_eq!(ed, 1); let para = new_para(); let index = NextFundIndex::::get(); let account_id = Crowdloan::fund_account_id(index); @@ -1984,10 +1965,9 @@ mod benchmarking { use super::{Pallet as Crowdloan, *}; use frame_support::{assert_ok, traits::OnInitialize}; use frame_system::RawOrigin; - use runtime_parachains::paras; + use polkadot_runtime_parachains::paras; use sp_core::crypto::UncheckedFrom; use sp_runtime::traits::{Bounded, CheckedSub}; - use sp_std::prelude::*; use frame_benchmarking::{account, benchmarks, whitelisted_caller}; diff --git a/polkadot/runtime/common/src/identity_migrator.rs b/polkadot/runtime/common/src/identity_migrator.rs index bf334a63e9588411f57ecc8b6ee2fca72861d7aa..126c886280e6ed713d81c93f5afedbb69b03a1b5 100644 --- a/polkadot/runtime/common/src/identity_migrator.rs +++ b/polkadot/runtime/common/src/identity_migrator.rs @@ -172,15 +172,15 @@ impl OnReapIdentity for () { #[benchmarks] mod benchmarks { use super::*; + use alloc::{boxed::Box, vec, vec::Vec}; + use codec::Encode; use frame_support::traits::EnsureOrigin; use frame_system::RawOrigin; use pallet_identity::{Data, IdentityInformationProvider, Judgement, Pallet as Identity}; - use parity_scale_codec::Encode; use sp_runtime::{ traits::{Bounded, Hash, StaticLookup}, Saturating, }; - use sp_std::{boxed::Box, vec::Vec, *}; const SEED: u32 = 0; diff --git a/polkadot/runtime/common/src/impls.rs b/polkadot/runtime/common/src/impls.rs index 85531e9c04fc47f83fb007802e30e87799c2150c..b6a93cf53685418fb2ffcda417a6ea16af5cafdc 100644 --- a/polkadot/runtime/common/src/impls.rs +++ b/polkadot/runtime/common/src/impls.rs @@ -16,24 +16,24 @@ //! Auxiliary `struct`/`enum`s for polkadot runtime. +use codec::{Decode, Encode, MaxEncodedLen}; use frame_support::traits::{ fungible::{Balanced, Credit}, tokens::imbalance::ResolveTo, Contains, ContainsPair, Imbalance, OnUnbalanced, }; use pallet_treasury::TreasuryAccountId; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; -use primitives::Balance; +use polkadot_primitives::Balance; use sp_runtime::{traits::TryConvert, Perquintill, RuntimeDebug}; use xcm::VersionedLocation; /// Logic for the author to get a portion of fees. -pub struct ToAuthor(sp_std::marker::PhantomData); +pub struct ToAuthor(core::marker::PhantomData); impl OnUnbalanced>> for ToAuthor where R: pallet_balances::Config + pallet_authorship::Config, - ::AccountId: From, - ::AccountId: Into, + ::AccountId: From, + ::AccountId: Into, { fn on_nonzero_unbalanced( amount: Credit<::AccountId, pallet_balances::Pallet>, @@ -44,14 +44,14 @@ where } } -pub struct DealWithFees(sp_std::marker::PhantomData); +pub struct DealWithFees(core::marker::PhantomData); impl OnUnbalanced>> for DealWithFees where R: pallet_balances::Config + pallet_authorship::Config + pallet_treasury::Config, - ::AccountId: From, - ::AccountId: Into, + ::AccountId: From, + ::AccountId: Into, { - fn on_unbalanceds( + fn on_unbalanceds( mut fees_then_tips: impl Iterator>>, ) { if let Some(fees) = fees_then_tips.next() { @@ -67,29 +67,51 @@ where } } -pub fn era_payout( - total_staked: Balance, - total_stakable: Balance, - max_annual_inflation: Perquintill, - period_fraction: Perquintill, - auctioned_slots: u64, -) -> (Balance, Balance) { - use pallet_staking_reward_fn::compute_inflation; +/// Parameters passed into [`relay_era_payout`] function. +pub struct EraPayoutParams { + /// Total staked amount. + pub total_staked: Balance, + /// Total stakable amount. + /// + /// Usually, this is equal to the total issuance, except if a large part of the issuance is + /// locked in another sub-system. + pub total_stakable: Balance, + /// Ideal stake ratio, which is deducted by `legacy_auction_proportion` if not `None`. + pub ideal_stake: Perquintill, + /// Maximum inflation rate. + pub max_annual_inflation: Perquintill, + /// Minimum inflation rate. + pub min_annual_inflation: Perquintill, + /// Falloff used to calculate era payouts. + pub falloff: Perquintill, + /// Fraction of the era period used to calculate era payouts. + pub period_fraction: Perquintill, + /// Legacy auction proportion, which substracts from `ideal_stake` if not `None`. + pub legacy_auction_proportion: Option, +} + +/// A specialized function to compute the inflation of the staking system, tailored for polkadot +/// relay chains, such as Polkadot, Kusama and Westend. +pub fn relay_era_payout(params: EraPayoutParams) -> (Balance, Balance) { use sp_runtime::traits::Saturating; - let min_annual_inflation = Perquintill::from_rational(25u64, 1000u64); - let delta_annual_inflation = max_annual_inflation.saturating_sub(min_annual_inflation); + let EraPayoutParams { + total_staked, + total_stakable, + ideal_stake, + max_annual_inflation, + min_annual_inflation, + falloff, + period_fraction, + legacy_auction_proportion, + } = params; - // 30% reserved for up to 60 slots. - let auction_proportion = Perquintill::from_rational(auctioned_slots.min(60), 200u64); + let delta_annual_inflation = max_annual_inflation.saturating_sub(min_annual_inflation); - // Therefore the ideal amount at stake (as a percentage of total issuance) is 75% less the - // amount that we expect to be taken up with auctions. - let ideal_stake = Perquintill::from_percent(75).saturating_sub(auction_proportion); + let ideal_stake = ideal_stake.saturating_sub(legacy_auction_proportion.unwrap_or_default()); let stake = Perquintill::from_rational(total_staked, total_stakable); - let falloff = Perquintill::from_percent(5); - let adjustment = compute_inflation(stake, ideal_stake, falloff); + let adjustment = pallet_staking_reward_fn::compute_inflation(stake, ideal_stake, falloff); let staking_inflation = min_annual_inflation.saturating_add(delta_annual_inflation * adjustment); @@ -249,13 +271,13 @@ mod tests { parameter_types, traits::{ tokens::{PayFromAccount, UnityAssetBalanceConversion}, - ConstU32, FindAuthor, + FindAuthor, }, weights::Weight, PalletId, }; use frame_system::limits; - use primitives::AccountId; + use polkadot_primitives::AccountId; use sp_core::{ConstU64, H256}; use sp_runtime::{ traits::{BlakeTwo256, IdentityLookup}, @@ -276,7 +298,6 @@ mod tests { ); parameter_types! { - pub const BlockHashCount: u64 = 250; pub BlockWeights: limits::BlockWeights = limits::BlockWeights::builder() .base_block(Weight::from_parts(10, 0)) .for_class(DispatchClass::all(), |weight| { @@ -302,7 +323,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type BlockLength = BlockLength; type BlockWeights = BlockWeights; type DbWeight = (); @@ -317,20 +337,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ConstU64<1>; type AccountStore = System; - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } parameter_types! { @@ -341,13 +350,8 @@ mod tests { impl pallet_treasury::Config for Test { type Currency = pallet_balances::Pallet; - type ApproveOrigin = frame_system::EnsureRoot; type RejectOrigin = frame_system::EnsureRoot; type RuntimeEvent = RuntimeEvent; - type OnSlash = (); - type ProposalBond = (); - type ProposalBondMinimum = (); - type ProposalBondMaximum = (); type SpendPeriod = (); type Burn = (); type BurnDestination = (); @@ -389,6 +393,46 @@ mod tests { t.into() } + pub fn deprecated_era_payout( + total_staked: Balance, + total_stakable: Balance, + max_annual_inflation: Perquintill, + period_fraction: Perquintill, + auctioned_slots: u64, + ) -> (Balance, Balance) { + use pallet_staking_reward_fn::compute_inflation; + use sp_runtime::traits::Saturating; + + let min_annual_inflation = Perquintill::from_rational(25u64, 1000u64); + let delta_annual_inflation = max_annual_inflation.saturating_sub(min_annual_inflation); + + // 30% reserved for up to 60 slots. + let auction_proportion = Perquintill::from_rational(auctioned_slots.min(60), 200u64); + + // Therefore the ideal amount at stake (as a percentage of total issuance) is 75% less the + // amount that we expect to be taken up with auctions. + let ideal_stake = Perquintill::from_percent(75).saturating_sub(auction_proportion); + + let stake = Perquintill::from_rational(total_staked, total_stakable); + let falloff = Perquintill::from_percent(5); + let adjustment = compute_inflation(stake, ideal_stake, falloff); + let staking_inflation = + min_annual_inflation.saturating_add(delta_annual_inflation * adjustment); + + let max_payout = period_fraction * max_annual_inflation * total_stakable; + let staking_payout = (period_fraction * staking_inflation) * total_stakable; + let rest = max_payout.saturating_sub(staking_payout); + + let other_issuance = total_stakable.saturating_sub(total_staked); + if total_staked > other_issuance { + let _cap_rest = + Perquintill::from_rational(other_issuance, total_staked) * staking_payout; + // We don't do anything with this, but if we wanted to, we could introduce a cap on the + // treasury amount with: `rest = rest.min(cap_rest);` + } + (staking_payout, rest) + } + #[test] fn test_fees_and_tip_split() { new_test_ext().execute_with(|| { @@ -443,13 +487,99 @@ mod tests { #[test] fn era_payout_should_give_sensible_results() { - assert_eq!( - era_payout(75, 100, Perquintill::from_percent(10), Perquintill::one(), 0,), - (10, 0) + let payout = + deprecated_era_payout(75, 100, Perquintill::from_percent(10), Perquintill::one(), 0); + assert_eq!(payout, (10, 0)); + + let payout = + deprecated_era_payout(80, 100, Perquintill::from_percent(10), Perquintill::one(), 0); + assert_eq!(payout, (6, 4)); + } + + #[test] + fn relay_era_payout_should_give_sensible_results() { + let params = EraPayoutParams { + total_staked: 75, + total_stakable: 100, + ideal_stake: Perquintill::from_percent(75), + max_annual_inflation: Perquintill::from_percent(10), + min_annual_inflation: Perquintill::from_rational(25u64, 1000u64), + falloff: Perquintill::from_percent(5), + period_fraction: Perquintill::one(), + legacy_auction_proportion: None, + }; + assert_eq!(relay_era_payout(params), (10, 0)); + + let params = EraPayoutParams { + total_staked: 80, + total_stakable: 100, + ideal_stake: Perquintill::from_percent(75), + max_annual_inflation: Perquintill::from_percent(10), + min_annual_inflation: Perquintill::from_rational(25u64, 1000u64), + falloff: Perquintill::from_percent(5), + period_fraction: Perquintill::one(), + legacy_auction_proportion: None, + }; + assert_eq!(relay_era_payout(params), (6, 4)); + } + + #[test] + fn relay_era_payout_should_give_same_results_as_era_payout() { + let total_staked = 1_000_000; + let total_stakable = 2_000_000; + let max_annual_inflation = Perquintill::from_percent(10); + let period_fraction = Perquintill::from_percent(25); + let auctioned_slots = 30; + + let params = EraPayoutParams { + total_staked, + total_stakable, + ideal_stake: Perquintill::from_percent(75), + max_annual_inflation, + min_annual_inflation: Perquintill::from_rational(25u64, 1000u64), + falloff: Perquintill::from_percent(5), + period_fraction, + legacy_auction_proportion: Some(Perquintill::from_rational( + auctioned_slots.min(60), + 200u64, + )), + }; + + let payout = deprecated_era_payout( + total_staked, + total_stakable, + max_annual_inflation, + period_fraction, + auctioned_slots, ); - assert_eq!( - era_payout(80, 100, Perquintill::from_percent(10), Perquintill::one(), 0,), - (6, 4) + assert_eq!(relay_era_payout(params), payout); + + let total_staked = 1_900_000; + let total_stakable = 2_000_000; + let auctioned_slots = 60; + + let params = EraPayoutParams { + total_staked, + total_stakable, + ideal_stake: Perquintill::from_percent(75), + max_annual_inflation, + min_annual_inflation: Perquintill::from_rational(25u64, 1000u64), + falloff: Perquintill::from_percent(5), + period_fraction, + legacy_auction_proportion: Some(Perquintill::from_rational( + auctioned_slots.min(60), + 200u64, + )), + }; + + let payout = deprecated_era_payout( + total_staked, + total_stakable, + max_annual_inflation, + period_fraction, + auctioned_slots, ); + + assert_eq!(relay_era_payout(params), payout); } } diff --git a/polkadot/runtime/common/src/integration_tests.rs b/polkadot/runtime/common/src/integration_tests.rs index 3e9ac1fc1b152574ea86d42c7d48f51da47ddc39..7a689a517eaa2ab97cd827890a0ffeb60bb59bb6 100644 --- a/polkadot/runtime/common/src/integration_tests.rs +++ b/polkadot/runtime/common/src/integration_tests.rs @@ -24,6 +24,8 @@ use crate::{ slots, traits::{AuctionStatus, Auctioneer, Leaser, Registrar as RegistrarT}, }; +use alloc::sync::Arc; +use codec::Encode; use frame_support::{ assert_noop, assert_ok, derive_impl, parameter_types, traits::{ConstU32, Currency, OnFinalize, OnInitialize}, @@ -33,12 +35,11 @@ use frame_support::{ use frame_support_test::TestRandomness; use frame_system::EnsureRoot; use pallet_identity::{self, legacy::IdentityInfo}; -use parity_scale_codec::Encode; -use primitives::{ +use polkadot_primitives::{ BlockNumber, HeadData, Id as ParaId, SessionIndex, ValidationCode, LOWEST_PUBLIC_ID, MAX_CODE_SIZE, }; -use runtime_parachains::{ +use polkadot_runtime_parachains::{ configuration, dmp, origin, paras, shared, Origin as ParaOrigin, ParaLifecycle, }; use sp_core::H256; @@ -50,7 +51,6 @@ use sp_runtime::{ transaction_validity::TransactionPriority, AccountId32, BuildStorage, MultiSignature, }; -use sp_std::sync::Arc; type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlockU32; @@ -109,7 +109,6 @@ where use crate::{auctions::Error as AuctionsError, crowdloan::Error as CrowdloanError}; parameter_types! { - pub const BlockHashCount: u32 = 250; pub BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights::simple_max( Weight::from_parts(4 * 1024 * 1024, u64::MAX), @@ -131,7 +130,6 @@ impl frame_system::Config for Test { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -175,23 +173,12 @@ impl pallet_timestamp::Config for Test { parameter_types! { pub static ExistentialDeposit: Balance = 1; - pub const MaxReserves: u32 = 50; } - +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type MaxLocks = (); type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } impl configuration::Config for Test { diff --git a/polkadot/runtime/common/src/lib.rs b/polkadot/runtime/common/src/lib.rs index 60cc684149b48fe7bb4a102cbad7f96f3c7b5826..41e1cdbab8011bc1cb502c5d87f0214bddfc445a 100644 --- a/polkadot/runtime/common/src/lib.rs +++ b/polkadot/runtime/common/src/lib.rs @@ -41,13 +41,15 @@ mod integration_tests; #[cfg(test)] mod mock; +extern crate alloc; + use frame_support::{ parameter_types, traits::{ConstU32, Currency, OneSessionHandler}, weights::{constants::WEIGHT_REF_TIME_PER_SECOND, Weight}, }; use frame_system::limits; -use primitives::{AssignmentId, Balance, BlockNumber, ValidatorId}; +use polkadot_primitives::{AssignmentId, Balance, BlockNumber, ValidatorId}; use sp_runtime::{FixedPointNumber, Perbill, Perquintill}; use static_assertions::const_assert; @@ -123,7 +125,7 @@ macro_rules! impl_runtime_weights { use frame_support::{dispatch::DispatchClass, weights::Weight}; use frame_system::limits; use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment}; - pub use runtime_common::{ + pub use polkadot_runtime_common::{ impl_elections_weights, AVERAGE_ON_INITIALIZE_RATIO, MAXIMUM_BLOCK_WEIGHT, NORMAL_DISPATCH_RATIO, }; @@ -165,11 +167,11 @@ macro_rules! impl_runtime_weights { /// /// This must only be used as long as the balance type is `u128`. pub type CurrencyToVote = sp_staking::currency_to_vote::U128CurrencyToVote; -static_assertions::assert_eq_size!(primitives::Balance, u128); +static_assertions::assert_eq_size!(polkadot_primitives::Balance, u128); /// A placeholder since there is currently no provided session key handler for parachain validator /// keys. -pub struct ParachainSessionKeyPlaceholder(sp_std::marker::PhantomData); +pub struct ParachainSessionKeyPlaceholder(core::marker::PhantomData); impl sp_runtime::BoundToRuntimeAppPublic for ParachainSessionKeyPlaceholder { type Public = ValidatorId; } @@ -198,7 +200,7 @@ impl OneSessionHandler /// A placeholder since there is currently no provided session key handler for parachain validator /// keys. -pub struct AssignmentSessionKeyPlaceholder(sp_std::marker::PhantomData); +pub struct AssignmentSessionKeyPlaceholder(core::marker::PhantomData); impl sp_runtime::BoundToRuntimeAppPublic for AssignmentSessionKeyPlaceholder { type Public = AssignmentId; } diff --git a/polkadot/runtime/common/src/mock.rs b/polkadot/runtime/common/src/mock.rs index c9e3a8c39f12d3424bd3fb47077812661b6202ba..54170b07fa62c63c226ee5bac8c095b5e479307f 100644 --- a/polkadot/runtime/common/src/mock.rs +++ b/polkadot/runtime/common/src/mock.rs @@ -17,11 +17,13 @@ //! Mocking utilities for testing. use crate::traits::Registrar; +use codec::{Decode, Encode}; use frame_support::{dispatch::DispatchResult, weights::Weight}; use frame_system::pallet_prelude::BlockNumberFor; -use parity_scale_codec::{Decode, Encode}; -use primitives::{HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, ValidationCode}; -use runtime_parachains::paras; +use polkadot_primitives::{ + HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, ValidationCode, +}; +use polkadot_runtime_parachains::paras; use sp_keyring::Sr25519Keyring; use sp_runtime::{traits::SaturatedConversion, DispatchError, Permill}; use std::{cell::RefCell, collections::HashMap}; @@ -35,7 +37,7 @@ thread_local! { static MANAGERS: RefCell>> = RefCell::new(HashMap::new()); } -pub struct TestRegistrar(sp_std::marker::PhantomData); +pub struct TestRegistrar(core::marker::PhantomData); impl Registrar for TestRegistrar { type AccountId = T::AccountId; @@ -239,7 +241,9 @@ impl frame_support::traits::EstimateNextSessionRotation for TestNextSession } } -pub fn validators_public_keys(validators: &[Sr25519Keyring]) -> Vec { +pub fn validators_public_keys( + validators: &[Sr25519Keyring], +) -> Vec { validators.iter().map(|v| v.public().into()).collect() } @@ -248,7 +252,7 @@ pub fn conclude_pvf_checking( validators: &[Sr25519Keyring], session_index: SessionIndex, ) { - let num_required = primitives::supermajority_threshold(validators.len()); + let num_required = polkadot_primitives::supermajority_threshold(validators.len()); validators.iter().enumerate().take(num_required).for_each(|(idx, key)| { let validator_index = idx as u32; let statement = PvfCheckStatement { diff --git a/polkadot/runtime/common/src/paras_registrar/migration.rs b/polkadot/runtime/common/src/paras_registrar/migration.rs index 18bb6bbfb559a23e44109230ad7fd87d0b2682ca..6b110d2ff5d5e03ba74bbd79fa835679d46d33a3 100644 --- a/polkadot/runtime/common/src/paras_registrar/migration.rs +++ b/polkadot/runtime/common/src/paras_registrar/migration.rs @@ -25,7 +25,7 @@ pub struct ParaInfoV1 { } pub struct VersionUncheckedMigrateToV1( - sp_std::marker::PhantomData<(T, UnlockParaIds)>, + core::marker::PhantomData<(T, UnlockParaIds)>, ); impl> UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV1 diff --git a/polkadot/runtime/common/src/paras_registrar/mod.rs b/polkadot/runtime/common/src/paras_registrar/mod.rs index a49ebab3e26a8df5ecfdf7615849b75d9e3c4671..07f02e92656120267272967d1d86ee3d9181da92 100644 --- a/polkadot/runtime/common/src/paras_registrar/mod.rs +++ b/polkadot/runtime/common/src/paras_registrar/mod.rs @@ -19,6 +19,8 @@ pub mod migration; +use alloc::{vec, vec::Vec}; +use core::result; use frame_support::{ dispatch::DispatchResult, ensure, @@ -26,18 +28,19 @@ use frame_support::{ traits::{Currency, Get, ReservableCurrency}, }; use frame_system::{self, ensure_root, ensure_signed}; -use primitives::{HeadData, Id as ParaId, ValidationCode, LOWEST_PUBLIC_ID, MIN_CODE_SIZE}; -use runtime_parachains::{ +use polkadot_primitives::{ + HeadData, Id as ParaId, ValidationCode, LOWEST_PUBLIC_ID, MIN_CODE_SIZE, +}; +use polkadot_runtime_parachains::{ configuration, ensure_parachain, paras::{self, ParaGenesisArgs, UpgradeStrategy}, Origin, ParaLifecycle, }; -use sp_std::{prelude::*, result}; use crate::traits::{OnSwap, Registrar}; +use codec::{Decode, Encode}; pub use pallet::*; -use parity_scale_codec::{Decode, Encode}; -use runtime_parachains::paras::{OnNewHead, ParaKind}; +use polkadot_runtime_parachains::paras::{OnNewHead, ParaKind}; use scale_info::TypeInfo; use sp_runtime::{ traits::{CheckedSub, Saturating}, @@ -208,7 +211,7 @@ pub mod pallet { #[pallet::genesis_config] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, pub next_free_para_id: ParaId, } @@ -425,7 +428,7 @@ pub mod pallet { new_code: ValidationCode, ) -> DispatchResult { Self::ensure_root_para_or_owner(origin, para)?; - runtime_parachains::schedule_code_upgrade::( + polkadot_runtime_parachains::schedule_code_upgrade::( para, new_code, UpgradeStrategy::ApplyAtExpectedBlock, @@ -445,7 +448,7 @@ pub mod pallet { new_head: HeadData, ) -> DispatchResult { Self::ensure_root_para_or_owner(origin, para)?; - runtime_parachains::set_current_head::(para, new_head); + polkadot_runtime_parachains::set_current_head::(para, new_head); Ok(()) } } @@ -510,7 +513,7 @@ impl Registrar for Pallet { paras::Pallet::::lifecycle(id) == Some(ParaLifecycle::Parathread), Error::::NotParathread ); - runtime_parachains::schedule_parathread_upgrade::(id) + polkadot_runtime_parachains::schedule_parathread_upgrade::(id) .map_err(|_| Error::::CannotUpgrade)?; Ok(()) @@ -523,7 +526,7 @@ impl Registrar for Pallet { paras::Pallet::::lifecycle(id) == Some(ParaLifecycle::Parachain), Error::::NotParachain ); - runtime_parachains::schedule_parachain_downgrade::(id) + polkadot_runtime_parachains::schedule_parachain_downgrade::(id) .map_err(|_| Error::::CannotDowngrade)?; Ok(()) } @@ -545,7 +548,7 @@ impl Registrar for Pallet { #[cfg(any(feature = "runtime-benchmarks", test))] fn execute_pending_transitions() { - use runtime_parachains::shared; + use polkadot_runtime_parachains::shared; shared::Pallet::::set_session_index(shared::Pallet::::scheduled_session()); paras::Pallet::::test_on_new_session(); } @@ -634,7 +637,7 @@ impl Pallet { Paras::::insert(id, info); // We check above that para has no lifecycle, so this should not fail. - let res = runtime_parachains::schedule_para_initialize::(id, genesis); + let res = polkadot_runtime_parachains::schedule_para_initialize::(id, genesis); debug_assert!(res.is_ok()); Self::deposit_event(Event::::Registered { para_id: id, manager: who }); Ok(()) @@ -647,7 +650,7 @@ impl Pallet { Some(ParaLifecycle::Parathread) | None => {}, _ => return Err(Error::::NotParathread.into()), } - runtime_parachains::schedule_para_cleanup::(id) + polkadot_runtime_parachains::schedule_para_cleanup::(id) .map_err(|_| Error::::CannotDeregister)?; if let Some(info) = Paras::::take(&id) { @@ -686,9 +689,9 @@ impl Pallet { /// Swap a lease holding parachain and parathread (on-demand parachain), which involves /// scheduling an appropriate lifecycle update. fn do_thread_and_chain_swap(to_downgrade: ParaId, to_upgrade: ParaId) { - let res1 = runtime_parachains::schedule_parachain_downgrade::(to_downgrade); + let res1 = polkadot_runtime_parachains::schedule_parachain_downgrade::(to_downgrade); debug_assert!(res1.is_ok()); - let res2 = runtime_parachains::schedule_parathread_upgrade::(to_upgrade); + let res2 = polkadot_runtime_parachains::schedule_parathread_upgrade::(to_upgrade); debug_assert!(res2.is_ok()); T::OnSwap::on_swap(to_upgrade, to_downgrade); } @@ -715,25 +718,23 @@ mod tests { use crate::{ mock::conclude_pvf_checking, paras_registrar, traits::Registrar as RegistrarTrait, }; + use alloc::collections::btree_map::BTreeMap; use frame_support::{ - assert_noop, assert_ok, derive_impl, - error::BadOrigin, - parameter_types, - traits::{ConstU32, OnFinalize, OnInitialize}, + assert_noop, assert_ok, derive_impl, parameter_types, + traits::{OnFinalize, OnInitialize}, }; use frame_system::limits; use pallet_balances::Error as BalancesError; - use primitives::{Balance, BlockNumber, SessionIndex, MAX_CODE_SIZE}; - use runtime_parachains::{configuration, origin, shared}; + use polkadot_primitives::{Balance, BlockNumber, SessionIndex, MAX_CODE_SIZE}; + use polkadot_runtime_parachains::{configuration, origin, shared}; use sp_core::H256; use sp_io::TestExternalities; use sp_keyring::Sr25519Keyring; use sp_runtime::{ - traits::{BlakeTwo256, IdentityLookup}, + traits::{BadOrigin, BlakeTwo256, IdentityLookup}, transaction_validity::TransactionPriority, BuildStorage, Perbill, }; - use sp_std::collections::btree_map::BTreeMap; type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; type Block = frame_system::mocking::MockBlockU32; @@ -761,7 +762,6 @@ mod tests { const NORMAL_RATIO: Perbill = Perbill::from_percent(75); parameter_types! { - pub const BlockHashCount: u32 = 250; pub BlockWeights: limits::BlockWeights = frame_system::limits::BlockWeights::simple_max(Weight::from_parts(1024, u64::MAX)); pub BlockLength: limits::BlockLength = @@ -780,7 +780,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type DbWeight = (); type BlockWeights = BlockWeights; type BlockLength = BlockLength; @@ -799,20 +798,11 @@ mod tests { pub const ExistentialDeposit: Balance = 1; } + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u128; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; + type Balance = Balance; type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } impl shared::Config for Test { @@ -943,7 +933,7 @@ mod tests { } fn para_origin(id: ParaId) -> RuntimeOrigin { - runtime_parachains::Origin::Parachain(id).into() + polkadot_runtime_parachains::Origin::Parachain(id).into() } fn max_code_size() -> u32 { @@ -1529,8 +1519,8 @@ mod benchmarking { use crate::traits::Registrar as RegistrarT; use frame_support::assert_ok; use frame_system::RawOrigin; - use primitives::{MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MIN_CODE_SIZE}; - use runtime_parachains::{paras, shared, Origin as ParaOrigin}; + use polkadot_primitives::{MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MIN_CODE_SIZE}; + use polkadot_runtime_parachains::{paras, shared, Origin as ParaOrigin}; use sp_runtime::traits::Bounded; use frame_benchmarking::{account, benchmarks, whitelisted_caller}; @@ -1556,7 +1546,7 @@ mod benchmarking { genesis_head, validation_code.clone() )); - assert_ok!(runtime_parachains::paras::Pallet::::add_trusted_validation_code( + assert_ok!(polkadot_runtime_parachains::paras::Pallet::::add_trusted_validation_code( frame_system::Origin::::Root.into(), validation_code, )); @@ -1597,7 +1587,7 @@ mod benchmarking { verify { assert_last_event::(Event::::Registered{ para_id: para, manager: caller }.into()); assert_eq!(paras::Pallet::::lifecycle(para), Some(ParaLifecycle::Onboarding)); - assert_ok!(runtime_parachains::paras::Pallet::::add_trusted_validation_code( + assert_ok!(polkadot_runtime_parachains::paras::Pallet::::add_trusted_validation_code( frame_system::Origin::::Root.into(), validation_code, )); @@ -1615,7 +1605,7 @@ mod benchmarking { verify { assert_last_event::(Event::::Registered { para_id: para, manager }.into()); assert_eq!(paras::Pallet::::lifecycle(para), Some(ParaLifecycle::Onboarding)); - assert_ok!(runtime_parachains::paras::Pallet::::add_trusted_validation_code( + assert_ok!(polkadot_runtime_parachains::paras::Pallet::::add_trusted_validation_code( frame_system::Origin::::Root.into(), validation_code, )); diff --git a/polkadot/runtime/common/src/paras_sudo_wrapper.rs b/polkadot/runtime/common/src/paras_sudo_wrapper.rs index b56dc96af436d0bdd2e4c4313e426a6e7bfc2995..af93c70b4783f717a2adddd0f0f34365ae27d954 100644 --- a/polkadot/runtime/common/src/paras_sudo_wrapper.rs +++ b/polkadot/runtime/common/src/paras_sudo_wrapper.rs @@ -16,17 +16,17 @@ //! A simple wrapper allowing `Sudo` to call into `paras` routines. +use alloc::boxed::Box; +use codec::Encode; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; pub use pallet::*; -use parity_scale_codec::Encode; -use primitives::Id as ParaId; -use runtime_parachains::{ +use polkadot_primitives::Id as ParaId; +use polkadot_runtime_parachains::{ configuration, dmp, hrmp, paras::{self, AssignCoretime, ParaGenesisArgs}, ParaLifecycle, }; -use sp_std::boxed::Box; #[frame_support::pallet] pub mod pallet { @@ -80,7 +80,7 @@ pub mod pallet { genesis: ParaGenesisArgs, ) -> DispatchResult { ensure_root(origin)?; - runtime_parachains::schedule_para_initialize::(id, genesis) + polkadot_runtime_parachains::schedule_para_initialize::(id, genesis) .map_err(|_| Error::::ParaAlreadyExists)?; T::AssignCoretime::assign_coretime(id)?; @@ -93,7 +93,7 @@ pub mod pallet { #[pallet::weight((1_000, DispatchClass::Operational))] pub fn sudo_schedule_para_cleanup(origin: OriginFor, id: ParaId) -> DispatchResult { ensure_root(origin)?; - runtime_parachains::schedule_para_cleanup::(id) + polkadot_runtime_parachains::schedule_para_cleanup::(id) .map_err(|_| Error::::CouldntCleanup)?; Ok(()) } @@ -111,7 +111,7 @@ pub mod pallet { paras::Pallet::::lifecycle(id) == Some(ParaLifecycle::Parathread), Error::::NotParathread, ); - runtime_parachains::schedule_parathread_upgrade::(id) + polkadot_runtime_parachains::schedule_parathread_upgrade::(id) .map_err(|_| Error::::CannotUpgrade)?; Ok(()) } @@ -129,7 +129,7 @@ pub mod pallet { paras::Pallet::::lifecycle(id) == Some(ParaLifecycle::Parachain), Error::::NotParachain, ); - runtime_parachains::schedule_parachain_downgrade::(id) + polkadot_runtime_parachains::schedule_parachain_downgrade::(id) .map_err(|_| Error::::CannotDowngrade)?; Ok(()) } diff --git a/polkadot/runtime/common/src/purchase.rs b/polkadot/runtime/common/src/purchase.rs index b90bbb3a7cfb87c8753114de74d12119ad8b6c56..d650548b8ac39a4059a7a9721e5926ae5ab528a9 100644 --- a/polkadot/runtime/common/src/purchase.rs +++ b/polkadot/runtime/common/src/purchase.rs @@ -16,20 +16,20 @@ //! Pallet to process purchase of DOTs. +use alloc::vec::Vec; +use codec::{Decode, Encode}; use frame_support::{ pallet_prelude::*, traits::{Currency, EnsureOrigin, ExistenceRequirement, Get, VestingSchedule}, }; use frame_system::pallet_prelude::*; pub use pallet::*; -use parity_scale_codec::{Decode, Encode}; use scale_info::TypeInfo; use sp_core::sr25519; use sp_runtime::{ traits::{CheckedAdd, Saturating, Verify, Zero}, AnySignature, DispatchError, DispatchResult, Permill, RuntimeDebug, }; -use sp_std::prelude::*; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; @@ -508,10 +508,6 @@ mod tests { type AccountId = AccountId32; - parameter_types! { - pub const BlockHashCount: u32 = 250; - } - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type BaseCallFilter = frame_support::traits::Everything; @@ -527,7 +523,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -539,24 +534,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } parameter_types! { diff --git a/polkadot/runtime/common/src/slots/mod.rs b/polkadot/runtime/common/src/slots/mod.rs index 738569ff4416c0049ca134e5ea94cf5e9245f81d..333f14c6608acb1d62df7fadbfe297741a39d6cd 100644 --- a/polkadot/runtime/common/src/slots/mod.rs +++ b/polkadot/runtime/common/src/slots/mod.rs @@ -25,6 +25,7 @@ pub mod migration; use crate::traits::{LeaseError, Leaser, Registrar}; +use alloc::{vec, vec::Vec}; use frame_support::{ pallet_prelude::*, traits::{Currency, ReservableCurrency}, @@ -32,9 +33,8 @@ use frame_support::{ }; use frame_system::pallet_prelude::*; pub use pallet::*; -use primitives::Id as ParaId; +use polkadot_primitives::Id as ParaId; use sp_runtime::traits::{CheckedConversion, CheckedSub, Saturating, Zero}; -use sp_std::prelude::*; type BalanceOf = <::Currency as Currency<::AccountId>>::Balance; @@ -309,7 +309,7 @@ impl Pallet { // Useful when trying to clean up a parachain leases, as this would tell // you all the balances you need to unreserve. fn all_deposits_held(para: ParaId) -> Vec<(T::AccountId, BalanceOf)> { - let mut tracker = sp_std::collections::btree_map::BTreeMap::new(); + let mut tracker = alloc::collections::btree_map::BTreeMap::new(); Leases::::get(para).into_iter().for_each(|lease| match lease { Some((who, amount)) => match tracker.get(&who) { Some(prev_amount) => @@ -329,7 +329,7 @@ impl Pallet { impl crate::traits::OnSwap for Pallet { fn on_swap(one: ParaId, other: ParaId) { - Leases::::mutate(one, |x| Leases::::mutate(other, |y| sp_std::mem::swap(x, y))) + Leases::::mutate(one, |x| Leases::::mutate(other, |y| core::mem::swap(x, y))) } } @@ -503,11 +503,11 @@ mod tests { use super::*; use crate::{mock::TestRegistrar, slots}; - use ::test_helpers::{dummy_head_data, dummy_validation_code}; use frame_support::{assert_noop, assert_ok, derive_impl, parameter_types}; use frame_system::EnsureRoot; use pallet_balances; - use primitives::BlockNumber; + use polkadot_primitives::BlockNumber; + use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code}; use sp_core::H256; use sp_runtime::{ traits::{BlakeTwo256, IdentityLookup}, @@ -525,10 +525,6 @@ mod tests { } ); - parameter_types! { - pub const BlockHashCount: u32 = 250; - } - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type BaseCallFilter = frame_support::traits::Everything; @@ -543,7 +539,6 @@ mod tests { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type DbWeight = (); type Version = (); type PalletInfo = PalletInfo; @@ -556,24 +551,9 @@ mod tests { type MaxConsumers = frame_support::traits::ConstU32<16>; } - parameter_types! { - pub const ExistentialDeposit: u64 = 1; - } - + #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type Balance = u64; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); - type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<1>; } parameter_types! { @@ -990,7 +970,7 @@ mod benchmarking { use super::*; use frame_support::assert_ok; use frame_system::RawOrigin; - use runtime_parachains::paras; + use polkadot_runtime_parachains::paras; use sp_runtime::traits::{Bounded, One}; use frame_benchmarking::{account, benchmarks, whitelisted_caller, BenchmarkError}; diff --git a/polkadot/runtime/common/src/traits.rs b/polkadot/runtime/common/src/traits.rs index 8f75bf5c2fd8362e324f2bb42f28f462375921c1..6e49abcee98b2778cbe2cce201d5daadf15d80f0 100644 --- a/polkadot/runtime/common/src/traits.rs +++ b/polkadot/runtime/common/src/traits.rs @@ -16,12 +16,12 @@ //! Traits used across pallets for Polkadot. +use alloc::vec::*; use frame_support::{ dispatch::DispatchResult, traits::{Currency, ReservableCurrency}, }; -use primitives::{HeadData, Id as ParaId, ValidationCode}; -use sp_std::vec::*; +use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode}; /// Parachain registration API. pub trait Registrar { @@ -56,7 +56,7 @@ pub trait Registrar { /// Remove any lock on the para registration. fn remove_lock(id: ParaId); - /// Register a Para ID under control of `who`. Registration may be be + /// Register a Para ID under control of `who`. Registration may be /// delayed by session rotation. fn register( who: Self::AccountId, diff --git a/polkadot/runtime/common/src/try_runtime.rs b/polkadot/runtime/common/src/try_runtime.rs index 81aa34317bfd7a7f82340bc4a8c10760049fd690..b22e1703292067c56160260aa2494d4958e0c589 100644 --- a/polkadot/runtime/common/src/try_runtime.rs +++ b/polkadot/runtime/common/src/try_runtime.rs @@ -16,13 +16,13 @@ //! Common try-runtime only tests for runtimes. +use alloc::{collections::btree_set::BTreeSet, vec::Vec}; use frame_support::{ dispatch::RawOrigin, traits::{Get, Hooks}, }; use pallet_fast_unstake::{Pallet as FastUnstake, *}; use pallet_staking::*; -use sp_std::{collections::btree_set::BTreeSet, prelude::*}; /// register all inactive nominators for fast-unstake, and progress until they have all been /// processed. diff --git a/polkadot/runtime/common/src/xcm_sender.rs b/polkadot/runtime/common/src/xcm_sender.rs index cbec1a8ca1036117275b5234229c2cfc06481056..dace785a535b914b6da3ca322ea11cfe94f5dbfd 100644 --- a/polkadot/runtime/common/src/xcm_sender.rs +++ b/polkadot/runtime/common/src/xcm_sender.rs @@ -16,16 +16,17 @@ //! XCM sender for relay chain. +use alloc::vec::Vec; +use codec::{Decode, Encode}; +use core::marker::PhantomData; use frame_support::traits::Get; use frame_system::pallet_prelude::BlockNumberFor; -use parity_scale_codec::{Decode, Encode}; -use primitives::Id as ParaId; -use runtime_parachains::{ +use polkadot_primitives::Id as ParaId; +use polkadot_runtime_parachains::{ configuration::{self, HostConfiguration}, dmp, FeeTracker, }; use sp_runtime::FixedPointNumber; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::prelude::*; use xcm_builder::InspectMessageQueues; use SendError::*; @@ -56,7 +57,7 @@ impl PriceForMessageDelivery for NoPriceForMessageDelivery { } /// Implementation of [`PriceForMessageDelivery`] which returns a fixed price. -pub struct ConstantPrice(sp_std::marker::PhantomData); +pub struct ConstantPrice(core::marker::PhantomData); impl> PriceForMessageDelivery for ConstantPrice { type Id = (); @@ -79,7 +80,7 @@ impl> PriceForMessageDelivery for ConstantPrice { /// - `B`: The base fee to pay for message delivery. /// - `M`: The fee to pay for each and every byte of the message after encoding it. /// - `F`: A fee factor multiplier. It can be understood as the exponent term in the formula. -pub struct ExponentialPrice(sp_std::marker::PhantomData<(A, B, M, F)>); +pub struct ExponentialPrice(core::marker::PhantomData<(A, B, M, F)>); impl, B: Get, M: Get, F: FeeTracker> PriceForMessageDelivery for ExponentialPrice { @@ -169,7 +170,7 @@ pub struct ToParachainDeliveryHelper< ParaId, ToParaIdHelper, >( - sp_std::marker::PhantomData<( + core::marker::PhantomData<( XcmConfig, ExistentialDeposit, PriceForDelivery, @@ -223,7 +224,7 @@ impl< } // overestimate delivery fee - let overestimated_xcm = vec![ClearOrigin; 128].into(); + let overestimated_xcm = alloc::vec![ClearOrigin; 128].into(); let overestimated_fees = PriceForDelivery::price_for_delivery(Parachain::get(), &overestimated_xcm); @@ -258,8 +259,9 @@ impl EnsureForParachain for () { mod tests { use super::*; use crate::integration_tests::new_test_ext; + use alloc::vec; use frame_support::{assert_ok, parameter_types}; - use runtime_parachains::FeeTracker; + use polkadot_runtime_parachains::FeeTracker; use sp_runtime::FixedU128; use xcm::MAX_XCM_DECODE_DEPTH; diff --git a/polkadot/runtime/metrics/Cargo.toml b/polkadot/runtime/metrics/Cargo.toml index 481627542865e1e79e4be790c3ccf46cc5878c07..3709e1eb697ea1a5941b307a4a8abd06238d3b57 100644 --- a/polkadot/runtime/metrics/Cargo.toml +++ b/polkadot/runtime/metrics/Cargo.toml @@ -10,22 +10,20 @@ description = "Runtime metric interface for the Polkadot node" workspace = true [dependencies] -sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false } -sp-tracing = { path = "../../../substrate/primitives/tracing", default-features = false } -parity-scale-codec = { version = "3.6.1", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } +sp-tracing = { workspace = true } +codec = { workspace = true } +polkadot-primitives = { workspace = true } +frame-benchmarking = { optional = true, workspace = true } -bs58 = { version = "0.5.0", default-features = false, features = ["alloc"] } +bs58 = { features = ["alloc"], workspace = true } [features] default = ["std"] std = [ "bs58/std", + "codec/std", "frame-benchmarking?/std", - "parity-scale-codec/std", - "primitives/std", - "sp-std/std", + "polkadot-primitives/std", "sp-tracing/std", ] runtime-metrics = ["frame-benchmarking", "sp-tracing/with-tracing"] diff --git a/polkadot/runtime/metrics/src/lib.rs b/polkadot/runtime/metrics/src/lib.rs index 6164d71f112a47bce0a91da044aa8d9166c8a8b7..479ec7a69c3aaf8a94b9da2a84f2c04f4fea7165 100644 --- a/polkadot/runtime/metrics/src/lib.rs +++ b/polkadot/runtime/metrics/src/lib.rs @@ -22,6 +22,8 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + #[cfg(feature = "runtime-metrics")] mod with_runtime_metrics; #[cfg(feature = "runtime-metrics")] diff --git a/polkadot/runtime/metrics/src/with_runtime_metrics.rs b/polkadot/runtime/metrics/src/with_runtime_metrics.rs index 562aa9ca162b55da49e7f384aa5470906fe8a7da..979d5eda9afc645c1b343959a3bf65dc7f3e295c 100644 --- a/polkadot/runtime/metrics/src/with_runtime_metrics.rs +++ b/polkadot/runtime/metrics/src/with_runtime_metrics.rs @@ -22,14 +22,13 @@ const TRACING_TARGET: &'static str = "metrics"; -use parity_scale_codec::Encode; -use primitives::{ +use alloc::vec::Vec; +use codec::Encode; +use polkadot_primitives::{ metric_definitions::{CounterDefinition, CounterVecDefinition, HistogramDefinition}, RuntimeMetricLabelValues, RuntimeMetricOp, RuntimeMetricUpdate, }; -use sp_std::prelude::*; - /// Holds a set of counters that have different values for their labels, /// like Prometheus `CounterVec`. pub struct CounterVec { diff --git a/polkadot/runtime/metrics/src/without_runtime_metrics.rs b/polkadot/runtime/metrics/src/without_runtime_metrics.rs index 41d9c24635ae49e544f5fe1eaf18bc740d8a30c9..555cdf4751c8b46aff2c40075eafcf0b50800697 100644 --- a/polkadot/runtime/metrics/src/without_runtime_metrics.rs +++ b/polkadot/runtime/metrics/src/without_runtime_metrics.rs @@ -18,7 +18,7 @@ //! provide a dummy implementation for the native runtime to avoid cluttering the runtime code //! with `#[cfg(feature = "runtime-metrics")]`. -use primitives::metric_definitions::{ +use polkadot_primitives::metric_definitions::{ CounterDefinition, CounterVecDefinition, HistogramDefinition, }; diff --git a/polkadot/runtime/parachains/Cargo.toml b/polkadot/runtime/parachains/Cargo.toml index 402c6e487a1f8b2b2ad9f535ca60bdc160c69895..cfe373e8cba2e6c186ea62d7121aff5f3d4cafa7 100644 --- a/polkadot/runtime/parachains/Cargo.toml +++ b/polkadot/runtime/parachains/Cargo.toml @@ -10,66 +10,66 @@ license.workspace = true workspace = true [dependencies] -impl-trait-for-tuples = "0.2.2" -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] } +impl-trait-for-tuples = { workspace = true } +bitvec = { features = ["alloc"], workspace = true } +codec = { features = ["derive", "max-encoded-len"], workspace = true } log = { workspace = true } -rustc-hex = { version = "2.1.0", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { features = ["alloc", "derive"], workspace = true } -derive_more = "0.99.17" -bitflags = "1.3.2" +derive_more = { workspace = true, default-features = true } +bitflags = { workspace = true } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false } -sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false, features = ["serde"] } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false, features = ["serde"] } -sp-core = { path = "../../../substrate/primitives/core", default-features = false, features = ["serde"] } -sp-keystore = { path = "../../../substrate/primitives/keystore", optional = true, default-features = false } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto", default-features = false, optional = true } -sp-tracing = { path = "../../../substrate/primitives/tracing", default-features = false, optional = true } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false } +sp-api = { workspace = true } +sp-inherents = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { features = ["serde"], workspace = true } +sp-session = { workspace = true } +sp-staking = { features = ["serde"], workspace = true } +sp-core = { features = ["serde"], workspace = true } +sp-keystore = { optional = true, workspace = true } +sp-application-crypto = { optional = true, workspace = true } +sp-tracing = { optional = true, workspace = true } +sp-arithmetic = { workspace = true } +sp-std = { workspace = true, optional = true } -pallet-authority-discovery = { path = "../../../substrate/frame/authority-discovery", default-features = false } -pallet-authorship = { path = "../../../substrate/frame/authorship", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-babe = { path = "../../../substrate/frame/babe", default-features = false } -pallet-broker = { path = "../../../substrate/frame/broker", default-features = false } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } -pallet-staking = { path = "../../../substrate/frame/staking", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-vesting = { path = "../../../substrate/frame/vesting", default-features = false } -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 } +pallet-authority-discovery = { workspace = true } +pallet-authorship = { workspace = true } +pallet-balances = { workspace = true } +pallet-babe = { workspace = true } +pallet-broker = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-mmr = { workspace = true, optional = true } +pallet-session = { workspace = true } +pallet-staking = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-vesting = { workspace = true } +frame-benchmarking = { optional = true, workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } -xcm = { package = "staging-xcm", path = "../../xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } +polkadot-primitives = { workspace = true } -rand = { version = "0.8.5", default-features = false } -rand_chacha = { version = "0.3.1", default-features = false } -static_assertions = { version = "1.1.0", optional = true } -polkadot-parachain-primitives = { path = "../../parachain", default-features = false } -polkadot-runtime-metrics = { path = "../metrics", default-features = false } -polkadot-core-primitives = { path = "../../core-primitives", default-features = false } +rand = { workspace = true } +rand_chacha = { workspace = true } +static_assertions = { optional = true, workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-metrics = { workspace = true } +polkadot-core-primitives = { workspace = true } [dev-dependencies] -futures = "0.3.30" -hex-literal = "0.4.1" -keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" } -frame-support-test = { path = "../../../substrate/frame/support/test" } -sc-keystore = { path = "../../../substrate/client/keystore" } -test-helpers = { package = "polkadot-primitives-test-helpers", path = "../../primitives/test-helpers" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -sp-crypto-hashing = { path = "../../../substrate/primitives/crypto/hashing" } -thousands = "0.2.0" -assert_matches = "1" -rstest = "0.18.2" +futures = { workspace = true } +hex-literal = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +frame-support-test = { workspace = true } +sc-keystore = { workspace = true, default-features = true } +polkadot-primitives-test-helpers = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +thousands = { workspace = true } +assert_matches = { workspace = true } +rstest = { workspace = true } serde_json = { workspace = true, default-features = true } [features] @@ -77,10 +77,10 @@ default = ["std"] no_std = [] std = [ "bitvec/std", + "codec/std", "frame-benchmarking?/std", "frame-support/std", "frame-system/std", - "inherents/std", "log/std", "pallet-authority-discovery/std", "pallet-authorship/std", @@ -88,31 +88,31 @@ std = [ "pallet-balances/std", "pallet-broker/std", "pallet-message-queue/std", + "pallet-mmr?/std", "pallet-session/std", "pallet-staking/std", "pallet-timestamp/std", "pallet-vesting/std", - "parity-scale-codec/std", "polkadot-core-primitives/std", "polkadot-parachain-primitives/std", + "polkadot-primitives/std", "polkadot-runtime-metrics/std", - "primitives/std", "rand/std", "rand_chacha/std", - "rustc-hex/std", "scale-info/std", "serde/std", "sp-api/std", "sp-application-crypto?/std", "sp-arithmetic/std", "sp-core/std", + "sp-inherents/std", "sp-io/std", "sp-keystore", "sp-keystore?/std", "sp-runtime/std", "sp-session/std", "sp-staking/std", - "sp-std/std", + "sp-std?/std", "xcm-executor/std", "xcm/std", ] @@ -124,14 +124,16 @@ runtime-benchmarks = [ "pallet-balances/runtime-benchmarks", "pallet-broker/runtime-benchmarks", "pallet-message-queue/runtime-benchmarks", + "pallet-mmr/runtime-benchmarks", "pallet-staking/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", "pallet-vesting/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", - "primitives/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", "sp-application-crypto", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", + "sp-std", "static_assertions", "xcm-executor/runtime-benchmarks", ] @@ -145,6 +147,7 @@ try-runtime = [ "pallet-balances/try-runtime", "pallet-broker/try-runtime", "pallet-message-queue/try-runtime", + "pallet-mmr/try-runtime", "pallet-session/try-runtime", "pallet-staking/try-runtime", "pallet-timestamp/try-runtime", diff --git a/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs b/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs index e2ba0b4f7ea5d5ca2eb49c903afb764229e0491f..6c63e062c4b9f54ad66ccc3a20a52041a3659d1a 100644 --- a/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs +++ b/polkadot/runtime/parachains/src/assigner_coretime/mock_helpers.rs @@ -26,7 +26,7 @@ use crate::{ }; use sp_runtime::Perbill; -use primitives::{Balance, HeadData, ValidationCode}; +use polkadot_primitives::{Balance, HeadData, ValidationCode}; fn default_genesis_config() -> MockGenesisConfig { MockGenesisConfig { @@ -44,7 +44,7 @@ pub struct GenesisConfigBuilder { pub on_demand_fee_variability: Perbill, pub on_demand_max_queue_size: u32, pub on_demand_target_queue_utilization: Perbill, - pub onboarded_on_demand_chains: Vec, + pub onboarded_on_demand_chains: Vec, } impl Default for GenesisConfigBuilder { diff --git a/polkadot/runtime/parachains/src/assigner_coretime/mod.rs b/polkadot/runtime/parachains/src/assigner_coretime/mod.rs index 1e821dd86846824719f6d84f0bdc0e19222ddd84..7ee76600b42c07bdbb011ddad1d238ec95b89bcf 100644 --- a/polkadot/runtime/parachains/src/assigner_coretime/mod.rs +++ b/polkadot/runtime/parachains/src/assigner_coretime/mod.rs @@ -28,20 +28,19 @@ mod mock_helpers; mod tests; use crate::{ - assigner_on_demand, configuration, + configuration, on_demand, paras::AssignCoretime, scheduler::common::{Assignment, AssignmentProvider}, ParaId, }; +use alloc::{vec, vec::Vec}; use frame_support::{defensive, pallet_prelude::*}; use frame_system::pallet_prelude::*; use pallet_broker::CoreAssignment; -use primitives::CoreIndex; +use polkadot_primitives::CoreIndex; use sp_runtime::traits::{One, Saturating}; -use sp_std::prelude::*; - pub use pallet::*; /// Fraction expressed as a nominator with an assumed denominator of 57,600. @@ -202,10 +201,7 @@ pub mod pallet { pub struct Pallet(_); #[pallet::config] - pub trait Config: - frame_system::Config + configuration::Config + assigner_on_demand::Config - { - } + pub trait Config: frame_system::Config + configuration::Config + on_demand::Config {} /// Scheduled assignment sets. /// @@ -282,8 +278,7 @@ impl AssignmentProvider> for Pallet { match a_type { CoreAssignment::Idle => None, - CoreAssignment::Pool => - assigner_on_demand::Pallet::::pop_assignment_for_core(core_idx), + CoreAssignment::Pool => on_demand::Pallet::::pop_assignment_for_core(core_idx), CoreAssignment::Task(para_id) => Some(Assignment::Bulk((*para_id).into())), } }) @@ -292,7 +287,7 @@ impl AssignmentProvider> for Pallet { fn report_processed(assignment: Assignment) { match assignment { Assignment::Pool { para_id, core_index } => - assigner_on_demand::Pallet::::report_processed(para_id, core_index), + on_demand::Pallet::::report_processed(para_id, core_index), Assignment::Bulk(_) => {}, } } @@ -305,7 +300,7 @@ impl AssignmentProvider> for Pallet { fn push_back_assignment(assignment: Assignment) { match assignment { Assignment::Pool { para_id, core_index } => - assigner_on_demand::Pallet::::push_back_assignment(para_id, core_index), + on_demand::Pallet::::push_back_assignment(para_id, core_index), Assignment::Bulk(_) => { // Session changes are rough. We just drop assignments that did not make it on a // session boundary. This seems sensible as bulk is region based. Meaning, even if @@ -317,7 +312,7 @@ impl AssignmentProvider> for Pallet { } #[cfg(any(feature = "runtime-benchmarks", test))] - fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment { + fn get_mock_assignment(_: CoreIndex, para_id: polkadot_primitives::Id) -> Assignment { // Given that we are not tracking anything in `Bulk` assignments, it is safe to always // return a bulk assignment. Assignment::Bulk(para_id) diff --git a/polkadot/runtime/parachains/src/assigner_coretime/tests.rs b/polkadot/runtime/parachains/src/assigner_coretime/tests.rs index 5d42a9d0c8eec877292b2d5d6ca318e7df8df5b4..e7994b8ef820773b4f310b6285303263170a2638 100644 --- a/polkadot/runtime/parachains/src/assigner_coretime/tests.rs +++ b/polkadot/runtime/parachains/src/assigner_coretime/tests.rs @@ -20,16 +20,16 @@ use crate::{ assigner_coretime::{mock_helpers::GenesisConfigBuilder, pallet::Error, Schedule}, initializer::SessionChangeNotification, mock::{ - new_test_ext, Balances, CoretimeAssigner, OnDemandAssigner, Paras, ParasShared, - RuntimeOrigin, Scheduler, System, Test, + new_test_ext, Balances, CoretimeAssigner, OnDemand, Paras, ParasShared, RuntimeOrigin, + Scheduler, System, Test, }, paras::{ParaGenesisArgs, ParaKind}, scheduler::common::Assignment, }; +use alloc::collections::btree_map::BTreeMap; use frame_support::{assert_noop, assert_ok, pallet_prelude::*, traits::Currency}; use pallet_broker::TaskId; -use primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode}; -use sp_std::collections::btree_map::BTreeMap; +use polkadot_primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode}; fn schedule_blank_para(id: ParaId, parakind: ParaKind) { let validation_code: ValidationCode = vec![1, 2, 3].into(); @@ -74,8 +74,11 @@ fn run_to_block( Paras::initializer_initialize(b + 1); Scheduler::initializer_initialize(b + 1); + // Update the spot traffic and revenue on every block. + OnDemand::on_initialize(b + 1); + // In the real runtime this is expected to be called by the `InclusionInherent` pallet. - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1); } } @@ -524,11 +527,7 @@ fn pop_assignment_for_core_works() { schedule_blank_para(para_id, ParaKind::Parathread); Balances::make_free_balance_be(&alice, amt); run_to_block(1, |n| if n == 1 { Some(Default::default()) } else { None }); - assert_ok!(OnDemandAssigner::place_order_allow_death( - RuntimeOrigin::signed(alice), - amt, - para_id - )); + assert_ok!(OnDemand::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id)); // Case 1: Assignment idle assert_ok!(CoretimeAssigner::assign_core( diff --git a/polkadot/runtime/parachains/src/assigner_parachains.rs b/polkadot/runtime/parachains/src/assigner_parachains.rs index e79facd1fef0856ba7933b1d03901e2e0d397b12..3c735b999cf2313b01150cb64832d0a394ce542e 100644 --- a/polkadot/runtime/parachains/src/assigner_parachains.rs +++ b/polkadot/runtime/parachains/src/assigner_parachains.rs @@ -23,7 +23,7 @@ mod mock_helpers; mod tests; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::CoreIndex; +use polkadot_primitives::CoreIndex; use crate::{ configuration, paras, @@ -59,7 +59,7 @@ impl AssignmentProvider> for Pallet { fn push_back_assignment(_: Assignment) {} #[cfg(any(feature = "runtime-benchmarks", test))] - fn get_mock_assignment(_: CoreIndex, para_id: primitives::Id) -> Assignment { + fn get_mock_assignment(_: CoreIndex, para_id: polkadot_primitives::Id) -> Assignment { Assignment::Bulk(para_id) } diff --git a/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs b/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs index a46e114daeaf458fb6bc985a5bb2ebad951d7e3b..d984fd9232c33a0eb12a09586ba349a3c57db493 100644 --- a/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs +++ b/polkadot/runtime/parachains/src/assigner_parachains/mock_helpers.rs @@ -21,7 +21,7 @@ use crate::{ paras::{ParaGenesisArgs, ParaKind}, }; -use primitives::{Balance, HeadData, ValidationCode}; +use polkadot_primitives::{Balance, HeadData, ValidationCode}; use sp_runtime::Perbill; fn default_genesis_config() -> MockGenesisConfig { @@ -40,7 +40,7 @@ pub struct GenesisConfigBuilder { pub on_demand_fee_variability: Perbill, pub on_demand_max_queue_size: u32, pub on_demand_target_queue_utilization: Perbill, - pub onboarded_on_demand_chains: Vec, + pub onboarded_on_demand_chains: Vec, } impl Default for GenesisConfigBuilder { diff --git a/polkadot/runtime/parachains/src/assigner_parachains/tests.rs b/polkadot/runtime/parachains/src/assigner_parachains/tests.rs index a110686aaeb08d6bcbb77c0bf42ba2ef4ab7adbf..817e43a7138ddbe121e84ea6c02497e07b323469 100644 --- a/polkadot/runtime/parachains/src/assigner_parachains/tests.rs +++ b/polkadot/runtime/parachains/src/assigner_parachains/tests.rs @@ -23,9 +23,9 @@ use crate::{ }, paras::{ParaGenesisArgs, ParaKind}, }; +use alloc::collections::btree_map::BTreeMap; use frame_support::{assert_ok, pallet_prelude::*}; -use primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode}; -use sp_std::collections::btree_map::BTreeMap; +use polkadot_primitives::{BlockNumber, Id as ParaId, SessionIndex, ValidationCode}; fn schedule_blank_para(id: ParaId, parakind: ParaKind) { let validation_code: ValidationCode = vec![1, 2, 3].into(); @@ -71,7 +71,7 @@ fn run_to_block( Scheduler::initializer_initialize(b + 1); // In the real runtime this is expected to be called by the `InclusionInherent` pallet. - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1); } } diff --git a/polkadot/runtime/parachains/src/builder.rs b/polkadot/runtime/parachains/src/builder.rs index d1e2bc392febe67deeda2f545387665435e42eaa..65e56881c315f141b4b2898617cb1bfa7b1d4841 100644 --- a/polkadot/runtime/parachains/src/builder.rs +++ b/polkadot/runtime/parachains/src/builder.rs @@ -21,29 +21,38 @@ use crate::{ scheduler::{self, common::AssignmentProvider, CoreOccupied, ParasEntry}, session_info, shared, }; +use alloc::{ + collections::{btree_map::BTreeMap, btree_set::BTreeSet, vec_deque::VecDeque}, + vec, + vec::Vec, +}; use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec}; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::*; -use primitives::{ - collator_signature_payload, node_features::FeatureIndex, AvailabilityBitfield, BackedCandidate, - CandidateCommitments, CandidateDescriptor, CandidateHash, CollatorId, CollatorSignature, - CommittedCandidateReceipt, CompactStatement, CoreIndex, DisputeStatement, DisputeStatementSet, - GroupIndex, HeadData, Id as ParaId, IndexedVec, InherentData as ParachainsInherentData, - InvalidDisputeStatementKind, PersistedValidationData, SessionIndex, SigningContext, - UncheckedSigned, ValidDisputeStatementKind, ValidationCode, ValidatorId, ValidatorIndex, - ValidityAttestation, +use polkadot_primitives::{ + node_features::FeatureIndex, AvailabilityBitfield, BackedCandidate, CandidateCommitments, + CandidateDescriptor, CandidateHash, CollatorId, CollatorSignature, CommittedCandidateReceipt, + CompactStatement, CoreIndex, DisputeStatement, DisputeStatementSet, GroupIndex, HeadData, + Id as ParaId, IndexedVec, InherentData as ParachainsInherentData, InvalidDisputeStatementKind, + PersistedValidationData, SessionIndex, SigningContext, UncheckedSigned, + ValidDisputeStatementKind, ValidationCode, ValidatorId, ValidatorIndex, ValidityAttestation, }; -use sp_core::{sr25519, H256}; +use sp_core::{sr25519, ByteArray, H256}; use sp_runtime::{ generic::Digest, traits::{Header as HeaderT, One, TrailingZeroInput, Zero}, RuntimeAppPublic, }; -use sp_std::{ - collections::{btree_map::BTreeMap, btree_set::BTreeSet, vec_deque::VecDeque}, - prelude::Vec, - vec, -}; + +/// Create a null collator id. +pub fn dummy_collator() -> CollatorId { + CollatorId::from_slice(&vec![0u8; 32]).expect("32 bytes; qed") +} + +/// Create a null collator signature. +pub fn dummy_collator_signature() -> CollatorSignature { + CollatorSignature::from_slice(&vec![0u8; 64]).expect("64 bytes; qed") +} fn mock_validation_code() -> ValidationCode { ValidationCode(vec![1, 2, 3]) @@ -59,6 +68,21 @@ fn account(name: &'static str, index: u32, seed: u32) -> Acco .expect("infinite input; no invalid input; qed") } +pub fn generate_validator_pairs( + validator_count: u32, +) -> Vec<(T::AccountId, ValidatorId)> { + (0..validator_count) + .map(|i| { + let public = ValidatorId::generate_pair(None); + + // The account Id is not actually used anywhere, just necessary to fulfill the + // expected type of the `validators` param of `test_trigger_on_new_session`. + let account: T::AccountId = account("validator", i, i); + (account, public) + }) + .collect() +} + /// Create a 32 byte slice based on the given number. fn byte32_slice_from(n: u32) -> [u8; 32] { let mut slice = [0u8; 32]; @@ -92,11 +116,17 @@ pub(crate) struct BenchBuilder { /// will correspond to core index 3. There must be one entry for each core with a dispute /// statement set. dispute_sessions: Vec, + /// Paras here will both be backed in the inherent data and already occupying a core (which is + /// freed via bitfields). + /// /// Map from para id to number of validity votes. Core indices are generated based on /// `elastic_paras` configuration. Each para id in `elastic_paras` gets the /// specified amount of consecutive cores assigned to it. If a para id is not present /// in `elastic_paras` it get assigned to a single core. backed_and_concluding_paras: BTreeMap, + + /// Paras which don't yet occupy a core, but will after the inherent has been processed. + backed_in_inherent_paras: BTreeMap, /// Map from para id (seed) to number of chained candidates. elastic_paras: BTreeMap, /// Make every candidate include a code upgrade by setting this to `Some` where the interior @@ -106,7 +136,7 @@ pub(crate) struct BenchBuilder { fill_claimqueue: bool, /// Cores which should not be available when being populated with pending candidates. unavailable_cores: Vec, - _phantom: sp_std::marker::PhantomData, + _phantom: core::marker::PhantomData, } /// Paras inherent `enter` benchmark scenario. @@ -132,11 +162,12 @@ impl BenchBuilder { dispute_statements: BTreeMap::new(), dispute_sessions: Default::default(), backed_and_concluding_paras: Default::default(), + backed_in_inherent_paras: Default::default(), elastic_paras: Default::default(), code_upgrade: None, fill_claimqueue: true, unavailable_cores: vec![], - _phantom: sp_std::marker::PhantomData::, + _phantom: core::marker::PhantomData::, } } @@ -167,6 +198,12 @@ impl BenchBuilder { self } + /// Set a map from para id seed to number of validity votes for votes in inherent data. + pub(crate) fn set_backed_in_inherent_paras(mut self, backed: BTreeMap) -> Self { + self.backed_in_inherent_paras = backed; + self + } + /// Set a map from para id seed to number of cores assigned to it. pub(crate) fn set_elastic_paras(mut self, elastic_paras: BTreeMap) -> Self { self.elastic_paras = elastic_paras; @@ -199,9 +236,10 @@ impl BenchBuilder { .expect("self.block_number is u32") } - /// Maximum number of validators that may be part of a validator group. + /// Fallback for the maximum number of validators participating in parachains consensus (a.k.a. + /// active validators). pub(crate) fn fallback_max_validators() -> u32 { - configuration::ActiveConfig::::get().max_validators.unwrap_or(200) + configuration::ActiveConfig::::get().max_validators.unwrap_or(1024) } /// Maximum number of validators participating in parachains consensus (a.k.a. active @@ -263,8 +301,8 @@ impl BenchBuilder { /// Get the minimum number of validity votes in order for a backed candidate to be included. #[cfg(feature = "runtime-benchmarks")] - pub(crate) fn fallback_min_validity_votes() -> u32 { - (Self::fallback_max_validators() / 2) + 1 + pub(crate) fn fallback_min_backing_votes() -> u32 { + 2 } fn mock_head_data() -> HeadData { @@ -334,11 +372,11 @@ impl BenchBuilder { availability_votes, commitments, ); - inclusion::PendingAvailability::::mutate(para_id, |maybe_andidates| { - if let Some(candidates) = maybe_andidates { + inclusion::PendingAvailability::::mutate(para_id, |maybe_candidates| { + if let Some(candidates) = maybe_candidates { candidates.push_back(candidate_availability); } else { - *maybe_andidates = + *maybe_candidates = Some([candidate_availability].into_iter().collect::>()); } }); @@ -400,20 +438,6 @@ impl BenchBuilder { } } - /// Generate validator key pairs and account ids. - fn generate_validator_pairs(validator_count: u32) -> Vec<(T::AccountId, ValidatorId)> { - (0..validator_count) - .map(|i| { - let public = ValidatorId::generate_pair(None); - - // The account Id is not actually used anywhere, just necessary to fulfill the - // expected type of the `validators` param of `test_trigger_on_new_session`. - let account: T::AccountId = account("validator", i, i); - (account, public) - }) - .collect() - } - fn signing_context(&self) -> SigningContext { SigningContext { parent_hash: Self::header(self.block_number).hash(), @@ -571,7 +595,6 @@ impl BenchBuilder { // This generates a pair and adds it to the keystore, returning just the // public. - let collator_public = CollatorId::generate_pair(None); let header = Self::header(self.block_number); let relay_parent = header.hash(); @@ -601,14 +624,6 @@ impl BenchBuilder { let pov_hash = Default::default(); let validation_code_hash = mock_validation_code().hash(); - let payload = collator_signature_payload( - &relay_parent, - ¶_id, - &persisted_validation_data_hash, - &pov_hash, - &validation_code_hash, - ); - let signature = collator_public.sign(&payload).unwrap(); let mut past_code_meta = paras::ParaPastCodeMeta::>::default(); @@ -621,11 +636,11 @@ impl BenchBuilder { descriptor: CandidateDescriptor:: { para_id, relay_parent, - collator: collator_public, + collator: dummy_collator(), persisted_validation_data_hash, pov_hash, erasure_root: Default::default(), - signature, + signature: dummy_collator_signature(), para_head: head_data.hash(), validation_code_hash, }, @@ -753,8 +768,8 @@ impl BenchBuilder { /// /// Note that this API only allows building scenarios where the `backed_and_concluding_paras` /// are mutually exclusive with the cores for disputes. So - /// `backed_and_concluding_paras.len() + dispute_sessions.len()` must be less than the max - /// number of cores. + /// `backed_and_concluding_paras.len() + dispute_sessions.len() + backed_in_inherent_paras` must + /// be less than the max number of cores. pub(crate) fn build(self) -> Bench { // Make sure relevant storage is cleared. This is just to get the asserts to work when // running tests because it seems the storage is not cleared in between. @@ -771,8 +786,10 @@ impl BenchBuilder { .sum::() .saturating_sub(self.elastic_paras.len() as usize); - let used_cores = - self.dispute_sessions.len() + self.backed_and_concluding_paras.len() + extra_cores; + let used_cores = self.dispute_sessions.len() + + self.backed_and_concluding_paras.len() + + self.backed_in_inherent_paras.len() + + extra_cores; assert!(used_cores <= max_cores); let fill_claimqueue = self.fill_claimqueue; @@ -784,7 +801,7 @@ impl BenchBuilder { c.scheduler_params.num_cores = used_cores as u32; }); - let validator_ids = Self::generate_validator_pairs(self.max_validators()); + let validator_ids = generate_validator_pairs::(self.max_validators()); let target_session = SessionIndex::from(self.target_session); let builder = self.setup_session(target_session, validator_ids, used_cores, extra_cores); @@ -793,8 +810,12 @@ impl BenchBuilder { &builder.elastic_paras, used_cores, ); + + let mut backed_in_inherent = BTreeMap::new(); + backed_in_inherent.append(&mut builder.backed_and_concluding_paras.clone()); + backed_in_inherent.append(&mut builder.backed_in_inherent_paras.clone()); let backed_candidates = builder.create_backed_candidates( - &builder.backed_and_concluding_paras, + &backed_in_inherent, &builder.elastic_paras, builder.code_upgrade, ); @@ -845,12 +866,16 @@ impl BenchBuilder { scheduler::AvailabilityCores::::set(cores); core_idx = 0u32; + + // We need entries in the claim queue for those: + all_cores.append(&mut builder.backed_in_inherent_paras.clone()); + if fill_claimqueue { let cores = all_cores .keys() .flat_map(|para_id| { (0..elastic_paras.get(¶_id).cloned().unwrap_or(1)) - .filter_map(|_para_local_core_idx| { + .map(|_para_local_core_idx| { let ttl = configuration::ActiveConfig::::get().scheduler_params.ttl; // Load an assignment into provider so that one is present to pop let assignment = @@ -859,17 +884,11 @@ impl BenchBuilder { ParaId::from(*para_id), ); - let entry = ( - CoreIndex(core_idx), - [ParasEntry::new(assignment, now + ttl)].into(), - ); - let res = if builder.unavailable_cores.contains(&core_idx) { - None - } else { - Some(entry) - }; core_idx += 1; - res + ( + CoreIndex(core_idx - 1), + [ParasEntry::new(assignment, now + ttl)].into(), + ) }) .collect::>)>>() }) diff --git a/polkadot/runtime/parachains/src/configuration.rs b/polkadot/runtime/parachains/src/configuration.rs index 34923897f02b38891ca7af122f48ee91988a483e..30fe95883e77f2cf09ada2a14ced20b93a7d1988 100644 --- a/polkadot/runtime/parachains/src/configuration.rs +++ b/polkadot/runtime/parachains/src/configuration.rs @@ -19,19 +19,19 @@ //! Configuration can change only at session boundaries and is buffered until then. use crate::{inclusion::MAX_UPWARD_MESSAGE_SIZE_BOUND, shared}; +use alloc::vec::Vec; +use codec::{Decode, Encode}; use frame_support::{pallet_prelude::*, DefaultNoBound}; use frame_system::pallet_prelude::*; -use parity_scale_codec::{Decode, Encode}; use polkadot_parachain_primitives::primitives::{ MAX_HORIZONTAL_MESSAGE_NUM, MAX_UPWARD_MESSAGE_NUM, }; -use primitives::{ +use polkadot_primitives::{ ApprovalVotingParams, AsyncBackingParams, Balance, ExecutorParamError, ExecutorParams, NodeFeatures, SessionIndex, LEGACY_MIN_BACKING_VOTES, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, MAX_POV_SIZE, ON_DEMAND_MAX_QUEUE_MAX_SIZE, }; use sp_runtime::{traits::Zero, Perbill, Percent}; -use sp_std::prelude::*; #[cfg(test)] mod tests; @@ -42,7 +42,7 @@ mod benchmarking; pub mod migration; pub use pallet::*; -use primitives::vstaging::SchedulerParams; +use polkadot_primitives::SchedulerParams; const LOG_TARGET: &str = "runtime::configuration"; @@ -335,6 +335,8 @@ pub enum InconsistentError { InconsistentExecutorParams { inner: ExecutorParamError }, /// TTL should be bigger than lookahead LookaheadExceedsTTL, + /// Lookahead is zero, while it must be at least 1 for parachains to work. + LookaheadZero, /// Passed in queue size for on-demand was too large. OnDemandQueueSizeTooLarge, /// Number of delay tranches cannot be 0. @@ -343,7 +345,7 @@ pub enum InconsistentError { impl HostConfiguration where - BlockNumber: Zero + PartialOrd + sp_std::fmt::Debug + Clone + From, + BlockNumber: Zero + PartialOrd + core::fmt::Debug + Clone + From, { /// Checks that this instance is consistent with the requirements on each individual member. /// @@ -432,6 +434,10 @@ where return Err(LookaheadExceedsTTL) } + if self.scheduler_params.lookahead == 0 { + return Err(LookaheadZero) + } + if self.scheduler_params.on_demand_queue_max_size > ON_DEMAND_MAX_QUEUE_MAX_SIZE { return Err(OnDemandQueueSizeTooLarge) } @@ -551,7 +557,7 @@ pub mod pallet { /// The list is sorted ascending by session index. Also, this list can only contain at most /// 2 items: for the next session and for the `scheduled_session`. #[pallet::storage] - pub(crate) type PendingConfigs = + pub type PendingConfigs = StorageValue<_, Vec<(SessionIndex, HostConfiguration>)>, ValueQuery>; /// If this is set, then the configuration setters will bypass the consistency checks. This @@ -1276,7 +1282,7 @@ pub mod pallet { fn integrity_test() { assert_eq!( &ActiveConfig::::hashed_key(), - primitives::well_known_keys::ACTIVE_CONFIG, + polkadot_primitives::well_known_keys::ACTIVE_CONFIG, "`well_known_keys::ACTIVE_CONFIG` doesn't match key of `ActiveConfig`! Make sure that the name of the\ configuration pallet is `Configuration` in the runtime!", ); @@ -1463,7 +1469,7 @@ impl Pallet { /// The implementation of `Get<(u32, u32)>` which reads `ActiveConfig` and returns `P` percent of /// `hrmp_channel_max_message_size` / `hrmp_channel_max_capacity`. -pub struct ActiveConfigHrmpChannelSizeAndCapacityRatio(sp_std::marker::PhantomData<(T, P)>); +pub struct ActiveConfigHrmpChannelSizeAndCapacityRatio(core::marker::PhantomData<(T, P)>); impl> Get<(u32, u32)> for ActiveConfigHrmpChannelSizeAndCapacityRatio { diff --git a/polkadot/runtime/parachains/src/configuration/benchmarking.rs b/polkadot/runtime/parachains/src/configuration/benchmarking.rs index 882b5aab096ad2f8227aa7ad0efaddfd2078c3ad..adc7f31a7b2913e020b3db5f7595de96abaac742 100644 --- a/polkadot/runtime/parachains/src/configuration/benchmarking.rs +++ b/polkadot/runtime/parachains/src/configuration/benchmarking.rs @@ -17,7 +17,7 @@ use crate::configuration::*; use frame_benchmarking::{benchmarks, BenchmarkError, BenchmarkResult}; use frame_system::RawOrigin; -use primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind}; +use polkadot_primitives::{ExecutorParam, ExecutorParams, PvfExecKind, PvfPrepKind}; use sp_runtime::traits::One; benchmarks! { diff --git a/polkadot/runtime/parachains/src/configuration/migration/v10.rs b/polkadot/runtime/parachains/src/configuration/migration/v10.rs index fa72c357d7dab20dfee26fefa270e677f6b8549f..9375af88306fd804d079be38672f1527f4ccacd2 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v10.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v10.rs @@ -17,18 +17,18 @@ //! A module that is responsible for migration of storage. use crate::configuration::{Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, traits::{Defensive, UncheckedOnRuntimeUpgrade}, weights::Weight, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{ +use polkadot_primitives::{ AsyncBackingParams, Balance, ExecutorParams, NodeFeatures, SessionIndex, LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, }; use sp_runtime::Perbill; -use sp_std::vec::Vec; use super::v9::V9HostConfiguration; // All configuration of the runtime with respect to paras. @@ -164,7 +164,7 @@ mod v10 { >; } -pub struct VersionUncheckedMigrateToV10(sp_std::marker::PhantomData); +pub struct VersionUncheckedMigrateToV10(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV10 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { @@ -275,7 +275,7 @@ fn migrate_to_v10() -> Weight { mod tests { use super::*; use crate::mock::{new_test_ext, Test}; - use primitives::LEGACY_MIN_BACKING_VOTES; + use polkadot_primitives::LEGACY_MIN_BACKING_VOTES; #[test] fn v10_deserialized_from_actual_data() { @@ -304,7 +304,8 @@ mod tests { ]; let v10 = - V10HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V10HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -333,7 +334,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v9 = V9HostConfiguration:: { + let v9 = V9HostConfiguration:: { needed_approvals: 69, paras_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -368,7 +369,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v10_no_pending() { - let v9 = V9HostConfiguration::::default(); + let v9 = V9HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v9 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/migration/v11.rs b/polkadot/runtime/parachains/src/configuration/migration/v11.rs index 65656e8d7c065ac916dde9be670e8c3dfdbfc477..4dce48fe52b0e37d954b3006cb69e9e190c8b3aa 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v11.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v11.rs @@ -17,6 +17,7 @@ //! A module that is responsible for migration of storage. use crate::configuration::{self, Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ migrations::VersionedMigration, pallet_prelude::*, @@ -24,11 +25,10 @@ use frame_support::{ weights::Weight, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{ +use polkadot_primitives::{ ApprovalVotingParams, AsyncBackingParams, ExecutorParams, NodeFeatures, SessionIndex, LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, }; -use sp_std::vec::Vec; use polkadot_core_primitives::Balance; use sp_arithmetic::Perbill; @@ -177,7 +177,7 @@ pub type MigrateToV11 = VersionedMigration< ::DbWeight, >; -pub struct UncheckedMigrateToV11(sp_std::marker::PhantomData); +pub struct UncheckedMigrateToV11(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrateToV11 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { @@ -289,7 +289,7 @@ approval_voting_params : ApprovalVotingParams { #[cfg(test)] mod tests { - use primitives::LEGACY_MIN_BACKING_VOTES; + use polkadot_primitives::LEGACY_MIN_BACKING_VOTES; use super::*; use crate::mock::{new_test_ext, Test}; @@ -321,7 +321,8 @@ mod tests { ]; let v11 = - V11HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V11HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -348,7 +349,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v10 = V10HostConfiguration:: { + let v10 = V10HostConfiguration:: { needed_approvals: 69, paras_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -424,7 +425,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v11_no_pending() { - let v10 = V10HostConfiguration::::default(); + let v10 = V10HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v10 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/migration/v12.rs b/polkadot/runtime/parachains/src/configuration/migration/v12.rs index 69bacc83d044670ed65c9b168c07ae9acca508a5..111b1a1999661aab11ecbe9746a3930061c88e1b 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v12.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v12.rs @@ -17,16 +17,16 @@ //! A module that is responsible for migration of storage. use crate::configuration::{self, migration::v11::V11HostConfiguration, Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ migrations::VersionedMigration, pallet_prelude::*, traits::{Defensive, UncheckedOnRuntimeUpgrade}, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::vstaging::SchedulerParams; +use polkadot_primitives::SchedulerParams; use sp_core::Get; use sp_staking::SessionIndex; -use sp_std::vec::Vec; type V12HostConfiguration = configuration::HostConfiguration; @@ -68,7 +68,7 @@ pub type MigrateToV12 = VersionedMigration< ::DbWeight, >; -pub struct UncheckedMigrateToV12(sp_std::marker::PhantomData); +pub struct UncheckedMigrateToV12(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrateToV12 { #[cfg(feature = "try-runtime")] @@ -181,7 +181,7 @@ fn migrate_to_v12() -> Weight { #[cfg(test)] mod tests { - use primitives::LEGACY_MIN_BACKING_VOTES; + use polkadot_primitives::LEGACY_MIN_BACKING_VOTES; use sp_arithmetic::Perbill; use super::*; @@ -214,7 +214,8 @@ mod tests { ]; let v12 = - V12HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V12HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -251,7 +252,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v11 = V11HostConfiguration:: { + let v11 = V11HostConfiguration:: { needed_approvals: 69, paras_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -334,7 +335,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v12_no_pending() { - let v11 = V11HostConfiguration::::default(); + let v11 = V11HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v10 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/migration/v6.rs b/polkadot/runtime/parachains/src/configuration/migration/v6.rs index 19031a90bab45c5c4cf58e50f07111db547365a6..468bf78692a12980d322233f51eb625720944e22 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v6.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v6.rs @@ -17,15 +17,13 @@ //! Contains the V6 storage definition of the host configuration. use crate::configuration::{Config, Pallet}; +use alloc::vec::Vec; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::BlockNumberFor; -use sp_std::vec::Vec; -use primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex}; -#[cfg(feature = "try-runtime")] -use sp_std::prelude::*; +use polkadot_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex}; -#[derive(parity_scale_codec::Encode, parity_scale_codec::Decode, Debug, Clone)] +#[derive(codec::Encode, codec::Decode, Debug, Clone)] pub struct V6HostConfiguration { pub max_code_size: u32, pub max_head_data_size: u32, diff --git a/polkadot/runtime/parachains/src/configuration/migration/v7.rs b/polkadot/runtime/parachains/src/configuration/migration/v7.rs index 1754b78e0a1d3bd1d764f44352601fdf187b85b5..9acd28d0f764e4f966fd48cbfd3e6fc9a5810200 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v7.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v7.rs @@ -17,20 +17,20 @@ //! A module that is responsible for migration of storage. use crate::configuration::{self, Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, traits::{Defensive, StorageVersion}, weights::Weight, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex}; -use sp_std::vec::Vec; +use polkadot_primitives::{AsyncBackingParams, Balance, ExecutorParams, SessionIndex}; use frame_support::traits::OnRuntimeUpgrade; use super::v6::V6HostConfiguration; -#[derive(parity_scale_codec::Encode, parity_scale_codec::Decode, Debug, Clone)] +#[derive(codec::Encode, codec::Decode, Debug, Clone)] pub struct V7HostConfiguration { pub max_code_size: u32, pub max_head_data_size: u32, @@ -154,7 +154,7 @@ mod v7 { >; } -pub struct MigrateToV7(sp_std::marker::PhantomData); +pub struct MigrateToV7(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToV7 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { @@ -289,7 +289,8 @@ mod tests { let raw_config = hex_literal::hex!["00003000005000005555150000008000fbff0100000200000a000000c80000006400000000000000000000000000500000c800000a0000000000000000c0220fca950300000000000000000000c0220fca9503000000000000000000e8030000009001000a0000000000000000900100008070000000000000000000000a000000050000000500000001000000010500000001c80000000600000058020000020000002800000000000000020000000100000001020000000f000000"]; let v6 = - V6HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V6HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -312,7 +313,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v6 = V6HostConfiguration:: { + let v6 = V6HostConfiguration:: { needed_approvals: 69, thread_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -390,7 +391,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v7_no_pending() { - let v6 = V6HostConfiguration::::default(); + let v6 = V6HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v6 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/migration/v8.rs b/polkadot/runtime/parachains/src/configuration/migration/v8.rs index 537dfa9abd77040f7017be6bd46150aa29bfef3c..81ced74bebb9770ff09fb50b42e9c89f213b6019 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v8.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v8.rs @@ -17,17 +17,17 @@ //! A module that is responsible for migration of storage. use crate::configuration::{self, Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, traits::{Defensive, StorageVersion}, weights::Weight, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{ +use polkadot_primitives::{ AsyncBackingParams, Balance, ExecutorParams, SessionIndex, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, }; use sp_runtime::Perbill; -use sp_std::vec::Vec; use frame_support::traits::OnRuntimeUpgrade; @@ -161,7 +161,7 @@ mod v8 { >; } -pub struct MigrateToV8(sp_std::marker::PhantomData); +pub struct MigrateToV8(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToV8 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { @@ -304,7 +304,8 @@ mod tests { ]; let v8 = - V8HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V8HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -329,7 +330,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v7 = V7HostConfiguration:: { + let v7 = V7HostConfiguration:: { needed_approvals: 69, thread_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -403,7 +404,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v8_no_pending() { - let v7 = V7HostConfiguration::::default(); + let v7 = V7HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v6 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/migration/v9.rs b/polkadot/runtime/parachains/src/configuration/migration/v9.rs index ca4bbd9dacef3fb645c41a060798e0298a0efc27..dff5fdb17a697cf209ccffa07b808175cfab2f7b 100644 --- a/polkadot/runtime/parachains/src/configuration/migration/v9.rs +++ b/polkadot/runtime/parachains/src/configuration/migration/v9.rs @@ -17,18 +17,18 @@ //! A module that is responsible for migration of storage. use crate::configuration::{self, Config, Pallet}; +use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, traits::{Defensive, StorageVersion}, weights::Weight, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{ +use polkadot_primitives::{ AsyncBackingParams, Balance, ExecutorParams, SessionIndex, LEGACY_MIN_BACKING_VOTES, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, }; use sp_runtime::Perbill; -use sp_std::vec::Vec; use frame_support::traits::OnRuntimeUpgrade; @@ -164,7 +164,7 @@ mod v9 { >; } -pub struct MigrateToV9(sp_std::marker::PhantomData); +pub struct MigrateToV9(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToV9 { #[cfg(feature = "try-runtime")] fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { @@ -308,7 +308,8 @@ mod tests { ]; let v9 = - V9HostConfiguration::::decode(&mut &raw_config[..]).unwrap(); + V9HostConfiguration::::decode(&mut &raw_config[..]) + .unwrap(); // We check only a sample of the values here. If we missed any fields or messed up data // types that would skew all the fields coming after. @@ -334,7 +335,7 @@ mod tests { // We specify only the picked fields and the rest should be provided by the `Default` // implementation. That implementation is copied over between the two types and should work // fine. - let v8 = V8HostConfiguration:: { + let v8 = V8HostConfiguration:: { needed_approvals: 69, paras_availability_period: 55, hrmp_recipient_deposit: 1337, @@ -408,7 +409,7 @@ mod tests { // pallet's storage. #[test] fn test_migrate_to_v9_no_pending() { - let v8 = V8HostConfiguration::::default(); + let v8 = V8HostConfiguration::::default(); new_test_ext(Default::default()).execute_with(|| { // Implant the v8 version in the state. diff --git a/polkadot/runtime/parachains/src/configuration/tests.rs b/polkadot/runtime/parachains/src/configuration/tests.rs index 64bbb8481fc1ba63ff8f851aa8b3d2ba5d6bd7df..dad8b6458e10ae16868d4354054ad80923f548d0 100644 --- a/polkadot/runtime/parachains/src/configuration/tests.rs +++ b/polkadot/runtime/parachains/src/configuration/tests.rs @@ -513,7 +513,7 @@ fn verify_externally_accessible() { // This test verifies that the value can be accessed through the well known keys and the // host configuration decodes into the abridged version. - use primitives::{well_known_keys, AbridgedHostConfiguration}; + use polkadot_primitives::{well_known_keys, AbridgedHostConfiguration}; new_test_ext(Default::default()).execute_with(|| { let mut ground_truth = HostConfiguration::default(); diff --git a/polkadot/runtime/parachains/src/coretime/benchmarking.rs b/polkadot/runtime/parachains/src/coretime/benchmarking.rs index d1ac71f580ee0e70015bf130b6836519005ee280..6d593f1954ff1500fd59ae5d178e038dd38e01b5 100644 --- a/polkadot/runtime/parachains/src/coretime/benchmarking.rs +++ b/polkadot/runtime/parachains/src/coretime/benchmarking.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! On demand assigner pallet benchmarking. +//! Coretime pallet benchmarking. #![cfg(feature = "runtime-benchmarks")] @@ -28,6 +28,30 @@ mod benchmarks { use super::*; use assigner_coretime::PartsOf57600; + #[benchmark] + fn request_revenue_at() { + let root_origin = ::RuntimeOrigin::root(); + let mhr = ::MaxHistoricalRevenue::get(); + frame_system::Pallet::::set_block_number((mhr + 2).into()); + let minimum_balance = ::Currency::minimum_balance(); + let rev: BoundedVec< + <::Currency as frame_support::traits::Currency< + T::AccountId, + >>::Balance, + T::MaxHistoricalRevenue, + > = BoundedVec::try_from((1..=mhr).map(|v| minimum_balance * v.into()).collect::>()) + .unwrap(); + on_demand::Revenue::::put(rev); + + ::Currency::make_free_balance_be( + &>::account_id(), + minimum_balance * (mhr * (mhr + 1)).into(), + ); + + #[extrinsic_call] + _(root_origin as ::RuntimeOrigin, mhr + 1) + } + #[benchmark] fn request_core_count() { // Setup diff --git a/polkadot/runtime/parachains/src/coretime/migration.rs b/polkadot/runtime/parachains/src/coretime/migration.rs index 6c8ddaa8aab30c702a4c13c25e3d1c571e6a79cf..d4be135aad65767fdccf8aea785019940e81c2bb 100644 --- a/polkadot/runtime/parachains/src/coretime/migration.rs +++ b/polkadot/runtime/parachains/src/coretime/migration.rs @@ -24,8 +24,13 @@ mod v_coretime { use crate::{ assigner_coretime, configuration, coretime::{mk_coretime_call, Config, PartsOf57600, WeightInfo}, - paras, }; + use alloc::{vec, vec::Vec}; + #[cfg(feature = "try-runtime")] + use codec::Decode; + #[cfg(feature = "try-runtime")] + use codec::Encode; + use core::{iter, result}; #[cfg(feature = "try-runtime")] use frame_support::ensure; use frame_support::{ @@ -34,36 +39,35 @@ mod v_coretime { }; use frame_system::pallet_prelude::BlockNumberFor; use pallet_broker::{CoreAssignment, CoreMask, ScheduleItem}; - #[cfg(feature = "try-runtime")] - use parity_scale_codec::Decode; - #[cfg(feature = "try-runtime")] - use parity_scale_codec::Encode; use polkadot_parachain_primitives::primitives::IsSystem; - use primitives::{CoreIndex, Id as ParaId}; + use polkadot_primitives::{CoreIndex, Id as ParaId}; use sp_arithmetic::traits::SaturatedConversion; use sp_core::Get; use sp_runtime::BoundedVec; - #[cfg(feature = "try-runtime")] - use sp_std::vec::Vec; - use sp_std::{iter, prelude::*, result}; use xcm::prelude::{send_xcm, Instruction, Junction, Location, SendError, WeightLimit, Xcm}; /// Return information about a legacy lease of a parachain. pub trait GetLegacyLease { /// If parachain is a lease holding parachain, return the block at which the lease expires. fn get_parachain_lease_in_blocks(para: ParaId) -> Option; + // All parachains holding a lease, no matter if there are gaps in the slots or not. + fn get_all_parachains_with_leases() -> Vec; } /// Migrate a chain to use coretime. /// /// This assumes that the `Coretime` and the `AssignerCoretime` pallets are added at the same /// time to a runtime. - pub struct MigrateToCoretime( - sp_std::marker::PhantomData<(T, SendXcm, LegacyLease)>, + pub struct MigrateToCoretime( + core::marker::PhantomData<(T, SendXcm, LegacyLease)>, ); - impl>> - MigrateToCoretime + impl< + T: Config, + SendXcm: xcm::v4::SendXcm, + LegacyLease: GetLegacyLease>, + const TIMESLICE_PERIOD: u32, + > MigrateToCoretime { fn already_migrated() -> bool { // We are using the assigner coretime because the coretime pallet doesn't has any @@ -95,7 +99,8 @@ mod v_coretime { T: Config + crate::dmp::Config, SendXcm: xcm::v4::SendXcm, LegacyLease: GetLegacyLease>, - > OnRuntimeUpgrade for MigrateToCoretime + const TIMESLICE_PERIOD: u32, + > OnRuntimeUpgrade for MigrateToCoretime { fn on_runtime_upgrade() -> Weight { if Self::already_migrated() { @@ -103,7 +108,7 @@ mod v_coretime { } log::info!("Migrating existing parachains to coretime."); - migrate_to_coretime::() + migrate_to_coretime::() } #[cfg(feature = "try-runtime")] @@ -112,7 +117,7 @@ mod v_coretime { return Ok(Vec::new()) } - let legacy_paras = paras::Parachains::::get(); + let legacy_paras = LegacyLease::get_all_parachains_with_leases(); let config = configuration::ActiveConfig::::get(); let total_core_count = config.scheduler_params.num_cores + legacy_paras.len() as u32; @@ -155,8 +160,9 @@ mod v_coretime { T: Config, SendXcm: xcm::v4::SendXcm, LegacyLease: GetLegacyLease>, + const TIMESLICE_PERIOD: u32, >() -> Weight { - let legacy_paras = paras::Parachains::::get(); + let legacy_paras = LegacyLease::get_all_parachains_with_leases(); let legacy_count = legacy_paras.len() as u32; let now = frame_system::Pallet::::block_number(); for (core, para_id) in legacy_paras.into_iter().enumerate() { @@ -176,7 +182,6 @@ mod v_coretime { } let config = configuration::ActiveConfig::::get(); - // num_cores was on_demand_cores until now: for on_demand in 0..config.scheduler_params.num_cores { let core = CoreIndex(legacy_count.saturating_add(on_demand as _)); let r = assigner_coretime::Pallet::::assign_core( @@ -194,7 +199,9 @@ mod v_coretime { c.scheduler_params.num_cores = total_cores; }); - if let Err(err) = migrate_send_assignments_to_coretime_chain::() { + if let Err(err) = + migrate_send_assignments_to_coretime_chain::( + ) { log::error!("Sending legacy chain data to coretime chain failed: {:?}", err); } @@ -211,8 +218,9 @@ mod v_coretime { T: Config, SendXcm: xcm::v4::SendXcm, LegacyLease: GetLegacyLease>, + const TIMESLICE_PERIOD: u32, >() -> result::Result<(), SendError> { - let legacy_paras = paras::Parachains::::get(); + let legacy_paras = LegacyLease::get_all_parachains_with_leases(); let legacy_paras_count = legacy_paras.len(); let (system_chains, lease_holding): (Vec<_>, Vec<_>) = legacy_paras.into_iter().partition(IsSystem::is_system); @@ -225,7 +233,7 @@ mod v_coretime { mk_coretime_call::(crate::coretime::CoretimeCalls::Reserve(schedule)) }); - let leases = lease_holding.into_iter().filter_map(|p| { + let mut leases = lease_holding.into_iter().filter_map(|p| { log::trace!(target: "coretime-migration", "Preparing sending of lease holding para {:?}", p); let Some(valid_until) = LegacyLease::get_parachain_lease_in_blocks(p) else { log::error!("Lease holding chain with no lease information?!"); @@ -238,10 +246,7 @@ mod v_coretime { return None }, }; - // We assume the coretime chain set this parameter to the recommended value in RFC-1: - const TIME_SLICE_PERIOD: u32 = 80; - let round_up = if valid_until % TIME_SLICE_PERIOD > 0 { 1 } else { 0 }; - let time_slice = valid_until / TIME_SLICE_PERIOD + TIME_SLICE_PERIOD * round_up; + let time_slice = (valid_until + TIMESLICE_PERIOD - 1) / TIMESLICE_PERIOD; log::trace!(target: "coretime-migration", "Sending of lease holding para {:?}, valid_until: {:?}, time_slice: {:?}", p, valid_until, time_slice); Some(mk_coretime_call::(crate::coretime::CoretimeCalls::SetLease(p.into(), time_slice))) }); @@ -270,16 +275,30 @@ mod v_coretime { }); let reservation_content = message_content.clone().chain(reservations).collect(); - let pool_content = message_content.clone().chain(pool).collect(); - let leases_content = message_content.clone().chain(leases).collect(); + let leases_content_1 = message_content + .clone() + .chain(leases.by_ref().take(legacy_paras_count / 2)) // split in two messages to avoid overweighted XCM + .collect(); + let leases_content_2 = message_content.clone().chain(leases).collect(); let set_core_count_content = message_content.clone().chain(set_core_count).collect(); - - let messages = vec![ - Xcm(reservation_content), - Xcm(pool_content), - Xcm(leases_content), - Xcm(set_core_count_content), - ]; + // If `pool_content` is empty don't send a blank XCM message + let messages = if core_count as usize > legacy_paras_count { + let pool_content = message_content.clone().chain(pool).collect(); + vec![ + Xcm(reservation_content), + Xcm(pool_content), + Xcm(leases_content_1), + Xcm(leases_content_2), + Xcm(set_core_count_content), + ] + } else { + vec![ + Xcm(reservation_content), + Xcm(leases_content_1), + Xcm(leases_content_2), + Xcm(set_core_count_content), + ] + }; for message in messages { send_xcm::( diff --git a/polkadot/runtime/parachains/src/coretime/mod.rs b/polkadot/runtime/parachains/src/coretime/mod.rs index 94bce4c83e6ff917c9e04d2036e276e7cf85627d..9b9bdb86878f3bc30545ed58e4504ae5ef5b4582 100644 --- a/polkadot/runtime/parachains/src/coretime/mod.rs +++ b/polkadot/runtime/parachains/src/coretime/mod.rs @@ -18,30 +18,49 @@ //! //! -use sp_std::{prelude::*, result}; - -use frame_support::{pallet_prelude::*, traits::Currency}; +use alloc::{vec, vec::Vec}; +use core::result; +use frame_support::{ + pallet_prelude::*, + traits::{defensive_prelude::*, Currency}, +}; use frame_system::pallet_prelude::*; pub use pallet::*; use pallet_broker::{CoreAssignment, CoreIndex as BrokerCoreIndex}; -use primitives::{CoreIndex, Id as ParaId}; +use polkadot_primitives::{Balance, BlockNumber, CoreIndex, Id as ParaId}; use sp_arithmetic::traits::SaturatedConversion; -use xcm::prelude::{ - send_xcm, Instruction, Junction, Location, OriginKind, SendXcm, WeightLimit, Xcm, +use sp_runtime::traits::TryConvert; +use xcm::{ + prelude::{send_xcm, Instruction, Junction, Location, OriginKind, SendXcm, WeightLimit, Xcm}, + v4::{ + Asset, + AssetFilter::Wild, + AssetId, Assets, Error as XcmError, + Fungibility::Fungible, + Instruction::{DepositAsset, ReceiveTeleportedAsset}, + Junctions::Here, + Reanchorable, + WildAsset::AllCounted, + XcmContext, + }, }; +use xcm_executor::traits::TransactAsset; use crate::{ assigner_coretime::{self, PartsOf57600}, initializer::{OnNewSession, SessionChangeNotification}, + on_demand, origin::{ensure_parachain, Origin}, }; mod benchmarking; pub mod migration; +const LOG_TARGET: &str = "runtime::parachains::coretime"; + pub trait WeightInfo { fn request_core_count() -> Weight; - //fn request_revenue_info_at() -> Weight; + fn request_revenue_at() -> Weight; //fn credit_account() -> Weight; fn assign_core(s: u32) -> Weight; } @@ -53,19 +72,23 @@ impl WeightInfo for TestWeightInfo { fn request_core_count() -> Weight { Weight::MAX } - // TODO: Add real benchmarking functionality for each of these to - // benchmarking.rs, then uncomment here and in trait definition. - /*fn request_revenue_info_at() -> Weight { + fn request_revenue_at() -> Weight { Weight::MAX } - fn credit_account() -> Weight { - Weight::MAX - }*/ + // TODO: Add real benchmarking functionality for each of these to + // benchmarking.rs, then uncomment here and in trait definition. + //fn credit_account() -> Weight { + // Weight::MAX + //} fn assign_core(_s: u32) -> Weight { Weight::MAX } } +/// Shorthand for the Balance type the runtime is using. +pub type BalanceOf = + <::Currency as Currency<::AccountId>>::Balance; + /// Broker pallet index on the coretime chain. Used to /// /// construct remote calls. The codec index must correspond to the index of `Broker` in the @@ -85,13 +108,19 @@ enum CoretimeCalls { SetLease(pallet_broker::TaskId, pallet_broker::Timeslice), #[codec(index = 19)] NotifyCoreCount(u16), + #[codec(index = 20)] + NotifyRevenue((BlockNumber, Balance)), #[codec(index = 99)] SwapLeases(ParaId, ParaId), } #[frame_support::pallet] pub mod pallet { + use crate::configuration; + use sp_runtime::traits::TryConvert; + use xcm::v4::InteriorLocation; + use xcm_executor::traits::TransactAsset; use super::*; @@ -100,18 +129,26 @@ pub mod pallet { pub struct Pallet(_); #[pallet::config] - pub trait Config: frame_system::Config + assigner_coretime::Config { + pub trait Config: frame_system::Config + assigner_coretime::Config + on_demand::Config { type RuntimeOrigin: From<::RuntimeOrigin> + Into::RuntimeOrigin>>; type RuntimeEvent: From> + IsType<::RuntimeEvent>; /// The runtime's definition of a Currency. type Currency: Currency; - /// The ParaId of the broker system parachain. + /// The ParaId of the coretime chain. #[pallet::constant] type BrokerId: Get; + /// The coretime chain pot location. + #[pallet::constant] + type BrokerPotLocation: Get; /// Something that provides the weight of this pallet. type WeightInfo: WeightInfo; + /// The XCM sender. type SendXcm: SendXcm; + /// The asset transactor. + type AssetTransactor: TransactAsset; + /// AccountId to Location converter + type AccountToLocation: for<'a> TryConvert<&'a Self::AccountId, Location>; /// Maximum weight for any XCM transact call that should be executed on the coretime chain. /// @@ -132,6 +169,11 @@ pub mod pallet { pub enum Error { /// The paraid making the call is not the coretime brokerage system parachain. NotBroker, + /// Requested revenue information `when` parameter was in the future from the current + /// block height. + RequestedFutureRevenue, + /// Failed to transfer assets to the coretime chain + AssetTransferFailed, } #[pallet::hooks] @@ -139,26 +181,32 @@ pub mod pallet { #[pallet::call] impl Pallet { + /// Request the configuration to be updated with the specified number of cores. Warning: + /// Since this only schedules a configuration update, it takes two sessions to come into + /// effect. + /// + /// - `origin`: Root or the Coretime Chain + /// - `count`: total number of cores #[pallet::weight(::WeightInfo::request_core_count())] #[pallet::call_index(1)] pub fn request_core_count(origin: OriginFor, count: u16) -> DispatchResult { - // Ignore requests not coming from the broker parachain or root. + // Ignore requests not coming from the coretime chain or root. Self::ensure_root_or_para(origin, ::BrokerId::get().into())?; configuration::Pallet::::set_coretime_cores_unchecked(u32::from(count)) } - //// TODO Impl me! - ////#[pallet::weight(::WeightInfo::request_revenue_info_at())] - //#[pallet::call_index(2)] - //pub fn request_revenue_info_at( - // origin: OriginFor, - // _when: BlockNumberFor, - //) -> DispatchResult { - // // Ignore requests not coming from the broker parachain or root. - // Self::ensure_root_or_para(origin, ::BrokerId::get().into())?; - // Ok(()) - //} + /// Request to claim the instantaneous coretime sales revenue starting from the block it was + /// last claimed until and up to the block specified. The claimed amount value is sent back + /// to the Coretime chain in a `notify_revenue` message. At the same time, the amount is + /// teleported to the Coretime chain. + #[pallet::weight(::WeightInfo::request_revenue_at())] + #[pallet::call_index(2)] + pub fn request_revenue_at(origin: OriginFor, when: BlockNumber) -> DispatchResult { + // Ignore requests not coming from the Coretime Chain or Root. + Self::ensure_root_or_para(origin, ::BrokerId::get().into())?; + Self::notify_revenue(when) + } //// TODO Impl me! ////#[pallet::weight(::WeightInfo::credit_account())] @@ -168,7 +216,7 @@ pub mod pallet { // _who: T::AccountId, // _amount: BalanceOf, //) -> DispatchResult { - // // Ignore requests not coming from the broker parachain or root. + // // Ignore requests not coming from the coretime chain or root. // Self::ensure_root_or_para(origin, ::BrokerId::get().into())?; // Ok(()) //} @@ -177,7 +225,7 @@ pub mod pallet { /// to be used. /// /// Parameters: - /// -`origin`: The `ExternalBrokerOrigin`, assumed to be the Broker system parachain. + /// -`origin`: The `ExternalBrokerOrigin`, assumed to be the coretime chain. /// -`core`: The core that should be scheduled. /// -`begin`: The starting blockheight of the instruction. /// -`assignment`: How the blockspace should be utilised. @@ -193,7 +241,7 @@ pub mod pallet { assignment: Vec<(CoreAssignment, PartsOf57600)>, end_hint: Option>, ) -> DispatchResult { - // Ignore requests not coming from the broker parachain or root. + // Ignore requests not coming from the coretime chain or root. Self::ensure_root_or_para(origin, T::BrokerId::get().into())?; let core = u32::from(core).into(); @@ -238,12 +286,44 @@ impl Pallet { Location::new(0, [Junction::Parachain(T::BrokerId::get())]), message, ) { - log::error!("Sending `NotifyCoreCount` to coretime chain failed: {:?}", err); + log::error!(target: LOG_TARGET, "Sending `NotifyCoreCount` to coretime chain failed: {:?}", err); } } } - // Handle legacy swaps in coretime. Notifies broker parachain that a lease swap has occurred via + /// Provide the amount of revenue accumulated from Instantaneous Coretime Sales from Relay-chain + /// block number last_until to until, not including until itself. last_until is defined as being + /// the until argument of the last notify_revenue message sent, or zero for the first call. If + /// revenue is None, this indicates that the information is no longer available. This explicitly + /// disregards the possibility of multiple parachains requesting and being notified of revenue + /// information. + /// + /// The Relay-chain must be configured to ensure that only a single revenue information + /// destination exists. + pub fn notify_revenue(until: BlockNumber) -> DispatchResult { + let now = >::block_number(); + let until_bnf: BlockNumberFor = until.into(); + + // When cannot be in the future. + ensure!(until_bnf <= now, Error::::RequestedFutureRevenue); + + let amount = >::claim_revenue_until(until_bnf); + log::debug!(target: LOG_TARGET, "Revenue info requested: {:?}", amount); + + let raw_revenue: Balance = amount.try_into().map_err(|_| { + log::error!(target: LOG_TARGET, "Converting on demand revenue for `NotifyRevenue` failed"); + Error::::AssetTransferFailed + })?; + + do_notify_revenue::(until, raw_revenue).map_err(|err| { + log::error!(target: LOG_TARGET, "notify_revenue failed: {err:?}"); + Error::::AssetTransferFailed + })?; + + Ok(()) + } + + // Handle legacy swaps in coretime. Notifies coretime chain that a lease swap has occurred via // XCM message. This function is meant to be used in an implementation of `OnSwap` trait. pub fn on_legacy_lease_swap(one: ParaId, other: ParaId) { let message = Xcm(vec![ @@ -257,7 +337,7 @@ impl Pallet { Location::new(0, [Junction::Parachain(T::BrokerId::get())]), message, ) { - log::error!("Sending `SwapLeases` to coretime chain failed: {:?}", err); + log::error!(target: LOG_TARGET, "Sending `SwapLeases` to coretime chain failed: {:?}", err); } } } @@ -275,3 +355,55 @@ fn mk_coretime_call(call: crate::coretime::CoretimeCalls) -> Instruct call: BrokerRuntimePallets::Broker(call).encode().into(), } } + +fn do_notify_revenue(when: BlockNumber, raw_revenue: Balance) -> Result<(), XcmError> { + let dest = Junction::Parachain(T::BrokerId::get()).into_location(); + let mut message = vec![Instruction::UnpaidExecution { + weight_limit: WeightLimit::Unlimited, + check_origin: None, + }]; + let asset = Asset { id: AssetId(Location::here()), fun: Fungible(raw_revenue) }; + let dummy_xcm_context = XcmContext { origin: None, message_id: [0; 32], topic: None }; + + if raw_revenue > 0 { + let on_demand_pot = + T::AccountToLocation::try_convert(&>::account_id()).map_err( + |err| { + log::error!( + target: LOG_TARGET, + "Failed to convert on-demand pot account to XCM location: {err:?}", + ); + XcmError::InvalidLocation + }, + )?; + + let withdrawn = T::AssetTransactor::withdraw_asset(&asset, &on_demand_pot, None)?; + + T::AssetTransactor::can_check_out(&dest, &asset, &dummy_xcm_context)?; + + let assets_reanchored = Into::::into(withdrawn) + .reanchored(&dest, &Here.into()) + .defensive_map_err(|_| XcmError::ReanchorFailed)?; + + message.extend( + [ + ReceiveTeleportedAsset(assets_reanchored), + DepositAsset { + assets: Wild(AllCounted(1)), + beneficiary: T::BrokerPotLocation::get().into_location(), + }, + ] + .into_iter(), + ); + } + + message.push(mk_coretime_call::(CoretimeCalls::NotifyRevenue((when, raw_revenue)))); + + send_xcm::(dest.clone(), Xcm(message))?; + + if raw_revenue > 0 { + T::AssetTransactor::check_out(&dest, &asset, &dummy_xcm_context); + } + + Ok(()) +} diff --git a/polkadot/runtime/parachains/src/disputes.rs b/polkadot/runtime/parachains/src/disputes.rs index 62e02e67157d9e0e84de995dae18ee14143488a5..f86573dadf562fee7b4cb63190399cbe390a4865 100644 --- a/polkadot/runtime/parachains/src/disputes.rs +++ b/polkadot/runtime/parachains/src/disputes.rs @@ -19,24 +19,25 @@ use crate::{ configuration, initializer::SessionChangeNotification, metrics::METRICS, session_info, }; +use alloc::{collections::btree_set::BTreeSet, vec::Vec}; use bitvec::{bitvec, order::Lsb0 as BitOrderLsb0}; +use codec::{Decode, Encode}; +use core::cmp::Ordering; use frame_support::{ensure, weights::Weight}; use frame_system::pallet_prelude::*; -use parity_scale_codec::{Decode, Encode}; -use polkadot_runtime_metrics::get_current_time; -use primitives::{ +use polkadot_primitives::{ byzantine_threshold, supermajority_threshold, ApprovalVote, ApprovalVoteMultipleCandidates, CandidateHash, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CompactStatement, ConsensusLog, DisputeState, DisputeStatement, DisputeStatementSet, ExplicitDisputeStatement, InvalidDisputeStatementKind, MultiDisputeStatementSet, SessionIndex, SigningContext, ValidDisputeStatementKind, ValidatorId, ValidatorIndex, ValidatorSignature, }; +use polkadot_runtime_metrics::get_current_time; use scale_info::TypeInfo; use sp_runtime::{ traits::{AppVerify, One, Saturating, Zero}, DispatchError, RuntimeDebug, SaturatedConversion, }; -use sp_std::{cmp::Ordering, collections::btree_set::BTreeSet, prelude::*}; #[cfg(test)] #[allow(unused_imports)] diff --git a/polkadot/runtime/parachains/src/disputes/migration.rs b/polkadot/runtime/parachains/src/disputes/migration.rs index ccd367e41b36e619d246bcd2785ae771aeafdec3..dd32340c9f64f357913a99d6a50f166f9a9382f2 100644 --- a/polkadot/runtime/parachains/src/disputes/migration.rs +++ b/polkadot/runtime/parachains/src/disputes/migration.rs @@ -21,16 +21,16 @@ use frame_support::traits::StorageVersion; pub mod v1 { use super::*; use crate::disputes::{Config, Pallet}; + use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, storage_alias, traits::OnRuntimeUpgrade, weights::Weight, }; - use primitives::SessionIndex; - use sp_std::prelude::*; + use polkadot_primitives::SessionIndex; #[storage_alias] type SpamSlots = StorageMap, Twox64Concat, SessionIndex, Vec>; - pub struct MigrateToV1(sp_std::marker::PhantomData); + pub struct MigrateToV1(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToV1 { fn on_runtime_upgrade() -> Weight { let mut weight: Weight = Weight::zero(); diff --git a/polkadot/runtime/parachains/src/disputes/slashing.rs b/polkadot/runtime/parachains/src/disputes/slashing.rs index a61d0c8998364c111f6e3a49fc03d5d39a5d76af..4b76fb47e1f8d5fff51e13274931514930ef5de7 100644 --- a/polkadot/runtime/parachains/src/disputes/slashing.rs +++ b/polkadot/runtime/parachains/src/disputes/slashing.rs @@ -50,7 +50,13 @@ use frame_support::{ }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{ +use alloc::{ + boxed::Box, + collections::{btree_map::Entry, btree_set::BTreeSet}, + vec, + vec::Vec, +}; +use polkadot_primitives::{ slashing::{DisputeProof, DisputesTimeSlot, PendingSlashes, SlashingOffenceKind}, CandidateHash, SessionIndex, ValidatorId, ValidatorIndex, }; @@ -65,10 +71,6 @@ use sp_runtime::{ }; use sp_session::{GetSessionNumber, GetValidatorCount}; use sp_staking::offence::{Kind, Offence, OffenceError, ReportOffence}; -use sp_std::{ - collections::{btree_map::Entry, btree_set::BTreeSet}, - prelude::*, -}; const LOG_TARGET: &str = "runtime::parachains::slashing"; @@ -158,7 +160,7 @@ impl SlashingOffence { /// This type implements `SlashingHandler`. pub struct SlashValidatorsForDisputes { - _phantom: sp_std::marker::PhantomData, + _phantom: core::marker::PhantomData, } impl Default for SlashValidatorsForDisputes { @@ -456,7 +458,8 @@ pub mod pallet { let validator_set_count = key_owner_proof.validator_count() as ValidatorSetCount; // check the membership proof to extract the offender's id - let key = (primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone()); + let key = + (polkadot_primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone()); let offender = T::KeyOwnerProofSystem::check_proof(key, key_owner_proof) .ok_or(Error::::InvalidKeyOwnershipProof)?; @@ -615,7 +618,7 @@ fn is_known_offence( key_owner_proof: &T::KeyOwnerProof, ) -> Result<(), TransactionValidityError> { // check the membership proof to extract the offender's id - let key = (primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone()); + let key = (polkadot_primitives::PARACHAIN_KEY_TYPE_ID, dispute_proof.validator_id.clone()); let offender = T::KeyOwnerProofSystem::check_proof(key, key_owner_proof.clone()) .ok_or(InvalidTransaction::BadProof)?; @@ -639,7 +642,7 @@ fn is_known_offence( /// When configured properly, should be instantiated with /// `T::KeyOwnerIdentification, Offences, ReportLongevity` parameters. pub struct SlashingReportHandler { - _phantom: sp_std::marker::PhantomData<(I, R, L)>, + _phantom: core::marker::PhantomData<(I, R, L)>, } impl Default for SlashingReportHandler { diff --git a/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs b/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs index 42a64725160c31746f9f1fe02b8239befd106a1e..b53f98caeea30cd2d55317eb59e705517ed07ec5 100644 --- a/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs +++ b/polkadot/runtime/parachains/src/disputes/slashing/benchmarking.rs @@ -17,12 +17,12 @@ use super::*; use crate::{disputes::SlashingHandler, initializer, shared}; +use codec::Decode; use frame_benchmarking::{benchmarks, whitelist_account}; use frame_support::traits::{OnFinalize, OnInitialize}; use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin}; use pallet_staking::testing_utils::create_validators; -use parity_scale_codec::Decode; -use primitives::{Hash, PARACHAIN_KEY_TYPE_ID}; +use polkadot_primitives::{Hash, PARACHAIN_KEY_TYPE_ID}; use sp_runtime::traits::{One, OpaqueKeys, StaticLookup}; use sp_session::MembershipProof; diff --git a/polkadot/runtime/parachains/src/disputes/tests.rs b/polkadot/runtime/parachains/src/disputes/tests.rs index 16b4fa3a9f1a6b551cb94ff56dd3ba8ac53323f6..f505bf4625a6429db3aedce23f81bc3849b7baf6 100644 --- a/polkadot/runtime/parachains/src/disputes/tests.rs +++ b/polkadot/runtime/parachains/src/disputes/tests.rs @@ -29,7 +29,7 @@ use frame_support::{ traits::{OnFinalize, OnInitialize}, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::BlockNumber; +use polkadot_primitives::BlockNumber; use sp_core::{crypto::CryptoType, Pair}; const VOTE_FOR: VoteKind = VoteKind::ExplicitValid; diff --git a/polkadot/runtime/parachains/src/dmp.rs b/polkadot/runtime/parachains/src/dmp.rs index df2f93e194214c7bec474668f197ceaca53818ed..03580e11b8e9cbe7dce4c9e375741ec3677bd9fe 100644 --- a/polkadot/runtime/parachains/src/dmp.rs +++ b/polkadot/runtime/parachains/src/dmp.rs @@ -46,15 +46,16 @@ use crate::{ configuration::{self, HostConfiguration}, initializer, FeeTracker, }; +use alloc::vec::Vec; +use core::fmt; use frame_support::pallet_prelude::*; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{DownwardMessage, Hash, Id as ParaId, InboundDownwardMessage}; +use polkadot_primitives::{DownwardMessage, Hash, Id as ParaId, InboundDownwardMessage}; use sp_core::MAX_POSSIBLE_ALLOCATION; use sp_runtime::{ traits::{BlakeTwo256, Hash as HashT, SaturatedConversion}, FixedU128, Saturating, }; -use sp_std::{fmt, prelude::*}; use xcm::latest::SendError; pub use pallet::*; @@ -286,7 +287,7 @@ impl Pallet { } /// Prunes the specified number of messages from the downward message queue of the given para. - pub(crate) fn prune_dmq(para: ParaId, processed_downward_messages: u32) -> Weight { + pub(crate) fn prune_dmq(para: ParaId, processed_downward_messages: u32) { let q_len = DownwardMessageQueues::::mutate(para, |q| { let processed_downward_messages = processed_downward_messages as usize; if processed_downward_messages > q.len() { @@ -305,7 +306,6 @@ impl Pallet { if q_len <= (threshold as usize) { Self::decrease_fee_factor(para); } - T::DbWeight::get().reads_writes(1, 1) } /// Returns the Head of Message Queue Chain for the given para or `None` if there is none diff --git a/polkadot/runtime/parachains/src/dmp/tests.rs b/polkadot/runtime/parachains/src/dmp/tests.rs index f39d7ae167330be3a32b9454c449373515ac28bc..de15159581252aa29775addda7797d84abc4d115 100644 --- a/polkadot/runtime/parachains/src/dmp/tests.rs +++ b/polkadot/runtime/parachains/src/dmp/tests.rs @@ -19,10 +19,10 @@ use crate::{ configuration::ActiveConfig, mock::{new_test_ext, Dmp, MockGenesisConfig, Paras, System, Test}, }; +use codec::Encode; use frame_support::assert_ok; use hex_literal::hex; -use parity_scale_codec::Encode; -use primitives::BlockNumber; +use polkadot_primitives::BlockNumber; pub(crate) fn run_to_block(to: BlockNumber, new_session: Option>) { while System::block_number() < to { @@ -210,7 +210,7 @@ fn queue_downward_message_critical() { #[test] fn verify_dmq_mqc_head_is_externally_accessible() { use hex_literal::hex; - use primitives::well_known_keys; + use polkadot_primitives::well_known_keys; let a = ParaId::from(2020); diff --git a/polkadot/runtime/parachains/src/hrmp.rs b/polkadot/runtime/parachains/src/hrmp.rs index 42a9c23e5aa1132c5f0ff4044b53df2407efdc1e..b149404b41b8716173d57b0dfa37a777618946db 100644 --- a/polkadot/runtime/parachains/src/hrmp.rs +++ b/polkadot/runtime/parachains/src/hrmp.rs @@ -18,11 +18,17 @@ use crate::{ configuration::{self, HostConfiguration}, dmp, ensure_parachain, initializer, paras, }; +use alloc::{ + collections::{btree_map::BTreeMap, btree_set::BTreeSet}, + vec, + vec::Vec, +}; +use codec::{Decode, Encode}; +use core::{fmt, mem}; use frame_support::{pallet_prelude::*, traits::ReservableCurrency, DefaultNoBound}; use frame_system::pallet_prelude::*; -use parity_scale_codec::{Decode, Encode}; use polkadot_parachain_primitives::primitives::{HorizontalMessages, IsSystem}; -use primitives::{ +use polkadot_primitives::{ Balance, Hash, HrmpChannelId, Id as ParaId, InboundHrmpMessage, OutboundHrmpMessage, SessionIndex, }; @@ -31,11 +37,6 @@ use sp_runtime::{ traits::{AccountIdConversion, BlakeTwo256, Hash as HashT, UniqueSaturatedInto, Zero}, ArithmeticError, }; -use sp_std::{ - collections::{btree_map::BTreeMap, btree_set::BTreeSet}, - fmt, mem, - prelude::*, -}; pub use pallet::*; @@ -487,7 +488,7 @@ pub mod pallet { #[derive(DefaultNoBound)] pub struct GenesisConfig { #[serde(skip)] - _config: sp_std::marker::PhantomData, + _config: core::marker::PhantomData, preopen_hrmp_channels: Vec<(ParaId, ParaId, u32, u32)>, } @@ -1304,9 +1305,7 @@ impl Pallet { remaining } - pub(crate) fn prune_hrmp(recipient: ParaId, new_hrmp_watermark: BlockNumberFor) -> Weight { - let mut weight = Weight::zero(); - + pub(crate) fn prune_hrmp(recipient: ParaId, new_hrmp_watermark: BlockNumberFor) { // sift through the incoming messages digest to collect the paras that sent at least one // message to this parachain between the old and new watermarks. let senders = HrmpChannelDigests::::mutate(&recipient, |digest| { @@ -1322,7 +1321,6 @@ impl Pallet { *digest = leftover; senders }); - weight += T::DbWeight::get().reads_writes(1, 1); // having all senders we can trivially find out the channels which we need to prune. let channels_to_prune = @@ -1355,21 +1353,13 @@ impl Pallet { channel.total_size -= pruned_size as u32; } }); - - weight += T::DbWeight::get().reads_writes(2, 2); } HrmpWatermarks::::insert(&recipient, new_hrmp_watermark); - weight += T::DbWeight::get().reads_writes(0, 1); - - weight } /// Process the outbound HRMP messages by putting them into the appropriate recipient queues. - /// - /// Returns the amount of weight consumed. - pub(crate) fn queue_outbound_hrmp(sender: ParaId, out_hrmp_msgs: HorizontalMessages) -> Weight { - let mut weight = Weight::zero(); + pub(crate) fn queue_outbound_hrmp(sender: ParaId, out_hrmp_msgs: HorizontalMessages) { let now = frame_system::Pallet::::block_number(); for out_msg in out_hrmp_msgs { @@ -1425,11 +1415,7 @@ impl Pallet { recipient_digest.push((now, vec![sender])); } HrmpChannelDigests::::insert(&channel_id.recipient, recipient_digest); - - weight += T::DbWeight::get().reads_writes(2, 2); } - - weight } /// Initiate opening a channel from a parachain to a given recipient with given channel @@ -1864,7 +1850,7 @@ impl Pallet { /// If the XCM version is unknown, the latest XCM version is used as a best effort. fn wrap_notification( mut notification: impl FnMut() -> xcm::opaque::latest::opaque::Xcm, - ) -> impl FnOnce(ParaId) -> primitives::DownwardMessage { + ) -> impl FnOnce(ParaId) -> polkadot_primitives::DownwardMessage { use xcm::{ opaque::VersionedXcm, prelude::{Junction, Location}, @@ -1892,7 +1878,7 @@ impl Pallet { log_label: &str, config: &HostConfiguration>, dest: ParaId, - notification_bytes_for: impl FnOnce(ParaId) -> primitives::DownwardMessage, + notification_bytes_for: impl FnOnce(ParaId) -> polkadot_primitives::DownwardMessage, ) { // prepare notification let notification_bytes = notification_bytes_for(dest); diff --git a/polkadot/runtime/parachains/src/hrmp/tests.rs b/polkadot/runtime/parachains/src/hrmp/tests.rs index acfaa8f2d290510d9d11ed85872c281e8b9c7d85..52db932c7962b49f0e7f4d99de7527d38882237d 100644 --- a/polkadot/runtime/parachains/src/hrmp/tests.rs +++ b/polkadot/runtime/parachains/src/hrmp/tests.rs @@ -27,8 +27,9 @@ use crate::{ }, shared, }; -use frame_support::{assert_noop, assert_ok, error::BadOrigin}; -use primitives::{BlockNumber, InboundDownwardMessage}; +use frame_support::{assert_noop, assert_ok}; +use polkadot_primitives::{BlockNumber, InboundDownwardMessage}; +use sp_runtime::traits::BadOrigin; use std::collections::BTreeMap; pub(crate) fn run_to_block(to: BlockNumber, new_session: Option>) { @@ -660,7 +661,7 @@ fn check_sent_messages() { #[test] fn verify_externally_accessible() { - use primitives::{well_known_keys, AbridgedHrmpChannel}; + use polkadot_primitives::{well_known_keys, AbridgedHrmpChannel}; let para_a = 2020.into(); let para_b = 2021.into(); diff --git a/polkadot/runtime/parachains/src/inclusion/benchmarking.rs b/polkadot/runtime/parachains/src/inclusion/benchmarking.rs index 169e858deda8aea05751450a65065550b881142b..978ef718ea4007e142340b0a4088b4c70ad8043d 100644 --- a/polkadot/runtime/parachains/src/inclusion/benchmarking.rs +++ b/polkadot/runtime/parachains/src/inclusion/benchmarking.rs @@ -15,23 +15,134 @@ // along with Polkadot. If not, see . use super::*; +use crate::{ + builder::generate_validator_pairs, + configuration, + hrmp::{HrmpChannel, HrmpChannels}, + initializer, HeadData, ValidationCode, +}; +use bitvec::{bitvec, prelude::Lsb0}; use frame_benchmarking::benchmarks; use pallet_message_queue as mq; +use polkadot_primitives::{ + CandidateCommitments, CollatorId, CollatorSignature, CommittedCandidateReceipt, HrmpChannelId, + OutboundHrmpMessage, SessionIndex, +}; +use sp_core::sr25519; + +fn create_candidate_commitments( + para_id: ParaId, + head_data: HeadData, + max_msg_len: usize, + ump_msg_count: u32, + hrmp_msg_count: u32, + code_upgrade: bool, +) -> CandidateCommitments { + let upward_messages = { + let unbounded = create_messages(max_msg_len, ump_msg_count as _); + BoundedVec::truncate_from(unbounded) + }; + + let horizontal_messages = { + let unbounded = create_messages(max_msg_len, hrmp_msg_count as _); + + for n in 0..unbounded.len() { + let channel_id = HrmpChannelId { sender: para_id, recipient: para_id + n as u32 + 1 }; + HrmpChannels::::insert( + &channel_id, + HrmpChannel { + sender_deposit: 42, + recipient_deposit: 42, + max_capacity: 10_000_000, + max_total_size: 1_000_000_000, + max_message_size: 10_000_000, + msg_count: 0, + total_size: 0, + mqc_head: None, + }, + ); + } + + let unbounded = unbounded + .into_iter() + .enumerate() + .map(|(n, data)| OutboundHrmpMessage { recipient: para_id + n as u32 + 1, data }) + .collect(); + BoundedVec::truncate_from(unbounded) + }; + + let new_validation_code = code_upgrade.then_some(ValidationCode(vec![42u8; 1024])); + + CandidateCommitments:: { + upward_messages, + horizontal_messages, + new_validation_code, + head_data, + processed_downward_messages: 0, + hrmp_watermark: 10, + } +} + +fn create_messages(msg_len: usize, n_msgs: usize) -> Vec> { + let best_number = 73_u8; // Chuck Norris of numbers + vec![vec![best_number; msg_len]; n_msgs] +} benchmarks! { where_clause { where - T: mq::Config, + T: mq::Config + configuration::Config + initializer::Config, } - receive_upward_messages { - let i in 1 .. 1000; + enact_candidate { + let u in 1 .. 32; + let h in 1 .. 32; + let c in 0 .. 1; + + let para = 42_u32.into(); // not especially important. let max_len = mq::MaxMessageLenOf::::get() as usize; - let para = 42u32.into(); // not especially important. - let upward_messages = vec![vec![0; max_len]; i as usize]; + + let config = configuration::ActiveConfig::::get(); + let n_validators = config.max_validators.unwrap_or(500); + let validators = generate_validator_pairs::(n_validators); + + let session = SessionIndex::from(0u32); + initializer::Pallet::::test_trigger_on_new_session( + false, + session, + validators.iter().map(|(a, v)| (a, v.clone())), + None, + ); + let backing_group_size = config.scheduler_params.max_validators_per_core.unwrap_or(5); + let head_data = HeadData(vec![0xFF; 1024]); + + let relay_parent_number = BlockNumberFor::::from(10u32); + let commitments = create_candidate_commitments::(para, head_data, max_len, u, h, c != 0); + let backers = bitvec![u8, Lsb0; 1; backing_group_size as usize]; + let availability_votes = bitvec![u8, Lsb0; 1; n_validators as usize]; + let core_index = CoreIndex::from(0); + let backing_group = GroupIndex::from(0); + + let descriptor = CandidateDescriptor:: { + para_id: para, + relay_parent: Default::default(), + collator: CollatorId::from(sr25519::Public::from_raw([42u8; 32])), + persisted_validation_data_hash: Default::default(), + pov_hash: Default::default(), + erasure_root: Default::default(), + signature: CollatorSignature::from(sr25519::Signature::from_raw([42u8; 64])), + para_head: Default::default(), + validation_code_hash: ValidationCode(vec![1, 2, 3]).hash(), + }; + + let receipt = CommittedCandidateReceipt:: { + descriptor, + commitments, + }; + Pallet::::receive_upward_messages(para, vec![vec![0; max_len]; 1].as_slice()); - }: { Pallet::::receive_upward_messages(para, upward_messages.as_slice()) } + } : { Pallet::::enact_candidate(relay_parent_number, receipt, backers, availability_votes, core_index, backing_group) } impl_benchmark_test_suite!( Pallet, diff --git a/polkadot/runtime/parachains/src/inclusion/migration.rs b/polkadot/runtime/parachains/src/inclusion/migration.rs index 5f35680ee694c45f519a1e31478c4aef0f7c19b9..36a810d341c655cf9309b9b8fec87032a8bc7486 100644 --- a/polkadot/runtime/parachains/src/inclusion/migration.rs +++ b/polkadot/runtime/parachains/src/inclusion/migration.rs @@ -16,10 +16,10 @@ pub use v1::MigrateToV1; pub mod v0 { use crate::inclusion::{Config, Pallet}; use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec}; + use codec::{Decode, Encode}; use frame_support::{storage_alias, Twox64Concat}; use frame_system::pallet_prelude::BlockNumberFor; - use parity_scale_codec::{Decode, Encode}; - use primitives::{ + use polkadot_primitives::{ AvailabilityBitfield, CandidateCommitments, CandidateDescriptor, CandidateHash, CoreIndex, GroupIndex, Id as ParaId, ValidatorIndex, }; @@ -73,19 +73,19 @@ mod v1 { CandidatePendingAvailability as V1CandidatePendingAvailability, Config, Pallet, PendingAvailability as V1PendingAvailability, }; + use alloc::{collections::vec_deque::VecDeque, vec::Vec}; use frame_support::{traits::UncheckedOnRuntimeUpgrade, weights::Weight}; use sp_core::Get; - use sp_std::{collections::vec_deque::VecDeque, vec::Vec}; + #[cfg(feature = "try-runtime")] + use codec::{Decode, Encode}; #[cfg(feature = "try-runtime")] use frame_support::{ ensure, traits::{GetStorageVersion, StorageVersion}, }; - #[cfg(feature = "try-runtime")] - use parity_scale_codec::{Decode, Encode}; - pub struct VersionUncheckedMigrateToV1(sp_std::marker::PhantomData); + pub struct VersionUncheckedMigrateToV1(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV1 { #[cfg(feature = "try-runtime")] @@ -217,8 +217,10 @@ mod tests { mock::{new_test_ext, MockGenesisConfig, Test}, }; use frame_support::traits::UncheckedOnRuntimeUpgrade; - use primitives::{AvailabilityBitfield, Id as ParaId}; - use test_helpers::{dummy_candidate_commitments, dummy_candidate_descriptor, dummy_hash}; + use polkadot_primitives::{AvailabilityBitfield, Id as ParaId}; + use polkadot_primitives_test_helpers::{ + dummy_candidate_commitments, dummy_candidate_descriptor, dummy_hash, + }; #[test] fn migrate_to_v1() { diff --git a/polkadot/runtime/parachains/src/inclusion/mod.rs b/polkadot/runtime/parachains/src/inclusion/mod.rs index 31befefa32201b4bf343301c2956abcfbfb6a896..b1d22996fd1228f07ebb74cf5659efdc1eb2e1dc 100644 --- a/polkadot/runtime/parachains/src/inclusion/mod.rs +++ b/polkadot/runtime/parachains/src/inclusion/mod.rs @@ -27,7 +27,14 @@ use crate::{ shared::{self, AllowedRelayParentsTracker}, util::make_persisted_validation_data_with_parent, }; +use alloc::{ + collections::{btree_map::BTreeMap, btree_set::BTreeSet, vec_deque::VecDeque}, + vec, + vec::Vec, +}; use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec}; +use codec::{Decode, Encode}; +use core::fmt; use frame_support::{ defensive, pallet_prelude::*, @@ -36,8 +43,7 @@ use frame_support::{ }; use frame_system::pallet_prelude::*; use pallet_message_queue::OnQueueChanged; -use parity_scale_codec::{Decode, Encode}; -use primitives::{ +use polkadot_primitives::{ effective_minimum_backing_votes, supermajority_threshold, well_known_keys, BackedCandidate, CandidateCommitments, CandidateDescriptor, CandidateHash, CandidateReceipt, CommittedCandidateReceipt, CoreIndex, GroupIndex, Hash, HeadData, Id as ParaId, @@ -46,12 +52,6 @@ use primitives::{ }; use scale_info::TypeInfo; use sp_runtime::{traits::One, DispatchError, SaturatedConversion, Saturating}; -#[cfg(feature = "std")] -use sp_std::fmt; -use sp_std::{ - collections::{btree_map::BTreeMap, btree_set::BTreeSet, vec_deque::VecDeque}, - prelude::*, -}; pub use pallet::*; @@ -64,18 +64,23 @@ mod benchmarking; pub mod migration; pub trait WeightInfo { - fn receive_upward_messages(i: u32) -> Weight; + /// Weight for `enact_candidate` extrinsic given the number of sent messages + /// (ump, hrmp) and whether there is a new code for a runtime upgrade. + /// + /// NOTE: due to a shortcoming of the current benchmarking framework, + /// we use `u32` for the code upgrade, even though it is a `bool`. + fn enact_candidate(u: u32, h: u32, c: u32) -> Weight; } pub struct TestWeightInfo; impl WeightInfo for TestWeightInfo { - fn receive_upward_messages(_: u32) -> Weight { - Weight::MAX + fn enact_candidate(_u: u32, _h: u32, _c: u32) -> Weight { + Weight::zero() } } impl WeightInfo for () { - fn receive_upward_messages(_: u32) -> Weight { + fn enact_candidate(_u: u32, _h: u32, _c: u32) -> Weight { Weight::zero() } } @@ -337,8 +342,6 @@ pub mod pallet { InsufficientBacking, /// Invalid (bad signature, unknown validator, etc.) backing. InvalidBacking, - /// Collator did not sign PoV. - NotCollatorSigned, /// The validation data hash does not match expected. ValidationDataHashMismatch, /// The downward message queue is not processed correctly. @@ -377,7 +380,7 @@ pub mod pallet { const LOG_TARGET: &str = "runtime::inclusion"; /// The reason that a candidate's outputs were rejected for. -#[cfg_attr(feature = "std", derive(Debug))] +#[derive(Debug)] enum AcceptanceCheckErr { HeadDataTooLarge, /// Code upgrades are not permitted at the current time. @@ -421,6 +424,7 @@ impl From for AcceptanceCheckErr { /// An error returned by [`Pallet::check_upward_messages`] that indicates a violation of one of /// acceptance criteria rules. #[cfg_attr(test, derive(PartialEq))] +#[allow(dead_code)] pub(crate) enum UmpAcceptanceCheckErr { /// The maximal number of messages that can be submitted in one batch was exceeded. MoreMessagesThanPermitted { sent: u32, permitted: u32 }, @@ -434,7 +438,6 @@ pub(crate) enum UmpAcceptanceCheckErr { IsOffboarding, } -#[cfg(feature = "std")] impl fmt::Debug for UmpAcceptanceCheckErr { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -507,7 +510,7 @@ impl Pallet { pub(crate) fn update_pending_availability_and_get_freed_cores( validators: &[ValidatorId], signed_bitfields: SignedAvailabilityBitfields, - ) -> Vec<(CoreIndex, CandidateHash)> { + ) -> (Weight, Vec<(CoreIndex, CandidateHash)>) { let threshold = availability_threshold(validators.len()); let mut votes_per_core: BTreeMap> = BTreeMap::new(); @@ -528,6 +531,7 @@ impl Pallet { } let mut freed_cores = vec![]; + let mut weight = Weight::zero(); let pending_paraids: Vec<_> = PendingAvailability::::iter_keys().collect(); for paraid in pending_paraids { @@ -581,7 +585,17 @@ impl Pallet { descriptor: candidate.descriptor, commitments: candidate.commitments, }; - let _weight = Self::enact_candidate( + + let has_runtime_upgrade = + receipt.commitments.new_validation_code.as_ref().map_or(0, |_| 1); + let u = receipt.commitments.upward_messages.len() as u32; + let h = receipt.commitments.horizontal_messages.len() as u32; + let enact_weight = ::WeightInfo::enact_candidate( + u, + h, + has_runtime_upgrade, + ); + Self::enact_candidate( candidate.relay_parent_number, receipt, candidate.backers, @@ -589,13 +603,14 @@ impl Pallet { candidate.core, candidate.backing_group, ); + weight.saturating_accrue(enact_weight); } } } }); } - freed_cores + (weight, freed_cores) } /// Process candidates that have been backed. Provide a set of @@ -638,6 +653,8 @@ impl Pallet { for (candidate, core) in para_candidates.iter() { let candidate_hash = candidate.candidate().hash(); + // The previous context is None, as it's already checked during candidate + // sanitization. let check_ctx = CandidateCheckContext::::new(None); let relay_parent_number = check_ctx.verify_backed_candidate( &allowed_relay_parents, @@ -717,7 +734,7 @@ impl Pallet { }) } - // Get the latest backed output head data of this para. + // Get the latest backed output head data of this para (including pending availability). pub(crate) fn para_latest_head_data(para_id: &ParaId) -> Option { match PendingAvailability::::get(para_id).and_then(|pending_candidates| { pending_candidates.back().map(|x| x.commitments.head_data.clone()) @@ -727,6 +744,16 @@ impl Pallet { } } + // Get the relay parent number of the most recent candidate (including pending availability). + pub(crate) fn para_most_recent_context(para_id: &ParaId) -> Option> { + match PendingAvailability::::get(para_id) + .and_then(|pending_candidates| pending_candidates.back().map(|x| x.relay_parent_number)) + { + Some(relay_parent_number) => Some(relay_parent_number), + None => paras::MostRecentContext::::get(para_id), + } + } + fn check_backing_votes( backed_candidate: &BackedCandidate, validators: &[ValidatorId], @@ -745,7 +772,7 @@ impl Pallet { backed_candidate.validator_indices_and_core_index(core_index_enabled); // check the signatures in the backing and that it is a majority. - let maybe_amount_validated = primitives::check_candidate_backing( + let maybe_amount_validated = polkadot_primitives::check_candidate_backing( backed_candidate.candidate().hash(), backed_candidate.validity_votes(), validator_indices, @@ -794,28 +821,25 @@ impl Pallet { pub(crate) fn check_validation_outputs_for_runtime_api( para_id: ParaId, relay_parent_number: BlockNumberFor, - validation_outputs: primitives::CandidateCommitments, + validation_outputs: polkadot_primitives::CandidateCommitments, ) -> bool { - let prev_context = paras::MostRecentContext::::get(para_id); + let prev_context = Self::para_most_recent_context(¶_id); let check_ctx = CandidateCheckContext::::new(prev_context); - if check_ctx - .check_validation_outputs( - para_id, - relay_parent_number, - &validation_outputs.head_data, - &validation_outputs.new_validation_code, - validation_outputs.processed_downward_messages, - &validation_outputs.upward_messages, - BlockNumberFor::::from(validation_outputs.hrmp_watermark), - &validation_outputs.horizontal_messages, - ) - .is_err() - { + if let Err(err) = check_ctx.check_validation_outputs( + para_id, + relay_parent_number, + &validation_outputs.head_data, + &validation_outputs.new_validation_code, + validation_outputs.processed_downward_messages, + &validation_outputs.upward_messages, + BlockNumberFor::::from(validation_outputs.hrmp_watermark), + &validation_outputs.horizontal_messages, + ) { log::debug!( target: LOG_TARGET, - "Validation outputs checking for parachain `{}` failed", - u32::from(para_id), + "Validation outputs checking for parachain `{}` failed, error: {:?}", + u32::from(para_id), err ); false } else { @@ -830,7 +854,7 @@ impl Pallet { availability_votes: BitVec, core_index: CoreIndex, backing_group: GroupIndex, - ) -> Weight { + ) { let plain = receipt.to_plain(); let commitments = receipt.commitments; let config = configuration::ActiveConfig::::get(); @@ -851,38 +875,36 @@ impl Pallet { .map(|(i, _)| ValidatorIndex(i as _)), ); - // initial weight is config read. - let mut weight = T::DbWeight::get().reads_writes(1, 0); if let Some(new_code) = commitments.new_validation_code { // Block number of candidate's inclusion. let now = frame_system::Pallet::::block_number(); - weight.saturating_add(paras::Pallet::::schedule_code_upgrade( + paras::Pallet::::schedule_code_upgrade( receipt.descriptor.para_id, new_code, now, &config, UpgradeStrategy::SetGoAheadSignal, - )); + ); } // enact the messaging facet of the candidate. - weight.saturating_accrue(dmp::Pallet::::prune_dmq( + dmp::Pallet::::prune_dmq( receipt.descriptor.para_id, commitments.processed_downward_messages, - )); - weight.saturating_accrue(Self::receive_upward_messages( + ); + Self::receive_upward_messages( receipt.descriptor.para_id, commitments.upward_messages.as_slice(), - )); - weight.saturating_accrue(hrmp::Pallet::::prune_hrmp( + ); + hrmp::Pallet::::prune_hrmp( receipt.descriptor.para_id, BlockNumberFor::::from(commitments.hrmp_watermark), - )); - weight.saturating_accrue(hrmp::Pallet::::queue_outbound_hrmp( + ); + hrmp::Pallet::::queue_outbound_hrmp( receipt.descriptor.para_id, commitments.horizontal_messages, - )); + ); Self::deposit_event(Event::::CandidateIncluded( plain, @@ -891,11 +913,11 @@ impl Pallet { backing_group, )); - weight.saturating_add(paras::Pallet::::note_new_head( + paras::Pallet::::note_new_head( receipt.descriptor.para_id, commitments.head_data, relay_parent_number, - )) + ); } pub(crate) fn relay_dispatch_queue_size(para_id: ParaId) -> (u32, u32) { @@ -960,7 +982,7 @@ impl Pallet { /// This function is infallible since the candidate was already accepted and we therefore need /// to deal with the messages as given. Messages that are too long will be ignored since such /// candidates should have already been rejected in [`Self::check_upward_messages`]. - pub(crate) fn receive_upward_messages(para: ParaId, upward_messages: &[Vec]) -> Weight { + pub(crate) fn receive_upward_messages(para: ParaId, upward_messages: &[Vec]) { let bounded = upward_messages .iter() .filter_map(|d| { @@ -979,19 +1001,17 @@ impl Pallet { pub(crate) fn receive_bounded_upward_messages( para: ParaId, messages: Vec>>, - ) -> Weight { + ) { let count = messages.len() as u32; if count == 0 { - return Weight::zero() + return } T::MessageQueue::enqueue_messages( messages.into_iter(), AggregateMessageOrigin::Ump(UmpQueueId::Para(para)), ); - let weight = ::WeightInfo::receive_upward_messages(count); Self::deposit_event(Event::UpwardMessagesReceived { from: para, count }); - weight } /// Cleans up all timed out candidates as well as their descendant candidates. @@ -1220,7 +1240,6 @@ impl CandidateCheckContext { /// /// Assures: /// * relay-parent in-bounds - /// * collator signature check passes /// * code hash of commitments matches current code hash /// * para head in the descriptor and commitments match /// @@ -1257,11 +1276,6 @@ impl CandidateCheckContext { ); } - ensure!( - backed_candidate_receipt.descriptor().check_collator_signature().is_ok(), - Error::::NotCollatorSigned, - ); - let validation_code_hash = paras::CurrentCodeHash::::get(para_id) // A candidate for a parachain without current validation code is not scheduled. .ok_or_else(|| Error::::UnscheduledCandidate)?; @@ -1288,9 +1302,10 @@ impl CandidateCheckContext { ) { log::debug!( target: LOG_TARGET, - "Validation outputs checking during inclusion of a candidate {:?} for parachain `{}` failed", + "Validation outputs checking during inclusion of a candidate {:?} for parachain `{}` failed, error: {:?}", backed_candidate_receipt.hash(), u32::from(para_id), + err ); Err(err.strip_into_dispatch_err::())?; }; @@ -1318,11 +1333,11 @@ impl CandidateCheckContext { para_id: ParaId, relay_parent_number: BlockNumberFor, head_data: &HeadData, - new_validation_code: &Option, + new_validation_code: &Option, processed_downward_messages: u32, - upward_messages: &[primitives::UpwardMessage], + upward_messages: &[polkadot_primitives::UpwardMessage], hrmp_watermark: BlockNumberFor, - horizontal_messages: &[primitives::OutboundHrmpMessage], + horizontal_messages: &[polkadot_primitives::OutboundHrmpMessage], ) -> Result<(), AcceptanceCheckErr> { ensure!( head_data.0.len() <= self.config.max_head_data_size as _, @@ -1346,10 +1361,49 @@ impl CandidateCheckContext { para_id, relay_parent_number, processed_downward_messages, + ) + .map_err(|e| { + log::debug!( + target: LOG_TARGET, + "Check processed downward messages for parachain `{}` on relay parent number `{:?}` failed, error: {:?}", + u32::from(para_id), + relay_parent_number, + e + ); + e + })?; + Pallet::::check_upward_messages(&self.config, para_id, upward_messages).map_err( + |e| { + log::debug!( + target: LOG_TARGET, + "Check upward messages for parachain `{}` failed, error: {:?}", + u32::from(para_id), + e + ); + e + }, )?; - Pallet::::check_upward_messages(&self.config, para_id, upward_messages)?; - hrmp::Pallet::::check_hrmp_watermark(para_id, relay_parent_number, hrmp_watermark)?; - hrmp::Pallet::::check_outbound_hrmp(&self.config, para_id, horizontal_messages)?; + hrmp::Pallet::::check_hrmp_watermark(para_id, relay_parent_number, hrmp_watermark) + .map_err(|e| { + log::debug!( + target: LOG_TARGET, + "Check hrmp watermark for parachain `{}` on relay parent number `{:?}` failed, error: {:?}", + u32::from(para_id), + relay_parent_number, + e + ); + e + })?; + hrmp::Pallet::::check_outbound_hrmp(&self.config, para_id, horizontal_messages) + .map_err(|e| { + log::debug!( + target: LOG_TARGET, + "Check outbound hrmp for parachain `{}` failed, error: {:?}", + u32::from(para_id), + e + ); + e + })?; Ok(()) } diff --git a/polkadot/runtime/parachains/src/inclusion/tests.rs b/polkadot/runtime/parachains/src/inclusion/tests.rs index c19bc6eb7bfc7eb8fcc13ad7de640990beeb4e40..95fd66bf8e4fbcd139198955fec3e2eff0b42801 100644 --- a/polkadot/runtime/parachains/src/inclusion/tests.rs +++ b/polkadot/runtime/parachains/src/inclusion/tests.rs @@ -25,24 +25,26 @@ use crate::{ paras_inherent::DisputedBitfield, shared::AllowedRelayParentsTracker, }; -use primitives::{ +use polkadot_primitives::{ effective_minimum_backing_votes, AvailabilityBitfield, SignedAvailabilityBitfields, UncheckedSignedAvailabilityBitfields, }; use assert_matches::assert_matches; +use codec::DecodeAll; use frame_support::assert_noop; -use keyring::Sr25519Keyring; -use parity_scale_codec::DecodeAll; -use primitives::{ +use polkadot_primitives::{ BlockNumber, CandidateCommitments, CandidateDescriptor, CollatorId, CompactStatement as Statement, Hash, SignedAvailabilityBitfield, SignedStatement, ValidationCode, ValidatorId, ValidityAttestation, PARACHAIN_KEY_TYPE_ID, }; +use polkadot_primitives_test_helpers::{ + dummy_collator, dummy_collator_signature, dummy_validation_code, +}; use sc_keystore::LocalKeystore; +use sp_keyring::Sr25519Keyring; use sp_keystore::{Keystore, KeystorePtr}; use std::sync::Arc; -use test_helpers::{dummy_collator, dummy_collator_signature, dummy_validation_code}; fn default_config() -> HostConfiguration { let mut config = HostConfiguration::default(); @@ -100,7 +102,7 @@ pub(crate) fn collator_sign_candidate( ) { candidate.descriptor.collator = collator.public().into(); - let payload = primitives::collator_signature_payload( + let payload = polkadot_primitives::collator_signature_payload( &candidate.descriptor.relay_parent, &candidate.descriptor.para_id, &candidate.descriptor.persisted_validation_data_hash, @@ -158,7 +160,7 @@ pub(crate) fn back_candidate( let backed = BackedCandidate::new(candidate, validity_votes, validator_indices.clone(), core_index); - let successfully_backed = primitives::check_candidate_backing( + let successfully_backed = polkadot_primitives::check_candidate_backing( backed.candidate().hash(), backed.validity_votes(), validator_indices.as_bitslice(), @@ -364,10 +366,11 @@ pub(crate) fn process_bitfields( ) -> Vec<(CoreIndex, CandidateHash)> { let validators = shared::ActiveValidatorKeys::::get(); - ParaInclusion::update_pending_availability_and_get_freed_cores( + let (_weight, bitfields) = ParaInclusion::update_pending_availability_and_get_freed_cores( &validators[..], signed_bitfields, - ) + ); + bitfields } #[test] @@ -1543,16 +1546,52 @@ fn candidate_checks() { None, ); - assert_noop!( - ParaInclusion::process_candidates( - &allowed_relay_parents, - &vec![(thread_a_assignment.0, vec![(backed, thread_a_assignment.1)])] - .into_iter() - .collect(), - &group_validators, - false - ), - Error::::NotCollatorSigned + let ProcessedCandidates { + core_indices: occupied_cores, + candidate_receipt_with_backing_validator_indices, + } = ParaInclusion::process_candidates( + &allowed_relay_parents, + &vec![(thread_a_assignment.0, vec![(backed.clone(), thread_a_assignment.1)])] + .into_iter() + .collect(), + &group_validators, + false, + ) + .expect("candidate is accepted with bad collator signature"); + + assert_eq!(occupied_cores, vec![(CoreIndex::from(2), thread_a)]); + + let mut expected = std::collections::HashMap::< + CandidateHash, + (CandidateReceipt, Vec<(ValidatorIndex, ValidityAttestation)>), + >::new(); + let backed_candidate = backed; + let candidate_receipt_with_backers = expected + .entry(backed_candidate.hash()) + .or_insert_with(|| (backed_candidate.receipt(), Vec::new())); + let (validator_indices, _maybe_core_index) = + backed_candidate.validator_indices_and_core_index(true); + assert_eq!(backed_candidate.validity_votes().len(), validator_indices.count_ones()); + candidate_receipt_with_backers.1.extend( + validator_indices + .iter() + .enumerate() + .filter(|(_, signed)| **signed) + .zip(backed_candidate.validity_votes().iter().cloned()) + .filter_map(|((validator_index_within_group, _), attestation)| { + let grp_idx = GroupIndex(2); + group_validators(grp_idx).map(|validator_indices| { + (validator_indices[validator_index_within_group], attestation) + }) + }), + ); + + assert_eq!( + expected, + candidate_receipt_with_backing_validator_indices + .into_iter() + .map(|c| (c.0.hash(), c)) + .collect() ); } diff --git a/polkadot/runtime/parachains/src/initializer.rs b/polkadot/runtime/parachains/src/initializer.rs index 511d74421032e9e97028a90140189f97b1945599..340f727097b58245d9fa9a2553f9e178544bcea1 100644 --- a/polkadot/runtime/parachains/src/initializer.rs +++ b/polkadot/runtime/parachains/src/initializer.rs @@ -25,15 +25,15 @@ use crate::{ disputes::{self, DisputesHandler as _, SlashingHandler as _}, dmp, hrmp, inclusion, paras, scheduler, session_info, shared, }; +use alloc::vec::Vec; +use codec::{Decode, Encode}; use frame_support::{ traits::{OneSessionHandler, Randomness}, weights::Weight, }; use frame_system::limits::BlockWeights; -use parity_scale_codec::{Decode, Encode}; -use primitives::{BlockNumber, ConsensusLog, SessionIndex, ValidatorId}; +use polkadot_primitives::{BlockNumber, ConsensusLog, SessionIndex, ValidatorId}; use scale_info::TypeInfo; -use sp_std::prelude::*; #[cfg(test)] mod tests; @@ -249,7 +249,7 @@ impl Pallet { // TODO: audit usage of randomness API // https://github.com/paritytech/polkadot/issues/2601 let (random_hash, _) = T::Randomness::random(&b"paras"[..]); - let len = sp_std::cmp::min(32, random_hash.as_ref().len()); + let len = core::cmp::min(32, random_hash.as_ref().len()); buf[..len].copy_from_slice(&random_hash.as_ref()[..len]); buf }; diff --git a/polkadot/runtime/parachains/src/initializer/benchmarking.rs b/polkadot/runtime/parachains/src/initializer/benchmarking.rs index ece41c726f04767fd7257cd8f016a209a9aecb66..2083c058fd04eb9bfcf7e1050275942bfbac9bb3 100644 --- a/polkadot/runtime/parachains/src/initializer/benchmarking.rs +++ b/polkadot/runtime/parachains/src/initializer/benchmarking.rs @@ -17,7 +17,7 @@ use super::*; use frame_benchmarking::benchmarks; use frame_system::RawOrigin; -use primitives::ConsensusLog; +use polkadot_primitives::ConsensusLog; use sp_runtime::DigestItem; // Random large number for the digest diff --git a/polkadot/runtime/parachains/src/initializer/tests.rs b/polkadot/runtime/parachains/src/initializer/tests.rs index e757e6b9d1178121b2c500e292d9433a53c7e98d..a2bdb36eaa64f603f82f8d89e3d49469878bdc23 100644 --- a/polkadot/runtime/parachains/src/initializer/tests.rs +++ b/polkadot/runtime/parachains/src/initializer/tests.rs @@ -20,8 +20,8 @@ use crate::{ paras::ParaKind, session_info, }; -use primitives::{HeadData, Id as ParaId}; -use test_helpers::dummy_validation_code; +use polkadot_primitives::{HeadData, Id as ParaId}; +use polkadot_primitives_test_helpers::dummy_validation_code; use frame_support::{ assert_ok, diff --git a/polkadot/runtime/parachains/src/lib.rs b/polkadot/runtime/parachains/src/lib.rs index 97d6ab74904d5283bc60524adeaa1fab02a71f17..f1162e1cc2154a66db7aa02e465eab9934130769 100644 --- a/polkadot/runtime/parachains/src/lib.rs +++ b/polkadot/runtime/parachains/src/lib.rs @@ -24,7 +24,6 @@ #![cfg_attr(not(feature = "std"), no_std)] pub mod assigner_coretime; -pub mod assigner_on_demand; pub mod assigner_parachains; pub mod configuration; pub mod coretime; @@ -34,6 +33,7 @@ pub mod hrmp; pub mod inclusion; pub mod initializer; pub mod metrics; +pub mod on_demand; pub mod origin; pub mod paras; pub mod paras_inherent; @@ -53,9 +53,11 @@ mod mock; #[cfg(test)] mod ump_tests; +extern crate alloc; + pub use origin::{ensure_parachain, Origin}; pub use paras::{ParaLifecycle, UpgradeStrategy}; -use primitives::{HeadData, Id as ParaId, ValidationCode}; +use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode}; use sp_runtime::{DispatchResult, FixedU128}; /// Trait for tracking message delivery fees on a transport protocol. @@ -86,7 +88,7 @@ pub fn schedule_para_initialize( } /// Schedule a para to be cleaned up at the start of the next session. -pub fn schedule_para_cleanup(id: primitives::Id) -> Result<(), ()> { +pub fn schedule_para_cleanup(id: polkadot_primitives::Id) -> Result<(), ()> { paras::Pallet::::schedule_para_cleanup(id).map_err(|_| ()) } diff --git a/polkadot/runtime/parachains/src/metrics.rs b/polkadot/runtime/parachains/src/metrics.rs index 023bd09f83a82577662eff7c2d95b82b39411dd3..7a17aafabd12d75b1e7cac6822d8430a07cdf3df 100644 --- a/polkadot/runtime/parachains/src/metrics.rs +++ b/polkadot/runtime/parachains/src/metrics.rs @@ -16,13 +16,13 @@ //! Runtime declaration of the parachain metrics. -use polkadot_runtime_metrics::{Counter, CounterVec, Histogram}; -use primitives::metric_definitions::{ +use polkadot_primitives::metric_definitions::{ PARACHAIN_CREATE_INHERENT_BITFIELDS_SIGNATURE_CHECKS, PARACHAIN_INHERENT_DATA_BITFIELDS_PROCESSED, PARACHAIN_INHERENT_DATA_CANDIDATES_PROCESSED, PARACHAIN_INHERENT_DATA_DISPUTE_SETS_PROCESSED, PARACHAIN_INHERENT_DATA_WEIGHT, PARACHAIN_VERIFY_DISPUTE_SIGNATURE, }; +use polkadot_runtime_metrics::{Counter, CounterVec, Histogram}; pub struct Metrics { /// Samples inherent data weight. diff --git a/polkadot/runtime/parachains/src/mock.rs b/polkadot/runtime/parachains/src/mock.rs index a32c9d11b36e737e436d998ebddea1e5d38143b2..75c9e3a5c9b947832a4ca8c15b8813e21d641b2b 100644 --- a/polkadot/runtime/parachains/src/mock.rs +++ b/polkadot/runtime/parachains/src/mock.rs @@ -17,29 +17,29 @@ //! Mocks for all the traits. use crate::{ - assigner_coretime, assigner_on_demand, assigner_parachains, configuration, coretime, disputes, - dmp, hrmp, + assigner_coretime, assigner_parachains, configuration, coretime, disputes, dmp, hrmp, inclusion::{self, AggregateMessageOrigin, UmpQueueId}, - initializer, origin, paras, + initializer, on_demand, origin, paras, paras::ParaKind, paras_inherent, scheduler, scheduler::common::AssignmentProvider, session_info, shared, ParaId, }; use frame_support::pallet_prelude::*; -use primitives::CoreIndex; +use polkadot_primitives::CoreIndex; +use codec::Decode; use frame_support::{ assert_ok, derive_impl, parameter_types, traits::{ Currency, ProcessMessage, ProcessMessageError, ValidatorSet, ValidatorSetWithIdentification, }, weights::{Weight, WeightMeter}, + PalletId, }; use frame_support_test::TestRandomness; use frame_system::limits; -use parity_scale_codec::Decode; -use primitives::{ +use polkadot_primitives::{ AuthorityDiscoveryId, Balance, BlockNumber, CandidateHash, Moment, SessionIndex, UpwardMessage, ValidationCode, ValidatorIndex, }; @@ -50,14 +50,13 @@ use sp_runtime::{ transaction_validity::TransactionPriority, BuildStorage, FixedU128, Perbill, Permill, }; -use sp_std::{ +use std::{ cell::RefCell, - collections::{btree_map::BTreeMap, vec_deque::VecDeque}, + collections::{btree_map::BTreeMap, vec_deque::VecDeque, HashMap}, }; -use std::collections::HashMap; use xcm::{ prelude::XcmVersion, - v4::{Assets, Location, SendError, SendResult, SendXcm, Xcm, XcmHash}, + v4::{Assets, InteriorLocation, Location, SendError, SendResult, SendXcm, Xcm, XcmHash}, IntoVersion, VersionedXcm, WrapVersion, }; @@ -78,7 +77,7 @@ frame_support::construct_runtime!( Scheduler: scheduler, MockAssigner: mock_assigner, ParachainsAssigner: assigner_parachains, - OnDemandAssigner: assigner_on_demand, + OnDemand: on_demand, CoretimeAssigner: assigner_coretime, Coretime: coretime, Initializer: initializer, @@ -100,7 +99,6 @@ where } parameter_types! { - pub const BlockHashCount: u32 = 250; pub static BlockWeights: frame_system::limits::BlockWeights = frame_system::limits::BlockWeights::simple_max( Weight::from_parts(4 * 1024 * 1024, u64::MAX), @@ -125,7 +123,6 @@ impl frame_system::Config for Test { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type Version = (); type PalletInfo = PalletInfo; type AccountData = pallet_balances::AccountData; @@ -141,20 +138,11 @@ parameter_types! { pub static ExistentialDeposit: u64 = 1; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = [u8; 8]; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } parameter_types! { @@ -402,17 +390,23 @@ impl pallet_message_queue::Config for Test { type IdleMaxServiceWeight = (); } +impl assigner_parachains::Config for Test {} + parameter_types! { pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1); + // Production chains should keep this numbar around twice the + // defined Timeslice for Coretime. + pub const MaxHistoricalRevenue: BlockNumber = 2 * 5; + pub const OnDemandPalletId: PalletId = PalletId(*b"py/ondmd"); } -impl assigner_parachains::Config for Test {} - -impl assigner_on_demand::Config for Test { +impl on_demand::Config for Test { type RuntimeEvent = RuntimeEvent; type Currency = Balances; type TrafficDefaultValue = OnDemandTrafficDefaultValue; - type WeightInfo = crate::assigner_on_demand::TestWeightInfo; + type WeightInfo = crate::on_demand::TestWeightInfo; + type MaxHistoricalRevenue = MaxHistoricalRevenue; + type PalletId = OnDemandPalletId; } impl assigner_coretime::Config for Test {} @@ -422,6 +416,13 @@ parameter_types! { pub MaxXcmTransactWeight: Weight = Weight::from_parts(10_000_000, 10_000); } +pub struct BrokerPot; +impl Get for BrokerPot { + fn get() -> InteriorLocation { + unimplemented!() + } +} + impl coretime::Config for Test { type RuntimeOrigin = RuntimeOrigin; type RuntimeEvent = RuntimeEvent; @@ -430,6 +431,9 @@ impl coretime::Config for Test { type WeightInfo = crate::coretime::TestWeightInfo; type SendXcm = DummyXcmSender; type MaxXcmTransactWeight = MaxXcmTransactWeight; + type BrokerPotLocation = BrokerPot; + type AssetTransactor = (); + type AccountToLocation = (); } pub struct DummyXcmSender; @@ -445,8 +449,16 @@ impl SendXcm for DummyXcmSender { } } +pub struct InclusionWeightInfo; + +impl crate::inclusion::WeightInfo for InclusionWeightInfo { + fn enact_candidate(_u: u32, _h: u32, _c: u32) -> Weight { + Weight::from_parts(1024 * 1024, 0) + } +} + impl crate::inclusion::Config for Test { - type WeightInfo = (); + type WeightInfo = InclusionWeightInfo; type RuntimeEvent = RuntimeEvent; type DisputesHandler = Disputes; type RewardValidators = TestRewardValidators; @@ -535,7 +547,7 @@ pub mod mock_assigner { // We don't care about core affinity in the test assigner fn report_processed(_assignment: Assignment) {} - // The results of this are tested in assigner_on_demand tests. No need to represent it + // The results of this are tested in on_demand tests. No need to represent it // in the mock assigner. fn push_back_assignment(_assignment: Assignment) {} @@ -671,7 +683,7 @@ impl inclusion::RewardValidators for TestRewardValidators { /// Create a new set of test externalities. pub fn new_test_ext(state: MockGenesisConfig) -> TestExternalities { use sp_keystore::{testing::MemoryKeystore, KeystoreExt, KeystorePtr}; - use sp_std::sync::Arc; + use std::sync::Arc; sp_tracing::try_init_simple(); diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs b/polkadot/runtime/parachains/src/on_demand/benchmarking.rs similarity index 96% rename from polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs rename to polkadot/runtime/parachains/src/on_demand/benchmarking.rs index 779d6f04e39638d5dfe2552c983de4715ee089d7..d494a77a5c4dbeee27e510e4df35f1f78741b885 100644 --- a/polkadot/runtime/parachains/src/assigner_on_demand/benchmarking.rs +++ b/polkadot/runtime/parachains/src/on_demand/benchmarking.rs @@ -25,11 +25,12 @@ use crate::{ shared::Pallet as ParasShared, }; +use alloc::vec; use frame_benchmarking::v2::*; use frame_system::RawOrigin; use sp_runtime::traits::Bounded; -use primitives::{ +use polkadot_primitives::{ HeadData, Id as ParaId, SessionIndex, ValidationCode, ON_DEMAND_DEFAULT_QUEUE_MAX_SIZE, }; @@ -93,7 +94,7 @@ mod benchmarks { impl_benchmark_test_suite!( Pallet, crate::mock::new_test_ext( - crate::assigner_on_demand::mock_helpers::GenesisConfigBuilder::default().build() + crate::on_demand::mock_helpers::GenesisConfigBuilder::default().build() ), crate::mock::Test ); diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs b/polkadot/runtime/parachains/src/on_demand/migration.rs similarity index 89% rename from polkadot/runtime/parachains/src/assigner_on_demand/migration.rs rename to polkadot/runtime/parachains/src/on_demand/migration.rs index 50e5e1daf41a56bb6bb191d0e2205d2cc9bb8b52..6cc25b20afb86204aa9324949032b9df67835426 100644 --- a/polkadot/runtime/parachains/src/assigner_on_demand/migration.rs +++ b/polkadot/runtime/parachains/src/on_demand/migration.rs @@ -23,7 +23,7 @@ use frame_support::{ mod v0 { use super::*; - use sp_std::collections::vec_deque::VecDeque; + use alloc::collections::vec_deque::VecDeque; #[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone)] pub(super) struct EnqueuedOrder { @@ -47,10 +47,10 @@ mod v0 { mod v1 { use super::*; - use crate::assigner_on_demand::LOG_TARGET; + use crate::on_demand::LOG_TARGET; /// Migration to V1 - pub struct UncheckedMigrateToV1(sp_std::marker::PhantomData); + pub struct UncheckedMigrateToV1(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrateToV1 { fn on_runtime_upgrade() -> Weight { let mut weight: Weight = Weight::zero(); @@ -88,7 +88,7 @@ mod v1 { } #[cfg(feature = "try-runtime")] - fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { + fn pre_upgrade() -> Result, sp_runtime::TryRuntimeError> { let n: u32 = v0::OnDemandQueue::::get().len() as u32; log::info!( @@ -100,7 +100,7 @@ mod v1 { } #[cfg(feature = "try-runtime")] - fn post_upgrade(state: Vec) -> Result<(), sp_runtime::TryRuntimeError> { + fn post_upgrade(state: alloc::vec::Vec) -> Result<(), sp_runtime::TryRuntimeError> { log::info!(target: LOG_TARGET, "Running post_upgrade()"); ensure!( @@ -142,8 +142,8 @@ pub type MigrateV0ToV1 = VersionedMigration< #[cfg(test)] mod tests { use super::{v0, v1, UncheckedOnRuntimeUpgrade, Weight}; - use crate::mock::{new_test_ext, MockGenesisConfig, OnDemandAssigner, Test}; - use primitives::Id as ParaId; + use crate::mock::{new_test_ext, MockGenesisConfig, OnDemand, Test}; + use polkadot_primitives::Id as ParaId; #[test] fn migration_to_v1_preserves_queue_ordering() { @@ -159,7 +159,7 @@ mod tests { let old_queue = v0::OnDemandQueue::::get(); assert_eq!(old_queue.len(), 5); // New queue has 0 orders - assert_eq!(OnDemandAssigner::get_queue_status().size(), 0); + assert_eq!(OnDemand::get_queue_status().size(), 0); // For tests, db weight is zero. assert_eq!( @@ -168,10 +168,10 @@ mod tests { ); // New queue has 5 orders - assert_eq!(OnDemandAssigner::get_queue_status().size(), 5); + assert_eq!(OnDemand::get_queue_status().size(), 5); // Compare each entry from the old queue with the entry in the new queue. - old_queue.iter().zip(OnDemandAssigner::get_free_entries().iter()).for_each( + old_queue.iter().zip(OnDemand::get_free_entries().iter()).for_each( |(old_enq, new_enq)| { assert_eq!(old_enq.para_id, new_enq.para_id); }, diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs b/polkadot/runtime/parachains/src/on_demand/mock_helpers.rs similarity index 97% rename from polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs rename to polkadot/runtime/parachains/src/on_demand/mock_helpers.rs index f8d1a894f0e4d5c619377ba4c34158c8f6d60597..d2a7a221587da1c9d76f18a0a64042c7992e1623 100644 --- a/polkadot/runtime/parachains/src/assigner_on_demand/mock_helpers.rs +++ b/polkadot/runtime/parachains/src/on_demand/mock_helpers.rs @@ -25,7 +25,7 @@ use crate::{ paras::{ParaGenesisArgs, ParaKind}, }; -use primitives::{Balance, HeadData, ValidationCode}; +use polkadot_primitives::{Balance, HeadData, ValidationCode}; fn default_genesis_config() -> MockGenesisConfig { MockGenesisConfig { diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs b/polkadot/runtime/parachains/src/on_demand/mod.rs similarity index 73% rename from polkadot/runtime/parachains/src/assigner_on_demand/mod.rs rename to polkadot/runtime/parachains/src/on_demand/mod.rs index 37788a67ea0c46d6c75b45039d994b8e40641e1c..dc046c194fd0b114ba0407878dea05d497be1f1b 100644 --- a/polkadot/runtime/parachains/src/assigner_on_demand/mod.rs +++ b/polkadot/runtime/parachains/src/on_demand/mod.rs @@ -31,41 +31,42 @@ //! occupying multiple cores in on-demand, we will likely add a separate order type, where the //! intent can be made explicit. +use sp_runtime::traits::Zero; mod benchmarking; pub mod migration; mod mock_helpers; +mod types; extern crate alloc; #[cfg(test)] mod tests; -use core::mem::take; - use crate::{configuration, paras, scheduler::common::Assignment}; - +use alloc::collections::BinaryHeap; +use core::mem::take; use frame_support::{ pallet_prelude::*, traits::{ + defensive_prelude::*, Currency, ExistenceRequirement::{self, AllowDeath, KeepAlive}, WithdrawReasons, }, + PalletId, }; -use frame_system::pallet_prelude::*; -use primitives::{CoreIndex, Id as ParaId, ON_DEMAND_MAX_QUEUE_MAX_SIZE}; +use frame_system::{pallet_prelude::*, Pallet as System}; +use polkadot_primitives::{CoreIndex, Id as ParaId}; use sp_runtime::{ - traits::{One, SaturatedConversion}, + traits::{AccountIdConversion, One, SaturatedConversion}, FixedPointNumber, FixedPointOperand, FixedU128, Perbill, Saturating, }; - -use alloc::collections::BinaryHeap; -use sp_std::{ - cmp::{Ord, Ordering, PartialOrd}, - prelude::*, +use types::{ + BalanceOf, CoreAffinityCount, EnqueuedOrder, QueuePushDirection, QueueStatusType, + SpotTrafficCalculationErr, }; -const LOG_TARGET: &str = "runtime::parachains::assigner-on-demand"; +const LOG_TARGET: &str = "runtime::parachains::on-demand"; pub use pallet::*; @@ -87,217 +88,6 @@ impl WeightInfo for TestWeightInfo { } } -/// Meta data for full queue. -/// -/// This includes elements with affinity and free entries. -/// -/// The actual queue is implemented via multiple priority queues. One for each core, for entries -/// which currently have a core affinity and one free queue, with entries without any affinity yet. -/// -/// The design aims to have most queue accessess be O(1) or O(log(N)). Absolute worst case is O(N). -/// Importantly this includes all accessess that happen in a single block. Even with 50 cores, the -/// total complexity of all operations in the block should maintain above complexities. In -/// particular O(N) stays O(N), it should never be O(N*cores). -/// -/// More concrete rundown on complexity: -/// -/// - insert: O(1) for placing an order, O(log(N)) for push backs. -/// - pop_assignment_for_core: O(log(N)), O(N) worst case: Can only happen for one core, next core -/// is already less work. -/// - report_processed & push back: If affinity dropped to 0, then O(N) in the worst case. Again -/// this divides per core. -/// -/// Reads still exist, also improved slightly, but worst case we fetch all entries. -#[derive(Encode, Decode, TypeInfo)] -struct QueueStatusType { - /// Last calculated traffic value. - traffic: FixedU128, - /// The next index to use. - next_index: QueueIndex, - /// Smallest index still in use. - /// - /// In case of a completely empty queue (free + affinity queues), `next_index - smallest_index - /// == 0`. - smallest_index: QueueIndex, - /// Indices that have been freed already. - /// - /// But have a hole to `smallest_index`, so we can not yet bump `smallest_index`. This binary - /// heap is roughly bounded in the number of on demand cores: - /// - /// For a single core, elements will always be processed in order. With each core added, a - /// level of out of order execution is added. - freed_indices: BinaryHeap, -} - -impl Default for QueueStatusType { - fn default() -> QueueStatusType { - QueueStatusType { - traffic: FixedU128::default(), - next_index: QueueIndex(0), - smallest_index: QueueIndex(0), - freed_indices: BinaryHeap::new(), - } - } -} - -impl QueueStatusType { - /// How many orders are queued in total? - /// - /// This includes entries which have core affinity. - fn size(&self) -> u32 { - self.next_index - .0 - .overflowing_sub(self.smallest_index.0) - .0 - .saturating_sub(self.freed_indices.len() as u32) - } - - /// Get current next index - /// - /// to use for an element newly pushed to the back of the queue. - fn push_back(&mut self) -> QueueIndex { - let QueueIndex(next_index) = self.next_index; - self.next_index = QueueIndex(next_index.overflowing_add(1).0); - QueueIndex(next_index) - } - - /// Push something to the front of the queue - fn push_front(&mut self) -> QueueIndex { - self.smallest_index = QueueIndex(self.smallest_index.0.overflowing_sub(1).0); - self.smallest_index - } - - /// The given index is no longer part of the queue. - /// - /// This updates `smallest_index` if need be. - fn consume_index(&mut self, removed_index: QueueIndex) { - if removed_index != self.smallest_index { - self.freed_indices.push(removed_index.reverse()); - return - } - let mut index = self.smallest_index.0.overflowing_add(1).0; - // Even more to advance? - while self.freed_indices.peek() == Some(&ReverseQueueIndex(index)) { - index = index.overflowing_add(1).0; - self.freed_indices.pop(); - } - self.smallest_index = QueueIndex(index); - } -} - -/// Keeps track of how many assignments a scheduler currently has at a specific `CoreIndex` for a -/// specific `ParaId`. -#[derive(Encode, Decode, Default, Clone, Copy, TypeInfo)] -#[cfg_attr(test, derive(PartialEq, RuntimeDebug))] -struct CoreAffinityCount { - core_index: CoreIndex, - count: u32, -} - -/// An indicator as to which end of the `OnDemandQueue` an assignment will be placed. -#[cfg_attr(test, derive(RuntimeDebug))] -enum QueuePushDirection { - Back, - Front, -} - -/// Shorthand for the Balance type the runtime is using. -type BalanceOf = - <::Currency as Currency<::AccountId>>::Balance; - -/// Errors that can happen during spot traffic calculation. -#[derive(PartialEq, RuntimeDebug)] -enum SpotTrafficCalculationErr { - /// The order queue capacity is at 0. - QueueCapacityIsZero, - /// The queue size is larger than the queue capacity. - QueueSizeLargerThanCapacity, - /// Arithmetic error during division, either division by 0 or over/underflow. - Division, -} - -/// Type used for priority indices. -// NOTE: The `Ord` implementation for this type is unsound in the general case. -// Do not use it for anything but it's intended purpose. -#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq, Copy)] -struct QueueIndex(u32); - -/// QueueIndex with reverse ordering. -/// -/// Same as `Reverse(QueueIndex)`, but with all the needed traits implemented. -#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq, Copy)] -struct ReverseQueueIndex(u32); - -impl QueueIndex { - fn reverse(self) -> ReverseQueueIndex { - ReverseQueueIndex(self.0) - } -} - -impl Ord for QueueIndex { - fn cmp(&self, other: &Self) -> Ordering { - let diff = self.0.overflowing_sub(other.0).0; - if diff == 0 { - Ordering::Equal - } else if diff <= ON_DEMAND_MAX_QUEUE_MAX_SIZE { - Ordering::Greater - } else { - Ordering::Less - } - } -} - -impl PartialOrd for QueueIndex { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(other)) - } -} - -impl Ord for ReverseQueueIndex { - fn cmp(&self, other: &Self) -> Ordering { - QueueIndex(other.0).cmp(&QueueIndex(self.0)) - } -} -impl PartialOrd for ReverseQueueIndex { - fn partial_cmp(&self, other: &Self) -> Option { - Some(self.cmp(&other)) - } -} - -/// Internal representation of an order after it has been enqueued already. -/// -/// This data structure is provided for a min BinaryHeap (Ord compares in reverse order with regards -/// to its elements) -#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq)] -struct EnqueuedOrder { - para_id: ParaId, - idx: QueueIndex, -} - -impl EnqueuedOrder { - fn new(idx: QueueIndex, para_id: ParaId) -> Self { - Self { idx, para_id } - } -} - -impl PartialOrd for EnqueuedOrder { - fn partial_cmp(&self, other: &Self) -> Option { - match other.idx.partial_cmp(&self.idx) { - Some(Ordering::Equal) => other.para_id.partial_cmp(&self.para_id), - o => o, - } - } -} - -impl Ord for EnqueuedOrder { - fn cmp(&self, other: &Self) -> Ordering { - match other.idx.cmp(&self.idx) { - Ordering::Equal => other.para_id.cmp(&self.para_id), - o => o, - } - } -} - #[frame_support::pallet] pub mod pallet { @@ -324,6 +114,15 @@ pub mod pallet { /// The default value for the spot traffic multiplier. #[pallet::constant] type TrafficDefaultValue: Get; + + /// The maximum number of blocks some historical revenue + /// information stored for. + #[pallet::constant] + type MaxHistoricalRevenue: Get; + + /// Identifier for the internal revenue balance. + #[pallet::constant] + type PalletId: Get; } /// Creates an empty queue status for an empty queue with initial traffic value. @@ -365,13 +164,18 @@ pub mod pallet { EntriesOnEmpty, >; + /// Keeps track of accumulated revenue from on demand order sales. + #[pallet::storage] + pub type Revenue = + StorageValue<_, BoundedVec, T::MaxHistoricalRevenue>, ValueQuery>; + #[pallet::event] #[pallet::generate_deposit(pub(super) fn deposit_event)] pub enum Event { - /// An order was placed at some spot price amount. - OnDemandOrderPlaced { para_id: ParaId, spot_price: BalanceOf }, - /// The value of the spot traffic multiplier changed. - SpotTrafficSet { traffic: FixedU128 }, + /// An order was placed at some spot price amount by orderer ordered_by + OnDemandOrderPlaced { para_id: ParaId, spot_price: BalanceOf, ordered_by: T::AccountId }, + /// The value of the spot price has likely changed + SpotPriceSet { spot_price: BalanceOf }, } #[pallet::error] @@ -386,6 +190,19 @@ pub mod pallet { #[pallet::hooks] impl Hooks> for Pallet { fn on_initialize(_now: BlockNumberFor) -> Weight { + // Update revenue information storage. + Revenue::::mutate(|revenue| { + if let Some(overdue) = + revenue.force_insert_keep_left(0, 0u32.into()).defensive_unwrap_or(None) + { + // We have some overdue revenue not claimed by the Coretime Chain, let's + // accumulate it at the oldest stored block + if let Some(last) = revenue.last_mut() { + *last = last.saturating_add(overdue); + } + } + }); + let config = configuration::ActiveConfig::::get(); // We need to update the spot traffic on block initialize in order to account for idle // blocks. @@ -393,8 +210,9 @@ pub mod pallet { Self::update_spot_traffic(&config, queue_status); }); - // 2 reads in config and queuestatus, at maximum 1 write to queuestatus. - T::DbWeight::get().reads_writes(2, 1) + // Reads: `Revenue`, `ActiveConfig`, `QueueStatus` + // Writes: `Revenue`, `QueueStatus` + T::DbWeight::get().reads_writes(3, 2) } } @@ -410,12 +228,11 @@ pub mod pallet { /// /// Errors: /// - `InsufficientBalance`: from the Currency implementation - /// - `InvalidParaId` /// - `QueueFull` /// - `SpotPriceHigherThanMaxAmount` /// /// Events: - /// - `SpotOrderPlaced` + /// - `OnDemandOrderPlaced` #[pallet::call_index(0)] #[pallet::weight(::WeightInfo::place_order_allow_death(QueueStatus::::get().size()))] pub fn place_order_allow_death( @@ -437,12 +254,11 @@ pub mod pallet { /// /// Errors: /// - `InsufficientBalance`: from the Currency implementation - /// - `InvalidParaId` /// - `QueueFull` /// - `SpotPriceHigherThanMaxAmount` /// /// Events: - /// - `SpotOrderPlaced` + /// - `OnDemandOrderPlaced` #[pallet::call_index(1)] #[pallet::weight(::WeightInfo::place_order_keep_alive(QueueStatus::::get().size()))] pub fn place_order_keep_alive( @@ -529,7 +345,8 @@ where } /// Helper function for `place_order_*` calls. Used to differentiate between placing orders - /// with a keep alive check or to allow the account to be reaped. + /// with a keep alive check or to allow the account to be reaped. The amount charged is + /// stored to the pallet account to be later paid out as revenue. /// /// Parameters: /// - `sender`: The sender of the call, funds will be withdrawn from this account. @@ -539,12 +356,11 @@ where /// /// Errors: /// - `InsufficientBalance`: from the Currency implementation - /// - `InvalidParaId` /// - `QueueFull` /// - `SpotPriceHigherThanMaxAmount` /// /// Events: - /// - `SpotOrderPlaced` + /// - `OnDemandOrderPlaced` fn do_place_order( sender: ::AccountId, max_amount: BalanceOf, @@ -565,19 +381,47 @@ where // Is the current price higher than `max_amount` ensure!(spot_price.le(&max_amount), Error::::SpotPriceHigherThanMaxAmount); - // Charge the sending account the spot price - let _ = T::Currency::withdraw( + ensure!( + queue_status.size() < config.scheduler_params.on_demand_queue_max_size, + Error::::QueueFull + ); + + // Charge the sending account the spot price. The amount will be teleported to the + // broker chain once it requests revenue information. + let amt = T::Currency::withdraw( &sender, spot_price, WithdrawReasons::FEE, existence_requirement, )?; - ensure!( - queue_status.size() < config.scheduler_params.on_demand_queue_max_size, - Error::::QueueFull - ); + // Consume the negative imbalance and deposit it into the pallet account. Make sure the + // account preserves even without the existential deposit. + let pot = Self::account_id(); + if !System::::account_exists(&pot) { + System::::inc_providers(&pot); + } + T::Currency::resolve_creating(&pot, amt); + + // Add the amount to the current block's (index 0) revenue information. + Revenue::::mutate(|bounded_revenue| { + if let Some(current_block) = bounded_revenue.get_mut(0) { + *current_block = current_block.saturating_add(spot_price); + } else { + // Revenue has already been claimed in the same block, including the block + // itself. It shouldn't normally happen as revenue claims in the future are + // not allowed. + bounded_revenue.try_push(spot_price).defensive_ok(); + } + }); + Pallet::::add_on_demand_order(queue_status, para_id, QueuePushDirection::Back); + Pallet::::deposit_event(Event::::OnDemandOrderPlaced { + para_id, + spot_price, + ordered_by: sender, + }); + Ok(()) }) } @@ -599,7 +443,14 @@ where // Only update storage on change if new_traffic != old_traffic { queue_status.traffic = new_traffic; - Pallet::::deposit_event(Event::::SpotTrafficSet { traffic: new_traffic }); + + // calculate the new spot price + let spot_price: BalanceOf = new_traffic.saturating_mul_int( + config.scheduler_params.on_demand_base_fee.saturated_into::>(), + ); + + // emit the event for updated new price + Pallet::::deposit_event(Event::::SpotPriceSet { spot_price }); } }, Err(err) => { @@ -721,7 +572,7 @@ where "Decreased affinity for a para that has not been served on a core?" ); if affinity != Some(0) { - return + return; } // No affinity more for entries on this core, free any entries: // @@ -754,7 +605,7 @@ where } else { *maybe_affinity = None; } - return Some(new_count) + return Some(new_count); } else { None } @@ -780,6 +631,29 @@ where }) } + /// Collect the revenue from the `when` blockheight + pub fn claim_revenue_until(when: BlockNumberFor) -> BalanceOf { + let now = >::block_number(); + let mut amount: BalanceOf = BalanceOf::::zero(); + Revenue::::mutate(|revenue| { + while !revenue.is_empty() { + let index = (revenue.len() - 1) as u32; + if when > now.saturating_sub(index.into()) { + amount = amount.saturating_add(revenue.pop().defensive_unwrap_or(0u32.into())); + } else { + break + } + } + }); + + amount + } + + /// Account of the pallet pot, where the funds from instantaneous coretime sale are accumulated. + pub fn account_id() -> T::AccountId { + T::PalletId::get().into_account_truncating() + } + /// Getter for the affinity tracker. #[cfg(test)] fn get_affinity_map(para_id: ParaId) -> Option { @@ -821,4 +695,9 @@ where fn get_traffic_default_value() -> FixedU128 { ::TrafficDefaultValue::get() } + + #[cfg(test)] + fn get_revenue() -> Vec> { + Revenue::::get().to_vec() + } } diff --git a/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs b/polkadot/runtime/parachains/src/on_demand/tests.rs similarity index 59% rename from polkadot/runtime/parachains/src/assigner_on_demand/tests.rs rename to polkadot/runtime/parachains/src/on_demand/tests.rs index 982efe77b939cf64d355e1111606c3856c4a0aea..9742954118103b5b46895dde5fc7456a59bf2877 100644 --- a/polkadot/runtime/parachains/src/assigner_on_demand/tests.rs +++ b/polkadot/runtime/parachains/src/on_demand/tests.rs @@ -17,18 +17,27 @@ use super::*; use crate::{ - assigner_on_demand::{mock_helpers::GenesisConfigBuilder, Error}, initializer::SessionChangeNotification, mock::{ - new_test_ext, Balances, OnDemandAssigner, Paras, ParasShared, RuntimeOrigin, Scheduler, - System, Test, + new_test_ext, Balances, OnDemand, Paras, ParasShared, RuntimeOrigin, Scheduler, System, + Test, + }, + on_demand::{ + self, + mock_helpers::GenesisConfigBuilder, + types::{QueueIndex, ReverseQueueIndex}, + Error, }, paras::{ParaGenesisArgs, ParaKind}, }; -use frame_support::{assert_noop, assert_ok, error::BadOrigin}; +use alloc::collections::btree_map::BTreeMap; +use core::cmp::{Ord, Ordering}; +use frame_support::{assert_noop, assert_ok}; use pallet_balances::Error as BalancesError; -use primitives::{BlockNumber, SessionIndex, ValidationCode}; -use sp_std::collections::btree_map::BTreeMap; +use polkadot_primitives::{ + BlockNumber, SessionIndex, ValidationCode, ON_DEMAND_MAX_QUEUE_MAX_SIZE, +}; +use sp_runtime::traits::BadOrigin; fn schedule_blank_para(id: ParaId, parakind: ParaKind) { let validation_code: ValidationCode = vec![1, 2, 3].into(); @@ -73,27 +82,37 @@ fn run_to_block( Paras::initializer_initialize(b + 1); Scheduler::initializer_initialize(b + 1); - // We need to update the spot traffic on every block. - OnDemandAssigner::on_initialize(b + 1); + // Update the spot traffic and revenue on every block. + OnDemand::on_initialize(b + 1); // In the real runtime this is expected to be called by the `InclusionInherent` pallet. - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1); } } -fn place_order(para_id: ParaId) { +fn place_order_run_to_blocknumber(para_id: ParaId, blocknumber: Option) { let alice = 100u64; let amt = 10_000_000u128; Balances::make_free_balance_be(&alice, amt); - run_to_block(101, |n| if n == 101 { Some(Default::default()) } else { None }); - OnDemandAssigner::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id).unwrap() + if let Some(bn) = blocknumber { + run_to_block(bn, |n| if n == bn { Some(Default::default()) } else { None }); + } + OnDemand::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id).unwrap() +} + +fn place_order_run_to_101(para_id: ParaId) { + place_order_run_to_blocknumber(para_id, Some(101)); +} + +fn place_order(para_id: ParaId) { + place_order_run_to_blocknumber(para_id, None); } #[test] fn spot_traffic_capacity_zero_returns_none() { - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( FixedU128::from(u128::MAX), 0u32, u32::MAX, @@ -107,7 +126,7 @@ fn spot_traffic_capacity_zero_returns_none() { #[test] fn spot_traffic_queue_size_larger_than_capacity_returns_none() { - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( FixedU128::from(u128::MAX), 1u32, 2u32, @@ -121,7 +140,7 @@ fn spot_traffic_queue_size_larger_than_capacity_returns_none() { #[test] fn spot_traffic_calculation_identity() { - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( FixedU128::from_u32(1), 1000, 100, @@ -137,7 +156,7 @@ fn spot_traffic_calculation_identity() { #[test] fn spot_traffic_calculation_u32_max() { - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( FixedU128::from_u32(1), u32::MAX, u32::MAX, @@ -153,7 +172,7 @@ fn spot_traffic_calculation_u32_max() { #[test] fn spot_traffic_calculation_u32_traffic_max() { - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( FixedU128::from(u128::MAX), u32::MAX, u32::MAX, @@ -169,7 +188,7 @@ fn spot_traffic_calculation_u32_traffic_max() { fn sustained_target_increases_spot_traffic() { let mut traffic = FixedU128::from_u32(1u32); for _ in 0..50 { - traffic = OnDemandAssigner::calculate_spot_traffic( + traffic = OnDemand::calculate_spot_traffic( traffic, 100, 12, @@ -184,7 +203,7 @@ fn sustained_target_increases_spot_traffic() { #[test] fn spot_traffic_can_decrease() { let traffic = FixedU128::from_u32(100u32); - match OnDemandAssigner::calculate_spot_traffic( + match OnDemand::calculate_spot_traffic( traffic, 100u32, 0u32, @@ -201,7 +220,7 @@ fn spot_traffic_can_decrease() { fn spot_traffic_decreases_over_time() { let mut traffic = FixedU128::from_u32(100u32); for _ in 0..5 { - traffic = OnDemandAssigner::calculate_spot_traffic( + traffic = OnDemand::calculate_spot_traffic( traffic, 100u32, 0u32, @@ -230,23 +249,20 @@ fn spot_traffic_decreases_between_idle_blocks() { assert!(Paras::is_parathread(para_id)); // Set the spot traffic to a large number - OnDemandAssigner::set_queue_status(QueueStatusType { + OnDemand::set_queue_status(QueueStatusType { traffic: FixedU128::from_u32(10), ..Default::default() }); - assert_eq!(OnDemandAssigner::get_queue_status().traffic, FixedU128::from_u32(10)); + assert_eq!(OnDemand::get_queue_status().traffic, FixedU128::from_u32(10)); // Run to block 101 and ensure that the traffic decreases. run_to_block(101, |n| if n == 100 { Some(Default::default()) } else { None }); - assert!(OnDemandAssigner::get_queue_status().traffic < FixedU128::from_u32(10)); + assert!(OnDemand::get_queue_status().traffic < FixedU128::from_u32(10)); // Run to block 102 and observe that we've hit the default traffic value. run_to_block(102, |n| if n == 100 { Some(Default::default()) } else { None }); - assert_eq!( - OnDemandAssigner::get_queue_status().traffic, - OnDemandAssigner::get_traffic_default_value() - ); + assert_eq!(OnDemand::get_queue_status().traffic, OnDemand::get_traffic_default_value()); }) } @@ -268,35 +284,27 @@ fn place_order_works() { // Does not work unsigned assert_noop!( - OnDemandAssigner::place_order_allow_death(RuntimeOrigin::none(), amt, para_id), + OnDemand::place_order_allow_death(RuntimeOrigin::none(), amt, para_id), BadOrigin ); // Does not work with max_amount lower than fee let low_max_amt = 1u128; assert_noop!( - OnDemandAssigner::place_order_allow_death( - RuntimeOrigin::signed(alice), - low_max_amt, - para_id, - ), + OnDemand::place_order_allow_death(RuntimeOrigin::signed(alice), low_max_amt, para_id,), Error::::SpotPriceHigherThanMaxAmount, ); // Does not work with insufficient balance assert_noop!( - OnDemandAssigner::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id), + OnDemand::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id), BalancesError::::InsufficientBalance ); // Works Balances::make_free_balance_be(&alice, amt); run_to_block(101, |n| if n == 101 { Some(Default::default()) } else { None }); - assert_ok!(OnDemandAssigner::place_order_allow_death( - RuntimeOrigin::signed(alice), - amt, - para_id - )); + assert_ok!(OnDemand::place_order_allow_death(RuntimeOrigin::signed(alice), amt, para_id)); }); } @@ -317,11 +325,7 @@ fn place_order_keep_alive_keeps_alive() { assert!(Paras::is_parathread(para_id)); assert_noop!( - OnDemandAssigner::place_order_keep_alive( - RuntimeOrigin::signed(alice), - max_amt, - para_id - ), + OnDemand::place_order_keep_alive(RuntimeOrigin::signed(alice), max_amt, para_id), BalancesError::::InsufficientBalance ); }); @@ -338,7 +342,7 @@ fn pop_assignment_for_core_works() { run_to_block(11, |n| if n == 11 { Some(Default::default()) } else { None }); // Pop should return none with empty queue - assert_eq!(OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)), None); + assert_eq!(OnDemand::pop_assignment_for_core(CoreIndex(0)), None); // Add enough assignments to the order queue. for _ in 0..2 { @@ -348,19 +352,19 @@ fn pop_assignment_for_core_works() { // Popped assignments should be for the correct paras and cores assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).map(|a| a.para_id()), + OnDemand::pop_assignment_for_core(CoreIndex(0)).map(|a| a.para_id()), Some(para_a) ); assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(1)).map(|a| a.para_id()), + OnDemand::pop_assignment_for_core(CoreIndex(1)).map(|a| a.para_id()), Some(para_b) ); assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).map(|a| a.para_id()), + OnDemand::pop_assignment_for_core(CoreIndex(0)).map(|a| a.para_id()), Some(para_a) ); assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(1)).map(|a| a.para_id()), + OnDemand::pop_assignment_for_core(CoreIndex(1)).map(|a| a.para_id()), Some(para_b) ); }); @@ -377,34 +381,25 @@ fn push_back_assignment_works() { run_to_block(11, |n| if n == 11 { Some(Default::default()) } else { None }); // Add enough assignments to the order queue. - place_order(para_a); - place_order(para_b); + place_order_run_to_101(para_a); + place_order_run_to_101(para_b); // Pop order a - assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), - para_a - ); + assert_eq!(OnDemand::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), para_a); // Para a should have affinity for core 0 - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 1); - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().core_index, CoreIndex(0)); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().core_index, CoreIndex(0)); // Push back order a - OnDemandAssigner::push_back_assignment(para_a, CoreIndex(0)); + OnDemand::push_back_assignment(para_a, CoreIndex(0)); // Para a should have no affinity - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).is_none(), true); + assert_eq!(OnDemand::get_affinity_map(para_a).is_none(), true); // Queue should contain orders a, b. A in front of b. - assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), - para_a - ); - assert_eq!( - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), - para_b - ); + assert_eq!(OnDemand::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), para_a); + assert_eq!(OnDemand::pop_assignment_for_core(CoreIndex(0)).unwrap().para_id(), para_b); }); } @@ -420,59 +415,59 @@ fn affinity_prohibits_parallel_scheduling() { run_to_block(11, |n| if n == 11 { Some(Default::default()) } else { None }); // There should be no affinity before starting. - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); - assert!(OnDemandAssigner::get_affinity_map(para_b).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); + assert!(OnDemand::get_affinity_map(para_b).is_none()); // Add 2 assignments for para_a for every para_b. - place_order(para_a); - place_order(para_a); - place_order(para_b); + place_order_run_to_101(para_a); + place_order_run_to_101(para_a); + place_order_run_to_101(para_b); // Approximate having 1 core. for _ in 0..3 { - assert!(OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).is_some()); + assert!(OnDemand::pop_assignment_for_core(CoreIndex(0)).is_some()); } - assert!(OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)).is_none()); + assert!(OnDemand::pop_assignment_for_core(CoreIndex(0)).is_none()); // Affinity on one core is meaningless. - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 2); - assert_eq!(OnDemandAssigner::get_affinity_map(para_b).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 2); + assert_eq!(OnDemand::get_affinity_map(para_b).unwrap().count, 1); assert_eq!( - OnDemandAssigner::get_affinity_map(para_a).unwrap().core_index, - OnDemandAssigner::get_affinity_map(para_b).unwrap().core_index, + OnDemand::get_affinity_map(para_a).unwrap().core_index, + OnDemand::get_affinity_map(para_b).unwrap().core_index, ); // Clear affinity - OnDemandAssigner::report_processed(para_a, 0.into()); - OnDemandAssigner::report_processed(para_a, 0.into()); - OnDemandAssigner::report_processed(para_b, 0.into()); + OnDemand::report_processed(para_a, 0.into()); + OnDemand::report_processed(para_a, 0.into()); + OnDemand::report_processed(para_b, 0.into()); // Add 2 assignments for para_a for every para_b. - place_order(para_a); - place_order(para_a); - place_order(para_b); + place_order_run_to_101(para_a); + place_order_run_to_101(para_a); + place_order_run_to_101(para_b); // Approximate having 3 cores. CoreIndex 2 should be unable to obtain an assignment for _ in 0..3 { - OnDemandAssigner::pop_assignment_for_core(CoreIndex(0)); - OnDemandAssigner::pop_assignment_for_core(CoreIndex(1)); - assert!(OnDemandAssigner::pop_assignment_for_core(CoreIndex(2)).is_none()); + OnDemand::pop_assignment_for_core(CoreIndex(0)); + OnDemand::pop_assignment_for_core(CoreIndex(1)); + assert!(OnDemand::pop_assignment_for_core(CoreIndex(2)).is_none()); } // Affinity should be the same as before, but on different cores. - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 2); - assert_eq!(OnDemandAssigner::get_affinity_map(para_b).unwrap().count, 1); - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().core_index, CoreIndex(0)); - assert_eq!(OnDemandAssigner::get_affinity_map(para_b).unwrap().core_index, CoreIndex(1)); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 2); + assert_eq!(OnDemand::get_affinity_map(para_b).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().core_index, CoreIndex(0)); + assert_eq!(OnDemand::get_affinity_map(para_b).unwrap().core_index, CoreIndex(1)); // Clear affinity - OnDemandAssigner::report_processed(para_a, CoreIndex(0)); - OnDemandAssigner::report_processed(para_a, CoreIndex(0)); - OnDemandAssigner::report_processed(para_b, CoreIndex(1)); + OnDemand::report_processed(para_a, CoreIndex(0)); + OnDemand::report_processed(para_a, CoreIndex(0)); + OnDemand::report_processed(para_b, CoreIndex(1)); // There should be no affinity after clearing. - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); - assert!(OnDemandAssigner::get_affinity_map(para_b).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); + assert!(OnDemand::get_affinity_map(para_b).is_none()); }); } @@ -486,54 +481,54 @@ fn affinity_changes_work() { run_to_block(11, |n| if n == 11 { Some(Default::default()) } else { None }); // There should be no affinity before starting. - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); // Add enough assignments to the order queue. for _ in 0..10 { - place_order(para_a); + place_order_run_to_101(para_a); } // There should be no affinity before the scheduler pops. - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); - OnDemandAssigner::pop_assignment_for_core(core_index); + OnDemand::pop_assignment_for_core(core_index); // Affinity count is 1 after popping. - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 1); - OnDemandAssigner::report_processed(para_a, 0.into()); - OnDemandAssigner::pop_assignment_for_core(core_index); + OnDemand::report_processed(para_a, 0.into()); + OnDemand::pop_assignment_for_core(core_index); // Affinity count is 1 after popping with a previous para. - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 1); for _ in 0..3 { - OnDemandAssigner::pop_assignment_for_core(core_index); + OnDemand::pop_assignment_for_core(core_index); } // Affinity count is 4 after popping 3 times without a previous para. - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 4); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 4); for _ in 0..5 { - OnDemandAssigner::report_processed(para_a, 0.into()); - assert!(OnDemandAssigner::pop_assignment_for_core(core_index).is_some()); + OnDemand::report_processed(para_a, 0.into()); + assert!(OnDemand::pop_assignment_for_core(core_index).is_some()); } // Affinity count should still be 4 but queue should be empty. - assert!(OnDemandAssigner::pop_assignment_for_core(core_index).is_none()); - assert_eq!(OnDemandAssigner::get_affinity_map(para_a).unwrap().count, 4); + assert!(OnDemand::pop_assignment_for_core(core_index).is_none()); + assert_eq!(OnDemand::get_affinity_map(para_a).unwrap().count, 4); // Pop 4 times and get to exactly 0 (None) affinity. for _ in 0..4 { - OnDemandAssigner::report_processed(para_a, 0.into()); - assert!(OnDemandAssigner::pop_assignment_for_core(core_index).is_none()); + OnDemand::report_processed(para_a, 0.into()); + assert!(OnDemand::pop_assignment_for_core(core_index).is_none()); } - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); // Decreasing affinity beyond 0 should still be None. - OnDemandAssigner::report_processed(para_a, 0.into()); - assert!(OnDemandAssigner::pop_assignment_for_core(core_index).is_none()); - assert!(OnDemandAssigner::get_affinity_map(para_a).is_none()); + OnDemand::report_processed(para_a, 0.into()); + assert!(OnDemand::pop_assignment_for_core(core_index).is_none()); + assert!(OnDemand::get_affinity_map(para_a).is_none()); }); } @@ -554,32 +549,29 @@ fn new_affinity_for_a_core_must_come_from_free_entries() { // Place orders for all chains. parachains.iter().for_each(|chain| { - place_order(*chain); + place_order_run_to_101(*chain); }); // There are 4 entries in free_entries. - let start_free_entries = OnDemandAssigner::get_free_entries().len(); + let start_free_entries = OnDemand::get_free_entries().len(); assert_eq!(start_free_entries, 4); // Pop assignments on all cores. core_indices.iter().enumerate().for_each(|(n, core_index)| { // There is no affinity on the core prior to popping. - assert!(OnDemandAssigner::get_affinity_entries(*core_index).is_empty()); + assert!(OnDemand::get_affinity_entries(*core_index).is_empty()); // There's always an order to be popped for each core. - let free_entries = OnDemandAssigner::get_free_entries(); + let free_entries = OnDemand::get_free_entries(); let next_order = free_entries.peek(); // There is no affinity on the paraid prior to popping. - assert!(OnDemandAssigner::get_affinity_map(next_order.unwrap().para_id).is_none()); + assert!(OnDemand::get_affinity_map(next_order.unwrap().para_id).is_none()); - match OnDemandAssigner::pop_assignment_for_core(*core_index) { + match OnDemand::pop_assignment_for_core(*core_index) { Some(assignment) => { // The popped assignment came from free entries. - assert_eq!( - start_free_entries - 1 - n, - OnDemandAssigner::get_free_entries().len() - ); + assert_eq!(start_free_entries - 1 - n, OnDemand::get_free_entries().len()); // The popped assignment has the same para id as the next order. assert_eq!(assignment.para_id(), next_order.unwrap().para_id); }, @@ -588,11 +580,11 @@ fn new_affinity_for_a_core_must_come_from_free_entries() { }); // All entries have been removed from free_entries. - assert!(OnDemandAssigner::get_free_entries().is_empty()); + assert!(OnDemand::get_free_entries().is_empty()); // All chains have an affinity count of 1. parachains.iter().for_each(|chain| { - assert_eq!(OnDemandAssigner::get_affinity_map(*chain).unwrap().count, 1); + assert_eq!(OnDemand::get_affinity_map(*chain).unwrap().count, 1); }); }); } @@ -672,38 +664,151 @@ fn queue_status_size_fn_works() { schedule_blank_para(*chain, ParaKind::Parathread); }); - assert_eq!(OnDemandAssigner::get_queue_status().size(), 0); + assert_eq!(OnDemand::get_queue_status().size(), 0); run_to_block(11, |n| if n == 11 { Some(Default::default()) } else { None }); // Place orders for all chains. parachains.iter().for_each(|chain| { // 2 per chain for a total of 6 - place_order(*chain); - place_order(*chain); + place_order_run_to_101(*chain); + place_order_run_to_101(*chain); }); // 6 orders in free entries - assert_eq!(OnDemandAssigner::get_free_entries().len(), 6); + assert_eq!(OnDemand::get_free_entries().len(), 6); // 6 orders via queue status size assert_eq!( - OnDemandAssigner::get_free_entries().len(), - OnDemandAssigner::get_queue_status().size() as usize + OnDemand::get_free_entries().len(), + OnDemand::get_queue_status().size() as usize ); core_indices.iter().for_each(|core_index| { - OnDemandAssigner::pop_assignment_for_core(*core_index); + OnDemand::pop_assignment_for_core(*core_index); }); // There should be 2 orders in the scheduler's claimqueue, // 2 in assorted AffinityMaps and 2 in free. // ParaId 111 - assert_eq!(OnDemandAssigner::get_affinity_entries(core_indices[0]).len(), 1); + assert_eq!(OnDemand::get_affinity_entries(core_indices[0]).len(), 1); // ParaId 222 - assert_eq!(OnDemandAssigner::get_affinity_entries(core_indices[1]).len(), 1); + assert_eq!(OnDemand::get_affinity_entries(core_indices[1]).len(), 1); // Free entries are from ParaId 333 - assert_eq!(OnDemandAssigner::get_free_entries().len(), 2); + assert_eq!(OnDemand::get_free_entries().len(), 2); // For a total size of 4. - assert_eq!(OnDemandAssigner::get_queue_status().size(), 4) + assert_eq!(OnDemand::get_queue_status().size(), 4) + }); +} + +#[test] +fn revenue_information_fetching_works() { + new_test_ext(GenesisConfigBuilder::default().build()).execute_with(|| { + let para_a = ParaId::from(111); + schedule_blank_para(para_a, ParaKind::Parathread); + // Mock assigner sets max revenue history to 10. + run_to_block(10, |n| if n == 10 { Some(Default::default()) } else { None }); + let revenue = OnDemand::claim_revenue_until(10); + + // No revenue should be recorded. + assert_eq!(revenue, 0); + + // Place one order + place_order_run_to_blocknumber(para_a, Some(11)); + let revenue = OnDemand::get_revenue(); + let amt = OnDemand::claim_revenue_until(11); + + // Revenue until the current block is still zero as "until" is non-inclusive + assert_eq!(amt, 0); + + let amt = OnDemand::claim_revenue_until(12); + + // Revenue for a single order should be recorded and shouldn't have been pruned by the + // previous call + assert_eq!(amt, revenue[0]); + + run_to_block(12, |n| if n == 12 { Some(Default::default()) } else { None }); + let revenue = OnDemand::claim_revenue_until(13); + + // No revenue should be recorded. + assert_eq!(revenue, 0); + + // Place many orders + place_order(para_a); + place_order(para_a); + + run_to_block(13, |n| if n == 13 { Some(Default::default()) } else { None }); + + place_order(para_a); + + run_to_block(14, |n| if n == 14 { Some(Default::default()) } else { None }); + + let revenue = OnDemand::claim_revenue_until(15); + + // All 3 orders should be accounted for. + assert_eq!(revenue, 30_000); + + // Place one order + place_order_run_to_blocknumber(para_a, Some(16)); + + let revenue = OnDemand::claim_revenue_until(15); + + // Order is not in range of the revenue_until call + assert_eq!(revenue, 0); + + run_to_block(20, |n| if n == 20 { Some(Default::default()) } else { None }); + let revenue = OnDemand::claim_revenue_until(21); + assert_eq!(revenue, 10_000); + + // Make sure overdue revenue is accumulated + for i in 21..=35 { + run_to_block(i, |n| if n % 10 == 0 { Some(Default::default()) } else { None }); + place_order(para_a); + } + let revenue = OnDemand::claim_revenue_until(36); + assert_eq!(revenue, 150_000); + }); +} + +#[test] +fn pot_account_is_immortal() { + new_test_ext(GenesisConfigBuilder::default().build()).execute_with(|| { + let para_a = ParaId::from(111); + let pot = OnDemand::account_id(); + assert!(!System::account_exists(&pot)); + schedule_blank_para(para_a, ParaKind::Parathread); + // Mock assigner sets max revenue history to 10. + + run_to_block(10, |n| if n == 10 { Some(Default::default()) } else { None }); + place_order_run_to_blocknumber(para_a, Some(12)); + let purchase_revenue = Balances::free_balance(&pot); + assert!(purchase_revenue > 0); + + run_to_block(15, |_| None); + let _imb = ::Currency::withdraw( + &pot, + purchase_revenue, + WithdrawReasons::FEE, + ExistenceRequirement::AllowDeath, + ); + assert_eq!(Balances::free_balance(&pot), 0); + assert!(System::account_exists(&pot)); + assert_eq!(System::providers(&pot), 1); + + // One more cycle to make sure providers are not increased on every transition from zero + run_to_block(20, |n| if n == 20 { Some(Default::default()) } else { None }); + place_order_run_to_blocknumber(para_a, Some(22)); + let purchase_revenue = Balances::free_balance(&pot); + assert!(purchase_revenue > 0); + + run_to_block(25, |_| None); + let _imb = ::Currency::withdraw( + &pot, + purchase_revenue, + WithdrawReasons::FEE, + ExistenceRequirement::AllowDeath, + ); + assert_eq!(Balances::free_balance(&pot), 0); + assert!(System::account_exists(&pot)); + assert_eq!(System::providers(&pot), 1); }); } diff --git a/polkadot/runtime/parachains/src/on_demand/types.rs b/polkadot/runtime/parachains/src/on_demand/types.rs new file mode 100644 index 0000000000000000000000000000000000000000..c87e7abaf86071f6233d4ed6532b3813c45e2a7f --- /dev/null +++ b/polkadot/runtime/parachains/src/on_demand/types.rs @@ -0,0 +1,238 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! On demand module types. + +use super::{alloc, pallet::Config}; +use alloc::collections::BinaryHeap; +use core::cmp::{Ord, Ordering, PartialOrd}; +use frame_support::{ + pallet_prelude::{Decode, Encode, RuntimeDebug, TypeInfo}, + traits::Currency, +}; +use polkadot_primitives::{CoreIndex, Id as ParaId, ON_DEMAND_MAX_QUEUE_MAX_SIZE}; +use sp_runtime::FixedU128; + +/// Shorthand for the Balance type the runtime is using. +pub type BalanceOf = + <::Currency as Currency<::AccountId>>::Balance; + +/// Meta data for full queue. +/// +/// This includes elements with affinity and free entries. +/// +/// The actual queue is implemented via multiple priority queues. One for each core, for entries +/// which currently have a core affinity and one free queue, with entries without any affinity yet. +/// +/// The design aims to have most queue accessess be O(1) or O(log(N)). Absolute worst case is O(N). +/// Importantly this includes all accessess that happen in a single block. Even with 50 cores, the +/// total complexity of all operations in the block should maintain above complexities. In +/// particular O(N) stays O(N), it should never be O(N*cores). +/// +/// More concrete rundown on complexity: +/// +/// - insert: O(1) for placing an order, O(log(N)) for push backs. +/// - pop_assignment_for_core: O(log(N)), O(N) worst case: Can only happen for one core, next core +/// is already less work. +/// - report_processed & push back: If affinity dropped to 0, then O(N) in the worst case. Again +/// this divides per core. +/// +/// Reads still exist, also improved slightly, but worst case we fetch all entries. +#[derive(Encode, Decode, TypeInfo)] +pub struct QueueStatusType { + /// Last calculated traffic value. + pub traffic: FixedU128, + /// The next index to use. + pub next_index: QueueIndex, + /// Smallest index still in use. + /// + /// In case of a completely empty queue (free + affinity queues), `next_index - smallest_index + /// == 0`. + pub smallest_index: QueueIndex, + /// Indices that have been freed already. + /// + /// But have a hole to `smallest_index`, so we can not yet bump `smallest_index`. This binary + /// heap is roughly bounded in the number of on demand cores: + /// + /// For a single core, elements will always be processed in order. With each core added, a + /// level of out of order execution is added. + pub freed_indices: BinaryHeap, +} + +impl Default for QueueStatusType { + fn default() -> QueueStatusType { + QueueStatusType { + traffic: FixedU128::default(), + next_index: QueueIndex(0), + smallest_index: QueueIndex(0), + freed_indices: BinaryHeap::new(), + } + } +} + +impl QueueStatusType { + /// How many orders are queued in total? + /// + /// This includes entries which have core affinity. + pub fn size(&self) -> u32 { + self.next_index + .0 + .overflowing_sub(self.smallest_index.0) + .0 + .saturating_sub(self.freed_indices.len() as u32) + } + + /// Get current next index + /// + /// to use for an element newly pushed to the back of the queue. + pub fn push_back(&mut self) -> QueueIndex { + let QueueIndex(next_index) = self.next_index; + self.next_index = QueueIndex(next_index.overflowing_add(1).0); + QueueIndex(next_index) + } + + /// Push something to the front of the queue + pub fn push_front(&mut self) -> QueueIndex { + self.smallest_index = QueueIndex(self.smallest_index.0.overflowing_sub(1).0); + self.smallest_index + } + + /// The given index is no longer part of the queue. + /// + /// This updates `smallest_index` if need be. + pub fn consume_index(&mut self, removed_index: QueueIndex) { + if removed_index != self.smallest_index { + self.freed_indices.push(removed_index.reverse()); + return + } + let mut index = self.smallest_index.0.overflowing_add(1).0; + // Even more to advance? + while self.freed_indices.peek() == Some(&ReverseQueueIndex(index)) { + index = index.overflowing_add(1).0; + self.freed_indices.pop(); + } + self.smallest_index = QueueIndex(index); + } +} + +/// Type used for priority indices. +// NOTE: The `Ord` implementation for this type is unsound in the general case. +// Do not use it for anything but it's intended purpose. +#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq, Copy)] +pub struct QueueIndex(pub u32); + +/// QueueIndex with reverse ordering. +/// +/// Same as `Reverse(QueueIndex)`, but with all the needed traits implemented. +#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq, Copy)] +pub struct ReverseQueueIndex(pub u32); + +impl QueueIndex { + fn reverse(self) -> ReverseQueueIndex { + ReverseQueueIndex(self.0) + } +} + +impl Ord for QueueIndex { + fn cmp(&self, other: &Self) -> Ordering { + let diff = self.0.overflowing_sub(other.0).0; + if diff == 0 { + Ordering::Equal + } else if diff <= ON_DEMAND_MAX_QUEUE_MAX_SIZE { + Ordering::Greater + } else { + Ordering::Less + } + } +} + +impl PartialOrd for QueueIndex { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(other)) + } +} + +impl Ord for ReverseQueueIndex { + fn cmp(&self, other: &Self) -> Ordering { + QueueIndex(other.0).cmp(&QueueIndex(self.0)) + } +} +impl PartialOrd for ReverseQueueIndex { + fn partial_cmp(&self, other: &Self) -> Option { + Some(self.cmp(&other)) + } +} + +/// Internal representation of an order after it has been enqueued already. +/// +/// This data structure is provided for a min BinaryHeap (Ord compares in reverse order with regards +/// to its elements) +#[derive(Encode, Decode, TypeInfo, Debug, PartialEq, Clone, Eq)] +pub struct EnqueuedOrder { + pub para_id: ParaId, + pub idx: QueueIndex, +} + +impl EnqueuedOrder { + pub fn new(idx: QueueIndex, para_id: ParaId) -> Self { + Self { idx, para_id } + } +} + +impl PartialOrd for EnqueuedOrder { + fn partial_cmp(&self, other: &Self) -> Option { + match other.idx.partial_cmp(&self.idx) { + Some(Ordering::Equal) => other.para_id.partial_cmp(&self.para_id), + o => o, + } + } +} + +impl Ord for EnqueuedOrder { + fn cmp(&self, other: &Self) -> Ordering { + match other.idx.cmp(&self.idx) { + Ordering::Equal => other.para_id.cmp(&self.para_id), + o => o, + } + } +} + +/// Keeps track of how many assignments a scheduler currently has at a specific `CoreIndex` for a +/// specific `ParaId`. +#[derive(Encode, Decode, Default, Clone, Copy, TypeInfo)] +#[cfg_attr(test, derive(PartialEq, RuntimeDebug))] +pub struct CoreAffinityCount { + pub core_index: CoreIndex, + pub count: u32, +} + +/// An indicator as to which end of the `OnDemandQueue` an assignment will be placed. +#[cfg_attr(test, derive(RuntimeDebug))] +pub enum QueuePushDirection { + Back, + Front, +} + +/// Errors that can happen during spot traffic calculation. +#[derive(PartialEq, RuntimeDebug)] +pub enum SpotTrafficCalculationErr { + /// The order queue capacity is at 0. + QueueCapacityIsZero, + /// The queue size is larger than the queue capacity. + QueueSizeLargerThanCapacity, + /// Arithmetic error during division, either division by 0 or over/underflow. + Division, +} diff --git a/polkadot/runtime/parachains/src/origin.rs b/polkadot/runtime/parachains/src/origin.rs index c83fec1b8923ad9048d1425e4de570c17fce5742..fd22929b08ff547398c7f731e9a823a780391a6c 100644 --- a/polkadot/runtime/parachains/src/origin.rs +++ b/polkadot/runtime/parachains/src/origin.rs @@ -16,9 +16,9 @@ //! Declaration of the parachain specific origin and a pallet that hosts it. -use primitives::Id as ParaId; +use core::result; +use polkadot_primitives::Id as ParaId; use sp_runtime::traits::BadOrigin; -use sp_std::result; pub use pallet::*; diff --git a/polkadot/runtime/parachains/src/paras/benchmarking.rs b/polkadot/runtime/parachains/src/paras/benchmarking.rs index 437c4091a98b58049a7cb3204f35079be8395ce0..7bf8b833ed915df49aabcb9047ec889076836af0 100644 --- a/polkadot/runtime/parachains/src/paras/benchmarking.rs +++ b/polkadot/runtime/parachains/src/paras/benchmarking.rs @@ -16,11 +16,15 @@ use super::*; use crate::configuration::HostConfiguration; +use alloc::vec; use frame_benchmarking::benchmarks; use frame_system::{pallet_prelude::BlockNumberFor, RawOrigin}; -use primitives::{HeadData, Id as ParaId, ValidationCode, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE}; +use polkadot_primitives::{ + HeadData, Id as ParaId, ValidationCode, MAX_CODE_SIZE, MAX_HEAD_DATA_SIZE, +}; use sp_runtime::traits::{One, Saturating}; +pub mod mmr_setup; mod pvf_check; use self::pvf_check::{VoteCause, VoteOutcome}; diff --git a/polkadot/runtime/parachains/src/paras/benchmarking/mmr_setup.rs b/polkadot/runtime/parachains/src/paras/benchmarking/mmr_setup.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab007692e78dc2e3b56dfdd4ad682accdfa0c037 --- /dev/null +++ b/polkadot/runtime/parachains/src/paras/benchmarking/mmr_setup.rs @@ -0,0 +1,40 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Implements benchmarking setup for the `merkle-mountain-range` pallet. + +use crate::paras::*; +use pallet_mmr::BenchmarkHelper; +use sp_std::vec; + +/// Struct to setup benchmarks for the `merkle-mountain-range` pallet. +pub struct MmrSetup(core::marker::PhantomData); + +impl BenchmarkHelper for MmrSetup +where + T: Config, +{ + fn setup() { + // Create a head with 1024 bytes of data. + let head = vec![42u8; 1024]; + + for para in 0..MAX_PARA_HEADS { + let id = (para as u32).into(); + let h = head.clone().into(); + Pallet::::heads_insert(&id, h); + } + } +} diff --git a/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs b/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs index 9281332fdada8fa6078100586be9329430623fd4..80443c7626e2b438ff754d140aa22f91bdc16805 100644 --- a/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs +++ b/polkadot/runtime/parachains/src/paras/benchmarking/pvf_check.rs @@ -17,9 +17,10 @@ //! This module focuses on the benchmarking of the `include_pvf_check_statement` dispatchable. use crate::{configuration, paras::*, shared::Pallet as ParasShared}; +use alloc::{vec, vec::Vec}; use frame_support::assert_ok; use frame_system::RawOrigin; -use primitives::{HeadData, Id as ParaId, ValidationCode, ValidatorId, ValidatorIndex}; +use polkadot_primitives::{HeadData, Id as ParaId, ValidationCode, ValidatorId, ValidatorIndex}; use sp_application_crypto::RuntimeAppPublic; // Constants for the benchmarking @@ -204,7 +205,7 @@ where { let validators = shared::ActiveValidatorKeys::::get(); - let accept_threshold = primitives::supermajority_threshold(validators.len()); + let accept_threshold = polkadot_primitives::supermajority_threshold(validators.len()); let required_votes = match vote_outcome { VoteOutcome::Accept => accept_threshold, VoteOutcome::Reject => validators.len() - accept_threshold, diff --git a/polkadot/runtime/parachains/src/paras/mod.rs b/polkadot/runtime/parachains/src/paras/mod.rs index 36a693bcc8e29a7a2cbce1cb75a430322b88b58b..5048656e63633d78f42a0ee70f8fab9faf5ad5ee 100644 --- a/polkadot/runtime/parachains/src/paras/mod.rs +++ b/polkadot/runtime/parachains/src/paras/mod.rs @@ -113,11 +113,13 @@ use crate::{ initializer::SessionChangeNotification, shared, }; +use alloc::{collections::btree_set::BTreeSet, vec::Vec}; use bitvec::{order::Lsb0 as BitOrderLsb0, vec::BitVec}; +use codec::{Decode, Encode}; +use core::{cmp, mem}; use frame_support::{pallet_prelude::*, traits::EstimateNextSessionRotation, DefaultNoBound}; use frame_system::pallet_prelude::*; -use parity_scale_codec::{Decode, Encode}; -use primitives::{ +use polkadot_primitives::{ ConsensusLog, HeadData, Id as ParaId, PvfCheckStatement, SessionIndex, UpgradeGoAhead, UpgradeRestriction, ValidationCode, ValidationCodeHash, ValidatorSignature, MIN_CODE_SIZE, }; @@ -127,14 +129,13 @@ use sp_runtime::{ traits::{AppVerify, One, Saturating}, DispatchResult, SaturatedConversion, }; -use sp_std::{cmp, collections::btree_set::BTreeSet, mem, prelude::*}; use serde::{Deserialize, Serialize}; pub use crate::Origin as ParachainOrigin; #[cfg(feature = "runtime-benchmarks")] -pub(crate) mod benchmarking; +pub mod benchmarking; #[cfg(test)] pub(crate) mod tests; @@ -348,9 +349,7 @@ impl Encode for ParaKind { } impl Decode for ParaKind { - fn decode( - input: &mut I, - ) -> Result { + fn decode(input: &mut I) -> Result { match bool::decode(input) { Ok(true) => Ok(ParaKind::Parachain), Ok(false) => Ok(ParaKind::Parathread), @@ -487,7 +486,7 @@ impl PvfCheckActiveVoteState { /// Returns `None` if the quorum is not reached, or the direction of the decision. fn quorum(&self, n_validators: usize) -> Option { - let accept_threshold = primitives::supermajority_threshold(n_validators); + let accept_threshold = polkadot_primitives::supermajority_threshold(n_validators); // At this threshold, a supermajority is no longer possible, so we reject. let reject_threshold = n_validators - accept_threshold; @@ -865,7 +864,7 @@ pub mod pallet { #[derive(DefaultNoBound)] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, pub paras: Vec<(ParaId, ParaGenesisArgs)>, } @@ -1223,6 +1222,15 @@ const INVALID_TX_BAD_VALIDATOR_IDX: u8 = 1; const INVALID_TX_BAD_SUBJECT: u8 = 2; const INVALID_TX_DOUBLE_VOTE: u8 = 3; +/// This is intermediate "fix" for this issue: +/// +/// +/// It does not actually fix it, but makes the worst case better. Without that limit someone +/// could completely DoS the relay chain by registering a ridiculously high amount of paras. +/// With this limit the same attack could lead to some parachains ceasing to being able to +/// communicate via offchain XCMP. Snowbridge will still work as it only cares about `BridgeHub`. +pub const MAX_PARA_HEADS: usize = 1024; + impl Pallet { /// This is a call to schedule code upgrades for parachains which is safe to be called /// outside of this module. That means this function does all checks necessary to ensure @@ -1292,6 +1300,16 @@ impl Pallet { }) } + /// Get a list of the first [`MAX_PARA_HEADS`] para heads sorted by para_id. + /// This method is likely to be removed in the future. + pub fn sorted_para_heads() -> Vec<(u32, Vec)> { + let mut heads: Vec<(u32, Vec)> = + Heads::::iter().map(|(id, head)| (id.into(), head.0)).collect(); + heads.sort_by_key(|(id, _)| *id); + heads.truncate(MAX_PARA_HEADS); + heads + } + // Apply all para actions queued for the given session index. // // The actions to take are based on the lifecycle of of the paras. @@ -1938,14 +1956,12 @@ impl Pallet { inclusion_block_number: BlockNumberFor, cfg: &configuration::HostConfiguration>, upgrade_strategy: UpgradeStrategy, - ) -> Weight { - let mut weight = T::DbWeight::get().reads(1); - + ) { // Should be prevented by checks in `schedule_code_upgrade_external` let new_code_len = new_code.0.len(); if new_code_len < MIN_CODE_SIZE as usize || new_code_len > cfg.max_code_size as usize { log::warn!(target: LOG_TARGET, "attempted to schedule an upgrade with invalid new validation code",); - return weight + return } // Enacting this should be prevented by the `can_upgrade_validation_code` @@ -1959,7 +1975,7 @@ impl Pallet { // NOTE: we cannot set `UpgradeGoAheadSignal` signal here since this will be reset by // the following call `note_new_head` log::warn!(target: LOG_TARGET, "ended up scheduling an upgrade while one is pending",); - return weight + return } let code_hash = new_code.hash(); @@ -1968,7 +1984,6 @@ impl Pallet { // process right away. // // We do not want to allow this since it will mess with the code reference counting. - weight += T::DbWeight::get().reads(1); if CurrentCodeHash::::get(&id) == Some(code_hash) { // NOTE: we cannot set `UpgradeGoAheadSignal` signal here since this will be reset by // the following call `note_new_head` @@ -1976,15 +1991,13 @@ impl Pallet { target: LOG_TARGET, "para tried to upgrade to the same code. Abort the upgrade", ); - return weight + return } // This is the start of the upgrade process. Prevent any further attempts at upgrading. - weight += T::DbWeight::get().writes(2); FutureCodeHash::::insert(&id, &code_hash); UpgradeRestrictionSignal::::insert(&id, UpgradeRestriction::Present); - weight += T::DbWeight::get().reads_writes(1, 1); let next_possible_upgrade_at = inclusion_block_number + cfg.validation_upgrade_cooldown; UpgradeCooldowns::::mutate(|upgrade_cooldowns| { let insert_idx = upgrade_cooldowns @@ -1993,14 +2006,12 @@ impl Pallet { upgrade_cooldowns.insert(insert_idx, (id, next_possible_upgrade_at)); }); - weight += Self::kick_off_pvf_check( + Self::kick_off_pvf_check( PvfCheckCause::Upgrade { id, included_at: inclusion_block_number, upgrade_strategy }, code_hash, new_code, cfg, ); - - weight } /// Makes sure that the given code hash has passed pre-checking. @@ -2090,11 +2101,11 @@ impl Pallet { id: ParaId, new_head: HeadData, execution_context: BlockNumberFor, - ) -> Weight { + ) { Heads::::insert(&id, &new_head); MostRecentContext::::insert(&id, execution_context); - let weight = if let Some(expected_at) = FutureCodeUpgrades::::get(&id) { + if let Some(expected_at) = FutureCodeUpgrades::::get(&id) { if expected_at <= execution_context { FutureCodeUpgrades::::remove(&id); UpgradeGoAheadSignal::::remove(&id); @@ -2104,14 +2115,10 @@ impl Pallet { new_code_hash } else { log::error!(target: LOG_TARGET, "Missing future code hash for {:?}", &id); - return T::DbWeight::get().reads_writes(3, 1 + 3) + return }; - let weight = Self::set_current_code(id, new_code_hash, expected_at); - - weight + T::DbWeight::get().reads_writes(3, 3) - } else { - T::DbWeight::get().reads_writes(1, 1 + 0) + Self::set_current_code(id, new_code_hash, expected_at); } } else { // This means there is no upgrade scheduled. @@ -2119,10 +2126,9 @@ impl Pallet { // In case the upgrade was aborted by the relay-chain we should reset // the `Abort` signal. UpgradeGoAheadSignal::::remove(&id); - T::DbWeight::get().reads_writes(1, 2) }; - weight.saturating_add(T::OnNewHead::on_new_head(id, &new_head)) + T::OnNewHead::on_new_head(id, &new_head); } /// Set the current code for the given parachain. diff --git a/polkadot/runtime/parachains/src/paras/tests.rs b/polkadot/runtime/parachains/src/paras/tests.rs index 0b458f2f91eb2db68fb5d56aa9c35df7c373e894..6e4f99aa3d84412f4644402bedf425fef9d6a13c 100644 --- a/polkadot/runtime/parachains/src/paras/tests.rs +++ b/polkadot/runtime/parachains/src/paras/tests.rs @@ -16,12 +16,12 @@ use super::*; use frame_support::{assert_err, assert_ok, assert_storage_noop}; -use keyring::Sr25519Keyring; -use primitives::{vstaging::SchedulerParams, BlockNumber, PARACHAIN_KEY_TYPE_ID}; +use polkadot_primitives::{BlockNumber, SchedulerParams, PARACHAIN_KEY_TYPE_ID}; +use polkadot_primitives_test_helpers::{dummy_head_data, dummy_validation_code, validator_pubkeys}; use sc_keystore::LocalKeystore; +use sp_keyring::Sr25519Keyring; use sp_keystore::{Keystore, KeystorePtr}; use std::sync::Arc; -use test_helpers::{dummy_head_data, dummy_validation_code, validator_pubkeys}; use crate::{ configuration::HostConfiguration, @@ -135,7 +135,10 @@ fn check_code_is_not_stored(validation_code: &ValidationCode) { /// An utility for checking that certain events were deposited. struct EventValidator { events: Vec< - frame_system::EventRecord<::RuntimeEvent, primitives::Hash>, + frame_system::EventRecord< + ::RuntimeEvent, + polkadot_primitives::Hash, + >, >, } @@ -1810,7 +1813,7 @@ fn add_trusted_validation_code_enacts_existing_pvf_vote() { #[test] fn verify_upgrade_go_ahead_signal_is_externally_accessible() { - use primitives::well_known_keys; + use polkadot_primitives::well_known_keys; let a = ParaId::from(2020); @@ -1826,7 +1829,7 @@ fn verify_upgrade_go_ahead_signal_is_externally_accessible() { #[test] fn verify_upgrade_restriction_signal_is_externally_accessible() { - use primitives::well_known_keys; + use polkadot_primitives::well_known_keys; let a = ParaId::from(2020); @@ -1842,7 +1845,7 @@ fn verify_upgrade_restriction_signal_is_externally_accessible() { #[test] fn verify_para_head_is_externally_accessible() { - use primitives::well_known_keys; + use polkadot_primitives::well_known_keys; let a = ParaId::from(2020); let expected_head_data = HeadData(vec![0, 1, 2, 3]); diff --git a/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs b/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs index e643888ae29a1464a20130dc16dc756c95799949..1742e91276d4b40bdb0b263dc97f87f962ee2592 100644 --- a/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs +++ b/polkadot/runtime/parachains/src/paras_inherent/benchmarking.rs @@ -16,15 +16,30 @@ use super::*; use crate::{inclusion, ParaId}; +use alloc::collections::btree_map::BTreeMap; +use core::cmp::min; use frame_benchmarking::{benchmarks, impl_benchmark_test_suite}; use frame_system::RawOrigin; -use sp_std::{cmp::min, collections::btree_map::BTreeMap}; -use primitives::v7::GroupIndex; +use polkadot_primitives::v8::GroupIndex; use crate::builder::BenchBuilder; benchmarks! { + enter_empty { + let scenario = BenchBuilder::::new() + .build(); + + let mut benchmark = scenario.data.clone(); + + benchmark.bitfields.clear(); + benchmark.backed_candidates.clear(); + benchmark.disputes.clear(); + }: enter(RawOrigin::None, benchmark) + verify { + // Assert that the block was not discarded + assert!(Included::::get().is_some()); + } // Variant over `v`, the number of dispute statements in a dispute statement set. This gives the // weight of a single dispute statement set. enter_variable_disputes { @@ -91,18 +106,8 @@ benchmarks! { // Variant over `v`, the amount of validity votes for a backed candidate. This gives the weight // of a single backed candidate. enter_backed_candidates_variable { - // NOTE: the starting value must be over half of the max validators per group so the backed - // candidate is not rejected. Also, we cannot have more validity votes than validators in - // the group. - - // Do not use this range for Rococo because it only has 1 validator per backing group, - // which causes issues when trying to create slopes with the benchmarking analysis. Instead - // use v = 1 for running Rococo benchmarks - let v in (BenchBuilder::::fallback_min_validity_votes()) - ..(BenchBuilder::::fallback_max_validators()); - - // Comment in for running rococo benchmarks - // let v = 1; + let v in (BenchBuilder::::fallback_min_backing_votes()) + ..(BenchBuilder::::fallback_max_validators_per_core()); let cores_with_backed: BTreeMap<_, _> = vec![(0, v)] // The backed candidate will have `v` validity votes. @@ -110,7 +115,7 @@ benchmarks! { .collect(); let scenario = BenchBuilder::::new() - .set_backed_and_concluding_paras(cores_with_backed.clone()) + .set_backed_in_inherent_paras(cores_with_backed.clone()) .build(); let mut benchmark = scenario.data.clone(); @@ -118,7 +123,6 @@ benchmarks! { // There is 1 backed, assert_eq!(benchmark.backed_candidates.len(), 1); // with `v` validity votes. - // let votes = v as usize; let votes = min(scheduler::Pallet::::group_validators(GroupIndex::from(0)).unwrap().len(), v as usize); assert_eq!(benchmark.backed_candidates.get(0).unwrap().validity_votes().len(), votes); @@ -156,19 +160,21 @@ benchmarks! { let v = crate::configuration::ActiveConfig::::get().max_code_size; let cores_with_backed: BTreeMap<_, _> - = vec![(0, BenchBuilder::::fallback_min_validity_votes())] + = vec![(0, BenchBuilder::::fallback_min_backing_votes())] .into_iter() .collect(); let scenario = BenchBuilder::::new() - .set_backed_and_concluding_paras(cores_with_backed.clone()) + .set_backed_in_inherent_paras(cores_with_backed.clone()) .set_code_upgrade(v) .build(); let mut benchmark = scenario.data.clone(); - // let votes = BenchBuilder::::fallback_min_validity_votes() as usize; - let votes = min(scheduler::Pallet::::group_validators(GroupIndex::from(0)).unwrap().len(), BenchBuilder::::fallback_min_validity_votes() as usize); + let votes = min( + scheduler::Pallet::::group_validators(GroupIndex::from(0)).unwrap().len(), + BenchBuilder::::fallback_min_backing_votes() as usize + ); // There is 1 backed assert_eq!(benchmark.backed_candidates.len(), 1); diff --git a/polkadot/runtime/parachains/src/paras_inherent/misc.rs b/polkadot/runtime/parachains/src/paras_inherent/misc.rs index dac9e6e256d0ef60c6b18b51d48f44c65e1cae8f..2858c3f95de2602e5020646f69d58ef54a63d97a 100644 --- a/polkadot/runtime/parachains/src/paras_inherent/misc.rs +++ b/polkadot/runtime/parachains/src/paras_inherent/misc.rs @@ -14,7 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use sp_std::{cmp::Ordering, vec::Vec}; +use alloc::vec::Vec; +use core::cmp::Ordering; /// A helper trait to allow calling retain while getting access /// to the index of the item in the `vec`. diff --git a/polkadot/runtime/parachains/src/paras_inherent/mod.rs b/polkadot/runtime/parachains/src/paras_inherent/mod.rs index ac4cf5dc8d413397b6a740c6503f69e8d592e20d..bd8d08a842c31ec7db3bba8ad677de79c0f92b97 100644 --- a/polkadot/runtime/parachains/src/paras_inherent/mod.rs +++ b/polkadot/runtime/parachains/src/paras_inherent/mod.rs @@ -32,6 +32,11 @@ use crate::{ shared::{self, AllowedRelayParentsTracker}, ParaId, }; +use alloc::{ + collections::{btree_map::BTreeMap, btree_set::BTreeSet}, + vec, + vec::Vec, +}; use bitvec::prelude::BitVec; use frame_support::{ defensive, @@ -42,7 +47,7 @@ use frame_support::{ }; use frame_system::pallet_prelude::*; use pallet_babe::{self, ParentBlockRandomness}; -use primitives::{ +use polkadot_primitives::{ effective_minimum_backing_votes, node_features::FeatureIndex, BackedCandidate, CandidateHash, CandidateReceipt, CheckedDisputeStatementSet, CheckedMultiDisputeStatementSet, CoreIndex, DisputeStatementSet, HeadData, InherentData as ParachainsInherentData, @@ -53,11 +58,6 @@ use primitives::{ use rand::{seq::SliceRandom, SeedableRng}; use scale_info::TypeInfo; use sp_runtime::traits::{Header as HeaderT, One}; -use sp_std::{ - collections::{btree_map::BTreeMap, btree_set::BTreeSet}, - prelude::*, - vec::Vec, -}; mod misc; mod weights; @@ -295,7 +295,7 @@ impl Pallet { fn process_inherent_data( data: ParachainsInherentData>, context: ProcessInherentDataContext, - ) -> sp_std::result::Result< + ) -> core::result::Result< (ParachainsInherentData>, PostDispatchInfo), DispatchErrorWithPostInfo, > { @@ -347,12 +347,12 @@ impl Pallet { let bitfields_weight = signed_bitfields_weight::(&bitfields); let disputes_weight = multi_dispute_statement_sets_weight::(&disputes); - // Weight before filtering/sanitization - let all_weight_before = candidates_weight + bitfields_weight + disputes_weight; + // Weight before filtering/sanitization except for enacting the candidates + let weight_before_filtering = candidates_weight + bitfields_weight + disputes_weight; - METRICS.on_before_filter(all_weight_before.ref_time()); - log::debug!(target: LOG_TARGET, "Size before filter: {}, candidates + bitfields: {}, disputes: {}", all_weight_before.proof_size(), candidates_weight.proof_size() + bitfields_weight.proof_size(), disputes_weight.proof_size()); - log::debug!(target: LOG_TARGET, "Time weight before filter: {}, candidates + bitfields: {}, disputes: {}", all_weight_before.ref_time(), candidates_weight.ref_time() + bitfields_weight.ref_time(), disputes_weight.ref_time()); + METRICS.on_before_filter(weight_before_filtering.ref_time()); + log::debug!(target: LOG_TARGET, "Size before filter: {}, candidates + bitfields: {}, disputes: {}", weight_before_filtering.proof_size(), candidates_weight.proof_size() + bitfields_weight.proof_size(), disputes_weight.proof_size()); + log::debug!(target: LOG_TARGET, "Time weight before filter: {}, candidates + bitfields: {}, disputes: {}", weight_before_filtering.ref_time(), candidates_weight.ref_time() + bitfields_weight.ref_time(), disputes_weight.ref_time()); let current_session = shared::CurrentSessionIndex::::get(); let expected_bits = scheduler::AvailabilityCores::::get().len(); @@ -409,7 +409,7 @@ impl Pallet { max_block_weight, ); - let all_weight_after = if context == ProcessInherentDataContext::ProvideInherent { + let mut all_weight_after = if context == ProcessInherentDataContext::ProvideInherent { // Assure the maximum block weight is adhered, by limiting bitfields and backed // candidates. Dispute statement sets were already limited before. let non_disputes_weight = apply_weight_limit::( @@ -424,11 +424,11 @@ impl Pallet { METRICS.on_after_filter(all_weight_after.ref_time()); log::debug!( - target: LOG_TARGET, - "[process_inherent_data] after filter: bitfields.len(): {}, backed_candidates.len(): {}, checked_disputes_sets.len() {}", - bitfields.len(), - backed_candidates.len(), - checked_disputes_sets.len() + target: LOG_TARGET, + "[process_inherent_data] after filter: bitfields.len(): {}, backed_candidates.len(): {}, checked_disputes_sets.len() {}", + bitfields.len(), + backed_candidates.len(), + checked_disputes_sets.len() ); log::debug!(target: LOG_TARGET, "Size after filter: {}, candidates + bitfields: {}, disputes: {}", all_weight_after.proof_size(), non_disputes_weight.proof_size(), checked_disputes_sets_consumed_weight.proof_size()); log::debug!(target: LOG_TARGET, "Time weight after filter: {}, candidates + bitfields: {}, disputes: {}", all_weight_after.ref_time(), non_disputes_weight.ref_time(), checked_disputes_sets_consumed_weight.ref_time()); @@ -440,17 +440,20 @@ impl Pallet { } else { // This check is performed in the context of block execution. Ensures inherent weight // invariants guaranteed by `create_inherent_data` for block authorship. - if all_weight_before.any_gt(max_block_weight) { + if weight_before_filtering.any_gt(max_block_weight) { log::error!( "Overweight para inherent data reached the runtime {:?}: {} > {}", parent_hash, - all_weight_before, + weight_before_filtering, max_block_weight ); } - ensure!(all_weight_before.all_lte(max_block_weight), Error::::InherentOverweight); - all_weight_before + ensure!( + weight_before_filtering.all_lte(max_block_weight), + Error::::InherentOverweight + ); + weight_before_filtering }; // Note that `process_checked_multi_dispute_data` will iterate and import each @@ -529,11 +532,32 @@ impl Pallet { // Process new availability bitfields, yielding any availability cores whose // work has now concluded. - let freed_concluded = + let (enact_weight, freed_concluded) = inclusion::Pallet::::update_pending_availability_and_get_freed_cores( &validator_public[..], bitfields.clone(), ); + all_weight_after.saturating_accrue(enact_weight); + log::debug!( + target: LOG_TARGET, + "Enacting weight: {}, all weight: {}", + enact_weight.ref_time(), + all_weight_after.ref_time(), + ); + + // It's possible that that after the enacting the candidates, the total weight + // goes over the limit, however, we can't do anything about it at this point. + // By using the `Mandatory` weight, we ensure the block is still accepted, + // but no other (user) transactions can be included. + if all_weight_after.any_gt(max_block_weight) { + log::warn!( + target: LOG_TARGET, + "Overweight para inherent data after enacting the candidates {:?}: {} > {}", + parent_hash, + all_weight_after, + max_block_weight, + ); + } // Inform the disputes module of all included candidates. for (_, candidate_hash) in &freed_concluded { @@ -560,7 +584,7 @@ impl Pallet { .chain(freed_disputed.into_iter().map(|core| (core, FreedReason::Concluded))) .chain(freed_timeout.into_iter().map(|c| (c, FreedReason::TimedOut))) .collect::>(); - scheduler::Pallet::::free_cores_and_fill_claimqueue(freed, now); + scheduler::Pallet::::free_cores_and_fill_claim_queue(freed, now); METRICS.on_candidates_processed_total(backed_candidates.len() as u64); @@ -570,12 +594,13 @@ impl Pallet { .map(|b| *b) .unwrap_or(false); - let mut scheduled: BTreeMap> = BTreeMap::new(); - let mut total_scheduled_cores = 0; + let mut eligible: BTreeMap> = BTreeMap::new(); + let mut total_eligible_cores = 0; - for (core_idx, para_id) in scheduler::Pallet::::scheduled_paras() { - total_scheduled_cores += 1; - scheduled.entry(para_id).or_default().insert(core_idx); + for (core_idx, para_id) in scheduler::Pallet::::eligible_paras() { + total_eligible_cores += 1; + log::trace!(target: LOG_TARGET, "Found eligible para {:?} on core {:?}", para_id, core_idx); + eligible.entry(para_id).or_default().insert(core_idx); } let initial_candidate_count = backed_candidates.len(); @@ -583,12 +608,12 @@ impl Pallet { backed_candidates, &allowed_relay_parents, concluded_invalid_hashes, - scheduled, + eligible, core_index_enabled, ); let count = count_backed_candidates(&backed_candidates_with_core); - ensure!(count <= total_scheduled_cores, Error::::UnscheduledCandidate); + ensure!(count <= total_eligible_cores, Error::::UnscheduledCandidate); METRICS.on_candidates_sanitized(count as u64); @@ -761,7 +786,7 @@ pub(crate) fn apply_weight_limit( let mut chained_candidates: Vec> = Vec::new(); let mut current_para_id = None; - for candidate in sp_std::mem::take(candidates).into_iter() { + for candidate in core::mem::take(candidates).into_iter() { let candidate_para_id = candidate.descriptor().para_id; if Some(candidate_para_id) == current_para_id { let chain = chained_candidates @@ -1242,22 +1267,27 @@ fn filter_unchained_candidates>>, allowed_relay_parents: &AllowedRelayParentsTracker>, ) { - let mut para_latest_head_data: BTreeMap = BTreeMap::new(); + let mut para_latest_context: BTreeMap)> = BTreeMap::new(); for para_id in candidates.keys() { - let latest_head_data = match inclusion::Pallet::::para_latest_head_data(¶_id) { - None => { - defensive!("Latest included head data for paraid {:?} is None", para_id); - continue - }, - Some(latest_head_data) => latest_head_data, + let Some(latest_head_data) = inclusion::Pallet::::para_latest_head_data(¶_id) else { + defensive!("Latest included head data for paraid {:?} is None", para_id); + continue + }; + let Some(latest_relay_parent) = inclusion::Pallet::::para_most_recent_context(¶_id) + else { + defensive!("Latest relay parent for paraid {:?} is None", para_id); + continue }; - para_latest_head_data.insert(*para_id, latest_head_data); + para_latest_context.insert(*para_id, (latest_head_data, latest_relay_parent)); } let mut para_visited_candidates: BTreeMap> = BTreeMap::new(); retain_candidates::(candidates, |para_id, candidate| { - let Some(latest_head_data) = para_latest_head_data.get(¶_id) else { return false }; + let Some((latest_head_data, latest_relay_parent)) = para_latest_context.get(¶_id) + else { + return false + }; let candidate_hash = candidate.candidate().hash(); let visited_candidates = @@ -1276,15 +1306,23 @@ fn filter_unchained_candidates::get(para_id); - let check_ctx = CandidateCheckContext::::new(prev_context); + let check_ctx = CandidateCheckContext::::new(Some(*latest_relay_parent)); - let res = match check_ctx.verify_backed_candidate( + match check_ctx.verify_backed_candidate( &allowed_relay_parents, candidate.candidate(), latest_head_data.clone(), ) { - Ok(_) => true, + Ok(relay_parent_block_number) => { + para_latest_context.insert( + para_id, + ( + candidate.candidate().commitments.head_data.clone(), + relay_parent_block_number, + ), + ); + true + }, Err(err) => { log::debug!( target: LOG_TARGET, @@ -1295,14 +1333,7 @@ fn filter_unchained_candidates MockGenesisConfig { MockGenesisConfig { @@ -53,13 +53,13 @@ mod enter { }, session_info, }; + use alloc::collections::btree_map::BTreeMap; use assert_matches::assert_matches; use core::panic; use frame_support::assert_ok; use frame_system::limits; - use primitives::{vstaging::SchedulerParams, AvailabilityBitfield, UncheckedSigned}; + use polkadot_primitives::{AvailabilityBitfield, SchedulerParams, UncheckedSigned}; use sp_runtime::Perbill; - use sp_std::collections::btree_map::BTreeMap; struct TestConfig { dispute_statements: BTreeMap, @@ -166,7 +166,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); // Nothing is filtered out (including the backed candidates.) assert_eq!( @@ -257,7 +257,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); assert!(pallet::OnChainVotes::::get().is_none()); @@ -372,7 +372,7 @@ mod enter { let mut inherent_data = InherentData::new(); inherent_data.put_data(PARACHAINS_INHERENT_IDENTIFIER, &scenario.data).unwrap(); - assert!(!scheduler::Pallet::::claimqueue_is_empty()); + assert!(!scheduler::Pallet::::claim_queue_is_empty()); // The right candidates have been filtered out (the ones for cores 0,4,5) assert_eq!( @@ -494,7 +494,7 @@ mod enter { #[test] fn test_session_is_tracked_in_on_chain_scraping() { use crate::disputes::run_to_block; - use primitives::{ + use polkadot_primitives::{ DisputeStatement, DisputeStatementSet, ExplicitDisputeStatement, InvalidDisputeStatementKind, ValidDisputeStatementKind, }; @@ -618,7 +618,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); let multi_dispute_inherent_data = Pallet::::create_inherent_inner(&inherent_data.clone()).unwrap(); @@ -690,7 +690,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); let limit_inherent_data = Pallet::::create_inherent_inner(&inherent_data.clone()).unwrap(); @@ -762,7 +762,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); // Nothing is filtered out (including the backed candidates.) let limit_inherent_data = @@ -849,7 +849,7 @@ mod enter { .unwrap(); // The current schedule is empty prior to calling `create_inherent_enter`. - assert!(scheduler::Pallet::::claimqueue_is_empty()); + assert!(scheduler::Pallet::::claim_queue_is_empty()); // Nothing is filtered out (including the backed candidates.) let limit_inherent_data = @@ -943,6 +943,65 @@ mod enter { }); } + // Ensure that even if the block is over weight due to candidates enactment, + // we still can import it. + #[test] + fn overweight_candidates_enactment_is_fine() { + sp_tracing::try_init_simple(); + new_test_ext(MockGenesisConfig::default()).execute_with(|| { + use crate::inclusion::WeightInfo as _; + + let mut backed_and_concluding = BTreeMap::new(); + // The number of candidates is chosen to go over the weight limit + // of the mock runtime together with the `enact_candidate`s weight. + let num_candidates = 5u32; + let max_weight = ::BlockWeights::get().max_block; + assert!(::WeightInfo::enact_candidate(0, 0, 0) + .saturating_mul(u64::from(num_candidates)) + .any_gt(max_weight)); + + for i in 0..num_candidates { + backed_and_concluding.insert(i, 2); + } + + let num_validators_per_core: u32 = 5; + let num_backed = backed_and_concluding.len(); + let bitfields_len = num_validators_per_core as usize * num_backed; + + let scenario = make_inherent_data(TestConfig { + dispute_statements: BTreeMap::new(), + dispute_sessions: vec![], + backed_and_concluding, + num_validators_per_core, + code_upgrade: None, + fill_claimqueue: true, + elastic_paras: BTreeMap::new(), + unavailable_cores: vec![], + }); + + let expected_para_inherent_data = scenario.data.clone(); + + // Check the para inherent data is as expected: + assert_eq!(expected_para_inherent_data.bitfields.len(), bitfields_len); + assert_eq!(expected_para_inherent_data.backed_candidates.len(), num_backed); + assert_eq!(expected_para_inherent_data.disputes.len(), 0); + + let mut inherent_data = InherentData::new(); + inherent_data + .put_data(PARACHAINS_INHERENT_IDENTIFIER, &expected_para_inherent_data) + .unwrap(); + + let limit_inherent_data = + Pallet::::create_inherent_inner(&inherent_data.clone()).unwrap(); + assert!(limit_inherent_data == expected_para_inherent_data); + + assert_ok!(Pallet::::enter( + frame_system::RawOrigin::None.into(), + limit_inherent_data, + )); + }); + } + fn max_block_weight_proof_size_adjusted() -> Weight { let raw_weight = ::BlockWeights::get().max_block; let block_length = ::BlockLength::get(); @@ -1467,8 +1526,8 @@ mod enter { } } -fn default_header() -> primitives::Header { - primitives::Header { +fn default_header() -> polkadot_primitives::Header { + polkadot_primitives::Header { parent_hash: Default::default(), number: 0, state_root: Default::default(), @@ -1487,7 +1546,7 @@ mod sanitizers { mock::new_test_ext, }; use bitvec::order::Lsb0; - use primitives::{ + use polkadot_primitives::{ AvailabilityBitfield, GroupIndex, Hash, Id as ParaId, SignedAvailabilityBitfield, ValidatorIndex, }; @@ -1495,13 +1554,13 @@ mod sanitizers { use sp_core::crypto::UncheckedFrom; use crate::mock::Test; - use keyring::Sr25519Keyring; - use primitives::PARACHAIN_KEY_TYPE_ID; + use polkadot_primitives::PARACHAIN_KEY_TYPE_ID; use sc_keystore::LocalKeystore; + use sp_keyring::Sr25519Keyring; use sp_keystore::{Keystore, KeystorePtr}; use std::sync::Arc; - fn validator_pubkeys(val_ids: &[keyring::Sr25519Keyring]) -> Vec { + fn validator_pubkeys(val_ids: &[sp_keyring::Sr25519Keyring]) -> Vec { val_ids.iter().map(|v| v.public().into()).collect() } @@ -1518,10 +1577,10 @@ mod sanitizers { let signing_context = SigningContext { parent_hash, session_index }; let validators = vec![ - keyring::Sr25519Keyring::Alice, - keyring::Sr25519Keyring::Bob, - keyring::Sr25519Keyring::Charlie, - keyring::Sr25519Keyring::Dave, + sp_keyring::Sr25519Keyring::Alice, + sp_keyring::Sr25519Keyring::Bob, + sp_keyring::Sr25519Keyring::Charlie, + sp_keyring::Sr25519Keyring::Dave, ]; for validator in validators.iter() { Keystore::sr25519_generate_new( @@ -1744,8 +1803,8 @@ mod sanitizers { scheduler::{common::Assignment, ParasEntry}, util::{make_persisted_validation_data, make_persisted_validation_data_with_parent}, }; - use primitives::ValidationCode; - use sp_std::collections::vec_deque::VecDeque; + use alloc::collections::vec_deque::VecDeque; + use polkadot_primitives::ValidationCode; use super::*; @@ -1754,7 +1813,7 @@ mod sanitizers { backed_candidates: Vec, expected_backed_candidates_with_core: BTreeMap>, - scheduled_paras: BTreeMap>, + scheduled_paras: BTreeMap>, } // Generate test data for the candidates and assert that the environment is set as expected @@ -1780,11 +1839,11 @@ mod sanitizers { let signing_context = SigningContext { parent_hash: relay_parent, session_index }; let validators = vec![ - keyring::Sr25519Keyring::Alice, - keyring::Sr25519Keyring::Bob, - keyring::Sr25519Keyring::Charlie, - keyring::Sr25519Keyring::Dave, - keyring::Sr25519Keyring::Eve, + sp_keyring::Sr25519Keyring::Alice, + sp_keyring::Sr25519Keyring::Bob, + sp_keyring::Sr25519Keyring::Charlie, + sp_keyring::Sr25519Keyring::Dave, + sp_keyring::Sr25519Keyring::Eve, ]; for validator in validators.iter() { Keystore::sr25519_generate_new( @@ -1818,7 +1877,7 @@ mod sanitizers { ]); // Update scheduler's claimqueue with the parachains - scheduler::Pallet::::set_claimqueue(BTreeMap::from([ + scheduler::Pallet::::set_claim_queue(BTreeMap::from([ ( CoreIndex::from(0), VecDeque::from([ParasEntry::new( @@ -1852,6 +1911,19 @@ mod sanitizers { ValidationCode(vec![2]), ) .unwrap(); + // Set the most recent relay parent. + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(1), + BlockNumberFor::::from(0u32), + ) + .unwrap(); + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(2), + BlockNumberFor::::from(0u32), + ) + .unwrap(); // Callback used for backing candidates let group_validators = |group_index: GroupIndex| { @@ -1965,14 +2037,14 @@ mod sanitizers { let signing_context = SigningContext { parent_hash: relay_parent, session_index }; let validators = vec![ - keyring::Sr25519Keyring::Alice, - keyring::Sr25519Keyring::Bob, - keyring::Sr25519Keyring::Charlie, - keyring::Sr25519Keyring::Dave, - keyring::Sr25519Keyring::Eve, - keyring::Sr25519Keyring::Ferdie, - keyring::Sr25519Keyring::One, - keyring::Sr25519Keyring::Two, + sp_keyring::Sr25519Keyring::Alice, + sp_keyring::Sr25519Keyring::Bob, + sp_keyring::Sr25519Keyring::Charlie, + sp_keyring::Sr25519Keyring::Dave, + sp_keyring::Sr25519Keyring::Eve, + sp_keyring::Sr25519Keyring::Ferdie, + sp_keyring::Sr25519Keyring::One, + sp_keyring::Sr25519Keyring::Two, ]; for validator in validators.iter() { Keystore::sr25519_generate_new( @@ -2001,7 +2073,7 @@ mod sanitizers { ]); // Update scheduler's claimqueue with the parachains - scheduler::Pallet::::set_claimqueue(BTreeMap::from([ + scheduler::Pallet::::set_claim_queue(BTreeMap::from([ ( CoreIndex::from(0), VecDeque::from([ParasEntry::new( @@ -2083,23 +2155,21 @@ mod sanitizers { ValidationCode(vec![id as u8]), ) .unwrap(); + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(id), + BlockNumberFor::::from(0u32), + ) + .unwrap(); } // Callback used for backing candidates let group_validators = |group_index: GroupIndex| { - match group_index { - group_index if group_index == GroupIndex::from(0) => Some(vec![0]), - group_index if group_index == GroupIndex::from(1) => Some(vec![1]), - group_index if group_index == GroupIndex::from(2) => Some(vec![2]), - group_index if group_index == GroupIndex::from(3) => Some(vec![3]), - group_index if group_index == GroupIndex::from(4) => Some(vec![4]), - group_index if group_index == GroupIndex::from(5) => Some(vec![5]), - group_index if group_index == GroupIndex::from(6) => Some(vec![6]), - group_index if group_index == GroupIndex::from(7) => Some(vec![7]), - - _ => panic!("Group index out of bounds"), + if group_index.0 as usize >= validators.len() { + panic!("Group index out of bounds") + } else { + Some(vec![ValidatorIndex(group_index.0)]) } - .map(|m| m.into_iter().map(ValidatorIndex).collect::>()) }; let mut backed_candidates = vec![]; @@ -2485,18 +2555,16 @@ mod sanitizers { // Para 4 scheduled on core 7 and 8. Duplicated candidates. fn get_test_data_for_order_checks(core_index_enabled: bool) -> TestData { const RELAY_PARENT_NUM: u32 = 3; + let header = default_header(); + let relay_parent = header.hash(); - // Add the relay parent to `shared` pallet. Otherwise some code (e.g. filtering backing - // votes) won't behave correctly shared::Pallet::::add_allowed_relay_parent( - default_header().hash(), + relay_parent, Default::default(), RELAY_PARENT_NUM, 1, ); - let header = default_header(); - let relay_parent = header.hash(); let session_index = SessionIndex::from(0_u32); let keystore = LocalKeystore::in_memory(); @@ -2504,15 +2572,15 @@ mod sanitizers { let signing_context = SigningContext { parent_hash: relay_parent, session_index }; let validators = vec![ - keyring::Sr25519Keyring::Alice, - keyring::Sr25519Keyring::Bob, - keyring::Sr25519Keyring::Charlie, - keyring::Sr25519Keyring::Dave, - keyring::Sr25519Keyring::Eve, - keyring::Sr25519Keyring::Ferdie, - keyring::Sr25519Keyring::One, - keyring::Sr25519Keyring::Two, - keyring::Sr25519Keyring::AliceStash, + sp_keyring::Sr25519Keyring::Alice, + sp_keyring::Sr25519Keyring::Bob, + sp_keyring::Sr25519Keyring::Charlie, + sp_keyring::Sr25519Keyring::Dave, + sp_keyring::Sr25519Keyring::Eve, + sp_keyring::Sr25519Keyring::Ferdie, + sp_keyring::Sr25519Keyring::One, + sp_keyring::Sr25519Keyring::Two, + sp_keyring::Sr25519Keyring::AliceStash, ]; for validator in validators.iter() { Keystore::sr25519_generate_new( @@ -2542,7 +2610,7 @@ mod sanitizers { ]); // Update scheduler's claimqueue with the parachains - scheduler::Pallet::::set_claimqueue(BTreeMap::from([ + scheduler::Pallet::::set_claim_queue(BTreeMap::from([ ( CoreIndex::from(0), VecDeque::from([ParasEntry::new( @@ -2617,24 +2685,21 @@ mod sanitizers { ValidationCode(vec![id as u8]), ) .unwrap(); + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(id), + BlockNumberFor::::from(0u32), + ) + .unwrap(); } // Callback used for backing candidates let group_validators = |group_index: GroupIndex| { - match group_index { - group_index if group_index == GroupIndex::from(0) => Some(vec![0]), - group_index if group_index == GroupIndex::from(1) => Some(vec![1]), - group_index if group_index == GroupIndex::from(2) => Some(vec![2]), - group_index if group_index == GroupIndex::from(3) => Some(vec![3]), - group_index if group_index == GroupIndex::from(4) => Some(vec![4]), - group_index if group_index == GroupIndex::from(5) => Some(vec![5]), - group_index if group_index == GroupIndex::from(6) => Some(vec![6]), - group_index if group_index == GroupIndex::from(7) => Some(vec![7]), - group_index if group_index == GroupIndex::from(8) => Some(vec![8]), - - _ => panic!("Group index out of bounds"), + if group_index.0 as usize >= validators.len() { + panic!("Group index out of bounds") + } else { + Some(vec![ValidatorIndex(group_index.0)]) } - .map(|m| m.into_iter().map(ValidatorIndex).collect::>()) }; let mut backed_candidates = vec![]; @@ -2980,6 +3045,430 @@ mod sanitizers { } } + // Para 1 scheduled on cores 0, 1 and 2. Three candidates are supplied but their relay + // parents look like this: 3, 2, 3. + // Para 2 scheduled on cores 3, 4 and 5. Three candidates are supplied and their relay + // parents look like this: 2, 3, 3. + fn get_test_data_for_relay_parent_ordering(core_index_enabled: bool) -> TestData { + const RELAY_PARENT_NUM: u32 = 3; + let header = default_header(); + let relay_parent = header.hash(); + + let prev_relay_parent = polkadot_primitives::Header { + parent_hash: Default::default(), + number: RELAY_PARENT_NUM - 1, + state_root: Default::default(), + extrinsics_root: Default::default(), + digest: Default::default(), + } + .hash(); + + let next_relay_parent = polkadot_primitives::Header { + parent_hash: Default::default(), + number: RELAY_PARENT_NUM + 1, + state_root: Default::default(), + extrinsics_root: Default::default(), + digest: Default::default(), + } + .hash(); + + // Add the relay parent to `shared` pallet. Otherwise some code (e.g. filtering backing + // votes) won't behave correctly + shared::Pallet::::add_allowed_relay_parent( + prev_relay_parent, + Default::default(), + RELAY_PARENT_NUM - 1, + 2, + ); + + shared::Pallet::::add_allowed_relay_parent( + relay_parent, + Default::default(), + RELAY_PARENT_NUM, + 2, + ); + + shared::Pallet::::add_allowed_relay_parent( + next_relay_parent, + Default::default(), + RELAY_PARENT_NUM + 1, + 2, + ); + + let session_index = SessionIndex::from(0_u32); + + let keystore = LocalKeystore::in_memory(); + let keystore = Arc::new(keystore) as KeystorePtr; + let signing_context = SigningContext { parent_hash: relay_parent, session_index }; + + let validators = vec![ + sp_keyring::Sr25519Keyring::Alice, + sp_keyring::Sr25519Keyring::Bob, + sp_keyring::Sr25519Keyring::Charlie, + sp_keyring::Sr25519Keyring::Dave, + sp_keyring::Sr25519Keyring::Eve, + sp_keyring::Sr25519Keyring::Ferdie, + ]; + for validator in validators.iter() { + Keystore::sr25519_generate_new( + &*keystore, + PARACHAIN_KEY_TYPE_ID, + Some(&validator.to_seed()), + ) + .unwrap(); + } + + // Set active validators in `shared` pallet + let validator_ids = + validators.iter().map(|v| v.public().into()).collect::>(); + shared::Pallet::::set_active_validators_ascending(validator_ids); + + // Set the validator groups in `scheduler` + scheduler::Pallet::::set_validator_groups(vec![ + vec![ValidatorIndex(0)], + vec![ValidatorIndex(1)], + vec![ValidatorIndex(2)], + vec![ValidatorIndex(3)], + vec![ValidatorIndex(4)], + vec![ValidatorIndex(5)], + ]); + + // Update scheduler's claimqueue with the parachains + scheduler::Pallet::::set_claim_queue(BTreeMap::from([ + ( + CoreIndex::from(0), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 1.into(), core_index: CoreIndex(0) }, + RELAY_PARENT_NUM, + )]), + ), + ( + CoreIndex::from(1), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 1.into(), core_index: CoreIndex(1) }, + RELAY_PARENT_NUM, + )]), + ), + ( + CoreIndex::from(2), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 1.into(), core_index: CoreIndex(2) }, + RELAY_PARENT_NUM, + )]), + ), + ( + CoreIndex::from(3), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 2.into(), core_index: CoreIndex(3) }, + RELAY_PARENT_NUM, + )]), + ), + ( + CoreIndex::from(4), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 2.into(), core_index: CoreIndex(4) }, + RELAY_PARENT_NUM, + )]), + ), + ( + CoreIndex::from(5), + VecDeque::from([ParasEntry::new( + Assignment::Pool { para_id: 2.into(), core_index: CoreIndex(5) }, + RELAY_PARENT_NUM, + )]), + ), + ])); + + // Set the on-chain included head data and current code hash. + for id in 1..=2u32 { + paras::Pallet::::set_current_head(ParaId::from(id), HeadData(vec![id as u8])); + paras::Pallet::::force_set_current_code( + RuntimeOrigin::root(), + ParaId::from(id), + ValidationCode(vec![id as u8]), + ) + .unwrap(); + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(id), + BlockNumberFor::::from(0u32), + ) + .unwrap(); + } + + // Callback used for backing candidates + let group_validators = |group_index: GroupIndex| { + if group_index.0 as usize >= validators.len() { + panic!("Group index out of bounds") + } else { + Some(vec![ValidatorIndex(group_index.0)]) + } + }; + + let mut backed_candidates = vec![]; + let mut expected_backed_candidates_with_core = BTreeMap::new(); + + // Para 1 + { + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(1), + relay_parent, + pov_hash: Hash::repeat_byte(1 as u8), + persisted_validation_data_hash: make_persisted_validation_data::( + ParaId::from(1), + RELAY_PARENT_NUM, + Default::default(), + ) + .unwrap() + .hash(), + head_data: HeadData(vec![1, 1]), + hrmp_watermark: RELAY_PARENT_NUM, + validation_code: ValidationCode(vec![1]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let prev_candidate = candidate.clone(); + let backed: BackedCandidate = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(0 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(0 as u32)), + ); + backed_candidates.push(backed.clone()); + if core_index_enabled { + expected_backed_candidates_with_core + .entry(ParaId::from(1)) + .or_insert(vec![]) + .push((backed, CoreIndex(0))); + } + + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(1), + relay_parent: prev_relay_parent, + pov_hash: Hash::repeat_byte(1 as u8), + persisted_validation_data_hash: make_persisted_validation_data_with_parent::< + Test, + >( + RELAY_PARENT_NUM - 1, + Default::default(), + prev_candidate.commitments.head_data, + ) + .hash(), + hrmp_watermark: RELAY_PARENT_NUM - 1, + validation_code: ValidationCode(vec![1]), + head_data: HeadData(vec![1, 1, 1]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let prev_candidate = candidate.clone(); + let backed = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(1 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(1 as u32)), + ); + backed_candidates.push(backed.clone()); + + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(1), + relay_parent, + pov_hash: Hash::repeat_byte(1 as u8), + persisted_validation_data_hash: make_persisted_validation_data_with_parent::< + Test, + >( + RELAY_PARENT_NUM, + Default::default(), + prev_candidate.commitments.head_data, + ) + .hash(), + hrmp_watermark: RELAY_PARENT_NUM, + validation_code: ValidationCode(vec![1]), + head_data: HeadData(vec![1, 1, 1, 1]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let backed = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(2 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(2 as u32)), + ); + backed_candidates.push(backed.clone()); + } + + // Para 2 + { + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(2), + relay_parent: prev_relay_parent, + pov_hash: Hash::repeat_byte(2 as u8), + persisted_validation_data_hash: make_persisted_validation_data::( + ParaId::from(2), + RELAY_PARENT_NUM - 1, + Default::default(), + ) + .unwrap() + .hash(), + head_data: HeadData(vec![2, 2]), + hrmp_watermark: RELAY_PARENT_NUM - 1, + validation_code: ValidationCode(vec![2]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let prev_candidate = candidate.clone(); + let backed: BackedCandidate = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(3 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(3 as u32)), + ); + backed_candidates.push(backed.clone()); + if core_index_enabled { + expected_backed_candidates_with_core + .entry(ParaId::from(2)) + .or_insert(vec![]) + .push((backed, CoreIndex(3))); + } + + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(2), + relay_parent, + pov_hash: Hash::repeat_byte(2 as u8), + persisted_validation_data_hash: make_persisted_validation_data_with_parent::< + Test, + >( + RELAY_PARENT_NUM, + Default::default(), + prev_candidate.commitments.head_data, + ) + .hash(), + hrmp_watermark: RELAY_PARENT_NUM, + validation_code: ValidationCode(vec![2]), + head_data: HeadData(vec![2, 2, 2]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let prev_candidate = candidate.clone(); + let backed = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(4 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(4 as u32)), + ); + backed_candidates.push(backed.clone()); + if core_index_enabled { + expected_backed_candidates_with_core + .entry(ParaId::from(2)) + .or_insert(vec![]) + .push((backed, CoreIndex(4))); + } + + let mut candidate = TestCandidateBuilder { + para_id: ParaId::from(2), + relay_parent, + pov_hash: Hash::repeat_byte(2 as u8), + persisted_validation_data_hash: make_persisted_validation_data_with_parent::< + Test, + >( + RELAY_PARENT_NUM, + Default::default(), + prev_candidate.commitments.head_data, + ) + .hash(), + hrmp_watermark: RELAY_PARENT_NUM, + validation_code: ValidationCode(vec![2]), + head_data: HeadData(vec![2, 2, 2, 2]), + ..Default::default() + } + .build(); + + collator_sign_candidate(Sr25519Keyring::One, &mut candidate); + + let backed = back_candidate( + candidate, + &validators, + group_validators(GroupIndex::from(5 as u32)).unwrap().as_ref(), + &keystore, + &signing_context, + BackingKind::Threshold, + core_index_enabled.then_some(CoreIndex(5 as u32)), + ); + backed_candidates.push(backed.clone()); + + if core_index_enabled { + expected_backed_candidates_with_core + .entry(ParaId::from(2)) + .or_insert(vec![]) + .push((backed, CoreIndex(5))); + } + } + + // State sanity checks + assert_eq!( + scheduler::Pallet::::scheduled_paras().collect::>(), + vec![ + (CoreIndex(0), ParaId::from(1)), + (CoreIndex(1), ParaId::from(1)), + (CoreIndex(2), ParaId::from(1)), + (CoreIndex(3), ParaId::from(2)), + (CoreIndex(4), ParaId::from(2)), + (CoreIndex(5), ParaId::from(2)), + ] + ); + let mut scheduled: BTreeMap> = BTreeMap::new(); + for (core_idx, para_id) in scheduler::Pallet::::scheduled_paras() { + scheduled.entry(para_id).or_default().insert(core_idx); + } + + assert_eq!( + shared::ActiveValidatorIndices::::get(), + vec![ + ValidatorIndex(0), + ValidatorIndex(1), + ValidatorIndex(2), + ValidatorIndex(3), + ValidatorIndex(4), + ValidatorIndex(5) + ] + ); + + TestData { + backed_candidates, + scheduled_paras: scheduled, + expected_backed_candidates_with_core, + } + } + #[rstest] #[case(false)] #[case(true)] @@ -3052,6 +3541,156 @@ mod sanitizers { }); } + #[rstest] + #[case(false)] + #[case(true)] + fn test_candidate_relay_parent_ordering(#[case] core_index_enabled: bool) { + // Para 1 scheduled on cores 0, 1 and 2. Three candidates are supplied but their relay + // parents look like this: 3, 2, 3. There are no pending availability candidates and the + // latest on-chain relay parent for this para is 0. + // Therefore, only the first candidate will get picked. + // + // Para 2 scheduled on cores 3, 4 and 5. Three candidates are supplied and their relay + // parents look like this: 2, 3, 3. There are no pending availability candidates and the + // latest on-chain relay parent for this para is 0. Therefore, all 3 will get picked. + new_test_ext(default_config()).execute_with(|| { + let TestData { + backed_candidates, + scheduled_paras: scheduled, + expected_backed_candidates_with_core, + } = get_test_data_for_relay_parent_ordering(core_index_enabled); + + assert_eq!( + sanitize_backed_candidates::( + backed_candidates.clone(), + &shared::AllowedRelayParents::::get(), + BTreeSet::new(), + scheduled, + core_index_enabled, + ), + expected_backed_candidates_with_core + ); + }); + + // Para 1 scheduled on cores 0, 1 and 2. Three candidates are supplied but their + // relay parents look like this: 3, 2, 3. There are no pending availability + // candidates but the latest on-chain relay parent for this para is 4. + // Therefore, no candidate will get picked. + // + // Para 2 scheduled on cores 3, 4 and 5. Three candidates are supplied and their relay + // parents look like this: 2, 3, 3. There are no pending availability candidates and the + // latest on-chain relay parent for this para is 2. Therefore, all 3 will get picked. + new_test_ext(default_config()).execute_with(|| { + let TestData { + backed_candidates, + scheduled_paras: scheduled, + expected_backed_candidates_with_core, + } = get_test_data_for_relay_parent_ordering(core_index_enabled); + + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(1), + BlockNumberFor::::from(4u32), + ) + .unwrap(); + + paras::Pallet::::force_set_most_recent_context( + RuntimeOrigin::root(), + ParaId::from(2), + BlockNumberFor::::from(2u32), + ) + .unwrap(); + + let res = sanitize_backed_candidates::( + backed_candidates.clone(), + &shared::AllowedRelayParents::::get(), + BTreeSet::new(), + scheduled, + core_index_enabled, + ); + + if core_index_enabled { + assert_eq!(res.len(), 1); + assert_eq!( + expected_backed_candidates_with_core.get(&ParaId::from(2)), + res.get(&ParaId::from(2)), + ); + } else { + assert!(res.is_empty()); + } + }); + + // Para 1 scheduled on cores 0, 1 and 2. Three candidates are supplied but their relay + // parents look like this: 3, 2, 3. + // The latest on-chain relay parent for this para is 0 but there is a pending + // availability candidate with relay parent 4. Therefore, no candidate will get + // picked. + // + // Para 2 scheduled on cores 3, 4 and 5. Three candidates are supplied and their relay + // parents look like this: 2, 3, 3. + // The latest on-chain relay parent for this para is 0 but there is a pending + // availability candidate with relay parent 2. Therefore, all 3 will get picked. + new_test_ext(default_config()).execute_with(|| { + let TestData { + backed_candidates, + scheduled_paras: scheduled, + expected_backed_candidates_with_core, + } = get_test_data_for_relay_parent_ordering(core_index_enabled); + + // For para 1, add a dummy pending candidate with relay parent 4. + let mut candidates = VecDeque::new(); + let mut commitments = backed_candidates[0].candidate().commitments.clone(); + commitments.head_data = paras::Heads::::get(&ParaId::from(1)).unwrap(); + candidates.push_back(inclusion::CandidatePendingAvailability::new( + CoreIndex(0), + CandidateHash(Hash::repeat_byte(1)), + backed_candidates[0].descriptor().clone(), + commitments, + Default::default(), + Default::default(), + 4, + 4, + GroupIndex(0), + )); + inclusion::PendingAvailability::::insert(ParaId::from(1), candidates); + + // For para 2, add a dummy pending candidate with relay parent 2. + let mut candidates = VecDeque::new(); + let mut commitments = backed_candidates[3].candidate().commitments.clone(); + commitments.head_data = paras::Heads::::get(&ParaId::from(2)).unwrap(); + candidates.push_back(inclusion::CandidatePendingAvailability::new( + CoreIndex(0), + CandidateHash(Hash::repeat_byte(2)), + backed_candidates[3].descriptor().clone(), + commitments, + Default::default(), + Default::default(), + 2, + 2, + GroupIndex(3), + )); + inclusion::PendingAvailability::::insert(ParaId::from(2), candidates); + + let res = sanitize_backed_candidates::( + backed_candidates.clone(), + &shared::AllowedRelayParents::::get(), + BTreeSet::new(), + scheduled, + core_index_enabled, + ); + + if core_index_enabled { + assert_eq!(res.len(), 1); + assert_eq!( + expected_backed_candidates_with_core.get(&ParaId::from(2)), + res.get(&ParaId::from(2)), + ); + } else { + assert!(res.is_empty()); + } + }); + } + // nothing is scheduled, so no paraids match, thus all backed candidates are skipped #[rstest] #[case(false, false)] diff --git a/polkadot/runtime/parachains/src/paras_inherent/weights.rs b/polkadot/runtime/parachains/src/paras_inherent/weights.rs index 0f4e5be572a66d16c1476ada7671c495a27bbc83..81c926a90e0bf81e427fe6ecfbb71c4c4c62f3b2 100644 --- a/polkadot/runtime/parachains/src/paras_inherent/weights.rs +++ b/polkadot/runtime/parachains/src/paras_inherent/weights.rs @@ -19,8 +19,9 @@ //! the relay chain, but we do care about the size of the block, by putting the tx in the //! proof_size we can use the already existing weight limiting code to limit the used size as well. -use parity_scale_codec::{Encode, WrapperTypeEncode}; -use primitives::{ +use crate::{configuration, inclusion}; +use codec::{Encode, WrapperTypeEncode}; +use polkadot_primitives::{ CheckedMultiDisputeStatementSet, MultiDisputeStatementSet, UncheckedSignedAvailabilityBitfield, UncheckedSignedAvailabilityBitfields, }; @@ -28,6 +29,8 @@ use primitives::{ use super::{BackedCandidate, Config, DisputeStatementSet, Weight}; pub trait WeightInfo { + /// The weight of processing an empty parachain inherent. + fn enter_empty() -> Weight; /// Variant over `v`, the count of dispute statements in a dispute statement set. This gives the /// weight of a single dispute statement set. fn enter_variable_disputes(v: u32) -> Weight; @@ -45,6 +48,9 @@ pub struct TestWeightInfo; // mock. #[cfg(not(feature = "runtime-benchmarks"))] impl WeightInfo for TestWeightInfo { + fn enter_empty() -> Weight { + Weight::zero() + } fn enter_variable_disputes(v: u32) -> Weight { // MAX Block Weight should fit 4 disputes Weight::from_parts(80_000 * v as u64 + 80_000, 0) @@ -66,6 +72,9 @@ impl WeightInfo for TestWeightInfo { // running as a test. #[cfg(feature = "runtime-benchmarks")] impl WeightInfo for TestWeightInfo { + fn enter_empty() -> Weight { + Weight::zero() + } fn enter_variable_disputes(_v: u32) -> Weight { Weight::zero() } @@ -88,6 +97,7 @@ pub fn paras_inherent_total_weight( backed_candidates_weight::(backed_candidates) .saturating_add(signed_bitfields_weight::(bitfields)) .saturating_add(multi_dispute_statement_sets_weight::(disputes)) + .saturating_add(enact_candidates_max_weight::(bitfields)) } pub fn multi_dispute_statement_sets_weight( @@ -123,7 +133,8 @@ where set_proof_size_to_tx_size( <::WeightInfo as WeightInfo>::enter_variable_disputes( statement_set.as_ref().statements.len() as u32, - ), + ) + .saturating_sub(<::WeightInfo as WeightInfo>::enter_empty()), statement_set, ) } @@ -133,6 +144,7 @@ pub fn signed_bitfields_weight( ) -> Weight { set_proof_size_to_tx_size( <::WeightInfo as WeightInfo>::enter_bitfields() + .saturating_sub(<::WeightInfo as WeightInfo>::enter_empty()) .saturating_mul(bitfields.len() as u64), bitfields, ) @@ -140,11 +152,33 @@ pub fn signed_bitfields_weight( pub fn signed_bitfield_weight(bitfield: &UncheckedSignedAvailabilityBitfield) -> Weight { set_proof_size_to_tx_size( - <::WeightInfo as WeightInfo>::enter_bitfields(), + <::WeightInfo as WeightInfo>::enter_bitfields() + .saturating_sub(<::WeightInfo as WeightInfo>::enter_empty()), bitfield, ) } +/// Worst case scenario is all candidates have been enacted +/// and process a maximum number of messages. +pub fn enact_candidates_max_weight( + bitfields: &UncheckedSignedAvailabilityBitfields, +) -> Weight { + let config = configuration::ActiveConfig::::get(); + let max_ump_msgs = config.max_upward_message_num_per_candidate; + let max_hrmp_msgs = config.hrmp_max_message_num_per_candidate; + // No bitfields - no enacted candidates + let bitfield_size = bitfields.first().map(|b| b.unchecked_payload().0.len()).unwrap_or(0); + set_proof_size_to_tx_size( + <::WeightInfo as inclusion::WeightInfo>::enact_candidate( + max_ump_msgs, + max_hrmp_msgs, + 1, // runtime upgrade + ) + .saturating_mul(bitfield_size as u64), + bitfields, + ) +} + pub fn backed_candidate_weight( candidate: &BackedCandidate, ) -> Weight { @@ -155,7 +189,8 @@ pub fn backed_candidate_weight( <::WeightInfo as WeightInfo>::enter_backed_candidates_variable( candidate.validity_votes().len() as u32, ) - }, + } + .saturating_sub(<::WeightInfo as WeightInfo>::enter_empty()), candidate, ) } diff --git a/polkadot/runtime/parachains/src/reward_points.rs b/polkadot/runtime/parachains/src/reward_points.rs index 3be743a2c55133da56e52b654bfa87f26ef596d1..69ef2db756c217e022cb37b5a0eefeeabb938171 100644 --- a/polkadot/runtime/parachains/src/reward_points.rs +++ b/polkadot/runtime/parachains/src/reward_points.rs @@ -22,9 +22,9 @@ //! for the time being, although we will build schemes to do so in the future. use crate::{session_info, shared}; +use alloc::collections::btree_set::BTreeSet; use frame_support::traits::{Defensive, ValidatorSet}; -use primitives::{SessionIndex, ValidatorIndex}; -use sp_std::collections::btree_set::BTreeSet; +use polkadot_primitives::{SessionIndex, ValidatorIndex}; /// The amount of era points given by backing a candidate that is included. pub const BACKING_POINTS: u32 = 20; @@ -32,7 +32,7 @@ pub const BACKING_POINTS: u32 = 20; pub const DISPUTE_STATEMENT_POINTS: u32 = 20; /// Rewards validators for participating in parachains with era points in pallet-staking. -pub struct RewardValidatorsWithEraPoints(sp_std::marker::PhantomData); +pub struct RewardValidatorsWithEraPoints(core::marker::PhantomData); impl RewardValidatorsWithEraPoints where diff --git a/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs b/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs index 3dca38050a0ac8c43bbb44cdd605572fd6760a82..697890232211315af749a365c95fa8cc23425450 100644 --- a/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs +++ b/polkadot/runtime/parachains/src/runtime_api_impl/v10.rs @@ -22,9 +22,10 @@ use crate::{ scheduler::{self, CoreOccupied}, session_info, shared, }; +use alloc::{collections::btree_map::BTreeMap, vec, vec::Vec}; use frame_support::traits::{GetStorageVersion, StorageVersion}; use frame_system::pallet_prelude::*; -use primitives::{ +use polkadot_primitives::{ async_backing::{ AsyncBackingParams, BackingState, CandidatePendingAvailability, Constraints, InboundHrmpLimitations, OutboundHrmpChannelLimitations, @@ -37,7 +38,6 @@ use primitives::{ ValidatorId, ValidatorIndex, ValidatorSignature, }; use sp_runtime::traits::One; -use sp_std::{collections::btree_map::BTreeMap, prelude::*}; /// Implementation for the `validators` function of the runtime API. pub fn validators() -> Vec { @@ -66,7 +66,7 @@ pub fn availability_cores() -> Vec::free_cores_and_fill_claimqueue(Vec::new(), now); + scheduler::Pallet::::free_cores_and_fill_claim_queue(Vec::new(), now); let time_out_for = scheduler::Pallet::::availability_timeout_predicate(); @@ -149,7 +149,10 @@ pub fn availability_cores() -> Vec { if let Some(para_id) = scheduled.get(&CoreIndex(i as _)).cloned() { - CoreState::Scheduled(primitives::ScheduledCore { para_id, collator: None }) + CoreState::Scheduled(polkadot_primitives::ScheduledCore { + para_id, + collator: None, + }) } else { CoreState::Free } @@ -161,7 +164,7 @@ pub fn availability_cores() -> Vec( ) -> (BlockNumberFor, ::Hash) { - use parity_scale_codec::Decode as _; + use codec::Decode as _; let state_version = frame_system::Pallet::::runtime_version().state_version(); let relay_parent_number = frame_system::Pallet::::block_number(); let relay_parent_storage_root = T::Hash::decode(&mut &sp_io::storage::root(state_version)[..]) @@ -241,7 +244,7 @@ pub fn assumed_validation_data( /// Implementation for the `check_validation_outputs` function of the runtime API. pub fn check_validation_outputs( para_id: ParaId, - outputs: primitives::CandidateCommitments, + outputs: polkadot_primitives::CandidateCommitments, ) -> bool { let relay_parent_number = frame_system::Pallet::::block_number(); inclusion::Pallet::::check_validation_outputs_for_runtime_api( @@ -302,7 +305,7 @@ pub fn validation_code( /// Implementation for the `candidate_pending_availability` function of the runtime API. #[deprecated( - note = "`candidate_pending_availability` will be removed. Use `candidates_pending_availability` to query + note = "`candidate_pending_availability` will be removed. Use `candidates_pending_availability` to query all candidates pending availability" )] pub fn candidate_pending_availability( diff --git a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs index 32bbdca84a3cce4946ce39edb4e3a3f8e5211188..4aa381e33b1bc2246abd3c16044cc56290597b12 100644 --- a/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs +++ b/polkadot/runtime/parachains/src/runtime_api_impl/vstaging.rs @@ -16,28 +16,37 @@ //! Put implementations of functions from staging APIs here. -use crate::{inclusion, initializer, scheduler}; -use primitives::{CommittedCandidateReceipt, CoreIndex, Id as ParaId}; -use sp_runtime::traits::One; -use sp_std::{ +use crate::{configuration, inclusion, initializer, scheduler}; +use alloc::{ collections::{btree_map::BTreeMap, vec_deque::VecDeque}, vec::Vec, }; +use polkadot_primitives::{CommittedCandidateReceipt, CoreIndex, Id as ParaId}; +use sp_runtime::traits::One; /// Returns the claimqueue from the scheduler pub fn claim_queue() -> BTreeMap> { let now = >::block_number() + One::one(); - // This explicit update is only strictly required for session boundaries: - // - // At the end of a session we clear the claim queues: Without this update call, nothing would be - // scheduled to the client. - >::free_cores_and_fill_claimqueue(Vec::new(), now); + // This is needed so that the claim queue always has the right size (equal to + // scheduling_lookahead). Otherwise, if a candidate is backed in the same block where the + // previous candidate is included, the claim queue will have already pop()-ed the next item + // from the queue and the length would be `scheduling_lookahead - 1`. + >::free_cores_and_fill_claim_queue(Vec::new(), now); + let config = configuration::ActiveConfig::::get(); + // Extra sanity, config should already never be smaller than 1: + let n_lookahead = config.scheduler_params.lookahead.max(1); scheduler::ClaimQueue::::get() .into_iter() .map(|(core_index, entries)| { - (core_index, entries.into_iter().map(|e| e.para_id()).collect()) + // on cores timing out internal claim queue size may be temporarily longer than it + // should be as the timed out assignment might got pushed back to an already full claim + // queue: + ( + core_index, + entries.into_iter().map(|e| e.para_id()).take(n_lookahead as usize).collect(), + ) }) .collect() } diff --git a/polkadot/runtime/parachains/src/scheduler.rs b/polkadot/runtime/parachains/src/scheduler.rs index baeec49839dfd03a9fb8fd71e7e88d2a3c79dc5c..445583d929aba9a82322f8fb94a70d38632a4f8f 100644 --- a/polkadot/runtime/parachains/src/scheduler.rs +++ b/polkadot/runtime/parachains/src/scheduler.rs @@ -36,18 +36,23 @@ //! number of groups as availability cores. Validator groups will be assigned to different //! availability cores over time. +use core::iter::Peekable; + use crate::{configuration, initializer::SessionChangeNotification, paras}; +use alloc::{ + collections::{ + btree_map::{self, BTreeMap}, + vec_deque::VecDeque, + }, + vec::Vec, +}; use frame_support::{pallet_prelude::*, traits::Defensive}; use frame_system::pallet_prelude::BlockNumberFor; pub use polkadot_core_primitives::v2::BlockNumber; -use primitives::{ +use polkadot_primitives::{ CoreIndex, GroupIndex, GroupRotationInfo, Id as ParaId, ScheduledCore, ValidatorIndex, }; use sp_runtime::traits::One; -use sp_std::{ - collections::{btree_map::BTreeMap, vec_deque::VecDeque}, - prelude::*, -}; pub mod common; @@ -190,7 +195,29 @@ pub mod pallet { } } -type PositionInClaimqueue = u32; +type PositionInClaimQueue = u32; + +struct ClaimQueueIterator { + next_idx: u32, + queue: Peekable>>, +} + +impl Iterator for ClaimQueueIterator { + type Item = (CoreIndex, VecDeque); + + fn next(&mut self) -> Option { + let (idx, _) = self.queue.peek()?; + let val = if idx != &CoreIndex(self.next_idx) { + log::trace!(target: LOG_TARGET, "idx did not match claim queue idx: {:?} vs {:?}", idx, self.next_idx); + (CoreIndex(self.next_idx), VecDeque::new()) + } else { + let (idx, q) = self.queue.next()?; + (idx, q) + }; + self.next_idx += 1; + Some(val) + } +} impl Pallet { /// Called by the initializer to initialize the scheduler pallet. @@ -203,7 +230,7 @@ impl Pallet { /// Called before the initializer notifies of a new session. pub(crate) fn pre_new_session() { - Self::push_claimqueue_items_to_assignment_provider(); + Self::push_claim_queue_items_to_assignment_provider(); Self::push_occupied_cores_to_assignment_provider(); } @@ -287,10 +314,8 @@ impl Pallet { .into_iter() .filter(|(freed_index, _)| (freed_index.0 as usize) < c_len) .for_each(|(freed_index, freed_reason)| { - match sp_std::mem::replace( - &mut cores[freed_index.0 as usize], - CoreOccupied::Free, - ) { + match core::mem::replace(&mut cores[freed_index.0 as usize], CoreOccupied::Free) + { CoreOccupied::Free => {}, CoreOccupied::Paras(entry) => { match freed_reason { @@ -309,37 +334,54 @@ impl Pallet { (concluded_paras, timedout_paras) } - /// Note that the given cores have become occupied. Update the claimqueue accordingly. + /// Get an iterator into the claim queues. + /// + /// This iterator will have an item for each and every core index up to the maximum core index + /// found in the claim queue. In other words there will be no holes/missing core indices, + /// between core 0 and the maximum, even if the claim queue was missing entries for particular + /// indices in between. (The iterator will return an empty `VecDeque` for those indices. + fn claim_queue_iterator() -> impl Iterator>)> { + let queues = ClaimQueue::::get(); + return ClaimQueueIterator::> { + next_idx: 0, + queue: queues.into_iter().peekable(), + } + } + + /// Note that the given cores have become occupied. Update the claim queue accordingly. + /// This will not push a new entry onto the claim queue, so the length after this call will be + /// the expected length - 1. The claim_queue runtime API will take care of adding another entry + /// here, to ensure the right lookahead. pub(crate) fn occupied( now_occupied: BTreeMap, - ) -> BTreeMap { + ) -> BTreeMap { let mut availability_cores = AvailabilityCores::::get(); log::debug!(target: LOG_TARGET, "[occupied] now_occupied {:?}", now_occupied); - let pos_mapping: BTreeMap = now_occupied + let pos_mapping: BTreeMap = now_occupied .iter() .flat_map(|(core_idx, para_id)| { - match Self::remove_from_claimqueue(*core_idx, *para_id) { + match Self::remove_from_claim_queue(*core_idx, *para_id) { Err(e) => { log::debug!( target: LOG_TARGET, - "[occupied] error on remove_from_claimqueue {}", + "[occupied] error on remove_from_claim queue {}", e ); None }, - Ok((pos_in_claimqueue, pe)) => { + Ok((pos_in_claim_queue, pe)) => { availability_cores[core_idx.0 as usize] = CoreOccupied::Paras(pe); - Some((*core_idx, pos_in_claimqueue)) + Some((*core_idx, pos_in_claim_queue)) }, } }) .collect(); // Drop expired claims after processing now_occupied. - Self::drop_expired_claims_from_claimqueue(); + Self::drop_expired_claims_from_claim_queue(); AvailabilityCores::::set(availability_cores); @@ -349,7 +391,7 @@ impl Pallet { /// Iterates through every element in all claim queues and tries to add new assignments from the /// `AssignmentProvider`. A claim is considered expired if it's `ttl` field is lower than the /// current block height. - fn drop_expired_claims_from_claimqueue() { + fn drop_expired_claims_from_claim_queue() { let now = frame_system::Pallet::::block_number(); let availability_cores = AvailabilityCores::::get(); let ttl = configuration::ActiveConfig::::get().scheduler_params.ttl; @@ -357,13 +399,13 @@ impl Pallet { ClaimQueue::::mutate(|cq| { for (idx, _) in (0u32..).zip(availability_cores) { let core_idx = CoreIndex(idx); - if let Some(core_claimqueue) = cq.get_mut(&core_idx) { + if let Some(core_claim_queue) = cq.get_mut(&core_idx) { let mut i = 0; let mut num_dropped = 0; - while i < core_claimqueue.len() { - let maybe_dropped = if let Some(entry) = core_claimqueue.get(i) { + while i < core_claim_queue.len() { + let maybe_dropped = if let Some(entry) = core_claim_queue.get(i) { if entry.ttl < now { - core_claimqueue.remove(i) + core_claim_queue.remove(i) } else { None } @@ -381,11 +423,11 @@ impl Pallet { for _ in 0..num_dropped { // For all claims dropped due to TTL, attempt to pop a new entry to - // the back of the claimqueue. + // the back of the claim queue. if let Some(assignment) = T::AssignmentProvider::pop_assignment_for_core(core_idx) { - core_claimqueue.push_back(ParasEntry::new(assignment, now + ttl)); + core_claim_queue.push_back(ParasEntry::new(assignment, now + ttl)); } } } @@ -525,7 +567,7 @@ impl Pallet { fn push_occupied_cores_to_assignment_provider() { AvailabilityCores::::mutate(|cores| { for core in cores.iter_mut() { - match sp_std::mem::replace(core, CoreOccupied::Free) { + match core::mem::replace(core, CoreOccupied::Free) { CoreOccupied::Free => continue, CoreOccupied::Paras(entry) => { Self::maybe_push_assignment(entry); @@ -536,10 +578,10 @@ impl Pallet { } // on new session - fn push_claimqueue_items_to_assignment_provider() { + fn push_claim_queue_items_to_assignment_provider() { for (_, claim_queue) in ClaimQueue::::take() { // Push back in reverse order so that when we pop from the provider again, - // the entries in the claimqueue are in the same order as they are right now. + // the entries in the claim queue are in the same order as they are right now. for para_entry in claim_queue.into_iter().rev() { Self::maybe_push_assignment(para_entry); } @@ -554,15 +596,8 @@ impl Pallet { } } - // - // ClaimQueue related functions - // - fn claimqueue_lookahead() -> u32 { - configuration::ActiveConfig::::get().scheduler_params.lookahead - } - - /// Frees cores and fills the free claimqueue spots by popping from the `AssignmentProvider`. - pub fn free_cores_and_fill_claimqueue( + /// Frees cores and fills the free claim queue spots by popping from the `AssignmentProvider`. + pub fn free_cores_and_fill_claim_queue( just_freed_cores: impl IntoIterator, now: BlockNumberFor, ) { @@ -573,26 +608,33 @@ impl Pallet { if ValidatorGroups::::decode_len().map_or(true, |l| l == 0) { return } - // If there exists a core, ensure we schedule at least one job onto it. - let n_lookahead = Self::claimqueue_lookahead().max(1); let n_session_cores = T::AssignmentProvider::session_core_count(); let cq = ClaimQueue::::get(); let config = configuration::ActiveConfig::::get(); + // Extra sanity, config should already never be smaller than 1: + let n_lookahead = config.scheduler_params.lookahead.max(1); let max_availability_timeouts = config.scheduler_params.max_availability_timeouts; let ttl = config.scheduler_params.ttl; for core_idx in 0..n_session_cores { let core_idx = CoreIndex::from(core_idx); + let n_lookahead_used = cq.get(&core_idx).map_or(0, |v| v.len() as u32); + // add previously timedout paras back into the queue if let Some(mut entry) = timedout_paras.remove(&core_idx) { if entry.availability_timeouts < max_availability_timeouts { // Increment the timeout counter. entry.availability_timeouts += 1; - // Reset the ttl so that a timed out assignment. - entry.ttl = now + ttl; - Self::add_to_claimqueue(core_idx, entry); - // The claim has been added back into the claimqueue. + if n_lookahead_used < n_lookahead { + entry.ttl = now + ttl; + } else { + // Over max capacity, we need to bump ttl (we exceeded the claim queue + // size, so otherwise the entry might get dropped before reaching the top): + entry.ttl = now + ttl + One::one(); + } + Self::add_to_claim_queue(core_idx, entry); + // The claim has been added back into the claim queue. // Do not pop another assignment for the core. continue } else { @@ -606,12 +648,9 @@ impl Pallet { if let Some(concluded_para) = concluded_paras.remove(&core_idx) { T::AssignmentProvider::report_processed(concluded_para); } - // We consider occupied cores to be part of the claimqueue - let n_lookahead_used = cq.get(&core_idx).map_or(0, |v| v.len() as u32) + - if Self::is_core_occupied(core_idx) { 1 } else { 0 }; for _ in n_lookahead_used..n_lookahead { if let Some(assignment) = T::AssignmentProvider::pop_assignment_for_core(core_idx) { - Self::add_to_claimqueue(core_idx, ParasEntry::new(assignment, now + ttl)); + Self::add_to_claim_queue(core_idx, ParasEntry::new(assignment, now + ttl)); } } } @@ -620,24 +659,17 @@ impl Pallet { debug_assert!(concluded_paras.is_empty()); } - fn is_core_occupied(core_idx: CoreIndex) -> bool { - match AvailabilityCores::::get().get(core_idx.0 as usize) { - None | Some(CoreOccupied::Free) => false, - Some(CoreOccupied::Paras(_)) => true, - } - } - - fn add_to_claimqueue(core_idx: CoreIndex, pe: ParasEntryType) { + fn add_to_claim_queue(core_idx: CoreIndex, pe: ParasEntryType) { ClaimQueue::::mutate(|la| { la.entry(core_idx).or_default().push_back(pe); }); } /// Returns `ParasEntry` with `para_id` at `core_idx` if found. - fn remove_from_claimqueue( + fn remove_from_claim_queue( core_idx: CoreIndex, para_id: ParaId, - ) -> Result<(PositionInClaimqueue, ParasEntryType), &'static str> { + ) -> Result<(PositionInClaimQueue, ParasEntryType), &'static str> { ClaimQueue::::mutate(|cq| { let core_claims = cq.get_mut(&core_idx).ok_or("core_idx not found in lookahead")?; @@ -654,20 +686,38 @@ impl Pallet { /// Paras scheduled next in the claim queue. pub(crate) fn scheduled_paras() -> impl Iterator { - let claimqueue = ClaimQueue::::get(); - claimqueue + let claim_queue = ClaimQueue::::get(); + claim_queue .into_iter() .filter_map(|(core_idx, v)| v.front().map(|e| (core_idx, e.assignment.para_id()))) } + /// Paras that may get backed on cores. + /// + /// 1. The para must be scheduled on core. + /// 2. Core needs to be free, otherwise backing is not possible. + pub(crate) fn eligible_paras() -> impl Iterator { + let availability_cores = AvailabilityCores::::get(); + + Self::claim_queue_iterator().zip(availability_cores.into_iter()).filter_map( + |((core_idx, queue), core)| { + if core != CoreOccupied::Free { + return None + } + let next_scheduled = queue.front()?; + Some((core_idx, next_scheduled.assignment.para_id())) + }, + ) + } + #[cfg(any(feature = "try-runtime", test))] - fn claimqueue_len() -> usize { + fn claim_queue_len() -> usize { ClaimQueue::::get().iter().map(|la_vec| la_vec.1.len()).sum() } #[cfg(all(not(feature = "runtime-benchmarks"), test))] - pub(crate) fn claimqueue_is_empty() -> bool { - Self::claimqueue_len() == 0 + pub(crate) fn claim_queue_is_empty() -> bool { + Self::claim_queue_len() == 0 } #[cfg(test)] @@ -676,7 +726,7 @@ impl Pallet { } #[cfg(test)] - pub(crate) fn set_claimqueue(claimqueue: BTreeMap>>) { - ClaimQueue::::set(claimqueue); + pub(crate) fn set_claim_queue(claim_queue: BTreeMap>>) { + ClaimQueue::::set(claim_queue); } } diff --git a/polkadot/runtime/parachains/src/scheduler/common.rs b/polkadot/runtime/parachains/src/scheduler/common.rs index 66a4e6d30be0830650295d5311b7d7e1fc3b1d20..114cd4b940bcdbeacdf0cbb7f62e74fc09dbad4d 100644 --- a/polkadot/runtime/parachains/src/scheduler/common.rs +++ b/polkadot/runtime/parachains/src/scheduler/common.rs @@ -22,7 +22,7 @@ use sp_runtime::{ RuntimeDebug, }; -use primitives::{CoreIndex, Id as ParaId}; +use polkadot_primitives::{CoreIndex, Id as ParaId}; /// Assignment (ParaId -> CoreIndex). #[derive(Encode, Decode, TypeInfo, RuntimeDebug, Clone, PartialEq)] diff --git a/polkadot/runtime/parachains/src/scheduler/migration.rs b/polkadot/runtime/parachains/src/scheduler/migration.rs index 5482c8821e58c7bdf8fd29b4607837355640a1f3..125f105ef70668c8ebacfdb9e2b267b9d00bfcbf 100644 --- a/polkadot/runtime/parachains/src/scheduler/migration.rs +++ b/polkadot/runtime/parachains/src/scheduler/migration.rs @@ -17,6 +17,7 @@ //! A module that is responsible for migration of storage. use super::*; +use alloc::vec::Vec; use frame_support::{ migrations::VersionedMigration, pallet_prelude::ValueQuery, storage_alias, traits::UncheckedOnRuntimeUpgrade, weights::Weight, @@ -34,7 +35,7 @@ struct V0Assignment { /// Old scheduler with explicit parathreads and `Scheduled` storage instead of `ClaimQueue`. mod v0 { use super::*; - use primitives::{CollatorId, Id}; + use polkadot_primitives::{CollatorId, Id}; #[storage_alias] pub(super) type Scheduled = StorageValue, Vec, ValueQuery>; @@ -164,7 +165,7 @@ mod v1 { } /// Migration to V1 - pub struct UncheckedMigrateToV1(sp_std::marker::PhantomData); + pub struct UncheckedMigrateToV1(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrateToV1 { fn on_runtime_upgrade() -> Weight { let mut weight: Weight = Weight::zero(); @@ -248,7 +249,7 @@ mod v1 { .count(); ensure!( - Pallet::::claimqueue_len() as u32 + availability_cores_waiting as u32 == + Pallet::::claim_queue_len() as u32 + availability_cores_waiting as u32 == expected_len, "ClaimQueue and AvailabilityCores should have the correct length", ); @@ -301,7 +302,7 @@ mod v2 { } /// Migration to V2 - pub struct UncheckedMigrateToV2(sp_std::marker::PhantomData); + pub struct UncheckedMigrateToV2(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for UncheckedMigrateToV2 { fn on_runtime_upgrade() -> Weight { diff --git a/polkadot/runtime/parachains/src/scheduler/tests.rs b/polkadot/runtime/parachains/src/scheduler/tests.rs index 200f49ff2e820cd2716f25693628173c56b0f4aa..5f80114b596368135e91ca59ca9c7e6f0b59510f 100644 --- a/polkadot/runtime/parachains/src/scheduler/tests.rs +++ b/polkadot/runtime/parachains/src/scheduler/tests.rs @@ -16,12 +16,12 @@ use super::*; +use alloc::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; use frame_support::assert_ok; -use keyring::Sr25519Keyring; -use primitives::{ - vstaging::SchedulerParams, BlockNumber, SessionIndex, ValidationCode, ValidatorId, +use polkadot_primitives::{ + BlockNumber, SchedulerParams, SessionIndex, ValidationCode, ValidatorId, }; -use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; +use sp_keyring::Sr25519Keyring; use crate::{ configuration::HostConfiguration, @@ -80,7 +80,7 @@ fn run_to_block( Scheduler::initializer_initialize(b + 1); // In the real runtime this is expected to be called by the `InclusionInherent` pallet. - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), b + 1); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), b + 1); } } @@ -158,6 +158,37 @@ fn scheduled_entries() -> impl Iterator(vec![para_id])); // Claim is dropped post call. - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); assert!(!claimqueue_contains_para_ids::(vec![para_id])); // Add a claim on core 0 with a ttl in the future (15). let paras_entry = ParasEntry::new(Assignment::Bulk(para_id), now + 5); - Scheduler::add_to_claimqueue(core_idx, paras_entry.clone()); + Scheduler::add_to_claim_queue(core_idx, paras_entry.clone()); // Claim is in queue post call. - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); assert!(claimqueue_contains_para_ids::(vec![para_id])); now = now + 6; run_to_block(now, |_| None); // Claim is dropped - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); assert!(!claimqueue_contains_para_ids::(vec![para_id])); // Add a claim on core 0 with a ttl == now (16) let paras_entry = ParasEntry::new(Assignment::Bulk(para_id), now); - Scheduler::add_to_claimqueue(core_idx, paras_entry.clone()); + Scheduler::add_to_claim_queue(core_idx, paras_entry.clone()); // Claim is in queue post call. - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); assert!(claimqueue_contains_para_ids::(vec![para_id])); now = now + 1; run_to_block(now, |_| None); // Drop expired claim. - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); assert!(!claimqueue_contains_para_ids::(vec![para_id])); // Add a claim on core 0 with a ttl == now (17) let paras_entry_non_expired = ParasEntry::new(Assignment::Bulk(para_id), now); let paras_entry_expired = ParasEntry::new(Assignment::Bulk(para_id), now - 2); // ttls = [17, 15, 17] - Scheduler::add_to_claimqueue(core_idx, paras_entry_non_expired.clone()); - Scheduler::add_to_claimqueue(core_idx, paras_entry_expired.clone()); - Scheduler::add_to_claimqueue(core_idx, paras_entry_non_expired.clone()); + Scheduler::add_to_claim_queue(core_idx, paras_entry_non_expired.clone()); + Scheduler::add_to_claim_queue(core_idx, paras_entry_expired.clone()); + Scheduler::add_to_claim_queue(core_idx, paras_entry_non_expired.clone()); let cq = scheduler::ClaimQueue::::get(); assert_eq!(cq.get(&core_idx).unwrap().len(), 3); @@ -231,7 +262,7 @@ fn claimqueue_ttl_drop_fn_works() { MockAssigner::add_test_assignment(assignment.clone()); // Drop expired claim. - Scheduler::drop_expired_claims_from_claimqueue(); + Scheduler::drop_expired_claims_from_claim_queue(); let cq = scheduler::ClaimQueue::::get(); let cqc = cq.get(&core_idx).unwrap(); @@ -378,7 +409,7 @@ fn fill_claimqueue_fills() { run_to_block(2, |_| None); { - assert_eq!(Scheduler::claimqueue_len(), 3); + assert_eq!(Scheduler::claim_queue_len(), 3); let scheduled: BTreeMap<_, _> = scheduled_entries().collect(); // Was added a block later, note the TTL. @@ -488,9 +519,8 @@ fn schedule_schedules_including_just_freed() { .for_each(|(_core_idx, core_queue)| assert_eq!(core_queue.len(), 0)) } - // add a couple more para claims - the claim on `b` will go to the 3rd core - // (2) and the claim on `d` will go back to the 1st para core (0). The claim on `e` - // then will go for core `1`. + MockAssigner::add_test_assignment(assignment_a.clone()); + MockAssigner::add_test_assignment(assignment_c.clone()); MockAssigner::add_test_assignment(assignment_b.clone()); MockAssigner::add_test_assignment(assignment_d.clone()); MockAssigner::add_test_assignment(assignment_e.clone()); @@ -500,8 +530,7 @@ fn schedule_schedules_including_just_freed() { { let scheduled: BTreeMap<_, _> = scheduled_entries().collect(); - // cores 0 and 1 are occupied by claims. core 2 was free. - assert_eq!(scheduled.len(), 1); + assert_eq!(scheduled.len(), 3); assert_eq!( scheduled.get(&CoreIndex(2)).unwrap(), &ParasEntry { @@ -519,7 +548,7 @@ fn schedule_schedules_including_just_freed() { ] .into_iter() .collect(); - Scheduler::free_cores_and_fill_claimqueue(just_updated, now); + Scheduler::free_cores_and_fill_claim_queue(just_updated, now); { let scheduled: BTreeMap<_, _> = scheduled_entries().collect(); @@ -529,17 +558,28 @@ fn schedule_schedules_including_just_freed() { assert_eq!( scheduled.get(&CoreIndex(0)).unwrap(), &ParasEntry { - assignment: Assignment::Bulk(para_d), + // Next entry in queue is `a` again: + assignment: Assignment::Bulk(para_a), availability_timeouts: 0, ttl: 8 }, ); // Although C was descheduled, the core `2` was occupied so C goes back to the queue. + assert_eq!( + scheduler::ClaimQueue::::get()[&CoreIndex(1)][1], + ParasEntry { + assignment: Assignment::Bulk(para_c), + // End of the queue should be the pushed back entry: + availability_timeouts: 1, + // ttl 1 higher: + ttl: 9 + }, + ); assert_eq!( scheduled.get(&CoreIndex(1)).unwrap(), &ParasEntry { assignment: Assignment::Bulk(para_c), - availability_timeouts: 1, + availability_timeouts: 0, ttl: 8 }, ); @@ -552,8 +592,6 @@ fn schedule_schedules_including_just_freed() { }, ); - // Para A claim should have been wiped, but para C claim should remain. - assert!(!claimqueue_contains_para_ids::(vec![para_a])); assert!(claimqueue_contains_para_ids::(vec![para_c])); assert!(!availability_cores_contains_para_ids::(vec![para_a, para_c])); } @@ -627,12 +665,13 @@ fn schedule_clears_availability_cores() { // Add more assignments MockAssigner::add_test_assignment(assignment_a.clone()); + MockAssigner::add_test_assignment(assignment_b.clone()); MockAssigner::add_test_assignment(assignment_c.clone()); run_to_block(3, |_| None); // now note that cores 0 and 2 were freed. - Scheduler::free_cores_and_fill_claimqueue( + Scheduler::free_cores_and_fill_claim_queue( vec![(CoreIndex(0), FreedReason::Concluded), (CoreIndex(2), FreedReason::Concluded)] .into_iter() .collect::>(), @@ -807,7 +846,7 @@ fn on_demand_claims_are_pruned_after_timing_out() { ] .into_iter() .collect(); - Scheduler::free_cores_and_fill_claimqueue(just_updated, now); + Scheduler::free_cores_and_fill_claim_queue(just_updated, now); // ParaId a exists in the claim queue until max_retries is reached. if n < max_timeouts + now { @@ -854,7 +893,7 @@ fn on_demand_claims_are_pruned_after_timing_out() { } } - Scheduler::free_cores_and_fill_claimqueue(just_updated, now); + Scheduler::free_cores_and_fill_claim_queue(just_updated, now); // ParaId a exists in the claim queue until groups are rotated. if n < 31 { @@ -943,12 +982,12 @@ fn next_up_on_available_uses_next_scheduled_or_none() { ttl: 5 as u32, }; - Scheduler::add_to_claimqueue(CoreIndex(0), entry_a.clone()); + Scheduler::add_to_claim_queue(CoreIndex(0), entry_a.clone()); run_to_block(2, |_| None); { - assert_eq!(Scheduler::claimqueue_len(), 1); + assert_eq!(Scheduler::claim_queue_len(), 1); assert_eq!(scheduler::AvailabilityCores::::get().len(), 1); let mut map = BTreeMap::new(); @@ -963,7 +1002,7 @@ fn next_up_on_available_uses_next_scheduled_or_none() { assert!(Scheduler::next_up_on_available(CoreIndex(0)).is_none()); - Scheduler::add_to_claimqueue(CoreIndex(0), entry_b); + Scheduler::add_to_claim_queue(CoreIndex(0), entry_b); assert_eq!( Scheduler::next_up_on_available(CoreIndex(0)).unwrap(), @@ -1032,7 +1071,7 @@ fn next_up_on_time_out_reuses_claim_if_nothing_queued() { MockAssigner::add_test_assignment(assignment_b.clone()); // Pop assignment_b into the claimqueue - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 2); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 2); //// Now that there is an earlier next-up, we use that. assert_eq!( @@ -1113,7 +1152,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() { _ => None, }); - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 3); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 3); assert_eq!( scheduler::ClaimQueue::::get(), @@ -1161,7 +1200,7 @@ fn session_change_requires_reschedule_dropping_removed_paras() { let groups = ValidatorGroups::::get(); assert_eq!(groups.len(), 5); - Scheduler::free_cores_and_fill_claimqueue(BTreeMap::new(), 4); + Scheduler::free_cores_and_fill_claim_queue(BTreeMap::new(), 4); assert_eq!( scheduler::ClaimQueue::::get(), diff --git a/polkadot/runtime/parachains/src/session_info.rs b/polkadot/runtime/parachains/src/session_info.rs index 2f7f1ead76ade121d5ed06182cb7f69bf2ba71c4..ea05c1aacaa946aa50bcb68e69930acbd60d79eb 100644 --- a/polkadot/runtime/parachains/src/session_info.rs +++ b/polkadot/runtime/parachains/src/session_info.rs @@ -24,13 +24,15 @@ use crate::{ configuration, paras, scheduler, shared, util::{take_active_subset, take_active_subset_and_inactive}, }; +use alloc::vec::Vec; use frame_support::{ pallet_prelude::*, traits::{OneSessionHandler, ValidatorSet, ValidatorSetWithIdentification}, }; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{AssignmentId, AuthorityDiscoveryId, ExecutorParams, SessionIndex, SessionInfo}; -use sp_std::vec::Vec; +use polkadot_primitives::{ + AssignmentId, AuthorityDiscoveryId, ExecutorParams, SessionIndex, SessionInfo, +}; pub use pallet::*; diff --git a/polkadot/runtime/parachains/src/session_info/tests.rs b/polkadot/runtime/parachains/src/session_info/tests.rs index 18b9d8f59010eb49a26768ad31a3c3296d65b41a..aec0ff56e670be84c088974de2c36c8bb02f5a39 100644 --- a/polkadot/runtime/parachains/src/session_info/tests.rs +++ b/polkadot/runtime/parachains/src/session_info/tests.rs @@ -24,8 +24,8 @@ use crate::{ }, util::take_active_subset, }; -use keyring::Sr25519Keyring; -use primitives::{vstaging::SchedulerParams, BlockNumber, ValidatorId, ValidatorIndex}; +use polkadot_primitives::{BlockNumber, SchedulerParams, ValidatorId, ValidatorIndex}; +use sp_keyring::Sr25519Keyring; fn run_to_block( to: BlockNumber, diff --git a/polkadot/runtime/parachains/src/shared.rs b/polkadot/runtime/parachains/src/shared.rs index 319b22515889568b7e29f84a4710f0ff5e10d8d0..154b7cfefc3aca68b3773b49194dba7038feccc5 100644 --- a/polkadot/runtime/parachains/src/shared.rs +++ b/polkadot/runtime/parachains/src/shared.rs @@ -19,14 +19,14 @@ //! To avoid cyclic dependencies, it is important that this pallet is not //! dependent on any of the other pallets. -use frame_support::{pallet_prelude::*, traits::DisabledValidators}; -use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{SessionIndex, ValidatorId, ValidatorIndex}; -use sp_runtime::traits::AtLeast32BitUnsigned; -use sp_std::{ +use alloc::{ collections::{btree_map::BTreeMap, vec_deque::VecDeque}, vec::Vec, }; +use frame_support::{pallet_prelude::*, traits::DisabledValidators}; +use frame_system::pallet_prelude::BlockNumberFor; +use polkadot_primitives::{SessionIndex, ValidatorId, ValidatorIndex}; +use sp_runtime::traits::AtLeast32BitUnsigned; use rand::{seq::SliceRandom, SeedableRng}; use rand_chacha::ChaCha20Rng; diff --git a/polkadot/runtime/parachains/src/shared/tests.rs b/polkadot/runtime/parachains/src/shared/tests.rs index 4ae37463a6d9d010332de3346750dc7d57156861..e47d1fd9cfe0d43adaf9b6c3f9befd2d604d2c8c 100644 --- a/polkadot/runtime/parachains/src/shared/tests.rs +++ b/polkadot/runtime/parachains/src/shared/tests.rs @@ -21,9 +21,9 @@ use crate::{ shared, }; use assert_matches::assert_matches; -use keyring::Sr25519Keyring; -use primitives::Hash; -use test_helpers::validator_pubkeys; +use polkadot_primitives::Hash; +use polkadot_primitives_test_helpers::validator_pubkeys; +use sp_keyring::Sr25519Keyring; #[test] fn tracker_earliest_block_number() { diff --git a/polkadot/runtime/parachains/src/ump_tests.rs b/polkadot/runtime/parachains/src/ump_tests.rs index 43829974b5693ea9f57494722cad54600b1beb7b..d914bf8b666120fba1c3db2f85f3420427fb9186 100644 --- a/polkadot/runtime/parachains/src/ump_tests.rs +++ b/polkadot/runtime/parachains/src/ump_tests.rs @@ -31,10 +31,9 @@ use frame_support::{ traits::{EnqueueMessage, ExecuteOverweightError, ServiceQueues}, weights::Weight, }; -use primitives::{well_known_keys, Id as ParaId, UpwardMessage}; +use polkadot_primitives::{well_known_keys, Id as ParaId, UpwardMessage}; use sp_crypto_hashing::{blake2_256, twox_64}; use sp_runtime::traits::Bounded; -use sp_std::prelude::*; pub(super) struct GenesisConfigBuilder { max_upward_message_size: u32, @@ -426,7 +425,7 @@ fn relay_dispatch_queue_size_key_is_correct() { // A "random" para id. let para: ParaId = u32::from_ne_bytes(twox_64(&i.encode())[..4].try_into().unwrap()).into(); - let well_known = primitives::well_known_keys::relay_dispatch_queue_size(para); + let well_known = polkadot_primitives::well_known_keys::relay_dispatch_queue_size(para); let aliased = RelayDispatchQueueSize::hashed_key_for(para); assert_eq!(well_known, aliased, "Old and new key must match"); diff --git a/polkadot/runtime/parachains/src/util.rs b/polkadot/runtime/parachains/src/util.rs index 5aa2d58da3c9bd70ec8ec201a59705c21faffb9b..3588e494438d066ffd925b2b2cc486431b8feab8 100644 --- a/polkadot/runtime/parachains/src/util.rs +++ b/polkadot/runtime/parachains/src/util.rs @@ -17,9 +17,9 @@ //! Utilities that don't belong to any particular module but may draw //! on all modules. +use alloc::{collections::btree_set::BTreeSet, vec::Vec}; use frame_system::pallet_prelude::BlockNumberFor; -use primitives::{HeadData, Id as ParaId, PersistedValidationData, ValidatorIndex}; -use sp_std::{collections::btree_set::BTreeSet, vec::Vec}; +use polkadot_primitives::{HeadData, Id as ParaId, PersistedValidationData, ValidatorIndex}; use crate::{configuration, hrmp, paras}; @@ -118,10 +118,10 @@ pub fn take_active_subset(active: &[ValidatorIndex], set: &[T]) -> Vec #[cfg(test)] mod tests { - use sp_std::vec::Vec; + use alloc::vec::Vec; use crate::util::{split_active_subset, take_active_subset}; - use primitives::ValidatorIndex; + use polkadot_primitives::ValidatorIndex; #[test] fn take_active_subset_is_compatible_with_split_active_subset() { diff --git a/polkadot/runtime/rococo/Cargo.toml b/polkadot/runtime/rococo/Cargo.toml index f4d8fb51b3fa2bfa95bd409cd8bd7a2aec17c1f8..4aaaf94da5865e8c97406c11e443267733a2280b 100644 --- a/polkadot/runtime/rococo/Cargo.toml +++ b/polkadot/runtime/rococo/Cargo.toml @@ -11,138 +11,133 @@ license.workspace = true workspace = true [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +scale-info = { features = ["derive"], workspace = true } log = { workspace = true } serde = { workspace = true } serde_derive = { optional = true, workspace = true } serde_json = { features = ["alloc"], workspace = true } -static_assertions = "1.1.0" -smallvec = "1.8.0" -bitvec = { version = "1.0.1", default-features = false, features = ["alloc"] } +static_assertions = { workspace = true, default-features = true } +smallvec = { workspace = true, default-features = true } +bitvec = { features = ["alloc"], workspace = true } -authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false } -babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false } -grandpa_primitives = { package = "sp-consensus-grandpa", path = "../../../substrate/primitives/consensus/grandpa", default-features = false } -binary-merkle-tree = { path = "../../../substrate/utils/binary-merkle-tree", default-features = false } -rococo-runtime-constants = { package = "rococo-runtime-constants", path = "constants", default-features = false } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -sp-genesis-builder = { path = "../../../substrate/primitives/genesis-builder", default-features = false } -inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false } -offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false } -sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-range", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-storage = { path = "../../../substrate/primitives/storage", default-features = false } -sp-version = { path = "../../../substrate/primitives/version", default-features = false } -tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false } -block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false } +sp-authority-discovery = { workspace = true } +sp-consensus-babe = { workspace = true } +sp-consensus-beefy = { workspace = true } +sp-consensus-grandpa = { workspace = true } +binary-merkle-tree = { workspace = true } +rococo-runtime-constants = { workspace = true } +sp-api = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-arithmetic = { workspace = true } +sp-io = { workspace = true } +sp-mmr-primitives = { workspace = true } +sp-runtime = { workspace = true } +sp-staking = { workspace = true } +sp-core = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-version = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-block-builder = { workspace = true } -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-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-child-bounties = { path = "../../../substrate/frame/child-bounties", default-features = false } -pallet-state-trie-migration = { path = "../../../substrate/frame/state-trie-migration", default-features = false } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-collective = { path = "../../../substrate/frame/collective", default-features = false } -pallet-conviction-voting = { path = "../../../substrate/frame/conviction-voting", default-features = false } -pallet-democracy = { path = "../../../substrate/frame/democracy", default-features = false } -pallet-elections-phragmen = { path = "../../../substrate/frame/elections-phragmen", default-features = false } -pallet-asset-rate = { path = "../../../substrate/frame/asset-rate", default-features = false } -frame-executive = { path = "../../../substrate/frame/executive", default-features = false } -pallet-grandpa = { path = "../../../substrate/frame/grandpa", default-features = false } -pallet-identity = { path = "../../../substrate/frame/identity", default-features = false } -pallet-indices = { path = "../../../substrate/frame/indices", default-features = false } -pallet-membership = { path = "../../../substrate/frame/membership", default-features = false } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -pallet-mmr = { path = "../../../substrate/frame/merkle-mountain-range", default-features = false } -pallet-multisig = { path = "../../../substrate/frame/multisig", default-features = false } -pallet-nis = { path = "../../../substrate/frame/nis", default-features = false } -pallet-offences = { path = "../../../substrate/frame/offences", 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-scheduler = { path = "../../../substrate/frame/scheduler", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } -pallet-society = { path = "../../../substrate/frame/society", default-features = false } -pallet-sudo = { path = "../../../substrate/frame/sudo", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false, features = ["tuples-96"] } -pallet-staking = { path = "../../../substrate/frame/staking", default-features = false } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-tips = { path = "../../../substrate/frame/tips", default-features = false } -pallet-treasury = { path = "../../../substrate/frame/treasury", 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 = "../../xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -pallet-root-testing = { path = "../../../substrate/frame/root-testing", default-features = false } +pallet-authority-discovery = { workspace = true } +pallet-authorship = { workspace = true } +pallet-babe = { workspace = true } +pallet-balances = { workspace = true } +pallet-beefy = { workspace = true } +pallet-beefy-mmr = { workspace = true } +pallet-bounties = { workspace = true } +pallet-child-bounties = { workspace = true } +pallet-state-trie-migration = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-collective = { workspace = true } +pallet-conviction-voting = { workspace = true } +pallet-democracy = { workspace = true } +pallet-elections-phragmen = { workspace = true } +pallet-asset-rate = { workspace = true } +frame-executive = { workspace = true } +pallet-grandpa = { workspace = true } +pallet-identity = { workspace = true } +pallet-indices = { workspace = true } +pallet-membership = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-mmr = { workspace = true } +pallet-multisig = { workspace = true } +pallet-nis = { workspace = true } +pallet-offences = { workspace = true } +pallet-parameters = { workspace = true } +pallet-preimage = { workspace = true } +pallet-proxy = { workspace = true } +pallet-ranked-collective = { workspace = true } +pallet-recovery = { workspace = true } +pallet-referenda = { workspace = true } +pallet-scheduler = { workspace = true } +pallet-session = { workspace = true } +pallet-society = { workspace = true } +pallet-sudo = { workspace = true } +frame-support = { features = ["tuples-96"], workspace = true } +pallet-staking = { workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-tips = { workspace = true } +pallet-treasury = { workspace = true } +pallet-utility = { workspace = true } +pallet-vesting = { workspace = true } +pallet-whitelist = { workspace = true } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +pallet-root-testing = { workspace = true } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-try-runtime = { path = "../../../substrate/frame/try-runtime", default-features = false, optional = true } -frame-system-benchmarking = { path = "../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -hex-literal = { version = "0.4.1" } +frame-benchmarking = { optional = true, workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-try-runtime = { optional = true, workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +hex-literal = { workspace = true, default-features = true } -runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false } -runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } -polkadot-parachain-primitives = { path = "../../parachain", default-features = false } +polkadot-runtime-common = { workspace = true } +polkadot-runtime-parachains = { workspace = true } +polkadot-primitives = { workspace = true } +polkadot-parachain-primitives = { workspace = true } -xcm = { package = "staging-xcm", path = "../../xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm/xcm-builder", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-builder = { workspace = true } +xcm-runtime-apis = { workspace = true } [dev-dependencies] -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" } -remote-externalities = { package = "frame-remote-externalities", path = "../../../substrate/utils/frame/remote-externalities" } -sp-trie = { path = "../../../substrate/primitives/trie" } -separator = "0.4.1" +tiny-keccak = { features = ["keccak"], workspace = true } +sp-keyring = { workspace = true, default-features = true } +remote-externalities = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } +separator = { workspace = true } serde_json = { workspace = true, default-features = true } -sp-tracing = { path = "../../../substrate/primitives/tracing", default-features = false } -tokio = { version = "1.24.2", features = ["macros"] } +sp-tracing = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] no_std = [] std = [ - "authority-discovery-primitives/std", - "babe-primitives/std", - "beefy-primitives/std", "binary-merkle-tree/std", "bitvec/std", - "block-builder-api/std", + "codec/std", "frame-benchmarking?/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", "frame-system/std", "frame-try-runtime/std", - "grandpa_primitives/std", - "inherents/std", "log/std", - "offchain-primitives/std", "pallet-asset-rate/std", "pallet-authority-discovery/std", "pallet-authorship/std", @@ -188,34 +183,39 @@ std = [ "pallet-whitelist/std", "pallet-xcm-benchmarks?/std", "pallet-xcm/std", - "parity-scale-codec/std", "polkadot-parachain-primitives/std", - "primitives/std", + "polkadot-primitives/std", + "polkadot-runtime-common/std", + "polkadot-runtime-parachains/std", "rococo-runtime-constants/std", - "runtime-common/std", - "runtime-parachains/std", "scale-info/std", "serde/std", "serde_derive", "serde_json/std", "sp-api/std", "sp-arithmetic/std", + "sp-authority-discovery/std", + "sp-block-builder/std", + "sp-consensus-babe/std", + "sp-consensus-beefy/std", + "sp-consensus-grandpa/std", "sp-core/std", "sp-genesis-builder/std", + "sp-inherents/std", "sp-io/std", "sp-mmr-primitives/std", + "sp-offchain/std", "sp-runtime/std", "sp-session/std", "sp-staking/std", - "sp-std/std", "sp-storage/std", "sp-tracing/std", + "sp-transaction-pool/std", "sp-version/std", "substrate-wasm-builder", - "tx-pool-api/std", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] runtime-benchmarks = [ @@ -226,6 +226,7 @@ runtime-benchmarks = [ "pallet-asset-rate/runtime-benchmarks", "pallet-babe/runtime-benchmarks", "pallet-balances/runtime-benchmarks", + "pallet-beefy-mmr/runtime-benchmarks", "pallet-bounties/runtime-benchmarks", "pallet-child-bounties/runtime-benchmarks", "pallet-collective/runtime-benchmarks", @@ -261,14 +262,14 @@ runtime-benchmarks = [ "pallet-xcm-benchmarks/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", - "primitives/runtime-benchmarks", - "runtime-common/runtime-benchmarks", - "runtime-parachains/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", + "polkadot-runtime-common/runtime-benchmarks", + "polkadot-runtime-parachains/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "frame-executive/try-runtime", @@ -319,17 +320,23 @@ try-runtime = [ "pallet-vesting/try-runtime", "pallet-whitelist/try-runtime", "pallet-xcm/try-runtime", - "runtime-common/try-runtime", - "runtime-parachains/try-runtime", + "polkadot-runtime-common/try-runtime", + "polkadot-runtime-parachains/try-runtime", "sp-runtime/try-runtime", ] +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + # Set timing constants (e.g. session period) to faster versions to speed up testing. fast-runtime = ["rococo-runtime-constants/fast-runtime"] -runtime-metrics = ["runtime-parachains/runtime-metrics", "sp-io/with-tracing"] +runtime-metrics = [ + "polkadot-runtime-parachains/runtime-metrics", + "sp-io/with-tracing", +] # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = ["metadata-hash"] diff --git a/polkadot/runtime/rococo/build.rs b/polkadot/runtime/rococo/build.rs index 403c31ff21c70f679059fa5b7e65478d309ba6a3..7aae84cd5e0fedcb29265f98d40bcd9ccd83ae43 100644 --- a/polkadot/runtime/rococo/build.rs +++ b/polkadot/runtime/rococo/build.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Substrate. If not, see . -#[cfg(feature = "std")] +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] fn main() { substrate_wasm_builder::WasmBuilder::build_using_defaults(); @@ -24,5 +24,18 @@ fn main() { .build(); } +#[cfg(all(feature = "metadata-hash", feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("ROC", 12) + .build(); + + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .set_file_name("fast_runtime_binary.rs") + .enable_feature("fast-runtime") + .enable_metadata_hash("ROC", 12) + .build(); +} + #[cfg(not(feature = "std"))] fn main() {} diff --git a/polkadot/runtime/rococo/constants/Cargo.toml b/polkadot/runtime/rococo/constants/Cargo.toml index 3ca3877a7650e453c25851ddb35899478a67faeb..1d0adac44af4dcbb099182ebfbc1a4a1333f8422 100644 --- a/polkadot/runtime/rococo/constants/Cargo.toml +++ b/polkadot/runtime/rococo/constants/Cargo.toml @@ -6,28 +6,31 @@ authors.workspace = true edition.workspace = true license.workspace = true +[package.metadata.polkadot-sdk] +exclude-from-umbrella = true + [lints] workspace = true [dependencies] -smallvec = "1.8.0" +smallvec = { workspace = true, default-features = true } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false } -runtime-common = { package = "polkadot-runtime-common", path = "../../common", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-weights = { path = "../../../../substrate/primitives/weights", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } +frame-support = { workspace = true } +polkadot-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +sp-runtime = { workspace = true } +sp-weights = { workspace = true } +sp-core = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../xcm", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../xcm/xcm-builder", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } [features] default = ["std"] std = [ "frame-support/std", - "primitives/std", - "runtime-common/std", + "polkadot-primitives/std", + "polkadot-runtime-common/std", "sp-core/std", "sp-runtime/std", "sp-weights/std", diff --git a/polkadot/runtime/rococo/constants/src/lib.rs b/polkadot/runtime/rococo/constants/src/lib.rs index 9209045364c28bc585c548d6d2b30176bd52bb20..47b50bf6c106918c5539cb327dd02af617de8c45 100644 --- a/polkadot/runtime/rococo/constants/src/lib.rs +++ b/polkadot/runtime/rococo/constants/src/lib.rs @@ -20,7 +20,7 @@ pub mod weights; /// Money matters. pub mod currency { - use primitives::Balance; + use polkadot_primitives::Balance; /// The existential deposit. pub const EXISTENTIAL_DEPOSIT: Balance = 1 * CENTS; @@ -37,9 +37,9 @@ pub mod currency { /// Time and blocks. pub mod time { - use runtime_common::prod_or_fast; + use polkadot_runtime_common::prod_or_fast; - use primitives::{BlockNumber, Moment}; + use polkadot_primitives::{BlockNumber, Moment}; pub const MILLISECS_PER_BLOCK: Moment = 6000; pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK; @@ -57,7 +57,7 @@ pub mod time { // 1 in 4 blocks (on average, not counting collisions) will be primary babe blocks. // The choice of is done in accordance to the slot duration and expected target // block time, for safely resisting network delays of maximum two seconds. - // + // pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4); } @@ -67,7 +67,7 @@ pub mod fee { use frame_support::weights::{ WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial, }; - use primitives::Balance; + use polkadot_primitives::Balance; use smallvec::smallvec; pub use sp_runtime::Perbill; @@ -103,7 +103,7 @@ pub mod fee { /// System Parachains. pub mod system_parachain { - use primitives::Id; + use polkadot_primitives::Id; use xcm_builder::IsChildSystemParachain; /// Network's Asset Hub parachain ID. @@ -121,6 +121,17 @@ pub mod system_parachain { /// All system parachains of Rococo. pub type SystemParachains = IsChildSystemParachain; + + /// Coretime constants + pub mod coretime { + /// Coretime timeslice period in blocks + /// WARNING: This constant is used accross chains, so additional care should be taken + /// when changing it. + #[cfg(feature = "fast-runtime")] + pub const TIMESLICE_PERIOD: u32 = 20; + #[cfg(not(feature = "fast-runtime"))] + pub const TIMESLICE_PERIOD: u32 = 80; + } } /// Rococo Treasury pallet instance. @@ -134,7 +145,7 @@ mod tests { }; use crate::weights::ExtrinsicBaseWeight; use frame_support::weights::WeightToFee as WeightToFeeT; - use runtime_common::MAXIMUM_BLOCK_WEIGHT; + use polkadot_runtime_common::MAXIMUM_BLOCK_WEIGHT; #[test] // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. diff --git a/polkadot/runtime/rococo/src/genesis_config_presets.rs b/polkadot/runtime/rococo/src/genesis_config_presets.rs index bac6902383e3b549bc99181f921905760a71cd96..17792cff18678623f373621e7206b609340f2bb6 100644 --- a/polkadot/runtime/rococo/src/genesis_config_presets.rs +++ b/polkadot/runtime/rococo/src/genesis_config_presets.rs @@ -17,17 +17,17 @@ //! Genesis configs presets for the Rococo runtime use crate::{SessionKeys, BABE_GENESIS_EPOCH_CONFIG}; -use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId; -use babe_primitives::AuthorityId as BabeId; -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; -use grandpa_primitives::AuthorityId as GrandpaId; -use primitives::{vstaging::SchedulerParams, AccountId, AccountPublic, AssignmentId, ValidatorId}; +#[cfg(not(feature = "std"))] +use alloc::format; +use alloc::vec::Vec; +use polkadot_primitives::{AccountId, AccountPublic, AssignmentId, SchedulerParams, ValidatorId}; use rococo_runtime_constants::currency::UNITS as ROC; +use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; +use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; +use sp_consensus_grandpa::AuthorityId as GrandpaId; use sp_core::{sr25519, Pair, Public}; use sp_runtime::traits::IdentifyAccount; -#[cfg(not(feature = "std"))] -use sp_std::alloc::format; -use sp_std::vec::Vec; /// Helper function to generate a crypto pair from seed fn get_from_seed(seed: &str) -> ::Public { @@ -105,12 +105,13 @@ fn rococo_session_keys( } fn default_parachains_host_configuration( -) -> runtime_parachains::configuration::HostConfiguration { - use primitives::{ +) -> polkadot_runtime_parachains::configuration::HostConfiguration +{ + use polkadot_primitives::{ node_features::FeatureIndex, AsyncBackingParams, MAX_CODE_SIZE, MAX_POV_SIZE, }; - runtime_parachains::configuration::HostConfiguration { + polkadot_runtime_parachains::configuration::HostConfiguration { validation_upgrade_cooldown: 2u32, validation_upgrade_delay: 2, code_retention_period: 1200, @@ -205,7 +206,7 @@ fn rococo_testnet_genesis( }, "sudo": { "key": Some(root_key.clone()) }, "configuration": { - "config": runtime_parachains::configuration::HostConfiguration { + "config": polkadot_runtime_parachains::configuration::HostConfiguration { scheduler_params: SchedulerParams { max_validators_per_core: Some(1), ..default_parachains_host_configuration().scheduler_params @@ -214,7 +215,7 @@ fn rococo_testnet_genesis( }, }, "registrar": { - "nextFreeParaId": primitives::LOWEST_PUBLIC_ID, + "nextFreeParaId": polkadot_primitives::LOWEST_PUBLIC_ID, } }) } @@ -473,7 +474,7 @@ fn rococo_staging_testnet_config_genesis() -> serde_json::Value { "config": default_parachains_host_configuration(), }, "registrar": { - "nextFreeParaId": primitives::LOWEST_PUBLIC_ID, + "nextFreeParaId": polkadot_primitives::LOWEST_PUBLIC_ID, }, }) } @@ -527,7 +528,7 @@ fn wococo_local_testnet_genesis() -> serde_json::Value { } /// Provides the JSON representation of predefined genesis config for given `id`. -pub fn get_preset(id: &sp_genesis_builder::PresetId) -> Option> { +pub fn get_preset(id: &sp_genesis_builder::PresetId) -> Option> { let patch = match id.try_into() { Ok("local_testnet") => rococo_local_testnet_genesis(), Ok("development") => rococo_development_config_genesis(), diff --git a/polkadot/runtime/rococo/src/governance/fellowship.rs b/polkadot/runtime/rococo/src/governance/fellowship.rs index a589b768afde2c0757e74a6535509228f1613a82..27a58a0eebd183bc5d21efa655113cf3a0251cc0 100644 --- a/polkadot/runtime/rococo/src/governance/fellowship.rs +++ b/polkadot/runtime/rococo/src/governance/fellowship.rs @@ -356,6 +356,7 @@ impl pallet_ranked_collective::Config for Runtime type MinRankOfClass = sp_runtime::traits::Identity; type MemberSwappedHandler = (); type VoteWeight = pallet_ranked_collective::Geometric; + type MaxMemberCount = (); #[cfg(feature = "runtime-benchmarks")] type BenchmarkSetup = (); } diff --git a/polkadot/runtime/rococo/src/impls.rs b/polkadot/runtime/rococo/src/impls.rs index ac7100d7858377dca5991e0d0308dc64577b9350..f01440ea02bc7c15377c732d22041e60d3425d66 100644 --- a/polkadot/runtime/rococo/src/impls.rs +++ b/polkadot/runtime/rococo/src/impls.rs @@ -15,13 +15,14 @@ // along with Polkadot. If not, see . use crate::xcm_config; +use alloc::{boxed::Box, vec}; +use codec::{Decode, Encode}; +use core::marker::PhantomData; use frame_support::pallet_prelude::DispatchResult; use frame_system::RawOrigin; -use parity_scale_codec::{Decode, Encode}; -use primitives::Balance; +use polkadot_primitives::Balance; +use polkadot_runtime_common::identity_migrator::{OnReapIdentity, WeightInfo}; use rococo_runtime_constants::currency::*; -use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo}; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm}; use xcm_executor::traits::TransactAsset; @@ -89,7 +90,7 @@ where fn on_reap_identity(who: &AccountId, fields: u32, subs: u32) -> DispatchResult { use crate::{ impls::IdentityMigratorCalls::PokeDeposit, - weights::runtime_common_identity_migrator::WeightInfo as MigratorWeights, + weights::polkadot_runtime_common_identity_migrator::WeightInfo as MigratorWeights, }; let total_to_send = Self::calculate_remote_deposit(fields, subs); diff --git a/polkadot/runtime/rococo/src/lib.rs b/polkadot/runtime/rococo/src/lib.rs index 22e6183e59460899e6eceb938d93222798ee3a34..dfc41b15bb1dc4468ecab0e0cceb4c09d3f6efd8 100644 --- a/polkadot/runtime/rococo/src/lib.rs +++ b/polkadot/runtime/rococo/src/lib.rs @@ -20,18 +20,21 @@ // `construct_runtime!` does a lot of recursion and requires us to increase the limit. #![recursion_limit = "512"] -use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId; -use beefy_primitives::{ - ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}, - mmr::{BeefyDataProvider, MmrLeafVersion}, +extern crate alloc; + +use alloc::{ + collections::{btree_map::BTreeMap, vec_deque::VecDeque}, + vec, + vec::Vec, }; +use codec::{Decode, Encode, MaxEncodedLen}; +use core::cmp::Ordering; use frame_support::{ dynamic_params::{dynamic_pallet_params, dynamic_params}, traits::FromContains, }; use pallet_nis::WithMaximumOf; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; -use primitives::{ +use polkadot_primitives::{ slashing, AccountId, AccountIndex, ApprovalVotingParams, Balance, BlockNumber, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment, @@ -39,8 +42,7 @@ use primitives::{ SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, PARACHAIN_KEY_TYPE_ID, }; -use rococo_runtime_constants::system_parachain::BROKER_ID; -use runtime_common::{ +use polkadot_runtime_common::{ assigned_slots, auctions, claims, crowdloan, identity_migrator, impl_runtime_weights, impls::{ ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset, @@ -50,15 +52,15 @@ use runtime_common::{ traits::{Leaser, OnSwap}, BlockHashCount, BlockLength, SlowAdjustingFeeUpdate, }; -use runtime_parachains::{ - assigner_coretime as parachains_assigner_coretime, - assigner_on_demand as parachains_assigner_on_demand, configuration as parachains_configuration, +use polkadot_runtime_parachains::{ + assigner_coretime as parachains_assigner_coretime, configuration as parachains_configuration, configuration::ActiveConfigHrmpChannelSizeAndCapacityRatio, coretime, disputes as parachains_disputes, disputes::slashing as parachains_slashing, dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion, inclusion::{AggregateMessageOrigin, UmpQueueId}, - initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras, + initializer as parachains_initializer, on_demand as parachains_on_demand, + origin as parachains_origin, paras as parachains_paras, paras_inherent as parachains_paras_inherent, runtime_api_impl::{ v10 as parachains_runtime_api_impl, vstaging as vstaging_parachains_runtime_api_impl, @@ -66,13 +68,14 @@ use runtime_parachains::{ scheduler as parachains_scheduler, session_info as parachains_session_info, shared as parachains_shared, }; +use rococo_runtime_constants::system_parachain::{coretime::TIMESLICE_PERIOD, BROKER_ID}; use scale_info::TypeInfo; -use sp_genesis_builder::PresetId; -use sp_std::{ - cmp::Ordering, - collections::{btree_map::BTreeMap, vec_deque::VecDeque}, - prelude::*, +use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; +use sp_consensus_beefy::{ + ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}, + mmr::{BeefyDataProvider, MmrLeafVersion}, }; +use sp_genesis_builder::PresetId; use frame_support::{ construct_runtime, derive_impl, @@ -92,12 +95,13 @@ use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId}; use pallet_identity::legacy::IdentityInfo; use pallet_session::historical as session_historical; use pallet_transaction_payment::{FeeDetails, FungibleAdapter, RuntimeDispatchInfo}; -use sp_core::{ConstU128, ConstU8, OpaqueMetadata, H256}; +use sp_core::{ConstU128, ConstU8, Get, OpaqueMetadata, H256}; use sp_runtime::{ create_runtime_str, generic, impl_opaque_keys, traits::{ - BlakeTwo256, Block as BlockT, ConstU32, ConvertInto, Extrinsic as ExtrinsicT, - IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, Verify, + AccountIdConversion, BlakeTwo256, Block as BlockT, ConstU32, ConvertInto, + Extrinsic as ExtrinsicT, IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, + Verify, }, transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity}, ApplyExtrinsicResult, FixedU128, KeyTypeId, Perbill, Percent, Permill, RuntimeDebug, @@ -106,10 +110,7 @@ use sp_staking::SessionIndex; #[cfg(any(feature = "std", test))] use sp_version::NativeVersion; use sp_version::RuntimeVersion; -use xcm::{ - latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, - VersionedXcm, -}; +use xcm::{latest::prelude::*, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm}; use xcm_builder::PayOverXcm; pub use frame_system::Call as SystemCall; @@ -134,8 +135,8 @@ use governance::{ pallet_custom_origins, AuctionAdmin, Fellows, GeneralAdmin, LeaseAdmin, Treasurer, TreasurySpender, }; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects}, +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::Error as XcmPaymentApiError, }; @@ -165,18 +166,18 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("rococo"), impl_name: create_runtime_str!("parity-rococo-v2.0"), authoring_version: 0, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 25, + transaction_version: 26, state_version: 1, }; /// The BABE epoch configuration at genesis. -pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration = - babe_primitives::BabeEpochConfiguration { +pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration = + sp_consensus_babe::BabeEpochConfiguration { c: PRIMARY_PROBABILITY, - allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots, + allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots, }; /// Native version. @@ -479,9 +480,6 @@ parameter_types! { } parameter_types! { - pub const ProposalBond: Permill = Permill::from_percent(5); - pub const ProposalBondMinimum: Balance = 2000 * CENTS; - pub const ProposalBondMaximum: Balance = 1 * GRAND; pub const SpendPeriod: BlockNumber = 6 * DAYS; pub const Burn: Permill = Permill::from_perthousand(2); pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry"); @@ -504,13 +502,8 @@ parameter_types! { impl pallet_treasury::Config for Runtime { type PalletId = TreasuryPalletId; type Currency = Balances; - type ApproveOrigin = EitherOfDiverse, Treasurer>; type RejectOrigin = EitherOfDiverse, Treasurer>; type RuntimeEvent = RuntimeEvent; - type OnSlash = Treasury; - type ProposalBond = ProposalBond; - type ProposalBondMinimum = ProposalBondMinimum; - type ProposalBondMaximum = ProposalBondMaximum; type SpendPeriod = SpendPeriod; type Burn = Burn; type BurnDestination = Society; @@ -542,7 +535,7 @@ impl pallet_treasury::Config for Runtime { >; type PayoutPeriod = PayoutSpendPeriod; #[cfg(feature = "runtime-benchmarks")] - type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments; + type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::TreasuryArguments; } parameter_types! { @@ -569,6 +562,7 @@ impl pallet_bounties::Config for Runtime { type RuntimeEvent = RuntimeEvent; type MaximumReasonLength = MaximumReasonLength; type WeightInfo = weights::pallet_bounties::WeightInfo; + type OnSlash = Treasury; } parameter_types! { @@ -643,7 +637,9 @@ where frame_system::CheckNonce::::from(nonce), frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(tip), + frame_metadata_hash_extension::CheckMetadataHash::new(true), ); + let raw_payload = SignedPayload::new(call, extra) .map_err(|e| { log::warn!("Unable to create signed payload: {:?}", e); @@ -678,7 +674,7 @@ impl claims::Config for Runtime { type VestingSchedule = Vesting; type Prefix = Prefix; type MoveClaimOrigin = EnsureRoot; - type WeightInfo = weights::runtime_common_claims::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_claims::WeightInfo; } parameter_types! { @@ -944,7 +940,7 @@ impl pallet_proxy::Config for Runtime { impl parachains_origin::Config for Runtime {} impl parachains_configuration::Config for Runtime { - type WeightInfo = weights::runtime_parachains_configuration::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_configuration::WeightInfo; } impl parachains_shared::Config for Runtime { @@ -957,7 +953,7 @@ impl parachains_session_info::Config for Runtime { /// Special `RewardValidators` that does nothing ;) pub struct RewardValidators; -impl runtime_parachains::inclusion::RewardValidators for RewardValidators { +impl polkadot_runtime_parachains::inclusion::RewardValidators for RewardValidators { fn reward_backing(_: impl IntoIterator) {} fn reward_bitfields(_: impl IntoIterator) {} } @@ -967,7 +963,7 @@ impl parachains_inclusion::Config for Runtime { type DisputesHandler = ParasDisputes; type RewardValidators = RewardValidators; type MessageQueue = MessageQueue; - type WeightInfo = weights::runtime_parachains_inclusion::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_inclusion::WeightInfo; } parameter_types! { @@ -976,7 +972,7 @@ parameter_types! { impl parachains_paras::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type WeightInfo = weights::runtime_parachains_paras::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_paras::WeightInfo; type UnsignedPriority = ParasUnsignedPriority; type QueueFootprinter = ParaInclusion; type NextSessionRotation = Babe; @@ -1050,11 +1046,11 @@ impl parachains_hrmp::Config for Runtime { HrmpChannelSizeAndCapacityWithSystemRatio, >; type VersionWrapper = crate::XcmPallet; - type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_hrmp::WeightInfo; } impl parachains_paras_inherent::Config for Runtime { - type WeightInfo = weights::runtime_parachains_paras_inherent::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_paras_inherent::WeightInfo; } impl parachains_scheduler::Config for Runtime { @@ -1065,28 +1061,48 @@ impl parachains_scheduler::Config for Runtime { parameter_types! { pub const BrokerId: u32 = BROKER_ID; + pub const BrokerPalletId: PalletId = PalletId(*b"py/broke"); pub MaxXcmTransactWeight: Weight = Weight::from_parts(200_000_000, 20_000); } +pub struct BrokerPot; +impl Get for BrokerPot { + fn get() -> InteriorLocation { + Junction::AccountId32 { network: None, id: BrokerPalletId::get().into_account_truncating() } + .into() + } +} + impl coretime::Config for Runtime { type RuntimeOrigin = RuntimeOrigin; type RuntimeEvent = RuntimeEvent; type Currency = Balances; type BrokerId = BrokerId; - type WeightInfo = weights::runtime_parachains_coretime::WeightInfo; + type BrokerPotLocation = BrokerPot; + type WeightInfo = weights::polkadot_runtime_parachains_coretime::WeightInfo; type SendXcm = crate::xcm_config::XcmRouter; + type AssetTransactor = crate::xcm_config::LocalAssetTransactor; + type AccountToLocation = xcm_builder::AliasesIntoAccountId32< + xcm_config::ThisNetwork, + ::AccountId, + >; type MaxXcmTransactWeight = MaxXcmTransactWeight; } parameter_types! { pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1); + // Keep 2 timeslices worth of revenue information. + pub const MaxHistoricalRevenue: BlockNumber = 2 * TIMESLICE_PERIOD; + pub const OnDemandPalletId: PalletId = PalletId(*b"py/ondmd"); } -impl parachains_assigner_on_demand::Config for Runtime { +impl parachains_on_demand::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; type TrafficDefaultValue = OnDemandTrafficDefaultValue; - type WeightInfo = weights::runtime_parachains_assigner_on_demand::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_on_demand::WeightInfo; + type MaxHistoricalRevenue = MaxHistoricalRevenue; + type PalletId = OnDemandPalletId; } impl parachains_assigner_coretime::Config for Runtime {} @@ -1094,7 +1110,7 @@ impl parachains_assigner_coretime::Config for Runtime {} impl parachains_initializer::Config for Runtime { type Randomness = pallet_babe::RandomnessFromOneEpochAgo; type ForceOrigin = EnsureRoot; - type WeightInfo = weights::runtime_parachains_initializer::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_initializer::WeightInfo; type CoretimeOnNewSession = Coretime; } @@ -1102,7 +1118,7 @@ impl parachains_disputes::Config for Runtime { type RuntimeEvent = RuntimeEvent; type RewardValidators = (); type SlashingHandler = parachains_slashing::SlashValidatorsForDisputes; - type WeightInfo = weights::runtime_parachains_disputes::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_disputes::WeightInfo; } impl parachains_slashing::Config for Runtime { @@ -1133,7 +1149,7 @@ impl paras_registrar::Config for Runtime { type OnSwap = (Crowdloan, Slots, SwapLeases); type ParaDeposit = ParaDeposit; type DataDepositPerByte = DataDepositPerByte; - type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_paras_registrar::WeightInfo; } parameter_types! { @@ -1147,7 +1163,7 @@ impl slots::Config for Runtime { type LeasePeriod = LeasePeriod; type LeaseOffset = (); type ForceOrigin = EitherOf, LeaseAdmin>; - type WeightInfo = weights::runtime_common_slots::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_slots::WeightInfo; } parameter_types! { @@ -1168,7 +1184,7 @@ impl crowdloan::Config for Runtime { type Registrar = Registrar; type Auctioneer = Auctions; type MaxMemoLength = MaxMemoLength; - type WeightInfo = weights::runtime_common_crowdloan::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_crowdloan::WeightInfo; } parameter_types! { @@ -1187,14 +1203,14 @@ impl auctions::Config for Runtime { type SampleLength = SampleLength; type Randomness = pallet_babe::RandomnessFromOneEpochAgo; type InitiateOrigin = EitherOf, AuctionAdmin>; - type WeightInfo = weights::runtime_common_auctions::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_auctions::WeightInfo; } impl identity_migrator::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Reaper = EnsureSigned; type ReapIdentityHandler = ToParachainIdentityReaper; - type WeightInfo = weights::runtime_common_identity_migrator::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_identity_migrator::WeightInfo; } type NisCounterpartInstance = pallet_balances::Instance2; @@ -1270,6 +1286,7 @@ impl pallet_beefy::Config for Runtime { type MaxNominators = ConstU32<0>; type MaxSetIdSessionEntries = BeefySetIdSessionEntries; type OnNewValidatorSet = MmrLeaf; + type AncestryHelper = MmrLeaf; type WeightInfo = (); type KeyOwnerProof = >::Proof; type EquivocationReportSystem = @@ -1290,9 +1307,11 @@ impl pallet_mmr::Config for Runtime { const INDEXING_PREFIX: &'static [u8] = mmr::INDEXING_PREFIX; type Hashing = Keccak256; type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest; - type WeightInfo = (); type LeafData = pallet_beefy_mmr::Pallet; type BlockHashProvider = pallet_mmr::DefaultBlockHashProvider; + type WeightInfo = weights::pallet_mmr::WeightInfo; + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = parachains_paras::benchmarking::mmr_setup::MmrSetup; } parameter_types! { @@ -1302,13 +1321,8 @@ parameter_types! { pub struct ParaHeadsRootProvider; impl BeefyDataProvider for ParaHeadsRootProvider { fn extra_data() -> H256 { - let mut para_heads: Vec<(u32, Vec)> = parachains_paras::Parachains::::get() - .into_iter() - .filter_map(|id| { - parachains_paras::Heads::::get(&id).map(|head| (id.into(), head.0)) - }) - .collect(); - para_heads.sort(); + let para_heads: Vec<(u32, Vec)> = + parachains_paras::Pallet::::sorted_para_heads(); binary_merkle_tree::merkle_root::( para_heads.into_iter().map(|pair| pair.encode()), ) @@ -1321,6 +1335,7 @@ impl pallet_beefy_mmr::Config for Runtime { type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum; type LeafExtra = H256; type BeefyDataProvider = ParaHeadsRootProvider; + type WeightInfo = weights::pallet_beefy_mmr::WeightInfo; } impl paras_sudo_wrapper::Config for Runtime {} @@ -1338,7 +1353,7 @@ impl assigned_slots::Config for Runtime { type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength; type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength; type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod; - type WeightInfo = weights::runtime_common_assigned_slots::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_assigned_slots::WeightInfo; } impl validator_manager::Config for Runtime { @@ -1365,7 +1380,7 @@ impl pallet_asset_rate::Config for Runtime { type Currency = Balances; type AssetKind = ::AssetKind; #[cfg(feature = "runtime-benchmarks")] - type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments; + type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::AssetRateArguments; } // Notify `coretime` pallet when a lease swap occurs @@ -1468,7 +1483,7 @@ construct_runtime! { ParasDisputes: parachains_disputes = 62, ParasSlashing: parachains_slashing = 63, MessageQueue: pallet_message_queue = 64, - OnDemandAssignmentProvider: parachains_assigner_on_demand = 66, + OnDemandAssignmentProvider: parachains_on_demand = 66, CoretimeAssignmentProvider: parachains_assigner_coretime = 68, // Parachain Onboarding Pallets. Start indices at 70 to leave room. @@ -1528,6 +1543,7 @@ pub type SignedExtra = ( frame_system::CheckNonce, frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -1564,6 +1580,13 @@ pub mod migrations { as Leaser>::lease_period_index(now)?; Some(index.saturating_add(lease.len() as u32).saturating_mul(LeasePeriod::get())) } + + fn get_all_parachains_with_leases() -> Vec { + slots::Leases::::iter() + .filter(|(_, lease)| !lease.is_empty()) + .map(|(para, _)| para) + .collect::>() + } } parameter_types! { @@ -1614,47 +1637,45 @@ pub mod migrations { /// Unreleased migrations. Add new ones here: pub type Unreleased = ( - pallet_society::migrations::MigrateToV2, - parachains_configuration::migration::v7::MigrateToV7, - assigned_slots::migration::v1::MigrateToV1, - parachains_scheduler::migration::MigrateV1ToV2, - parachains_configuration::migration::v8::MigrateToV8, - parachains_configuration::migration::v9::MigrateToV9, - paras_registrar::migration::MigrateToV1, - pallet_referenda::migration::v1::MigrateV0ToV1, - pallet_referenda::migration::v1::MigrateV0ToV1, - - // Unlock & unreserve Gov1 funds - - pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds, - pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds, - pallet_tips::migrations::unreserve_deposits::UnreserveDeposits, - - // Delete all Gov v1 pallet storage key/values. - - frame_support::migrations::RemovePallet::DbWeight>, - frame_support::migrations::RemovePallet::DbWeight>, - frame_support::migrations::RemovePallet::DbWeight>, - frame_support::migrations::RemovePallet::DbWeight>, - frame_support::migrations::RemovePallet::DbWeight>, - frame_support::migrations::RemovePallet::DbWeight>, - - pallet_grandpa::migrations::MigrateV4ToV5, - parachains_configuration::migration::v10::MigrateToV10, - - // Migrate Identity pallet for Usernames - pallet_identity::migration::versioned::V0ToV1, - parachains_configuration::migration::v11::MigrateToV11, - // This needs to come after the `parachains_configuration` above as we are reading the configuration. - coretime::migration::MigrateToCoretime, - parachains_configuration::migration::v12::MigrateToV12, - parachains_assigner_on_demand::migration::MigrateV0ToV1, - - // permanent - pallet_xcm::migration::MigrateToLatestXcmVersion, - - parachains_inclusion::migration::MigrateToV1, - ); + pallet_society::migrations::MigrateToV2, + parachains_configuration::migration::v7::MigrateToV7, + assigned_slots::migration::v1::MigrateToV1, + parachains_scheduler::migration::MigrateV1ToV2, + parachains_configuration::migration::v8::MigrateToV8, + parachains_configuration::migration::v9::MigrateToV9, + paras_registrar::migration::MigrateToV1, + pallet_referenda::migration::v1::MigrateV0ToV1, + pallet_referenda::migration::v1::MigrateV0ToV1, + + // Unlock & unreserve Gov1 funds + + pallet_elections_phragmen::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds, + pallet_democracy::migrations::unlock_and_unreserve_all_funds::UnlockAndUnreserveAllFunds, + pallet_tips::migrations::unreserve_deposits::UnreserveDeposits, + + // Delete all Gov v1 pallet storage key/values. + + frame_support::migrations::RemovePallet::DbWeight>, + frame_support::migrations::RemovePallet::DbWeight>, + frame_support::migrations::RemovePallet::DbWeight>, + frame_support::migrations::RemovePallet::DbWeight>, + frame_support::migrations::RemovePallet::DbWeight>, + frame_support::migrations::RemovePallet::DbWeight>, + pallet_grandpa::migrations::MigrateV4ToV5, + parachains_configuration::migration::v10::MigrateToV10, + + // Migrate Identity pallet for Usernames + pallet_identity::migration::versioned::V0ToV1, + parachains_configuration::migration::v11::MigrateToV11, + // This needs to come after the `parachains_configuration` above as we are reading the configuration. + coretime::migration::MigrateToCoretime, + parachains_configuration::migration::v12::MigrateToV12, + parachains_on_demand::migration::MigrateV0ToV1, + + // permanent + pallet_xcm::migration::MigrateToLatestXcmVersion, + parachains_inclusion::migration::MigrateToV1, + ); } /// Executive: handles dispatch to the various modules. @@ -1701,25 +1722,26 @@ mod benches { // Polkadot // NOTE: Make sure to prefix these with `runtime_common::` so // the that path resolves correctly in the generated file. - [runtime_common::assigned_slots, AssignedSlots] - [runtime_common::auctions, Auctions] - [runtime_common::coretime, Coretime] - [runtime_common::crowdloan, Crowdloan] - [runtime_common::claims, Claims] - [runtime_common::identity_migrator, IdentityMigrator] - [runtime_common::slots, Slots] - [runtime_common::paras_registrar, Registrar] - [runtime_parachains::configuration, Configuration] - [runtime_parachains::hrmp, Hrmp] - [runtime_parachains::disputes, ParasDisputes] - [runtime_parachains::inclusion, ParaInclusion] - [runtime_parachains::initializer, Initializer] - [runtime_parachains::paras_inherent, ParaInherent] - [runtime_parachains::paras, Paras] - [runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider] + [polkadot_runtime_common::assigned_slots, AssignedSlots] + [polkadot_runtime_common::auctions, Auctions] + [polkadot_runtime_common::crowdloan, Crowdloan] + [polkadot_runtime_common::claims, Claims] + [polkadot_runtime_common::identity_migrator, IdentityMigrator] + [polkadot_runtime_common::slots, Slots] + [polkadot_runtime_common::paras_registrar, Registrar] + [polkadot_runtime_parachains::configuration, Configuration] + [polkadot_runtime_parachains::coretime, Coretime] + [polkadot_runtime_parachains::hrmp, Hrmp] + [polkadot_runtime_parachains::disputes, ParasDisputes] + [polkadot_runtime_parachains::inclusion, ParaInclusion] + [polkadot_runtime_parachains::initializer, Initializer] + [polkadot_runtime_parachains::paras_inherent, ParaInherent] + [polkadot_runtime_parachains::paras, Paras] + [polkadot_runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider] // Substrate [pallet_balances, Balances] [pallet_balances, NisCounterpartBalances] + [pallet_beefy_mmr, MmrLeaf] [frame_benchmarking::baseline, Baseline::] [pallet_bounties, Bounties] [pallet_child_bounties, ChildBounties] @@ -1728,6 +1750,7 @@ mod benches { [pallet_identity, Identity] [pallet_indices, Indices] [pallet_message_queue, MessageQueue] + [pallet_mmr, Mmr] [pallet_multisig, Multisig] [pallet_parameters, Parameters] [pallet_preimage, Preimage] @@ -1767,17 +1790,10 @@ sp_api::impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { - let acceptable = vec![ - // native token - VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get())) - ]; - - Ok(acceptable - .into_iter() - .filter_map(|asset| asset.into_version(xcm_version).ok()) - .collect()) + let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())]; + XcmPallet::query_acceptable_payment_assets(xcm_version, acceptable_assets) } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { @@ -1787,11 +1803,11 @@ sp_api::impl_runtime_apis! { Ok(WeightToFee::weight_to_fee(&weight)) }, Ok(asset_id) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + log::trace!(target: "xcm::xcm_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); Err(XcmPaymentApiError::AssetNotFound) }, Err(_) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + log::trace!(target: "xcm::xcm_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); Err(XcmPaymentApiError::VersionedConversionFailed) } } @@ -1806,63 +1822,25 @@ sp_api::impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm_executor::RecordXcm; - pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; - let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + XcmPallet::dry_run_call::(origin, call) } fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - let origin_location: Location = origin_location.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Location version conversion failed with error: {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let xcm: Xcm = xcm.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Xcm version conversion failed with error {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256); - let result = xcm_executor::XcmExecutor::::prepare_and_execute( - origin_location, - xcm, - &mut hash, - Weight::MAX, // Max limit available for execution. - Weight::zero(), - ); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(XcmDryRunEffects { - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + XcmPallet::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationConverter, + >::convert_location(location) } } @@ -1875,12 +1853,12 @@ sp_api::impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } - impl block_builder_api::BlockBuilder for Runtime { + impl sp_block_builder::BlockBuilder for Runtime { fn apply_extrinsic(extrinsic: ::Extrinsic) -> ApplyExtrinsicResult { Executive::apply_extrinsic(extrinsic) } @@ -1889,19 +1867,19 @@ sp_api::impl_runtime_apis! { Executive::finalize_block() } - fn inherent_extrinsics(data: inherents::InherentData) -> Vec<::Extrinsic> { + fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<::Extrinsic> { data.create_extrinsics() } fn check_inherents( block: Block, - data: inherents::InherentData, - ) -> inherents::CheckInherentsResult { + data: sp_inherents::InherentData, + ) -> sp_inherents::CheckInherentsResult { data.check_extrinsics(&block) } } - impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime { + impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { fn validate_transaction( source: TransactionSource, tx: ::Extrinsic, @@ -1911,14 +1889,14 @@ sp_api::impl_runtime_apis! { } } - impl offchain_primitives::OffchainWorkerApi for Runtime { + impl sp_offchain::OffchainWorkerApi for Runtime { fn offchain_worker(header: &::Header) { Executive::offchain_worker(header) } } #[api_version(11)] - impl primitives::runtime_api::ParachainHost for Runtime { + impl polkadot_primitives::runtime_api::ParachainHost for Runtime { fn validators() -> Vec { parachains_runtime_api_impl::validators::() } @@ -1948,7 +1926,7 @@ sp_api::impl_runtime_apis! { fn check_validation_outputs( para_id: ParaId, - outputs: primitives::CandidateCommitments, + outputs: polkadot_primitives::CandidateCommitments, ) -> bool { parachains_runtime_api_impl::check_validation_outputs::(para_id, outputs) } @@ -2005,8 +1983,8 @@ sp_api::impl_runtime_apis! { } fn submit_pvf_check_statement( - stmt: primitives::PvfCheckStatement, - signature: primitives::ValidatorSignature + stmt: polkadot_primitives::PvfCheckStatement, + signature: polkadot_primitives::ValidatorSignature ) { parachains_runtime_api_impl::submit_pvf_check_statement::(stmt, signature) } @@ -2033,7 +2011,7 @@ sp_api::impl_runtime_apis! { fn key_ownership_proof( validator_id: ValidatorId, ) -> Option { - use parity_scale_codec::Encode; + use codec::Encode; Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id)) .map(|p| p.encode()) @@ -2054,11 +2032,11 @@ sp_api::impl_runtime_apis! { parachains_runtime_api_impl::minimum_backing_votes::() } - fn para_backing_state(para_id: ParaId) -> Option { + fn para_backing_state(para_id: ParaId) -> Option { parachains_runtime_api_impl::backing_state::(para_id) } - fn async_backing_params() -> primitives::AsyncBackingParams { + fn async_backing_params() -> polkadot_primitives::AsyncBackingParams { parachains_runtime_api_impl::async_backing_params::() } @@ -2083,41 +2061,77 @@ sp_api::impl_runtime_apis! { } } - #[api_version(3)] - impl beefy_primitives::BeefyApi for Runtime { + #[api_version(5)] + impl sp_consensus_beefy::BeefyApi for Runtime { fn beefy_genesis() -> Option { pallet_beefy::GenesisBlock::::get() } - fn validator_set() -> Option> { + fn validator_set() -> Option> { Beefy::validator_set() } - fn submit_report_equivocation_unsigned_extrinsic( - equivocation_proof: beefy_primitives::DoubleVotingProof< + fn submit_report_double_voting_unsigned_extrinsic( + equivocation_proof: sp_consensus_beefy::DoubleVotingProof< BlockNumber, BeefyId, BeefySignature, >, - key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; - Beefy::submit_unsigned_equivocation_report( + Beefy::submit_unsigned_double_voting_report( equivocation_proof, key_owner_proof, ) } + fn submit_report_fork_voting_unsigned_extrinsic( + equivocation_proof: + sp_consensus_beefy::ForkVotingProof< + ::Header, + BeefyId, + sp_runtime::OpaqueValue + >, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_fork_voting_report( + equivocation_proof.try_into()?, + key_owner_proof.decode()?, + ) + } + + fn submit_report_future_block_voting_unsigned_extrinsic( + equivocation_proof: sp_consensus_beefy::FutureBlockVotingProof, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_future_block_voting_report( + equivocation_proof, + key_owner_proof.decode()?, + ) + } + fn generate_key_ownership_proof( - _set_id: beefy_primitives::ValidatorSetId, + _set_id: sp_consensus_beefy::ValidatorSetId, authority_id: BeefyId, - ) -> Option { - use parity_scale_codec::Encode; + ) -> Option { + use codec::Encode; + + Historical::prove((sp_consensus_beefy::KEY_TYPE, authority_id)) + .map(|p| p.encode()) + .map(sp_consensus_beefy::OpaqueKeyOwnershipProof::new) + } + + fn generate_ancestry_proof( + prev_block_number: BlockNumber, + best_known_block_number: Option, + ) -> Option { + use sp_consensus_beefy::AncestryHelper; - Historical::prove((beefy_primitives::KEY_TYPE, authority_id)) + MmrLeaf::generate_proof(prev_block_number, best_known_block_number) .map(|p| p.encode()) - .map(beefy_primitives::OpaqueKeyOwnershipProof::new) + .map(sp_runtime::OpaqueValue::new) } } @@ -2134,7 +2148,7 @@ sp_api::impl_runtime_apis! { fn generate_proof( block_numbers: Vec, best_known_block_number: Option, - ) -> Result<(Vec, mmr::Proof), mmr::Error> { + ) -> Result<(Vec, mmr::LeafProof), mmr::Error> { Mmr::generate_proof(block_numbers, best_known_block_number).map( |(leaves, proof)| { ( @@ -2148,7 +2162,7 @@ sp_api::impl_runtime_apis! { ) } - fn verify_proof(leaves: Vec, proof: mmr::Proof) + fn verify_proof(leaves: Vec, proof: mmr::LeafProof) -> Result<(), mmr::Error> { let leaves = leaves.into_iter().map(|leaf| @@ -2161,7 +2175,7 @@ sp_api::impl_runtime_apis! { fn verify_proof_stateless( root: mmr::Hash, leaves: Vec, - proof: mmr::Proof + proof: mmr::LeafProof ) -> Result<(), mmr::Error> { let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect(); pallet_mmr::verify_leaves_proof::(root, nodes, proof) @@ -2196,7 +2210,7 @@ sp_api::impl_runtime_apis! { _set_id: fg_primitives::SetId, authority_id: fg_primitives::AuthorityId, ) -> Option { - use parity_scale_codec::Encode; + use codec::Encode; Historical::prove((fg_primitives::KEY_TYPE, authority_id)) .map(|p| p.encode()) @@ -2204,10 +2218,10 @@ sp_api::impl_runtime_apis! { } } - impl babe_primitives::BabeApi for Runtime { - fn configuration() -> babe_primitives::BabeConfiguration { + impl sp_consensus_babe::BabeApi for Runtime { + fn configuration() -> sp_consensus_babe::BabeConfiguration { let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG); - babe_primitives::BabeConfiguration { + sp_consensus_babe::BabeConfiguration { slot_duration: Babe::slot_duration(), epoch_length: EpochDurationInBlocks::get().into(), c: epoch_config.c, @@ -2217,32 +2231,32 @@ sp_api::impl_runtime_apis! { } } - fn current_epoch_start() -> babe_primitives::Slot { + fn current_epoch_start() -> sp_consensus_babe::Slot { Babe::current_epoch_start() } - fn current_epoch() -> babe_primitives::Epoch { + fn current_epoch() -> sp_consensus_babe::Epoch { Babe::current_epoch() } - fn next_epoch() -> babe_primitives::Epoch { + fn next_epoch() -> sp_consensus_babe::Epoch { Babe::next_epoch() } fn generate_key_ownership_proof( - _slot: babe_primitives::Slot, - authority_id: babe_primitives::AuthorityId, - ) -> Option { - use parity_scale_codec::Encode; + _slot: sp_consensus_babe::Slot, + authority_id: sp_consensus_babe::AuthorityId, + ) -> Option { + use codec::Encode; - Historical::prove((babe_primitives::KEY_TYPE, authority_id)) + Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id)) .map(|p| p.encode()) - .map(babe_primitives::OpaqueKeyOwnershipProof::new) + .map(sp_consensus_babe::OpaqueKeyOwnershipProof::new) } fn submit_report_equivocation_unsigned_extrinsic( - equivocation_proof: babe_primitives::EquivocationProof<::Header>, - key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof, + equivocation_proof: sp_consensus_babe::EquivocationProof<::Header>, + key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; @@ -2253,7 +2267,7 @@ sp_api::impl_runtime_apis! { } } - impl authority_discovery_primitives::AuthorityDiscoveryApi for Runtime { + impl sp_authority_discovery::AuthorityDiscoveryApi for Runtime { fn authorities() -> Vec { parachains_runtime_api_impl::relevant_authority_ids::() } @@ -2296,11 +2310,11 @@ sp_api::impl_runtime_apis! { } impl pallet_beefy_mmr::BeefyMmrApi for RuntimeApi { - fn authority_set_proof() -> beefy_primitives::mmr::BeefyAuthoritySet { + fn authority_set_proof() -> sp_consensus_beefy::mmr::BeefyAuthoritySet { MmrLeaf::authority_set_proof() } - fn next_authority_set_proof() -> beefy_primitives::mmr::BeefyNextAuthoritySet { + fn next_authority_set_proof() -> sp_consensus_beefy::mmr::BeefyNextAuthoritySet { MmrLeaf::next_authority_set_proof() } } @@ -2376,14 +2390,14 @@ sp_api::impl_runtime_apis! { impl frame_benchmarking::baseline::Config for Runtime {} impl pallet_xcm::benchmarking::Config for Runtime { type DeliveryHelper = ( - runtime_common::xcm_sender::ToParachainDeliveryHelper< + polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, AssetHubParaId, (), >, - runtime_common::xcm_sender::ToParachainDeliveryHelper< + polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, @@ -2419,7 +2433,7 @@ sp_api::impl_runtime_apis! { } fn set_up_complex_asset_transfer( - ) -> Option<(Assets, u32, Location, Box)> { + ) -> Option<(Assets, u32, Location, alloc::boxed::Box)> { // Relay supports only native token, either reserve transfer it to non-system parachains, // or teleport it to system parachain. Use the teleport case for benchmarking as it's // slightly heavier. @@ -2442,7 +2456,7 @@ sp_api::impl_runtime_apis! { impl pallet_xcm_benchmarks::Config for Runtime { type XcmConfig = XcmConfig; type AccountIdConverter = LocationConverter; - type DeliveryHelper = runtime_common::xcm_sender::ToParachainDeliveryHelper< + type DeliveryHelper = polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, diff --git a/polkadot/runtime/rococo/src/validator_manager.rs b/polkadot/runtime/rococo/src/validator_manager.rs index 0677ba7fbb2b29afda7039ba8b396cb2d66131d8..ecfbff4fa0688486acebe0313d149d1d87cbab42 100644 --- a/polkadot/runtime/rococo/src/validator_manager.rs +++ b/polkadot/runtime/rococo/src/validator_manager.rs @@ -16,8 +16,8 @@ //! A pallet for managing validators on Rococo. +use alloc::vec::Vec; use sp_staking::SessionIndex; -use sp_std::vec::Vec; pub use pallet::*; diff --git a/polkadot/runtime/rococo/src/weights/mod.rs b/polkadot/runtime/rococo/src/weights/mod.rs index 3c6845dfb43e65e85dc33b2e288f35a9a8742e1e..020f8e22594a602f4bf12336eba92470ec754c4e 100644 --- a/polkadot/runtime/rococo/src/weights/mod.rs +++ b/polkadot/runtime/rococo/src/weights/mod.rs @@ -19,12 +19,14 @@ pub mod frame_system; pub mod pallet_asset_rate; pub mod pallet_balances_balances; pub mod pallet_balances_nis_counterpart_balances; +pub mod pallet_beefy_mmr; pub mod pallet_bounties; pub mod pallet_child_bounties; pub mod pallet_conviction_voting; pub mod pallet_identity; pub mod pallet_indices; pub mod pallet_message_queue; +pub mod pallet_mmr; pub mod pallet_multisig; pub mod pallet_nis; pub mod pallet_parameters; @@ -42,20 +44,20 @@ pub mod pallet_utility; pub mod pallet_vesting; pub mod pallet_whitelist; pub mod pallet_xcm; -pub mod runtime_common_assigned_slots; -pub mod runtime_common_auctions; -pub mod runtime_common_claims; -pub mod runtime_common_crowdloan; -pub mod runtime_common_identity_migrator; -pub mod runtime_common_paras_registrar; -pub mod runtime_common_slots; -pub mod runtime_parachains_assigner_on_demand; -pub mod runtime_parachains_configuration; -pub mod runtime_parachains_coretime; -pub mod runtime_parachains_disputes; -pub mod runtime_parachains_hrmp; -pub mod runtime_parachains_inclusion; -pub mod runtime_parachains_initializer; -pub mod runtime_parachains_paras; -pub mod runtime_parachains_paras_inherent; +pub mod polkadot_runtime_common_assigned_slots; +pub mod polkadot_runtime_common_auctions; +pub mod polkadot_runtime_common_claims; +pub mod polkadot_runtime_common_crowdloan; +pub mod polkadot_runtime_common_identity_migrator; +pub mod polkadot_runtime_common_paras_registrar; +pub mod polkadot_runtime_common_slots; +pub mod polkadot_runtime_parachains_configuration; +pub mod polkadot_runtime_parachains_coretime; +pub mod polkadot_runtime_parachains_disputes; +pub mod polkadot_runtime_parachains_hrmp; +pub mod polkadot_runtime_parachains_inclusion; +pub mod polkadot_runtime_parachains_initializer; +pub mod polkadot_runtime_parachains_on_demand; +pub mod polkadot_runtime_parachains_paras; +pub mod polkadot_runtime_parachains_paras_inherent; pub mod xcm; diff --git a/polkadot/runtime/rococo/src/weights/pallet_beefy_mmr.rs b/polkadot/runtime/rococo/src/weights/pallet_beefy_mmr.rs new file mode 100644 index 0000000000000000000000000000000000000000..317c9149ec6c57c8e1c9d5bc5deb5ee648175ada --- /dev/null +++ b/polkadot/runtime/rococo/src/weights/pallet_beefy_mmr.rs @@ -0,0 +1,89 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `pallet_beefy_mmr` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-13, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_beefy_mmr +// --chain=rococo-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/rococo/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_beefy_mmr`. +pub struct WeightInfo(PhantomData); +impl pallet_beefy_mmr::WeightInfo for WeightInfo { + /// Storage: `System::BlockHash` (r:1 w:0) + /// Proof: `System::BlockHash` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) + fn extract_validation_context() -> Weight { + // Proof Size summary in bytes: + // Measured: `92` + // Estimated: `3509` + // Minimum execution time: 7_116_000 picoseconds. + Weight::from_parts(7_343_000, 0) + .saturating_add(Weight::from_parts(0, 3509)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: `Mmr::Nodes` (r:1 w:0) + /// Proof: `Mmr::Nodes` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + fn read_peak() -> Weight { + // Proof Size summary in bytes: + // Measured: `234` + // Estimated: `3505` + // Minimum execution time: 5_652_000 picoseconds. + Weight::from_parts(5_963_000, 0) + .saturating_add(Weight::from_parts(0, 3505)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: `Mmr::RootHash` (r:1 w:0) + /// Proof: `Mmr::RootHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Mmr::NumberOfLeaves` (r:1 w:0) + /// Proof: `Mmr::NumberOfLeaves` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// The range of component `n` is `[2, 512]`. + fn n_items_proof_is_non_canonical(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `226` + // Estimated: `1517` + // Minimum execution time: 11_953_000 picoseconds. + Weight::from_parts(15_978_891, 0) + .saturating_add(Weight::from_parts(0, 1517)) + // Standard Error: 1_780 + .saturating_add(Weight::from_parts(1_480_582, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(2)) + } +} diff --git a/polkadot/runtime/rococo/src/weights/pallet_mmr.rs b/polkadot/runtime/rococo/src/weights/pallet_mmr.rs new file mode 100644 index 0000000000000000000000000000000000000000..361bfc7a661b0737c936a95d20f1b6751db76aec --- /dev/null +++ b/polkadot/runtime/rococo/src/weights/pallet_mmr.rs @@ -0,0 +1,77 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `pallet_mmr` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-15, STEPS: `5`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/testnet/polkadot +// benchmark +// pallet +// --steps=5 +// --repeat=1 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --pallet=pallet_mmr +// --chain=westend-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/westend/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_mmr`. +pub struct WeightInfo(PhantomData); +impl pallet_mmr::WeightInfo for WeightInfo { + /// Storage: `Mmr::NumberOfLeaves` (r:1 w:1) + /// Proof: `Mmr::NumberOfLeaves` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `System::ParentHash` (r:1 w:0) + /// Proof: `System::ParentHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Paras::Heads` (r:2049 w:0) + /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `BeefyMmrLeaf::BeefyNextAuthorities` (r:1 w:0) + /// Proof: `BeefyMmrLeaf::BeefyNextAuthorities` (`max_values`: Some(1), `max_size`: Some(44), added: 539, mode: `MaxEncodedLen`) + /// Storage: `System::Digest` (r:1 w:1) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Mmr::Nodes` (r:0 w:1000) + /// Proof: `Mmr::Nodes` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `Mmr::RootHash` (r:0 w:1) + /// Proof: `Mmr::RootHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// The range of component `x` is `[1, 1000]`. + fn on_initialize(x: u32) -> Weight { + // Proof Size summary in bytes: + // Measured: `2140817` + // Estimated: `7213082` + // Minimum execution time: 20_387_000_000 picoseconds. + Weight::from_parts(223_625_477_528, 0) + .saturating_add(Weight::from_parts(0, 7213082)) + // Standard Error: 310_550_970 + .saturating_add(Weight::from_parts(16_906_397_286, 0).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(2053)) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } +} diff --git a/polkadot/runtime/rococo/src/weights/pallet_session.rs b/polkadot/runtime/rococo/src/weights/pallet_session.rs index dbeca534add8259fdf77010296d0c6d557365204..7f573d4e3952e8b0cdfbd1253d8c02bf389d5bb5 100644 --- a/polkadot/runtime/rococo/src/weights/pallet_session.rs +++ b/polkadot/runtime/rococo/src/weights/pallet_session.rs @@ -38,7 +38,7 @@ #![allow(unused_imports)] use frame_support::{traits::Get, weights::Weight}; -use sp_std::marker::PhantomData; +use core::marker::PhantomData; /// Weight functions for `pallet_session`. pub struct WeightInfo(PhantomData); diff --git a/polkadot/runtime/rococo/src/weights/pallet_treasury.rs b/polkadot/runtime/rococo/src/weights/pallet_treasury.rs index 144e9d5b872382b7381e2d77c6fb08a8fbece4fa..06246ada72f16fb04623f3fc6534265cc1156b79 100644 --- a/polkadot/runtime/rococo/src/weights/pallet_treasury.rs +++ b/polkadot/runtime/rococo/src/weights/pallet_treasury.rs @@ -63,51 +63,6 @@ impl pallet_treasury::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Treasury ProposalCount (r:1 w:1) - /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Treasury Proposals (r:0 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - fn propose_spend() -> Weight { - // Proof Size summary in bytes: - // Measured: `143` - // Estimated: `1489` - // Minimum execution time: 354_000_000 picoseconds. - Weight::from_parts(376_000_000, 0) - .saturating_add(Weight::from_parts(0, 1489)) - .saturating_add(T::DbWeight::get().reads(1)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: Treasury Proposals (r:1 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - fn reject_proposal() -> Weight { - // Proof Size summary in bytes: - // Measured: `301` - // Estimated: `3593` - // Minimum execution time: 547_000_000 picoseconds. - Weight::from_parts(550_000_000, 0) - .saturating_add(Weight::from_parts(0, 3593)) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: Treasury Proposals (r:1 w:0) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) - /// The range of component `p` is `[0, 99]`. - fn approve_proposal(p: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `470 + p * (8 ±0)` - // Estimated: `3573` - // Minimum execution time: 104_000_000 picoseconds. - Weight::from_parts(121_184_402, 0) - .saturating_add(Weight::from_parts(0, 3573)) - // Standard Error: 42_854 - .saturating_add(Weight::from_parts(153_112, 0).saturating_mul(p.into())) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(1)) - } /// Storage: Treasury Approvals (r:1 w:1) /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) fn remove_approval() -> Weight { diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_assigned_slots.rs similarity index 98% rename from polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_assigned_slots.rs index a6beeded428649fdda8530fda4c10492867f11a2..2aaf282c59d5c82a48e9cb228412eb2e4b83f7a1 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_assigned_slots.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_assigned_slots.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::assigned_slots`. pub struct WeightInfo(PhantomData); -impl runtime_common::assigned_slots::WeightInfo for WeightInfo { +impl polkadot_runtime_common::assigned_slots::WeightInfo for WeightInfo { /// Storage: `Registrar::Paras` (r:1 w:1) /// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Paras::ParaLifecycles` (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_auctions.rs similarity index 98% rename from polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_auctions.rs index 3cd7c7a47e90ee1bf6590d0421faf580c1c776f6..897dc1c1752a5697f903b53a394237736fcc4c0c 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_auctions.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_auctions.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::auctions`. pub struct WeightInfo(PhantomData); -impl runtime_common::auctions::WeightInfo for WeightInfo { +impl polkadot_runtime_common::auctions::WeightInfo for WeightInfo { /// Storage: Auctions AuctionInfo (r:1 w:1) /// Proof: Auctions AuctionInfo (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) /// Storage: Auctions AuctionCounter (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_claims.rs similarity index 98% rename from polkadot/runtime/rococo/src/weights/runtime_common_claims.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_claims.rs index 52e0dd24afa0aa5e4cd75d53f53ca7d032ca9588..8fbc798dbd46156c93e606b1ca669b2db706c613 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_claims.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_claims.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::claims`. pub struct WeightInfo(PhantomData); -impl runtime_common::claims::WeightInfo for WeightInfo { +impl polkadot_runtime_common::claims::WeightInfo for WeightInfo { /// Storage: Claims Claims (r:1 w:1) /// Proof Skipped: Claims Claims (max_values: None, max_size: None, mode: Measured) /// Storage: Claims Signing (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_crowdloan.rs similarity index 99% rename from polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_crowdloan.rs index 0e7420cba2e6c981d4f9c0dd9e3c95c9ce26f1c5..b75ff8d42e7e0949f89293fff1e7dd22f0cf8e1e 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_crowdloan.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_crowdloan.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::crowdloan`. pub struct WeightInfo(PhantomData); -impl runtime_common::crowdloan::WeightInfo for WeightInfo { +impl polkadot_runtime_common::crowdloan::WeightInfo for WeightInfo { /// Storage: Crowdloan Funds (r:1 w:1) /// Proof Skipped: Crowdloan Funds (max_values: None, max_size: None, mode: Measured) /// Storage: Registrar Paras (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_identity_migrator.rs similarity index 97% rename from polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_identity_migrator.rs index cec357453b67be400c0191ac7d5c12e6961a4bee..4ea6f67968017e312562842c5f2400754ac83b95 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_identity_migrator.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_identity_migrator.rs @@ -42,7 +42,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::identity_migrator`. pub struct WeightInfo(PhantomData); -impl runtime_common::identity_migrator::WeightInfo for WeightInfo { +impl polkadot_runtime_common::identity_migrator::WeightInfo for WeightInfo { /// Storage: `Identity::IdentityOf` (r:1 w:1) /// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`) /// Storage: `Identity::SubsOf` (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_paras_registrar.rs similarity index 99% rename from polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_paras_registrar.rs index 0a56562a1a95f24e9efddc6c26e16c4feeaf37c2..0ce09d1be2a46afebc421526bad324acef4bdeb6 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_paras_registrar.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_paras_registrar.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::paras_registrar`. pub struct WeightInfo(PhantomData); -impl runtime_common::paras_registrar::WeightInfo for WeightInfo { +impl polkadot_runtime_common::paras_registrar::WeightInfo for WeightInfo { /// Storage: Registrar NextFreeParaId (r:1 w:1) /// Proof Skipped: Registrar NextFreeParaId (max_values: Some(1), max_size: None, mode: Measured) /// Storage: Registrar Paras (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_slots.rs similarity index 98% rename from polkadot/runtime/rococo/src/weights/runtime_common_slots.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_common_slots.rs index 23ab1ed3ee0efff9e95fd3526d022c9becad7b93..8c601aa8486f86ad702c94dfa6ef69ba46407dbf 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_slots.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_common_slots.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::slots`. pub struct WeightInfo(PhantomData); -impl runtime_common::slots::WeightInfo for WeightInfo { +impl polkadot_runtime_common::slots::WeightInfo for WeightInfo { /// Storage: Slots Leases (r:1 w:1) /// Proof Skipped: Slots Leases (max_values: None, max_size: None, mode: Measured) /// Storage: System Account (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_configuration.rs similarity index 98% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_configuration.rs index ca0575cb1b64689b7b016d63a2cfc5080dc874a5..5592a85c90fab339f57ca8d52f2e8e5330aa1813 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_configuration.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_configuration.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::configuration`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::configuration::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::configuration::WeightInfo for WeightInfo { /// Storage: `Configuration::PendingConfigs` (r:1 w:1) /// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0) diff --git a/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_coretime.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_coretime.rs new file mode 100644 index 0000000000000000000000000000000000000000..b2329c098cead5d2780b6ac44a1d6b5963efcaf8 --- /dev/null +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_coretime.rs @@ -0,0 +1,106 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `runtime_common::coretime` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-1pho9goo-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=runtime_common::coretime +// --chain=rococo-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/rococo/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `runtime_common::coretime`. +pub struct WeightInfo(PhantomData); +impl polkadot_runtime_parachains::coretime::WeightInfo for WeightInfo { + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0) + /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `XcmPallet::SupportedVersion` (r:1 w:0) + /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn request_revenue_at() -> Weight { + // Proof Size summary in bytes: + // Measured: `2963` + // Estimated: `6428` + // Minimum execution time: 36_613_000 picoseconds. + Weight::from_parts(37_637_000, 0) + .saturating_add(Weight::from_parts(0, 6428)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(3)) + } + /// Storage: `Configuration::PendingConfigs` (r:1 w:1) + /// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0) + /// Proof: `Configuration::BypassConsistencyCheck` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0) + /// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn request_core_count() -> Weight { + // Proof Size summary in bytes: + // Measured: `151` + // Estimated: `1636` + // Minimum execution time: 7_527_000 picoseconds. + Weight::from_parts(7_784_000, 0) + .saturating_add(Weight::from_parts(0, 1636)) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(1)) + } + /// Storage: `CoretimeAssignmentProvider::CoreDescriptors` (r:1 w:1) + /// Proof: `CoretimeAssignmentProvider::CoreDescriptors` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `CoretimeAssignmentProvider::CoreSchedules` (r:0 w:1) + /// Proof: `CoretimeAssignmentProvider::CoreSchedules` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// The range of component `s` is `[1, 100]`. + fn assign_core(s: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `180` + // Estimated: `3645` + // Minimum execution time: 9_220_000 picoseconds. + Weight::from_parts(9_905_773, 0) + .saturating_add(Weight::from_parts(0, 3645)) + // Standard Error: 257 + .saturating_add(Weight::from_parts(12_400, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(2)) + } +} diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_disputes.rs similarity index 95% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_disputes.rs index 63a8c3addc7da4296041627ee8492945945bce7f..a20515502b1910ccb8eaf6477d3c51e00db9064e 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_disputes.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_disputes.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::disputes`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::disputes::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::disputes::WeightInfo for WeightInfo { /// Storage: ParasDisputes Frozen (r:0 w:1) /// Proof Skipped: ParasDisputes Frozen (max_values: Some(1), max_size: None, mode: Measured) fn force_unfreeze() -> Weight { diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_hrmp.rs similarity index 99% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_hrmp.rs index 572ecc7d4110f0335b18a3c276032b4f6d285db5..3c9def0b37e5dccdb03b8dd99169e3038edace9a 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_hrmp.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_hrmp.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::hrmp`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::hrmp::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::hrmp::WeightInfo for WeightInfo { /// Storage: `Paras::ParaLifecycles` (r:1 w:0) /// Proof: `Paras::ParaLifecycles` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Hrmp::HrmpOpenChannelRequests` (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_inclusion.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_inclusion.rs new file mode 100644 index 0000000000000000000000000000000000000000..4c6ce8835573b9c256d3a723bc7213a7f7d8f563 --- /dev/null +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_inclusion.rs @@ -0,0 +1,123 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `polkadot_runtime_parachains::inclusion` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=polkadot_runtime_parachains::inclusion +// --chain=rococo-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/rococo/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `polkadot_runtime_parachains::inclusion`. +pub struct WeightInfo(PhantomData); +impl polkadot_runtime_parachains::inclusion::WeightInfo for WeightInfo { + /// Storage: `Paras::FutureCodeHash` (r:1 w:1) + /// Proof: `Paras::FutureCodeHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CurrentCodeHash` (r:1 w:0) + /// Proof: `Paras::CurrentCodeHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeCooldowns` (r:1 w:1) + /// Proof: `Paras::UpgradeCooldowns` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::PvfActiveVoteMap` (r:1 w:1) + /// Proof: `Paras::PvfActiveVoteMap` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CodeByHash` (r:1 w:1) + /// Proof: `Paras::CodeByHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorKeys` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorKeys` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::PvfActiveVoteList` (r:1 w:1) + /// Proof: `Paras::PvfActiveVoteList` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CodeByHashRefs` (r:1 w:1) + /// Proof: `Paras::CodeByHashRefs` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:1) + /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `MessageQueue::BookStateFor` (r:1 w:1) + /// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(55), added: 2530, mode: `MaxEncodedLen`) + /// Storage: `MessageQueue::Pages` (r:1 w:32) + /// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(32818), added: 35293, mode: `MaxEncodedLen`) + /// Storage: `Hrmp::HrmpChannelDigests` (r:33 w:33) + /// Proof: `Hrmp::HrmpChannelDigests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Hrmp::HrmpChannels` (r:32 w:32) + /// Proof: `Hrmp::HrmpChannels` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Hrmp::HrmpChannelContents` (r:32 w:32) + /// Proof: `Hrmp::HrmpChannelContents` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::FutureCodeUpgrades` (r:1 w:0) + /// Proof: `Paras::FutureCodeUpgrades` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Registrar::Paras` (r:1 w:0) + /// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: UNKNOWN KEY `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) + /// Proof: UNKNOWN KEY `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) + /// Storage: `Hrmp::HrmpWatermarks` (r:0 w:1) + /// Proof: `Hrmp::HrmpWatermarks` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::Heads` (r:0 w:1) + /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeGoAheadSignal` (r:0 w:1) + /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::MostRecentContext` (r:0 w:1) + /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeRestrictionSignal` (r:0 w:1) + /// Proof: `Paras::UpgradeRestrictionSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: UNKNOWN KEY `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) + /// Proof: UNKNOWN KEY `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) + /// The range of component `u` is `[1, 32]`. + /// The range of component `h` is `[1, 32]`. + /// The range of component `c` is `[0, 1]`. + fn enact_candidate(u: u32, h: u32, c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `33353 + c * (16114 ±0) + h * (75 ±0)` + // Estimated: `36818 + c * (26467 ±0) + h * (2551 ±0)` + // Minimum execution time: 4_829_551_000 picoseconds. + Weight::from_parts(1_892_697_027, 0) + .saturating_add(Weight::from_parts(0, 36818)) + // Standard Error: 793_993 + .saturating_add(Weight::from_parts(126_698_671, 0).saturating_mul(u.into())) + // Standard Error: 793_993 + .saturating_add(Weight::from_parts(144_116_038, 0).saturating_mul(h.into())) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(h.into()))) + .saturating_add(T::DbWeight::get().reads((8_u64).saturating_mul(c.into()))) + .saturating_add(T::DbWeight::get().writes(10)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into()))) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(h.into()))) + .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(c.into()))) + .saturating_add(Weight::from_parts(0, 26467).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(0, 2551).saturating_mul(h.into())) + } +} diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_initializer.rs similarity index 96% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_initializer.rs index 5c627507dfb682a603152fee2155b620773dcd49..6065c32b17411fe60ba4797fc9d34f224867abdd 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_initializer.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_initializer.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::initializer`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::initializer::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::initializer::WeightInfo for WeightInfo { /// Storage: System Digest (r:1 w:1) /// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured) /// The range of component `d` is `[0, 65536]`. diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_on_demand.rs similarity index 63% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_on_demand.rs index dba9e7904c79065c33c9fffc9851171c72c2e66a..0c36eeaf7d4506c0d4d6045b4720faf8ae4ae437 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_assigner_on_demand.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_on_demand.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! Autogenerated weights for `runtime_parachains::assigner_on_demand` +//! Autogenerated weights for `runtime_parachains::on_demand` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-1pho9goo-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -32,7 +32,7 @@ // --wasm-execution=compiled // --heap-pages=4096 // --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=runtime_parachains::assigner_on_demand +// --pallet=runtime_parachains::on_demand // --chain=rococo-dev // --header=./polkadot/file_header.txt // --output=./polkadot/runtime/rococo/src/weights/ @@ -45,11 +45,15 @@ use frame_support::{traits::Get, weights::Weight}; use core::marker::PhantomData; -/// Weight functions for `runtime_parachains::assigner_on_demand`. +/// Weight functions for `runtime_parachains::on_demand`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::on_demand::WeightInfo for WeightInfo { /// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1) /// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0) /// Proof: `OnDemandAssignmentProvider::ParaIdAffinity` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::FreeEntries` (r:1 w:1) @@ -57,19 +61,23 @@ impl runtime_parachains::assigner_on_demand::WeightInfo /// The range of component `s` is `[1, 9999]`. fn place_order_keep_alive(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `218 + s * (8 ±0)` - // Estimated: `3681 + s * (8 ±0)` - // Minimum execution time: 21_053_000 picoseconds. - Weight::from_parts(17_291_897, 0) - .saturating_add(Weight::from_parts(0, 3681)) - // Standard Error: 104 - .saturating_add(Weight::from_parts(18_779, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `270 + s * (8 ±0)` + // Estimated: `3733 + s * (8 ±0)` + // Minimum execution time: 28_422_000 picoseconds. + Weight::from_parts(28_146_882, 0) + .saturating_add(Weight::from_parts(0, 3733)) + // Standard Error: 140 + .saturating_add(Weight::from_parts(21_283, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(s.into())) } /// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1) /// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0) /// Proof: `OnDemandAssignmentProvider::ParaIdAffinity` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::FreeEntries` (r:1 w:1) @@ -77,15 +85,15 @@ impl runtime_parachains::assigner_on_demand::WeightInfo /// The range of component `s` is `[1, 9999]`. fn place_order_allow_death(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `218 + s * (8 ±0)` - // Estimated: `3681 + s * (8 ±0)` - // Minimum execution time: 20_843_000 picoseconds. - Weight::from_parts(16_881_986, 0) - .saturating_add(Weight::from_parts(0, 3681)) - // Standard Error: 104 - .saturating_add(Weight::from_parts(18_788, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `270 + s * (8 ±0)` + // Estimated: `3733 + s * (8 ±0)` + // Minimum execution time: 28_680_000 picoseconds. + Weight::from_parts(31_024_579, 0) + .saturating_add(Weight::from_parts(0, 3733)) + // Standard Error: 119 + .saturating_add(Weight::from_parts(20_989, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(s.into())) } } diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras.rs similarity index 99% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras.rs index dfd95006dc7d0a6cedeeab9908d99a2c1c7e561a..2dcabb7c36bbdf994e2460b320566efca709facc 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras.rs @@ -46,7 +46,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::paras`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::paras::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::paras::WeightInfo for WeightInfo { /// Storage: Paras CurrentCodeHash (r:1 w:1) /// Proof Skipped: Paras CurrentCodeHash (max_values: None, max_size: None, mode: Measured) /// Storage: Paras CodeByHashRefs (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras_inherent.rs similarity index 81% rename from polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs rename to polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras_inherent.rs index c250c86665be0eebf54e570e73290a3ebdbdab82..b7b3d12d4d92c301c4b4a8754890676d3ca291d6 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_paras_inherent.rs +++ b/polkadot/runtime/rococo/src/weights/polkadot_runtime_parachains_paras_inherent.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! Autogenerated weights for `runtime_parachains::paras_inherent` +//! Autogenerated weights for `polkadot_runtime_parachains::paras_inherent` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 // Executed Command: @@ -32,7 +32,7 @@ // --wasm-execution=compiled // --heap-pages=4096 // --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=runtime_parachains::paras_inherent +// --pallet=polkadot_runtime_parachains::paras_inherent // --chain=rococo-dev // --header=./polkadot/file_header.txt // --output=./polkadot/runtime/rococo/src/weights/ @@ -45,9 +45,49 @@ use frame_support::{traits::Get, weights::Weight}; use core::marker::PhantomData; -/// Weight functions for `runtime_parachains::paras_inherent`. +/// Weight functions for `polkadot_runtime_parachains::paras_inherent`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::paras_inherent::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::paras_inherent::WeightInfo for WeightInfo { + /// Storage: `ParaInherent::Included` (r:1 w:1) + /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::ParentHash` (r:1 w:0) + /// Proof: `System::ParentHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `ParasShared::AllowedRelayParents` (r:1 w:1) + /// Proof: `ParasShared::AllowedRelayParents` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0) + /// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::AvailabilityCores` (r:1 w:1) + /// Proof: `ParaScheduler::AvailabilityCores` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorKeys` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorKeys` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Babe::AuthorVrfRandomness` (r:1 w:0) + /// Proof: `Babe::AuthorVrfRandomness` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`) + /// Storage: `ParaInherent::OnChainVotes` (r:1 w:1) + /// Proof: `ParaInherent::OnChainVotes` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasDisputes::Frozen` (r:1 w:0) + /// Proof: `ParasDisputes::Frozen` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaInclusion::V1` (r:1 w:0) + /// Proof: `ParaInclusion::V1` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::SessionStartBlock` (r:1 w:0) + /// Proof: `ParaScheduler::SessionStartBlock` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::ValidatorGroups` (r:1 w:0) + /// Proof: `ParaScheduler::ValidatorGroups` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::ClaimQueue` (r:1 w:1) + /// Proof: `ParaScheduler::ClaimQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorIndices` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorIndices` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Session::DisabledValidators` (r:1 w:0) + /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn enter_empty() -> Weight { + // Proof Size summary in bytes: + // Measured: `8967` + // Estimated: `12432` + // Minimum execution time: 144_751_000 picoseconds. + Weight::from_parts(153_966_000, 0) + .saturating_add(Weight::from_parts(0, 12432)) + .saturating_add(T::DbWeight::get().reads(15)) + .saturating_add(T::DbWeight::get().writes(5)) + } /// Storage: `ParaInherent::Included` (r:1 w:1) /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `System::ParentHash` (r:1 w:0) @@ -109,13 +149,13 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// The range of component `v` is `[10, 200]`. fn enter_variable_disputes(v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `67785` - // Estimated: `73725 + v * (23 ±0)` - // Minimum execution time: 949_716_000 picoseconds. - Weight::from_parts(482_361_515, 0) - .saturating_add(Weight::from_parts(0, 73725)) - // Standard Error: 17_471 - .saturating_add(Weight::from_parts(50_100_764, 0).saturating_mul(v.into())) + // Measured: `67786` + // Estimated: `73726 + v * (23 ±0)` + // Minimum execution time: 972_311_000 picoseconds. + Weight::from_parts(645_559_304, 0) + .saturating_add(Weight::from_parts(0, 73726)) + // Standard Error: 53_320 + .saturating_add(Weight::from_parts(41_795_493, 0).saturating_mul(v.into())) .saturating_add(T::DbWeight::get().reads(25)) .saturating_add(T::DbWeight::get().writes(15)) .saturating_add(Weight::from_parts(0, 23).saturating_mul(v.into())) @@ -140,18 +180,6 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `ParasDisputes::Frozen` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParaInclusion::V1` (r:2 w:1) /// Proof: `ParaInclusion::V1` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) - /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:1) - /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Hrmp::HrmpChannelDigests` (r:1 w:1) - /// Proof: `Hrmp::HrmpChannelDigests` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::FutureCodeUpgrades` (r:1 w:0) - /// Proof: `Paras::FutureCodeUpgrades` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Registrar::Paras` (r:1 w:0) - /// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `ParasDisputes::Disputes` (r:1 w:0) - /// Proof: `ParasDisputes::Disputes` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `ParaScheduler::SessionStartBlock` (r:1 w:0) /// Proof: `ParaScheduler::SessionStartBlock` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParaScheduler::ValidatorGroups` (r:1 w:0) @@ -164,25 +192,15 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `ParasShared::ActiveValidatorIndices` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Session::DisabledValidators` (r:1 w:0) /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - /// Storage: `ParasDisputes::Included` (r:0 w:1) - /// Proof: `ParasDisputes::Included` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Hrmp::HrmpWatermarks` (r:0 w:1) - /// Proof: `Hrmp::HrmpWatermarks` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::Heads` (r:0 w:1) - /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::UpgradeGoAheadSignal` (r:0 w:1) - /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::MostRecentContext` (r:0 w:1) - /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) fn enter_bitfields() -> Weight { // Proof Size summary in bytes: - // Measured: `42757` - // Estimated: `48697` - // Minimum execution time: 437_627_000 picoseconds. - Weight::from_parts(460_975_000, 0) - .saturating_add(Weight::from_parts(0, 48697)) - .saturating_add(T::DbWeight::get().reads(23)) - .saturating_add(T::DbWeight::get().writes(15)) + // Measured: `42374` + // Estimated: `48314` + // Minimum execution time: 361_262_000 picoseconds. + Weight::from_parts(370_617_000, 0) + .saturating_add(Weight::from_parts(0, 48314)) + .saturating_add(T::DbWeight::get().reads(17)) + .saturating_add(T::DbWeight::get().writes(7)) } /// Storage: `ParaInherent::Included` (r:1 w:1) /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) @@ -247,13 +265,13 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// The range of component `v` is `[101, 200]`. fn enter_backed_candidates_variable(v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `42829` - // Estimated: `48769` - // Minimum execution time: 1_305_254_000 picoseconds. - Weight::from_parts(1_347_160_667, 0) - .saturating_add(Weight::from_parts(0, 48769)) - // Standard Error: 22_128 - .saturating_add(Weight::from_parts(57_229, 0).saturating_mul(v.into())) + // Measured: `42830` + // Estimated: `48770` + // Minimum execution time: 1_322_051_000 picoseconds. + Weight::from_parts(1_379_846_608, 0) + .saturating_add(Weight::from_parts(0, 48770)) + // Standard Error: 19_959 + .saturating_add(Weight::from_parts(24_630, 0).saturating_mul(v.into())) .saturating_add(T::DbWeight::get().reads(26)) .saturating_add(T::DbWeight::get().writes(15)) } @@ -323,11 +341,11 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) fn enter_backed_candidate_code_upgrade() -> Weight { // Proof Size summary in bytes: - // Measured: `42842` - // Estimated: `48782` - // Minimum execution time: 38_637_547_000 picoseconds. - Weight::from_parts(41_447_412_000, 0) - .saturating_add(Weight::from_parts(0, 48782)) + // Measured: `42843` + // Estimated: `48783` + // Minimum execution time: 37_550_515_000 picoseconds. + Weight::from_parts(37_886_489_000, 0) + .saturating_add(Weight::from_parts(0, 48783)) .saturating_add(T::DbWeight::get().reads(28)) .saturating_add(T::DbWeight::get().writes(15)) } diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs deleted file mode 100644 index d9f2d45207b923e3afe661a6021629cb8441970e..0000000000000000000000000000000000000000 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_coretime.rs +++ /dev/null @@ -1,73 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Polkadot. - -// Polkadot 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. - -// Polkadot 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 Polkadot. If not, see . - -//! Autogenerated weights for `runtime_parachains::coretime` -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-12-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-r43aesjn-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` -//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("rococo-dev")`, DB CACHE: 1024 - -// Executed Command: -// target/production/polkadot -// benchmark -// pallet -// --steps=50 -// --repeat=20 -// --extrinsic=* -// --wasm-execution=compiled -// --heap-pages=4096 -// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=runtime_common::coretime -// --chain=rococo-dev -// --header=./polkadot/file_header.txt -// --output=./polkadot/runtime/rococo/src/weights/ - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(missing_docs)] - -use frame_support::{traits::Get, weights::Weight}; -use core::marker::PhantomData; - -use runtime_parachains::configuration::{self, WeightInfo as ConfigWeightInfo}; - -/// Weight functions for `runtime_common::coretime`. -pub struct WeightInfo(PhantomData); -impl runtime_parachains::coretime::WeightInfo for WeightInfo { - fn request_core_count() -> Weight { - ::WeightInfo::set_config_with_u32() - } - /// Storage: `CoreTimeAssignmentProvider::CoreDescriptors` (r:1 w:1) - /// Proof: `CoreTimeAssignmentProvider::CoreDescriptors` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `CoreTimeAssignmentProvider::CoreSchedules` (r:0 w:1) - /// Proof: `CoreTimeAssignmentProvider::CoreSchedules` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `s` is `[1, 100]`. - fn assign_core(s: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `76` - // Estimated: `3541` - // Minimum execution time: 6_275_000 picoseconds. - Weight::from_parts(6_883_543, 0) - .saturating_add(Weight::from_parts(0, 3541)) - // Standard Error: 202 - .saturating_add(Weight::from_parts(15_028, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(1)) - .saturating_add(T::DbWeight::get().writes(2)) - } -} diff --git a/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs b/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs deleted file mode 100644 index a121ad774cefecf91e57838e03107fde22674f94..0000000000000000000000000000000000000000 --- a/polkadot/runtime/rococo/src/weights/runtime_parachains_inclusion.rs +++ /dev/null @@ -1,74 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Polkadot. - -// Polkadot 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. - -// Polkadot 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 Polkadot. If not, see . - -//! Autogenerated weights for `runtime_parachains::inclusion` -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-05-26, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `bm5`, CPU: `Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 1024 - -// Executed Command: -// ./target/production/polkadot -// benchmark -// pallet -// --chain=rococo-dev -// --steps=50 -// --repeat=20 -// --pallet=runtime_parachains::inclusion -// --extrinsic=* -// --execution=wasm -// --wasm-execution=compiled -// --header=./file_header.txt -// --output=./runtime/rococo/src/weights/runtime_parachains_inclusion.rs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(missing_docs)] - -use frame_support::{traits::Get, weights::Weight}; -use core::marker::PhantomData; - -/// Weight functions for `runtime_parachains::inclusion`. -pub struct WeightInfo(PhantomData); -impl runtime_parachains::inclusion::WeightInfo for WeightInfo { - /// Storage: MessageQueue BookStateFor (r:1 w:1) - /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(55), added: 2530, mode: MaxEncodedLen) - /// Storage: MessageQueue Pages (r:1 w:999) - /// Proof: MessageQueue Pages (max_values: None, max_size: Some(32818), added: 35293, mode: MaxEncodedLen) - /// Storage: Configuration ActiveConfig (r:1 w:0) - /// Proof Skipped: Configuration ActiveConfig (max_values: Some(1), max_size: None, mode: Measured) - /// Storage: unknown `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) - /// Proof Skipped: unknown `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) - /// Storage: unknown `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) - /// Proof Skipped: unknown `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) - /// The range of component `i` is `[1, 1000]`. - fn receive_upward_messages(i: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `33280` - // Estimated: `36283` - // Minimum execution time: 71_094_000 picoseconds. - Weight::from_parts(71_436_000, 0) - .saturating_add(Weight::from_parts(0, 36283)) - // Standard Error: 22_149 - .saturating_add(Weight::from_parts(51_495_472, 0).saturating_mul(i.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(3)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) - } -} diff --git a/polkadot/runtime/rococo/src/weights/xcm/mod.rs b/polkadot/runtime/rococo/src/weights/xcm/mod.rs index 12f3df897b1eedb6e722e8f4871eb631bd35aaa3..bd2b0fbb8c061519f99ac1b33b53bb3a387ece74 100644 --- a/polkadot/runtime/rococo/src/weights/xcm/mod.rs +++ b/polkadot/runtime/rococo/src/weights/xcm/mod.rs @@ -18,8 +18,8 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::Runtime; +use alloc::vec::Vec; use frame_support::weights::Weight; -use sp_std::prelude::*; use xcm::{latest::prelude::*, DoubleEncoded}; use pallet_xcm_benchmarks_fungible::WeightInfo as XcmBalancesWeight; diff --git a/polkadot/runtime/rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/polkadot/runtime/rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 60c40429b1ac323e69bca1345c41c3c04c221f79..7d743b209124a51c3a09edfd84fbff4d18eb665f 100644 --- a/polkadot/runtime/rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/polkadot/runtime/rococo/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-09-28, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-nbnwcyh-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("rococo-dev"), DB CACHE: 1024 // Executed Command: @@ -55,8 +55,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 23_189_000 picoseconds. - Weight::from_parts(23_896_000, 3593) + // Minimum execution time: 30_672_000 picoseconds. + Weight::from_parts(31_677_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -66,8 +66,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 50_299_000 picoseconds. - Weight::from_parts(50_962_000, 6196) + // Minimum execution time: 41_132_000 picoseconds. + Weight::from_parts(41_654_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -83,10 +83,10 @@ impl WeightInfo { /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn transfer_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `243` + // Measured: `281` // Estimated: `6196` - // Minimum execution time: 71_748_000 picoseconds. - Weight::from_parts(74_072_000, 6196) + // Minimum execution time: 97_174_000 picoseconds. + Weight::from_parts(99_537_000, 6196) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(4)) } @@ -105,16 +105,18 @@ impl WeightInfo { /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn initiate_reserve_withdraw() -> Weight { // Proof Size summary in bytes: - // Measured: `142` - // Estimated: `3607` - // Minimum execution time: 27_806_000 picoseconds. - Weight::from_parts(28_594_000, 3607) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `281` + // Estimated: `3746` + // Minimum execution time: 67_105_000 picoseconds. + Weight::from_parts(68_659_000, 3746) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -122,8 +124,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 21_199_000 picoseconds. - Weight::from_parts(21_857_000, 3593) + // Minimum execution time: 30_780_000 picoseconds. + Weight::from_parts(31_496_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -133,27 +135,27 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 23_578_000 picoseconds. - Weight::from_parts(24_060_000, 3593) + // Minimum execution time: 23_411_000 picoseconds. + Weight::from_parts(23_891_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: `System::Account` (r:1 w:1) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0) /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `XcmPallet::SupportedVersion` (r:1 w:0) /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn deposit_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `142` - // Estimated: `3607` - // Minimum execution time: 48_522_000 picoseconds. - Weight::from_parts(49_640_000, 3607) + // Measured: `180` + // Estimated: `3645` + // Minimum execution time: 61_541_000 picoseconds. + Weight::from_parts(63_677_000, 3645) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -169,10 +171,10 @@ impl WeightInfo { /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn initiate_teleport() -> Weight { // Proof Size summary in bytes: - // Measured: `142` - // Estimated: `3607` - // Minimum execution time: 50_429_000 picoseconds. - Weight::from_parts(51_295_000, 3607) + // Measured: `180` + // Estimated: `3645` + // Minimum execution time: 48_574_000 picoseconds. + Weight::from_parts(49_469_000, 3645) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) } diff --git a/polkadot/runtime/rococo/src/xcm_config.rs b/polkadot/runtime/rococo/src/xcm_config.rs index decbc795143f006ee50cc98d860e795165269cf5..05e0ee64820a421eb4a8bdb6d8bd7624edcf611e 100644 --- a/polkadot/runtime/rococo/src/xcm_config.rs +++ b/polkadot/runtime/rococo/src/xcm_config.rs @@ -29,11 +29,11 @@ use frame_support::{ weights::Weight, }; use frame_system::EnsureRoot; -use rococo_runtime_constants::{currency::CENTS, system_parachain::*}; -use runtime_common::{ +use polkadot_runtime_common::{ xcm_sender::{ChildParachainRouter, ExponentialPrice}, ToAuthor, }; +use rococo_runtime_constants::{currency::CENTS, system_parachain::*}; use sp_core::ConstU32; use xcm::latest::prelude::*; use xcm_builder::{ @@ -41,10 +41,10 @@ use xcm_builder::{ AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, ChildParachainAsNative, ChildParachainConvertsVia, DescribeAllTerminal, DescribeFamily, FixedWeightBounds, FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsChildSystemParachain, - IsConcrete, MintLocation, OriginToPluralityVoice, SignedAccountId32AsNative, - SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, - UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, - XcmFeeManagerFromComponents, XcmFeeToAccount, + IsConcrete, MintLocation, OriginToPluralityVoice, SendXcmFeeToAccount, + SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, + TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, + XcmFeeManagerFromComponents, }; use xcm_executor::XcmExecutor; @@ -213,7 +213,7 @@ impl xcm_executor::Config for XcmConfig { type MaxAssetsIntoHolding = MaxAssetsIntoHolding; type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/polkadot/runtime/test-runtime/Cargo.toml b/polkadot/runtime/test-runtime/Cargo.toml index 6552ed4ef8aeaa2e36aa1f410879cc4cf0eeaf07..ac379b69e3f2ca99f22a7ed336b09b6193342fec 100644 --- a/polkadot/runtime/test-runtime/Cargo.toml +++ b/polkadot/runtime/test-runtime/Cargo.toml @@ -11,68 +11,67 @@ license.workspace = true workspace = true [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } +codec = { features = ["derive"], workspace = true } log = { workspace = true } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +scale-info = { features = ["derive"], workspace = true } serde = { workspace = true } -authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false } -babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false } -offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-genesis-builder = { path = "../../../substrate/primitives/genesis-builder", default-features = false } -sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-range", default-features = false } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-version = { path = "../../../substrate/primitives/version", default-features = false } -frame-election-provider-support = { path = "../../../substrate/frame/election-provider-support", default-features = false } -tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false } -block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false } +sp-authority-discovery = { workspace = true } +sp-consensus-babe = { workspace = true } +sp-consensus-beefy = { workspace = true } +sp-api = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +sp-staking = { workspace = true } +sp-core = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-mmr-primitives = { workspace = true } +sp-session = { workspace = true } +sp-version = { workspace = true } +frame-election-provider-support = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-block-builder = { workspace = true } -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-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -frame-executive = { path = "../../../substrate/frame/executive", default-features = false } -pallet-grandpa = { path = "../../../substrate/frame/grandpa", default-features = false } -pallet-indices = { path = "../../../substrate/frame/indices", default-features = false } -pallet-offences = { path = "../../../substrate/frame/offences", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -pallet-staking = { path = "../../../substrate/frame/staking", default-features = false } -pallet-staking-reward-curve = { path = "../../../substrate/frame/staking/reward-curve" } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false } -test-runtime-constants = { package = "test-runtime-constants", path = "constants", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-sudo = { path = "../../../substrate/frame/sudo", default-features = false } -pallet-vesting = { path = "../../../substrate/frame/vesting", default-features = false } +pallet-authority-discovery = { workspace = true } +pallet-authorship = { workspace = true } +pallet-babe = { workspace = true } +pallet-balances = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +frame-executive = { workspace = true } +pallet-grandpa = { workspace = true } +pallet-indices = { workspace = true } +pallet-offences = { workspace = true } +pallet-session = { workspace = true } +frame-support = { workspace = true } +pallet-staking = { workspace = true } +pallet-staking-reward-curve = { workspace = true, default-features = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +test-runtime-constants = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-sudo = { workspace = true } +pallet-vesting = { workspace = true } -runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } -pallet-xcm = { path = "../../xcm/pallet-xcm", default-features = false } -polkadot-runtime-parachains = { path = "../parachains", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm/xcm-builder", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false } -xcm = { package = "staging-xcm", path = "../../xcm", default-features = false } +polkadot-runtime-common = { workspace = true } +polkadot-primitives = { workspace = true } +pallet-xcm = { workspace = true } +polkadot-runtime-parachains = { workspace = true } +xcm-builder = { workspace = true } +xcm-executor = { workspace = true } +xcm = { workspace = true } [dev-dependencies] -hex-literal = "0.4.1" -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" } -sp-trie = { path = "../../../substrate/primitives/trie" } +hex-literal = { workspace = true, default-features = true } +tiny-keccak = { features = ["keccak"], workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] @@ -84,18 +83,13 @@ runtime-metrics = [ ] std = [ - "authority-discovery-primitives/std", - "babe-primitives/std", - "beefy-primitives/std", - "block-builder-api/std", + "codec/std", "frame-election-provider-support/std", "frame-executive/std", "frame-support/std", "frame-system-rpc-runtime-api/std", "frame-system/std", - "inherents/std", "log/std", - "offchain-primitives/std", "pallet-authority-discovery/std", "pallet-authorship/std", "pallet-babe/std", @@ -111,24 +105,28 @@ std = [ "pallet-transaction-payment/std", "pallet-vesting/std", "pallet-xcm/std", - "parity-scale-codec/std", + "polkadot-primitives/std", + "polkadot-runtime-common/std", "polkadot-runtime-parachains/std", - "primitives/std", - "runtime-common/std", "scale-info/std", "serde/std", "sp-api/std", + "sp-authority-discovery/std", + "sp-block-builder/std", + "sp-consensus-babe/std", + "sp-consensus-beefy/std", "sp-core/std", "sp-genesis-builder/std", + "sp-inherents/std", "sp-io/std", "sp-mmr-primitives/std", + "sp-offchain/std", "sp-runtime/std", "sp-session/std", "sp-staking/std", - "sp-std/std", + "sp-transaction-pool/std", "sp-version/std", "test-runtime-constants/std", - "tx-pool-api/std", "xcm-builder/std", "xcm-executor/std", "xcm/std", @@ -148,9 +146,9 @@ runtime-benchmarks = [ "pallet-timestamp/runtime-benchmarks", "pallet-vesting/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", + "polkadot-runtime-common/runtime-benchmarks", "polkadot-runtime-parachains/runtime-benchmarks", - "primitives/runtime-benchmarks", - "runtime-common/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", "xcm-builder/runtime-benchmarks", diff --git a/polkadot/runtime/test-runtime/constants/Cargo.toml b/polkadot/runtime/test-runtime/constants/Cargo.toml index 5b8a4d7a051af84701065a3836d813630011bd0c..807774be7136961b5b2fa146cca50f4efc666fa7 100644 --- a/polkadot/runtime/test-runtime/constants/Cargo.toml +++ b/polkadot/runtime/test-runtime/constants/Cargo.toml @@ -10,16 +10,16 @@ license.workspace = true workspace = true [dependencies] -smallvec = "1.8.0" +smallvec = { workspace = true, default-features = true } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } +frame-support = { workspace = true } +polkadot-primitives = { workspace = true } +sp-runtime = { workspace = true } [features] default = ["std"] std = [ "frame-support/std", - "primitives/std", + "polkadot-primitives/std", "sp-runtime/std", ] diff --git a/polkadot/runtime/test-runtime/constants/src/lib.rs b/polkadot/runtime/test-runtime/constants/src/lib.rs index 77c83b063cf0f8fb7771545faa074b315fa75a03..0d16909b2990590105df1a2dbde0416728e105d1 100644 --- a/polkadot/runtime/test-runtime/constants/src/lib.rs +++ b/polkadot/runtime/test-runtime/constants/src/lib.rs @@ -20,7 +20,7 @@ pub mod weights; /// Money matters. pub mod currency { - use primitives::Balance; + use polkadot_primitives::Balance; pub const DOTS: Balance = 1_000_000_000_000; pub const DOLLARS: Balance = DOTS; @@ -30,7 +30,7 @@ pub mod currency { /// Time and blocks. pub mod time { - use primitives::{BlockNumber, Moment}; + use polkadot_primitives::{BlockNumber, Moment}; // Testnet pub const MILLISECS_PER_BLOCK: Moment = 6000; pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK; @@ -45,7 +45,7 @@ pub mod time { // 1 in 4 blocks (on average, not counting collisions) will be primary babe blocks. // The choice of is done in accordance to the slot duration and expected target // block time, for safely resisting network delays of maximum two seconds. - // + // pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4); } @@ -55,7 +55,7 @@ pub mod fee { use frame_support::weights::{ WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial, }; - use primitives::Balance; + use polkadot_primitives::Balance; use smallvec::smallvec; pub use sp_runtime::Perbill; diff --git a/polkadot/runtime/test-runtime/src/lib.rs b/polkadot/runtime/test-runtime/src/lib.rs index 0509ba382b2e8b262a391af97dae42cb24291c23..8e34320d38f2f26edc800343cf37217977e8bad1 100644 --- a/polkadot/runtime/test-runtime/src/lib.rs +++ b/polkadot/runtime/test-runtime/src/lib.rs @@ -20,12 +20,15 @@ // `construct_runtime!` does a lot of recursion and requires us to increase the limit to 256. #![recursion_limit = "256"] -use pallet_transaction_payment::FungibleAdapter; -use parity_scale_codec::Encode; -use sp_std::{ +extern crate alloc; + +use alloc::{ collections::{btree_map::BTreeMap, vec_deque::VecDeque}, - prelude::*, + vec, + vec::Vec, }; +use codec::Encode; +use pallet_transaction_payment::FungibleAdapter; use polkadot_runtime_parachains::{ assigner_parachains as parachains_assigner_parachains, @@ -41,8 +44,6 @@ use polkadot_runtime_parachains::{ shared as parachains_shared, }; -use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId; -use beefy_primitives::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}; use frame_election_provider_support::{ bounds::{ElectionBounds, ElectionBoundsBuilder}, onchain, SequentialPhragmen, @@ -55,9 +56,9 @@ use frame_support::{ }; use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId}; use pallet_session::historical as session_historical; +use pallet_timestamp::Now; use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo}; -use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints; -use primitives::{ +use polkadot_primitives::{ slashing, AccountId, AccountIndex, Balance, BlockNumber, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash as HashT, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, @@ -65,10 +66,13 @@ use primitives::{ SessionInfo as SessionInfoData, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, PARACHAIN_KEY_TYPE_ID, }; -use runtime_common::{ +use polkadot_runtime_common::{ claims, impl_runtime_weights, paras_sudo_wrapper, BlockHashCount, BlockLength, SlowAdjustingFeeUpdate, }; +use polkadot_runtime_parachains::reward_points::RewardValidatorsWithEraPoints; +use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; +use sp_consensus_beefy::ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}; use sp_core::{ConstU32, OpaqueMetadata}; use sp_mmr_primitives as mmr; use sp_runtime::{ @@ -121,10 +125,10 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { }; /// The BABE epoch configuration at genesis. -pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration = - babe_primitives::BabeEpochConfiguration { +pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration = + sp_consensus_babe::BabeEpochConfiguration { c: PRIMARY_PROBABILITY, - allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots, + allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots, }; /// Native version. @@ -324,7 +328,8 @@ parameter_types! { pub struct OnChainSeqPhragmen; impl onchain::Config for OnChainSeqPhragmen { type System = Runtime; - type Solver = SequentialPhragmen; + type Solver = + SequentialPhragmen; type DataProvider = Staking; type WeightInfo = (); type Bounds = ElectionBoundsOnChain; @@ -338,7 +343,7 @@ impl pallet_staking::Config for Runtime { type Currency = Balances; type CurrencyBalance = Balance; type UnixTime = Timestamp; - type CurrencyToVote = runtime_common::CurrencyToVote; + type CurrencyToVote = polkadot_runtime_common::CurrencyToVote; type RewardRemainder = (); type RuntimeEvent = RuntimeEvent; type Slash = (); @@ -361,7 +366,7 @@ impl pallet_staking::Config for Runtime { type MaxUnlockingChunks = frame_support::traits::ConstU32<32>; type MaxControllersInDeprecationBatch = ConstU32<5900>; type HistoryDepth = frame_support::traits::ConstU32<84>; - type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig; + type BenchmarkingConfig = polkadot_runtime_common::StakingBenchmarkingConfig; type EventListeners = (); type WeightInfo = (); type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy; @@ -791,12 +796,12 @@ sp_api::impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> Vec { Runtime::metadata_versions() } } - impl block_builder_api::BlockBuilder for Runtime { + impl sp_block_builder::BlockBuilder for Runtime { fn apply_extrinsic(extrinsic: ::Extrinsic) -> ApplyExtrinsicResult { Executive::apply_extrinsic(extrinsic) } @@ -805,19 +810,19 @@ sp_api::impl_runtime_apis! { Executive::finalize_block() } - fn inherent_extrinsics(data: inherents::InherentData) -> Vec<::Extrinsic> { + fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<::Extrinsic> { data.create_extrinsics() } fn check_inherents( block: Block, - data: inherents::InherentData, - ) -> inherents::CheckInherentsResult { + data: sp_inherents::InherentData, + ) -> sp_inherents::CheckInherentsResult { data.check_extrinsics(&block) } } - impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime { + impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { fn validate_transaction( source: TransactionSource, tx: ::Extrinsic, @@ -827,20 +832,20 @@ sp_api::impl_runtime_apis! { } } - impl offchain_primitives::OffchainWorkerApi for Runtime { + impl sp_offchain::OffchainWorkerApi for Runtime { fn offchain_worker(header: &::Header) { Executive::offchain_worker(header) } } - impl authority_discovery_primitives::AuthorityDiscoveryApi for Runtime { + impl sp_authority_discovery::AuthorityDiscoveryApi for Runtime { fn authorities() -> Vec { runtime_impl::relevant_authority_ids::() } } #[api_version(11)] - impl primitives::runtime_api::ParachainHost for Runtime { + impl polkadot_primitives::runtime_api::ParachainHost for Runtime { fn validators() -> Vec { runtime_impl::validators::() } @@ -871,7 +876,7 @@ sp_api::impl_runtime_apis! { fn check_validation_outputs( para_id: ParaId, - outputs: primitives::CandidateCommitments, + outputs: polkadot_primitives::CandidateCommitments, ) -> bool { runtime_impl::check_validation_outputs::(para_id, outputs) } @@ -924,8 +929,8 @@ sp_api::impl_runtime_apis! { } fn submit_pvf_check_statement( - stmt: primitives::PvfCheckStatement, - signature: primitives::ValidatorSignature, + stmt: polkadot_primitives::PvfCheckStatement, + signature: polkadot_primitives::ValidatorSignature, ) { runtime_impl::submit_pvf_check_statement::(stmt, signature) } @@ -952,7 +957,7 @@ sp_api::impl_runtime_apis! { fn key_ownership_proof( validator_id: ValidatorId, ) -> Option { - use parity_scale_codec::Encode; + use codec::Encode; Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id)) .map(|p| p.encode()) @@ -973,15 +978,15 @@ sp_api::impl_runtime_apis! { runtime_impl::minimum_backing_votes::() } - fn para_backing_state(para_id: ParaId) -> Option { + fn para_backing_state(para_id: ParaId) -> Option { runtime_impl::backing_state::(para_id) } - fn async_backing_params() -> primitives::AsyncBackingParams { + fn async_backing_params() -> polkadot_primitives::AsyncBackingParams { runtime_impl::async_backing_params::() } - fn approval_voting_params() -> primitives::ApprovalVotingParams { + fn approval_voting_params() -> polkadot_primitives::ApprovalVotingParams { runtime_impl::approval_voting_params::() } @@ -989,7 +994,7 @@ sp_api::impl_runtime_apis! { runtime_impl::disabled_validators::() } - fn node_features() -> primitives::NodeFeatures { + fn node_features() -> polkadot_primitives::NodeFeatures { runtime_impl::node_features::() } @@ -1002,32 +1007,58 @@ sp_api::impl_runtime_apis! { } } - impl beefy_primitives::BeefyApi for Runtime { + impl sp_consensus_beefy::BeefyApi for Runtime { fn beefy_genesis() -> Option { // dummy implementation due to lack of BEEFY pallet. None } - fn validator_set() -> Option> { + fn validator_set() -> Option> { // dummy implementation due to lack of BEEFY pallet. None } - fn submit_report_equivocation_unsigned_extrinsic( - _equivocation_proof: beefy_primitives::DoubleVotingProof< + fn submit_report_double_voting_unsigned_extrinsic( + _equivocation_proof: sp_consensus_beefy::DoubleVotingProof< BlockNumber, BeefyId, BeefySignature, >, - _key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof, + _key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + None + } + + fn submit_report_fork_voting_unsigned_extrinsic( + _equivocation_proof: + sp_consensus_beefy::ForkVotingProof< + ::Header, + BeefyId, + sp_runtime::OpaqueValue + >, + _key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + None + } + + fn submit_report_future_block_voting_unsigned_extrinsic( + _equivocation_proof: sp_consensus_beefy::FutureBlockVotingProof, + _key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, ) -> Option<()> { None } fn generate_key_ownership_proof( - _set_id: beefy_primitives::ValidatorSetId, + _set_id: sp_consensus_beefy::ValidatorSetId, _authority_id: BeefyId, - ) -> Option { + ) -> Option { + None + } + + fn generate_ancestry_proof( + _prev_block_number: BlockNumber, + _best_known_block_number: Option, + ) -> Option { None } } @@ -1044,11 +1075,11 @@ sp_api::impl_runtime_apis! { fn generate_proof( _block_numbers: Vec, _best_known_block_number: Option, - ) -> Result<(Vec, mmr::Proof), mmr::Error> { + ) -> Result<(Vec, mmr::LeafProof), mmr::Error> { Err(mmr::Error::PalletNotIncluded) } - fn verify_proof(_leaves: Vec, _proof: mmr::Proof) + fn verify_proof(_leaves: Vec, _proof: mmr::LeafProof) -> Result<(), mmr::Error> { Err(mmr::Error::PalletNotIncluded) @@ -1057,7 +1088,7 @@ sp_api::impl_runtime_apis! { fn verify_proof_stateless( _root: Hash, _leaves: Vec, - _proof: mmr::Proof + _proof: mmr::LeafProof ) -> Result<(), mmr::Error> { Err(mmr::Error::PalletNotIncluded) } @@ -1090,10 +1121,10 @@ sp_api::impl_runtime_apis! { } } - impl babe_primitives::BabeApi for Runtime { - fn configuration() -> babe_primitives::BabeConfiguration { + impl sp_consensus_babe::BabeApi for Runtime { + fn configuration() -> sp_consensus_babe::BabeConfiguration { let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG); - babe_primitives::BabeConfiguration { + sp_consensus_babe::BabeConfiguration { slot_duration: Babe::slot_duration(), epoch_length: EpochDuration::get(), c: epoch_config.c, @@ -1103,28 +1134,28 @@ sp_api::impl_runtime_apis! { } } - fn current_epoch_start() -> babe_primitives::Slot { + fn current_epoch_start() -> sp_consensus_babe::Slot { Babe::current_epoch_start() } - fn current_epoch() -> babe_primitives::Epoch { + fn current_epoch() -> sp_consensus_babe::Epoch { Babe::current_epoch() } - fn next_epoch() -> babe_primitives::Epoch { + fn next_epoch() -> sp_consensus_babe::Epoch { Babe::next_epoch() } fn generate_key_ownership_proof( - _slot: babe_primitives::Slot, - _authority_id: babe_primitives::AuthorityId, - ) -> Option { + _slot: sp_consensus_babe::Slot, + _authority_id: sp_consensus_babe::AuthorityId, + ) -> Option { None } fn submit_report_equivocation_unsigned_extrinsic( - _equivocation_proof: babe_primitives::EquivocationProof<::Header>, - _key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof, + _equivocation_proof: sp_consensus_babe::EquivocationProof<::Header>, + _key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof, ) -> Option<()> { None } @@ -1185,7 +1216,7 @@ sp_api::impl_runtime_apis! { impl crate::GetLastTimestamp for Runtime { fn get_last_timestamp() -> u64 { - Timestamp::now() + Now::::get() } } diff --git a/polkadot/runtime/test-runtime/src/xcm_config.rs b/polkadot/runtime/test-runtime/src/xcm_config.rs index fc3d0dc42a3b93408f15c8363b631aa9761cbe36..b424b9a3ee55b4f3504cf3a72849cd5ad5dd09e4 100644 --- a/polkadot/runtime/test-runtime/src/xcm_config.rs +++ b/polkadot/runtime/test-runtime/src/xcm_config.rs @@ -20,8 +20,8 @@ use frame_support::{ weights::Weight, }; use frame_system::EnsureRoot; +use polkadot_runtime_common::xcm_sender::{ChildParachainRouter, PriceForMessageDelivery}; use polkadot_runtime_parachains::FeeTracker; -use runtime_common::xcm_sender::{ChildParachainRouter, PriceForMessageDelivery}; use xcm::latest::prelude::*; use xcm_builder::{ AllowUnpaidExecutionFrom, EnsureXcmOrigin, FixedWeightBounds, FrameTransactionalProcessor, @@ -54,7 +54,7 @@ pub type LocalOriginToLocation = ( /// This implementation ensures that messages with non-reanchored assets return higher /// prices than messages with reanchored assets. /// Useful for `deposit_reserve_asset_works_for_any_xcm_sender` integration test. -pub struct TestDeliveryPrice(sp_std::marker::PhantomData<(A, F)>); +pub struct TestDeliveryPrice(core::marker::PhantomData<(A, F)>); impl, F: FeeTracker> PriceForMessageDelivery for TestDeliveryPrice { type Id = F::Id; diff --git a/polkadot/runtime/westend/Cargo.toml b/polkadot/runtime/westend/Cargo.toml index f02cae0e9d493834b3c0ebe5d33fb3dbc92b9d9a..83c0eb037f4a15de4634ccce14e1c7573e2671c1 100644 --- a/polkadot/runtime/westend/Cargo.toml +++ b/polkadot/runtime/westend/Cargo.toml @@ -11,144 +11,140 @@ license.workspace = true workspace = true [dependencies] -bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +bitvec = { features = ["alloc"], workspace = true } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +scale-info = { features = ["derive"], workspace = true } log = { workspace = true } -rustc-hex = { version = "2.1.0", default-features = false } serde = { workspace = true } serde_derive = { optional = true, workspace = true } -smallvec = "1.8.0" +smallvec = { workspace = true, default-features = true } -authority-discovery-primitives = { package = "sp-authority-discovery", path = "../../../substrate/primitives/authority-discovery", default-features = false } -babe-primitives = { package = "sp-consensus-babe", path = "../../../substrate/primitives/consensus/babe", default-features = false } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../substrate/primitives/consensus/beefy", default-features = false } -binary-merkle-tree = { path = "../../../substrate/utils/binary-merkle-tree", default-features = false } -inherents = { package = "sp-inherents", path = "../../../substrate/primitives/inherents", default-features = false } -offchain-primitives = { package = "sp-offchain", path = "../../../substrate/primitives/offchain", default-features = false } -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -sp-application-crypto = { path = "../../../substrate/primitives/application-crypto", default-features = false } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false } -sp-std = { package = "sp-std", path = "../../../substrate/primitives/std", default-features = false } -sp-genesis-builder = { path = "../../../substrate/primitives/genesis-builder", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-mmr-primitives = { path = "../../../substrate/primitives/merkle-mountain-range", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-staking = { path = "../../../substrate/primitives/staking", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-session = { path = "../../../substrate/primitives/session", default-features = false } -sp-storage = { path = "../../../substrate/primitives/storage", default-features = false } -sp-version = { path = "../../../substrate/primitives/version", default-features = false } -tx-pool-api = { package = "sp-transaction-pool", path = "../../../substrate/primitives/transaction-pool", default-features = false } -block-builder-api = { package = "sp-block-builder", path = "../../../substrate/primitives/block-builder", default-features = false } -sp-npos-elections = { path = "../../../substrate/primitives/npos-elections", default-features = false } +sp-authority-discovery = { workspace = true } +sp-consensus-babe = { workspace = true } +sp-consensus-beefy = { workspace = true } +binary-merkle-tree = { workspace = true } +sp-inherents = { workspace = true } +sp-offchain = { workspace = true } +sp-api = { workspace = true } +sp-application-crypto = { workspace = true } +sp-arithmetic = { workspace = true } +sp-genesis-builder = { workspace = true } +sp-io = { workspace = true } +sp-mmr-primitives = { workspace = true } +sp-runtime = { workspace = true } +sp-staking = { workspace = true } +sp-core = { workspace = true } +sp-session = { workspace = true } +sp-storage = { workspace = true } +sp-version = { workspace = true } +sp-transaction-pool = { workspace = true } +sp-block-builder = { workspace = true } +sp-npos-elections = { workspace = true } -frame-election-provider-support = { path = "../../../substrate/frame/election-provider-support", default-features = false } -frame-executive = { path = "../../../substrate/frame/executive", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false, features = ["experimental", "tuples-96"] } -frame-system = { path = "../../../substrate/frame/system", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../substrate/frame/system/rpc/runtime-api", default-features = false } -westend-runtime-constants = { package = "westend-runtime-constants", path = "constants", default-features = false } -pallet-asset-rate = { path = "../../../substrate/frame/asset-rate", 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-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-collective = { path = "../../../substrate/frame/collective", default-features = false } -pallet-democracy = { path = "../../../substrate/frame/democracy", default-features = false } -pallet-elections-phragmen = { package = "pallet-elections-phragmen", path = "../../../substrate/frame/elections-phragmen", default-features = false } -pallet-election-provider-multi-phase = { path = "../../../substrate/frame/election-provider-multi-phase", default-features = false } -pallet-fast-unstake = { path = "../../../substrate/frame/fast-unstake", default-features = false } -pallet-grandpa = { path = "../../../substrate/frame/grandpa", default-features = false } -pallet-identity = { path = "../../../substrate/frame/identity", default-features = false } -pallet-indices = { path = "../../../substrate/frame/indices", default-features = false } -pallet-membership = { path = "../../../substrate/frame/membership", default-features = false } -pallet-message-queue = { path = "../../../substrate/frame/message-queue", default-features = false } -pallet-mmr = { path = "../../../substrate/frame/merkle-mountain-range", default-features = false } -pallet-multisig = { path = "../../../substrate/frame/multisig", default-features = false } -pallet-nomination-pools = { path = "../../../substrate/frame/nomination-pools", default-features = false } -pallet-conviction-voting = { path = "../../../substrate/frame/conviction-voting", default-features = false } -pallet-offences = { path = "../../../substrate/frame/offences", default-features = false } -pallet-preimage = { path = "../../../substrate/frame/preimage", default-features = false } -pallet-proxy = { path = "../../../substrate/frame/proxy", default-features = false } -pallet-recovery = { path = "../../../substrate/frame/recovery", default-features = false } -pallet-referenda = { path = "../../../substrate/frame/referenda", default-features = false } -pallet-scheduler = { path = "../../../substrate/frame/scheduler", default-features = false } -pallet-session = { path = "../../../substrate/frame/session", 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 = { package = "pallet-staking-reward-curve", path = "../../../substrate/frame/staking/reward-curve" } -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-sudo = { path = "../../../substrate/frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../substrate/frame/timestamp", default-features = false } -pallet-transaction-payment = { path = "../../../substrate/frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../substrate/frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-nomination-pools-runtime-api = { path = "../../../substrate/frame/nomination-pools/runtime-api", default-features = false } -pallet-treasury = { path = "../../../substrate/frame/treasury", 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 = "../../xcm/pallet-xcm", default-features = false } -pallet-xcm-benchmarks = { path = "../../xcm/pallet-xcm-benchmarks", default-features = false, optional = true } -pallet-root-testing = { path = "../../../substrate/frame/root-testing", default-features = false } +frame-election-provider-support = { workspace = true } +frame-executive = { workspace = true } +frame-metadata-hash-extension = { workspace = true } +frame-support = { features = ["experimental", "tuples-96"], workspace = true } +frame-system = { workspace = true } +frame-system-rpc-runtime-api = { workspace = true } +westend-runtime-constants = { workspace = true } +pallet-asset-rate = { workspace = true } +pallet-authority-discovery = { workspace = true } +pallet-authorship = { workspace = true } +pallet-babe = { workspace = true } +pallet-bags-list = { workspace = true } +pallet-balances = { workspace = true } +pallet-beefy = { workspace = true } +pallet-beefy-mmr = { workspace = true } +pallet-collective = { workspace = true } +pallet-democracy = { workspace = true } +pallet-elections-phragmen = { workspace = true } +pallet-election-provider-multi-phase = { workspace = true } +pallet-fast-unstake = { workspace = true } +pallet-grandpa = { workspace = true } +pallet-identity = { workspace = true } +pallet-indices = { workspace = true } +pallet-membership = { workspace = true } +pallet-message-queue = { workspace = true } +pallet-mmr = { workspace = true } +pallet-multisig = { workspace = true } +pallet-nomination-pools = { workspace = true } +pallet-conviction-voting = { workspace = true } +pallet-offences = { workspace = true } +pallet-parameters = { workspace = true } +pallet-preimage = { workspace = true } +pallet-proxy = { workspace = true } +pallet-recovery = { workspace = true } +pallet-referenda = { workspace = true } +pallet-scheduler = { workspace = true } +pallet-session = { workspace = true } +pallet-society = { workspace = true } +pallet-staking = { workspace = true } +pallet-staking-runtime-api = { workspace = true } +pallet-delegated-staking = { workspace = true } +pallet-state-trie-migration = { workspace = true } +pallet-sudo = { workspace = true } +pallet-timestamp = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-transaction-payment-rpc-runtime-api = { workspace = true } +pallet-nomination-pools-runtime-api = { workspace = true } +pallet-treasury = { workspace = true } +pallet-utility = { workspace = true } +pallet-vesting = { workspace = true } +pallet-whitelist = { workspace = true } +pallet-xcm = { workspace = true } +pallet-xcm-benchmarks = { optional = true, workspace = true } +pallet-root-testing = { workspace = true } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -frame-try-runtime = { path = "../../../substrate/frame/try-runtime", default-features = false, optional = true } -frame-system-benchmarking = { path = "../../../substrate/frame/system/benchmarking", default-features = false, optional = true } -pallet-election-provider-support-benchmarking = { path = "../../../substrate/frame/election-provider-support/benchmarking", default-features = false, optional = true } -pallet-nomination-pools-benchmarking = { path = "../../../substrate/frame/nomination-pools/benchmarking", default-features = false, optional = true } -pallet-offences-benchmarking = { path = "../../../substrate/frame/offences/benchmarking", default-features = false, optional = true } -pallet-session-benchmarking = { path = "../../../substrate/frame/session/benchmarking", default-features = false, optional = true } -hex-literal = { version = "0.4.1", optional = true } +frame-benchmarking = { optional = true, workspace = true } +frame-try-runtime = { optional = true, workspace = true } +frame-system-benchmarking = { optional = true, workspace = true } +pallet-election-provider-support-benchmarking = { optional = true, workspace = true } +pallet-nomination-pools-benchmarking = { optional = true, workspace = true } +pallet-offences-benchmarking = { optional = true, workspace = true } +pallet-session-benchmarking = { optional = true, workspace = true } +hex-literal = { optional = true, workspace = true, default-features = true } -runtime-common = { package = "polkadot-runtime-common", path = "../common", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../primitives", default-features = false } -polkadot-parachain-primitives = { path = "../../parachain", default-features = false } -runtime-parachains = { package = "polkadot-runtime-parachains", path = "../parachains", default-features = false } +polkadot-runtime-common = { workspace = true } +polkadot-primitives = { workspace = true } +polkadot-parachain-primitives = { workspace = true } +polkadot-runtime-parachains = { workspace = true } -xcm = { package = "staging-xcm", path = "../../xcm", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm/xcm-executor", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm/xcm-builder", default-features = false } -xcm-fee-payment-runtime-api = { path = "../../xcm/xcm-fee-payment-runtime-api", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-builder = { workspace = true } +xcm-runtime-apis = { workspace = true } [dev-dependencies] -hex-literal = "0.4.1" -tiny-keccak = { version = "2.0.2", features = ["keccak"] } -keyring = { package = "sp-keyring", path = "../../../substrate/primitives/keyring" } +hex-literal = { workspace = true, default-features = true } +tiny-keccak = { features = ["keccak"], workspace = true } +sp-keyring = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -remote-externalities = { package = "frame-remote-externalities", path = "../../../substrate/utils/frame/remote-externalities" } -tokio = { version = "1.24.2", features = ["macros"] } -sp-tracing = { path = "../../../substrate/primitives/tracing", default-features = false } +remote-externalities = { workspace = true, default-features = true } +tokio = { features = ["macros"], workspace = true, default-features = true } +sp-tracing = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../substrate/utils/wasm-builder" } +substrate-wasm-builder = { workspace = true, default-features = true } [features] default = ["std"] no_std = [] only-staking = [] std = [ - "authority-discovery-primitives/std", - "babe-primitives/std", - "beefy-primitives/std", "binary-merkle-tree/std", "bitvec/std", - "block-builder-api/std", + "codec/std", "frame-benchmarking?/std", "frame-election-provider-support/std", "frame-executive/std", + "frame-metadata-hash-extension/std", "frame-support/std", "frame-system-benchmarking?/std", "frame-system-rpc-runtime-api/std", "frame-system/std", "frame-try-runtime/std", - "inherents/std", "log/std", - "offchain-primitives/std", "pallet-asset-rate/std", "pallet-authority-discovery/std", "pallet-authorship/std", @@ -159,6 +155,7 @@ std = [ "pallet-beefy/std", "pallet-collective/std", "pallet-conviction-voting/std", + "pallet-delegated-staking/std", "pallet-democracy/std", "pallet-election-provider-multi-phase/std", "pallet-election-provider-support-benchmarking?/std", @@ -176,6 +173,7 @@ std = [ "pallet-nomination-pools/std", "pallet-offences-benchmarking?/std", "pallet-offences/std", + "pallet-parameters/std", "pallet-preimage/std", "pallet-proxy/std", "pallet-recovery/std", @@ -198,35 +196,38 @@ std = [ "pallet-whitelist/std", "pallet-xcm-benchmarks?/std", "pallet-xcm/std", - "parity-scale-codec/std", "polkadot-parachain-primitives/std", - "primitives/std", - "runtime-common/std", - "runtime-parachains/std", - "rustc-hex/std", + "polkadot-primitives/std", + "polkadot-runtime-common/std", + "polkadot-runtime-parachains/std", "scale-info/std", "serde/std", "serde_derive", "sp-api/std", "sp-application-crypto/std", "sp-arithmetic/std", + "sp-authority-discovery/std", + "sp-block-builder/std", + "sp-consensus-babe/std", + "sp-consensus-beefy/std", "sp-core/std", "sp-genesis-builder/std", + "sp-inherents/std", "sp-io/std", "sp-mmr-primitives/std", "sp-npos-elections/std", + "sp-offchain/std", "sp-runtime/std", "sp-session/std", "sp-staking/std", - "sp-std/std", "sp-storage/std", "sp-tracing/std", + "sp-transaction-pool/std", "sp-version/std", - "tx-pool-api/std", "westend-runtime-constants/std", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] runtime-benchmarks = [ @@ -240,8 +241,10 @@ runtime-benchmarks = [ "pallet-babe/runtime-benchmarks", "pallet-bags-list/runtime-benchmarks", "pallet-balances/runtime-benchmarks", + "pallet-beefy-mmr/runtime-benchmarks", "pallet-collective/runtime-benchmarks", "pallet-conviction-voting/runtime-benchmarks", + "pallet-delegated-staking/runtime-benchmarks", "pallet-democracy/runtime-benchmarks", "pallet-election-provider-multi-phase/runtime-benchmarks", "pallet-election-provider-support-benchmarking/runtime-benchmarks", @@ -258,6 +261,7 @@ runtime-benchmarks = [ "pallet-nomination-pools/runtime-benchmarks", "pallet-offences-benchmarking/runtime-benchmarks", "pallet-offences/runtime-benchmarks", + "pallet-parameters/runtime-benchmarks", "pallet-preimage/runtime-benchmarks", "pallet-proxy/runtime-benchmarks", "pallet-recovery/runtime-benchmarks", @@ -276,14 +280,14 @@ runtime-benchmarks = [ "pallet-xcm-benchmarks/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", - "primitives/runtime-benchmarks", - "runtime-common/runtime-benchmarks", - "runtime-parachains/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", + "polkadot-runtime-common/runtime-benchmarks", + "polkadot-runtime-parachains/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "sp-staking/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "frame-election-provider-support/try-runtime", @@ -302,6 +306,7 @@ try-runtime = [ "pallet-beefy/try-runtime", "pallet-collective/try-runtime", "pallet-conviction-voting/try-runtime", + "pallet-delegated-staking/try-runtime", "pallet-democracy/try-runtime", "pallet-election-provider-multi-phase/try-runtime", "pallet-elections-phragmen/try-runtime", @@ -315,6 +320,7 @@ try-runtime = [ "pallet-multisig/try-runtime", "pallet-nomination-pools/try-runtime", "pallet-offences/try-runtime", + "pallet-parameters/try-runtime", "pallet-preimage/try-runtime", "pallet-proxy/try-runtime", "pallet-recovery/try-runtime", @@ -333,17 +339,23 @@ try-runtime = [ "pallet-vesting/try-runtime", "pallet-whitelist/try-runtime", "pallet-xcm/try-runtime", - "runtime-common/try-runtime", - "runtime-parachains/try-runtime", + "polkadot-runtime-common/try-runtime", + "polkadot-runtime-parachains/try-runtime", "sp-runtime/try-runtime", ] +# Enable the metadata hash generation in the wasm builder. +metadata-hash = ["substrate-wasm-builder/metadata-hash"] + # Set timing constants (e.g. session period) to faster versions to speed up testing. fast-runtime = [] -runtime-metrics = ["runtime-parachains/runtime-metrics", "sp-io/with-tracing"] +runtime-metrics = [ + "polkadot-runtime-parachains/runtime-metrics", + "sp-io/with-tracing", +] # A feature that should be enabled when the runtime should be built for on-chain # deployment. This will disable stuff that shouldn't be part of the on-chain wasm # to make it smaller, like logging for example. -on-chain-release-build = ["sp-api/disable-logging"] +on-chain-release-build = ["metadata-hash"] diff --git a/polkadot/runtime/westend/build.rs b/polkadot/runtime/westend/build.rs index 0b3e12c78c746517a32538c8c1e5f9da63747fc5..55ccd36401293342d2dff4ccca14b674f6b1aeec 100644 --- a/polkadot/runtime/westend/build.rs +++ b/polkadot/runtime/westend/build.rs @@ -14,8 +14,26 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use substrate_wasm_builder::WasmBuilder; +#[cfg(all(not(feature = "metadata-hash"), feature = "std"))] +fn main() { + substrate_wasm_builder::WasmBuilder::build_using_defaults(); + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .set_file_name("fast_runtime_binary.rs") + .enable_feature("fast-runtime") + .build(); +} +#[cfg(all(feature = "metadata-hash", feature = "std"))] fn main() { - WasmBuilder::build_using_defaults(); + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("WND", 12) + .build(); + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .set_file_name("fast_runtime_binary.rs") + .enable_feature("fast-runtime") + .enable_metadata_hash("WND", 12) + .build(); } + +#[cfg(not(feature = "std"))] +fn main() {} diff --git a/polkadot/runtime/westend/constants/Cargo.toml b/polkadot/runtime/westend/constants/Cargo.toml index 81df8f4f024dd32f23edd679b651e2edc4d32687..27d5b19b8e77113a8f4ea5f14bfb701364308f07 100644 --- a/polkadot/runtime/westend/constants/Cargo.toml +++ b/polkadot/runtime/westend/constants/Cargo.toml @@ -6,31 +6,37 @@ authors.workspace = true edition.workspace = true license.workspace = true +[package.metadata.polkadot-sdk] +exclude-from-umbrella = true + [lints] workspace = true [dependencies] -smallvec = "1.8.0" +smallvec = { workspace = true, default-features = true } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -primitives = { package = "polkadot-primitives", path = "../../../primitives", default-features = false } -runtime-common = { package = "polkadot-runtime-common", path = "../../common", default-features = false } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-weights = { path = "../../../../substrate/primitives/weights", default-features = false } -sp-core = { path = "../../../../substrate/primitives/core", default-features = false } +frame-support = { workspace = true } +polkadot-primitives = { workspace = true } +polkadot-runtime-common = { workspace = true } +sp-runtime = { workspace = true } +sp-weights = { workspace = true } +sp-core = { workspace = true } -xcm = { package = "staging-xcm", path = "../../../xcm", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../../../xcm/xcm-builder", default-features = false } +xcm = { workspace = true } +xcm-builder = { workspace = true } [features] default = ["std"] std = [ "frame-support/std", - "primitives/std", - "runtime-common/std", + "polkadot-primitives/std", + "polkadot-runtime-common/std", "sp-core/std", "sp-runtime/std", "sp-weights/std", "xcm-builder/std", "xcm/std", ] + +# Set timing constants (e.g. session period) to faster versions to speed up testing. +fast-runtime = [] diff --git a/polkadot/runtime/westend/constants/src/lib.rs b/polkadot/runtime/westend/constants/src/lib.rs index c98f4b114fd88241dea1e2e5ffcf694848448007..8d66ac2868d0b7a53011b8624c41161860b2cd42 100644 --- a/polkadot/runtime/westend/constants/src/lib.rs +++ b/polkadot/runtime/westend/constants/src/lib.rs @@ -20,7 +20,7 @@ pub mod weights; /// Money matters. pub mod currency { - use primitives::Balance; + use polkadot_primitives::Balance; /// The existential deposit. pub const EXISTENTIAL_DEPOSIT: Balance = 1 * CENTS; @@ -37,8 +37,8 @@ pub mod currency { /// Time and blocks. pub mod time { - use primitives::{BlockNumber, Moment}; - use runtime_common::prod_or_fast; + use polkadot_primitives::{BlockNumber, Moment}; + use polkadot_runtime_common::prod_or_fast; pub const MILLISECS_PER_BLOCK: Moment = 6000; pub const SLOT_DURATION: Moment = MILLISECS_PER_BLOCK; @@ -52,7 +52,7 @@ pub mod time { // 1 in 4 blocks (on average, not counting collisions) will be primary babe blocks. // The choice of is done in accordance to the slot duration and expected target // block time, for safely resisting network delays of maximum two seconds. - // + // pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4); } @@ -62,7 +62,7 @@ pub mod fee { use frame_support::weights::{ WeightToFeeCoefficient, WeightToFeeCoefficients, WeightToFeePolynomial, }; - use primitives::Balance; + use polkadot_primitives::Balance; use smallvec::smallvec; pub use sp_runtime::Perbill; @@ -98,7 +98,7 @@ pub mod fee { /// System Parachains. pub mod system_parachain { - use primitives::Id; + use polkadot_primitives::Id; use xcm_builder::IsChildSystemParachain; /// Network's Asset Hub parachain ID. @@ -116,6 +116,17 @@ pub mod system_parachain { /// All system parachains of Westend. pub type SystemParachains = IsChildSystemParachain; + + /// Coretime constants + pub mod coretime { + /// Coretime timeslice period in blocks + /// WARNING: This constant is used accross chains, so additional care should be taken + /// when changing it. + #[cfg(feature = "fast-runtime")] + pub const TIMESLICE_PERIOD: u32 = 20; + #[cfg(not(feature = "fast-runtime"))] + pub const TIMESLICE_PERIOD: u32 = 80; + } } /// Westend Treasury pallet instance. @@ -144,7 +155,7 @@ mod tests { }; use crate::weights::ExtrinsicBaseWeight; use frame_support::weights::WeightToFee as WeightToFeeT; - use runtime_common::MAXIMUM_BLOCK_WEIGHT; + use polkadot_runtime_common::MAXIMUM_BLOCK_WEIGHT; #[test] // Test that the fee for `MAXIMUM_BLOCK_WEIGHT` of weight has sane bounds. diff --git a/polkadot/runtime/westend/src/impls.rs b/polkadot/runtime/westend/src/impls.rs index 71e6b696a20a0feb89e669067d02b12e6eeb89fd..ac3f9e679f8d3d5d7b1409a858598cc866f7c415 100644 --- a/polkadot/runtime/westend/src/impls.rs +++ b/polkadot/runtime/westend/src/impls.rs @@ -15,12 +15,13 @@ // along with Polkadot. If not, see . use crate::xcm_config; +use alloc::{boxed::Box, vec}; +use codec::{Decode, Encode}; +use core::marker::PhantomData; use frame_support::pallet_prelude::DispatchResult; use frame_system::RawOrigin; -use parity_scale_codec::{Decode, Encode}; -use primitives::Balance; -use runtime_common::identity_migrator::{OnReapIdentity, WeightInfo}; -use sp_std::{marker::PhantomData, prelude::*}; +use polkadot_primitives::Balance; +use polkadot_runtime_common::identity_migrator::{OnReapIdentity, WeightInfo}; use westend_runtime_constants::currency::*; use xcm::{latest::prelude::*, VersionedLocation, VersionedXcm}; use xcm_executor::traits::TransactAsset; @@ -89,7 +90,7 @@ where fn on_reap_identity(who: &AccountId, fields: u32, subs: u32) -> DispatchResult { use crate::{ impls::IdentityMigratorCalls::PokeDeposit, - weights::runtime_common_identity_migrator::WeightInfo as MigratorWeights, + weights::polkadot_runtime_common_identity_migrator::WeightInfo as MigratorWeights, }; let total_to_send = Self::calculate_remote_deposit(fields, subs); diff --git a/polkadot/runtime/westend/src/lib.rs b/polkadot/runtime/westend/src/lib.rs index cae12ab49c0242903a99442bea01b02bcecb532c..e8fe11615d743a914aceaaa3445d9c6f1940054d 100644 --- a/polkadot/runtime/westend/src/lib.rs +++ b/polkadot/runtime/westend/src/lib.rs @@ -20,20 +20,25 @@ // `#[frame_support::runtime]!` does a lot of recursion and requires us to increase the limit. #![recursion_limit = "512"] -use authority_discovery_primitives::AuthorityId as AuthorityDiscoveryId; -use beefy_primitives::{ - ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}, - mmr::{BeefyDataProvider, MmrLeafVersion}, +extern crate alloc; + +use alloc::{ + collections::{btree_map::BTreeMap, vec_deque::VecDeque}, + vec, + vec::Vec, }; +use codec::{Decode, Encode, MaxEncodedLen}; use frame_election_provider_support::{bounds::ElectionBoundsBuilder, onchain, SequentialPhragmen}; use frame_support::{ derive_impl, + dynamic_params::{dynamic_pallet_params, dynamic_params}, genesis_builder_helper::{build_state, get_preset}, parameter_types, traits::{ fungible::HoldConsideration, tokens::UnityOrOuterConversion, ConstU32, Contains, EitherOf, - EitherOfDiverse, EverythingBut, FromContains, InstanceFilter, KeyOwnerProofSystem, - LinearStoragePrice, ProcessMessage, ProcessMessageError, WithdrawReasons, + EitherOfDiverse, EnsureOriginWithArg, EverythingBut, FromContains, InstanceFilter, + KeyOwnerProofSystem, LinearStoragePrice, ProcessMessage, ProcessMessageError, + VariantCountOf, WithdrawReasons, }, weights::{ConstantMultiplier, WeightMeter, WeightToFee as _}, PalletId, @@ -43,8 +48,7 @@ use pallet_grandpa::{fg_primitives, AuthorityId as GrandpaId}; use pallet_identity::legacy::IdentityInfo; use pallet_session::historical as session_historical; use pallet_transaction_payment::{FeeDetails, FungibleAdapter, RuntimeDispatchInfo}; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; -use primitives::{ +use polkadot_primitives::{ slashing, AccountId, AccountIndex, ApprovalVotingParams, Balance, BlockNumber, CandidateEvent, CandidateHash, CommittedCandidateReceipt, CoreIndex, CoreState, DisputeState, ExecutorParams, GroupRotationInfo, Hash, Id as ParaId, InboundDownwardMessage, InboundHrmpMessage, Moment, @@ -52,28 +56,28 @@ use primitives::{ ScrapedOnChainVotes, SessionInfo, Signature, ValidationCode, ValidationCodeHash, ValidatorId, ValidatorIndex, ValidatorSignature, PARACHAIN_KEY_TYPE_ID, }; -use runtime_common::{ +use polkadot_runtime_common::{ assigned_slots, auctions, crowdloan, elections::OnChainAccuracy, identity_migrator, impl_runtime_weights, impls::{ - ContainsParts, LocatableAssetConverter, ToAuthor, VersionedLocatableAsset, - VersionedLocationConverter, + relay_era_payout, ContainsParts, EraPayoutParams, LocatableAssetConverter, ToAuthor, + VersionedLocatableAsset, VersionedLocationConverter, }, paras_registrar, paras_sudo_wrapper, prod_or_fast, slots, - traits::{Leaser, OnSwap}, + traits::OnSwap, BalanceToU256, BlockHashCount, BlockLength, CurrencyToVote, SlowAdjustingFeeUpdate, U256ToBalance, }; -use runtime_parachains::{ - assigner_coretime as parachains_assigner_coretime, - assigner_on_demand as parachains_assigner_on_demand, configuration as parachains_configuration, +use polkadot_runtime_parachains::{ + assigner_coretime as parachains_assigner_coretime, configuration as parachains_configuration, configuration::ActiveConfigHrmpChannelSizeAndCapacityRatio, coretime, disputes as parachains_disputes, disputes::slashing as parachains_slashing, dmp as parachains_dmp, hrmp as parachains_hrmp, inclusion as parachains_inclusion, inclusion::{AggregateMessageOrigin, UmpQueueId}, - initializer as parachains_initializer, origin as parachains_origin, paras as parachains_paras, + initializer as parachains_initializer, on_demand as parachains_on_demand, + origin as parachains_origin, paras as parachains_paras, paras_inherent as parachains_paras_inherent, reward_points as parachains_reward_points, runtime_api_impl::{ v10 as parachains_runtime_api_impl, vstaging as vstaging_parachains_runtime_api_impl, @@ -82,34 +86,30 @@ use runtime_parachains::{ shared as parachains_shared, }; use scale_info::TypeInfo; +use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; +use sp_consensus_beefy::{ + ecdsa_crypto::{AuthorityId as BeefyId, Signature as BeefySignature}, + mmr::{BeefyDataProvider, MmrLeafVersion}, +}; use sp_core::{ConstU8, OpaqueMetadata, RuntimeDebug, H256}; use sp_runtime::{ - create_runtime_str, - curve::PiecewiseLinear, - generic, impl_opaque_keys, + create_runtime_str, generic, impl_opaque_keys, traits::{ - BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT, IdentityLookup, - Keccak256, OpaqueKeys, SaturatedConversion, Verify, + AccountIdConversion, BlakeTwo256, Block as BlockT, ConvertInto, Extrinsic as ExtrinsicT, + IdentityLookup, Keccak256, OpaqueKeys, SaturatedConversion, Verify, }, transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity}, - ApplyExtrinsicResult, FixedU128, KeyTypeId, Perbill, Percent, Permill, + ApplyExtrinsicResult, FixedU128, KeyTypeId, Percent, Permill, }; use sp_staking::SessionIndex; -use sp_std::{ - collections::{btree_map::BTreeMap, vec_deque::VecDeque}, - prelude::*, -}; #[cfg(any(feature = "std", test))] use sp_version::NativeVersion; use sp_version::RuntimeVersion; -use xcm::{ - latest::prelude::*, IntoVersion, VersionedAssetId, VersionedAssets, VersionedLocation, - VersionedXcm, -}; +use xcm::{latest::prelude::*, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm}; use xcm_builder::PayOverXcm; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunEffects}, +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::Error as XcmPaymentApiError, }; @@ -125,7 +125,12 @@ use sp_runtime::traits::Get; pub use sp_runtime::BuildStorage; /// Constant values used within the runtime. -use westend_runtime_constants::{currency::*, fee::*, system_parachain::BROKER_ID, time::*}; +use westend_runtime_constants::{ + currency::*, + fee::*, + system_parachain::{coretime::TIMESLICE_PERIOD, BROKER_ID}, + time::*, +}; mod bag_thresholds; mod weights; @@ -151,24 +156,29 @@ impl_runtime_weights!(westend_runtime_constants); #[cfg(feature = "std")] include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs")); +#[cfg(feature = "std")] +pub mod fast_runtime_binary { + include!(concat!(env!("OUT_DIR"), "/fast_runtime_binary.rs")); +} + /// Runtime version (Westend). #[sp_version::runtime_version] pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("westend"), impl_name: create_runtime_str!("parity-westend"), authoring_version: 2, - spec_version: 1_011_000, + spec_version: 1_015_000, impl_version: 0, apis: RUNTIME_API_VERSIONS, - transaction_version: 25, + transaction_version: 26, state_version: 1, }; /// The BABE epoch configuration at genesis. -pub const BABE_GENESIS_EPOCH_CONFIG: babe_primitives::BabeEpochConfiguration = - babe_primitives::BabeEpochConfiguration { +pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration = + sp_consensus_babe::BabeEpochConfiguration { c: PRIMARY_PROBABILITY, - allowed_slots: babe_primitives::AllowedSlots::PrimaryAndSecondaryVRFSlots, + allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryVRFSlots, }; /// Native version. @@ -239,6 +249,80 @@ parameter_types! { pub const PreimageHoldReason: RuntimeHoldReason = RuntimeHoldReason::Preimage(pallet_preimage::HoldReason::Preimage); } +/// Dynamic params that can be adjusted at runtime. +#[dynamic_params(RuntimeParameters, pallet_parameters::Parameters::)] +pub mod dynamic_params { + use super::*; + + /// Parameters used to calculate era payouts, see + /// [`polkadot_runtime_common::impls::EraPayoutParams`]. + #[dynamic_pallet_params] + #[codec(index = 0)] + pub mod inflation { + /// Minimum inflation rate used to calculate era payouts. + #[codec(index = 0)] + pub static MinInflation: Perquintill = Perquintill::from_rational(25u64, 1000u64); + + /// Maximum inflation rate used to calculate era payouts. + #[codec(index = 1)] + pub static MaxInflation: Perquintill = Perquintill::from_rational(10u64, 100u64); + + /// Ideal stake ratio used to calculate era payouts. + #[codec(index = 2)] + pub static IdealStake: Perquintill = Perquintill::from_rational(50u64, 100u64); + + /// Falloff used to calculate era payouts. + #[codec(index = 3)] + pub static Falloff: Perquintill = Perquintill::from_rational(50u64, 1000u64); + + /// Whether to use auction slots or not in the calculation of era payouts. If set to true, + /// the `legacy_auction_proportion` of 60% will be used in the calculation of era payouts. + #[codec(index = 4)] + pub static UseAuctionSlots: bool = false; + } +} + +#[cfg(feature = "runtime-benchmarks")] +impl Default for RuntimeParameters { + fn default() -> Self { + RuntimeParameters::Inflation(dynamic_params::inflation::Parameters::MinInflation( + dynamic_params::inflation::MinInflation, + Some(Perquintill::from_rational(25u64, 1000u64)), + )) + } +} + +impl pallet_parameters::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type RuntimeParameters = RuntimeParameters; + type AdminOrigin = DynamicParameterOrigin; + type WeightInfo = weights::pallet_parameters::WeightInfo; +} + +/// Defines what origin can modify which dynamic parameters. +pub struct DynamicParameterOrigin; +impl EnsureOriginWithArg for DynamicParameterOrigin { + type Success = (); + + fn try_origin( + origin: RuntimeOrigin, + key: &RuntimeParametersKey, + ) -> Result { + use crate::RuntimeParametersKey::*; + + match key { + Inflation(_) => frame_system::ensure_root(origin.clone()), + } + .map_err(|_| origin) + } + + #[cfg(feature = "runtime-benchmarks")] + fn try_successful_origin(_key: &RuntimeParametersKey) -> Result { + // Provide the origin for the parameter returned by `Default`: + Ok(RuntimeOrigin::root()) + } +} + impl pallet_preimage::Config for Runtime { type WeightInfo = weights::pallet_preimage::WeightInfo; type RuntimeEvent = RuntimeEvent; @@ -313,7 +397,7 @@ impl pallet_balances::Config for Runtime { type RuntimeHoldReason = RuntimeHoldReason; type RuntimeFreezeReason = RuntimeFreezeReason; type FreezeIdentifier = RuntimeFreezeReason; - type MaxFreezes = ConstU32<1>; + type MaxFreezes = VariantCountOf; } parameter_types! { @@ -326,6 +410,7 @@ impl pallet_beefy::Config for Runtime { type MaxNominators = MaxNominators; type MaxSetIdSessionEntries = BeefySetIdSessionEntries; type OnNewValidatorSet = BeefyMmrLeaf; + type AncestryHelper = BeefyMmrLeaf; type WeightInfo = (); type KeyOwnerProof = sp_session::MembershipProof; type EquivocationReportSystem = @@ -336,9 +421,11 @@ impl pallet_mmr::Config for Runtime { const INDEXING_PREFIX: &'static [u8] = mmr::INDEXING_PREFIX; type Hashing = Keccak256; type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest; - type WeightInfo = (); type LeafData = pallet_beefy_mmr::Pallet; type BlockHashProvider = pallet_mmr::DefaultBlockHashProvider; + type WeightInfo = weights::pallet_mmr::WeightInfo; + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = parachains_paras::benchmarking::mmr_setup::MmrSetup; } /// MMR helper types. @@ -360,13 +447,8 @@ parameter_types! { pub struct ParaHeadsRootProvider; impl BeefyDataProvider for ParaHeadsRootProvider { fn extra_data() -> H256 { - let mut para_heads: Vec<(u32, Vec)> = parachains_paras::Parachains::::get() - .into_iter() - .filter_map(|id| { - parachains_paras::Heads::::get(&id).map(|head| (id.into(), head.0)) - }) - .collect(); - para_heads.sort_by_key(|k| k.0); + let para_heads: Vec<(u32, Vec)> = + parachains_paras::Pallet::::sorted_para_heads(); binary_merkle_tree::merkle_root::( para_heads.into_iter().map(|pair| pair.encode()), ) @@ -379,6 +461,7 @@ impl pallet_beefy_mmr::Config for Runtime { type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum; type LeafExtra = H256; type BeefyDataProvider = ParaHeadsRootProvider; + type WeightInfo = weights::pallet_beefy_mmr::WeightInfo; } parameter_types! { @@ -519,20 +602,20 @@ impl pallet_election_provider_multi_phase::MinerConfig for Runtime { type MaxWeight = OffchainSolutionWeightLimit; type Solution = NposCompactSolution16; type MaxVotesPerVoter = < - ::DataProvider - as - frame_election_provider_support::ElectionDataProvider - >::MaxVotesPerVoter; + ::DataProvider + as + frame_election_provider_support::ElectionDataProvider + >::MaxVotesPerVoter; type MaxWinners = MaxActiveValidators; // The unsigned submissions have to respect the weight of the submit_unsigned call, thus their // weight estimate function is wired to this call's weight. fn solution_weight(v: u32, t: u32, a: u32, d: u32) -> Weight { < - ::WeightInfo - as - pallet_election_provider_multi_phase::WeightInfo - >::submit_unsigned(v, t, a, d) + ::WeightInfo + as + pallet_election_provider_multi_phase::WeightInfo + >::submit_unsigned(v, t, a, d) } } @@ -553,7 +636,7 @@ impl pallet_election_provider_multi_phase::Config for Runtime { ::MaxWeight; type MinerConfig = Self; type SlashHandler = (); // burn slashes - type RewardHandler = (); // nothing to do upon rewards + type RewardHandler = (); // rewards are minted from the void type BetterSignedThreshold = (); type OffchainRepeat = OffchainRepeat; type MinerTxPriority = NposSolutionPriority; @@ -573,7 +656,7 @@ impl pallet_election_provider_multi_phase::Config for Runtime { pallet_election_provider_multi_phase::SolutionAccuracyOf, (), >; - type BenchmarkingConfig = runtime_common::elections::BenchmarkConfig; + type BenchmarkingConfig = polkadot_runtime_common::elections::BenchmarkConfig; type ForceOrigin = EnsureRoot; type WeightInfo = weights::pallet_election_provider_multi_phase::WeightInfo; type MaxWinners = MaxActiveValidators; @@ -593,15 +676,37 @@ impl pallet_bags_list::Config for Runtime { type Score = sp_npos_elections::VoteWeight; } -pallet_staking_reward_curve::build! { - const REWARD_CURVE: PiecewiseLinear<'static> = curve!( - min_inflation: 0_025_000, - max_inflation: 0_100_000, - ideal_stake: 0_500_000, - falloff: 0_050_000, - max_piece_count: 40, - test_precision: 0_005_000, - ); +pub struct EraPayout; +impl pallet_staking::EraPayout for EraPayout { + fn era_payout( + total_staked: Balance, + total_issuance: Balance, + era_duration_millis: u64, + ) -> (Balance, Balance) { + const MILLISECONDS_PER_YEAR: u64 = 1000 * 3600 * 24 * 36525 / 100; + + let params = EraPayoutParams { + total_staked, + total_stakable: total_issuance, + ideal_stake: dynamic_params::inflation::IdealStake::get(), + max_annual_inflation: dynamic_params::inflation::MaxInflation::get(), + min_annual_inflation: dynamic_params::inflation::MinInflation::get(), + falloff: dynamic_params::inflation::Falloff::get(), + period_fraction: Perquintill::from_rational(era_duration_millis, MILLISECONDS_PER_YEAR), + legacy_auction_proportion: if dynamic_params::inflation::UseAuctionSlots::get() { + let auctioned_slots = parachains_paras::Parachains::::get() + .into_iter() + // all active para-ids that do not belong to a system chain is the number of + // parachains that we should take into account for inflation. + .filter(|i| *i >= 2000.into()) + .count() as u64; + Some(Perquintill::from_rational(auctioned_slots.min(60), 200u64)) + } else { + None + }, + }; + relay_era_payout(params) + } } parameter_types! { @@ -611,7 +716,6 @@ parameter_types! { pub const BondingDuration: sp_staking::EraIndex = 2; // 1 era in which slashes can be cancelled (6 hours). pub const SlashDeferDuration: sp_staking::EraIndex = 1; - pub const RewardCurve: &'static PiecewiseLinear<'static> = &REWARD_CURVE; pub const MaxExposurePageSize: u32 = 64; // Note: this is not really correct as Max Nominators is (MaxExposurePageSize * page_count) but // this is an unbounded number. We just set it to a reasonably high value, 1 full page @@ -635,7 +739,7 @@ impl pallet_staking::Config for Runtime { type SlashDeferDuration = SlashDeferDuration; type AdminOrigin = EitherOf, StakingAdmin>; type SessionInterface = Self; - type EraPayout = pallet_staking::ConvertCurve; + type EraPayout = EraPayout; type MaxExposurePageSize = MaxExposurePageSize; type NextNewSession = Session; type ElectionProvider = ElectionProviderMultiPhase; @@ -646,8 +750,8 @@ impl pallet_staking::Config for Runtime { type MaxUnlockingChunks = frame_support::traits::ConstU32<32>; type HistoryDepth = frame_support::traits::ConstU32<84>; type MaxControllersInDeprecationBatch = MaxControllersInDeprecationBatch; - type BenchmarkingConfig = runtime_common::StakingBenchmarkingConfig; - type EventListeners = NominationPools; + type BenchmarkingConfig = polkadot_runtime_common::StakingBenchmarkingConfig; + type EventListeners = (NominationPools, DelegatedStaking); type WeightInfo = weights::pallet_staking::WeightInfo; type DisablingStrategy = pallet_staking::UpToLimitDisablingStrategy; } @@ -664,9 +768,6 @@ impl pallet_fast_unstake::Config for Runtime { } parameter_types! { - pub const ProposalBond: Permill = Permill::from_percent(5); - pub const ProposalBondMinimum: Balance = 2000 * CENTS; - pub const ProposalBondMaximum: Balance = 1 * GRAND; pub const SpendPeriod: BlockNumber = 6 * DAYS; pub const Burn: Permill = Permill::from_perthousand(2); pub const TreasuryPalletId: PalletId = PalletId(*b"py/trsry"); @@ -689,13 +790,8 @@ parameter_types! { impl pallet_treasury::Config for Runtime { type PalletId = TreasuryPalletId; type Currency = Balances; - type ApproveOrigin = EitherOfDiverse, Treasurer>; type RejectOrigin = EitherOfDiverse, Treasurer>; type RuntimeEvent = RuntimeEvent; - type OnSlash = Treasury; - type ProposalBond = ProposalBond; - type ProposalBondMinimum = ProposalBondMinimum; - type ProposalBondMaximum = ProposalBondMaximum; type SpendPeriod = SpendPeriod; type Burn = Burn; type BurnDestination = (); @@ -727,7 +823,7 @@ impl pallet_treasury::Config for Runtime { >; type PayoutPeriod = PayoutSpendPeriod; #[cfg(feature = "runtime-benchmarks")] - type BenchmarkHelper = runtime_common::impls::benchmarks::TreasuryArguments; + type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::TreasuryArguments; } impl pallet_offences::Config for Runtime { @@ -797,6 +893,7 @@ where frame_system::CheckNonce::::from(nonce), frame_system::CheckWeight::::new(), pallet_transaction_payment::ChargeTransactionPayment::::from(tip), + frame_metadata_hash_extension::CheckMetadataHash::::new(true), ); let raw_payload = SignedPayload::new(call, extra) .map_err(|e| { @@ -1081,7 +1178,7 @@ impl pallet_proxy::Config for Runtime { impl parachains_origin::Config for Runtime {} impl parachains_configuration::Config for Runtime { - type WeightInfo = weights::runtime_parachains_configuration::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_configuration::WeightInfo; } impl parachains_shared::Config for Runtime { @@ -1097,7 +1194,7 @@ impl parachains_inclusion::Config for Runtime { type DisputesHandler = ParasDisputes; type RewardValidators = parachains_reward_points::RewardValidatorsWithEraPoints; type MessageQueue = MessageQueue; - type WeightInfo = weights::runtime_parachains_inclusion::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_inclusion::WeightInfo; } parameter_types! { @@ -1106,7 +1203,7 @@ parameter_types! { impl parachains_paras::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type WeightInfo = weights::runtime_parachains_paras::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_paras::WeightInfo; type UnsignedPriority = ParasUnsignedPriority; type QueueFootprinter = ParaInclusion; type NextSessionRotation = Babe; @@ -1180,11 +1277,11 @@ impl parachains_hrmp::Config for Runtime { HrmpChannelSizeAndCapacityWithSystemRatio, >; type VersionWrapper = crate::XcmPallet; - type WeightInfo = weights::runtime_parachains_hrmp::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_hrmp::WeightInfo; } impl parachains_paras_inherent::Config for Runtime { - type WeightInfo = weights::runtime_parachains_paras_inherent::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_paras_inherent::WeightInfo; } impl parachains_scheduler::Config for Runtime { @@ -1195,28 +1292,48 @@ impl parachains_scheduler::Config for Runtime { parameter_types! { pub const BrokerId: u32 = BROKER_ID; + pub const BrokerPalletId: PalletId = PalletId(*b"py/broke"); pub MaxXcmTransactWeight: Weight = Weight::from_parts(200_000_000, 20_000); } +pub struct BrokerPot; +impl Get for BrokerPot { + fn get() -> InteriorLocation { + Junction::AccountId32 { network: None, id: BrokerPalletId::get().into_account_truncating() } + .into() + } +} + impl coretime::Config for Runtime { type RuntimeOrigin = RuntimeOrigin; type RuntimeEvent = RuntimeEvent; type Currency = Balances; type BrokerId = BrokerId; - type WeightInfo = weights::runtime_parachains_coretime::WeightInfo; + type BrokerPotLocation = BrokerPot; + type WeightInfo = weights::polkadot_runtime_parachains_coretime::WeightInfo; type SendXcm = crate::xcm_config::XcmRouter; + type AssetTransactor = crate::xcm_config::LocalAssetTransactor; + type AccountToLocation = xcm_builder::AliasesIntoAccountId32< + xcm_config::ThisNetwork, + ::AccountId, + >; type MaxXcmTransactWeight = MaxXcmTransactWeight; } parameter_types! { pub const OnDemandTrafficDefaultValue: FixedU128 = FixedU128::from_u32(1); + // Keep 2 timeslices worth of revenue information. + pub const MaxHistoricalRevenue: BlockNumber = 2 * TIMESLICE_PERIOD; + pub const OnDemandPalletId: PalletId = PalletId(*b"py/ondmd"); } -impl parachains_assigner_on_demand::Config for Runtime { +impl parachains_on_demand::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; type TrafficDefaultValue = OnDemandTrafficDefaultValue; - type WeightInfo = weights::runtime_parachains_assigner_on_demand::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_on_demand::WeightInfo; + type MaxHistoricalRevenue = MaxHistoricalRevenue; + type PalletId = OnDemandPalletId; } impl parachains_assigner_coretime::Config for Runtime {} @@ -1224,7 +1341,7 @@ impl parachains_assigner_coretime::Config for Runtime {} impl parachains_initializer::Config for Runtime { type Randomness = pallet_babe::RandomnessFromOneEpochAgo; type ForceOrigin = EnsureRoot; - type WeightInfo = weights::runtime_parachains_initializer::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_initializer::WeightInfo; type CoretimeOnNewSession = Coretime; } @@ -1243,14 +1360,14 @@ impl assigned_slots::Config for Runtime { type PermanentSlotLeasePeriodLength = PermanentSlotLeasePeriodLength; type TemporarySlotLeasePeriodLength = TemporarySlotLeasePeriodLength; type MaxTemporarySlotPerLeasePeriod = MaxTemporarySlotPerLeasePeriod; - type WeightInfo = weights::runtime_common_assigned_slots::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_assigned_slots::WeightInfo; } impl parachains_disputes::Config for Runtime { type RuntimeEvent = RuntimeEvent; type RewardValidators = parachains_reward_points::RewardValidatorsWithEraPoints; type SlashingHandler = parachains_slashing::SlashValidatorsForDisputes; - type WeightInfo = weights::runtime_parachains_disputes::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_disputes::WeightInfo; } impl parachains_slashing::Config for Runtime { @@ -1266,7 +1383,7 @@ impl parachains_slashing::Config for Runtime { Offences, ReportLongevity, >; - type WeightInfo = weights::runtime_parachains_disputes_slashing::WeightInfo; + type WeightInfo = weights::polkadot_runtime_parachains_disputes_slashing::WeightInfo; type BenchmarkingConfig = parachains_slashing::BenchConfig<300>; } @@ -1282,7 +1399,7 @@ impl paras_registrar::Config for Runtime { type OnSwap = (Crowdloan, Slots, SwapLeases); type ParaDeposit = ParaDeposit; type DataDepositPerByte = RegistrarDataDepositPerByte; - type WeightInfo = weights::runtime_common_paras_registrar::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_paras_registrar::WeightInfo; } parameter_types! { @@ -1296,7 +1413,7 @@ impl slots::Config for Runtime { type LeasePeriod = LeasePeriod; type LeaseOffset = (); type ForceOrigin = EitherOf, LeaseAdmin>; - type WeightInfo = weights::runtime_common_slots::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_slots::WeightInfo; } parameter_types! { @@ -1317,7 +1434,7 @@ impl crowdloan::Config for Runtime { type Registrar = Registrar; type Auctioneer = Auctions; type MaxMemoLength = MaxMemoLength; - type WeightInfo = weights::runtime_common_crowdloan::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_crowdloan::WeightInfo; } parameter_types! { @@ -1336,14 +1453,14 @@ impl auctions::Config for Runtime { type SampleLength = SampleLength; type Randomness = pallet_babe::RandomnessFromOneEpochAgo; type InitiateOrigin = EitherOf, AuctionAdmin>; - type WeightInfo = weights::runtime_common_auctions::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_auctions::WeightInfo; } impl identity_migrator::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Reaper = EnsureSigned; type ReapIdentityHandler = ToParachainIdentityReaper; - type WeightInfo = weights::runtime_common_identity_migrator::WeightInfo; + type WeightInfo = weights::polkadot_runtime_common_identity_migrator::WeightInfo; } parameter_types! { @@ -1359,7 +1476,8 @@ impl pallet_nomination_pools::Config for Runtime { type RewardCounter = FixedU128; type BalanceToU256 = BalanceToU256; type U256ToBalance = U256ToBalance; - type Staking = Staking; + type StakeAdapter = + pallet_nomination_pools::adapter::DelegateStake; type PostUnbondingPoolsWindow = ConstU32<4>; type MaxMetadataLen = ConstU32<256>; // we use the same number of allowed unlocking chunks as with staking. @@ -1369,6 +1487,21 @@ impl pallet_nomination_pools::Config for Runtime { type AdminOrigin = EitherOf, StakingAdmin>; } +parameter_types! { + pub const DelegatedStakingPalletId: PalletId = PalletId(*b"py/dlstk"); + pub const SlashRewardFraction: Perbill = Perbill::from_percent(1); +} + +impl pallet_delegated_staking::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type PalletId = DelegatedStakingPalletId; + type Currency = Balances; + type OnSlash = (); + type SlashRewardFraction = SlashRewardFraction; + type RuntimeHoldReason = RuntimeHoldReason; + type CoreStaking = Staking; +} + impl pallet_root_testing::Config for Runtime { type RuntimeEvent = RuntimeEvent; } @@ -1389,7 +1522,7 @@ impl pallet_asset_rate::Config for Runtime { type Currency = Balances; type AssetKind = ::AssetKind; #[cfg(feature = "runtime-benchmarks")] - type BenchmarkHelper = runtime_common::impls::benchmarks::AssetRateArguments; + type BenchmarkHelper = polkadot_runtime_common::impls::benchmarks::AssetRateArguments; } // Notify `coretime` pallet when a lease swap occurs @@ -1443,6 +1576,8 @@ mod runtime { pub type Offences = pallet_offences; #[runtime::pallet_index(27)] pub type Historical = session_historical; + #[runtime::pallet_index(70)] + pub type Parameters = pallet_parameters; #[runtime::pallet_index(8)] pub type Session = pallet_session; @@ -1517,6 +1652,10 @@ mod runtime { #[runtime::pallet_index(37)] pub type Treasury = pallet_treasury; + // Staking extension for delegation + #[runtime::pallet_index(38)] + pub type DelegatedStaking = pallet_delegated_staking; + // Parachains pallets. Start indices at 40 to leave room. #[runtime::pallet_index(41)] pub type ParachainsOrigin = parachains_origin; @@ -1546,7 +1685,7 @@ mod runtime { #[runtime::pallet_index(54)] pub type ParasSlashing = parachains_slashing; #[runtime::pallet_index(56)] - pub type OnDemandAssignmentProvider = parachains_assigner_on_demand; + pub type OnDemandAssignmentProvider = parachains_on_demand; #[runtime::pallet_index(57)] pub type CoretimeAssignmentProvider = parachains_assigner_coretime; @@ -1617,13 +1756,12 @@ pub type SignedExtra = ( frame_system::CheckNonce, frame_system::CheckWeight, pallet_transaction_payment::ChargeTransactionPayment, + frame_metadata_hash_extension::CheckMetadataHash, ); -pub struct NominationPoolsMigrationV4OldPallet; -impl Get for NominationPoolsMigrationV4OldPallet { - fn get() -> Perbill { - Perbill::from_percent(100) - } +parameter_types! { + /// Bounding number of agent pot accounts to be migrated in a single block. + pub const MaxAgentsToMigrate: u32 = 300; } /// All migrations that will run on the next runtime upgrade. @@ -1637,26 +1775,14 @@ pub type Migrations = migrations::Unreleased; pub mod migrations { use super::*; - pub struct GetLegacyLeaseImpl; - impl coretime::migration::GetLegacyLease for GetLegacyLeaseImpl { - fn get_parachain_lease_in_blocks(para: ParaId) -> Option { - let now = frame_system::Pallet::::block_number(); - let lease = slots::Leases::::get(para); - if lease.is_empty() { - return None; - } - // Lease not yet started, ignore: - if lease.iter().any(Option::is_none) { - return None; - } - let (index, _) = - as Leaser>::lease_period_index(now)?; - Some(index.saturating_add(lease.len() as u32).saturating_mul(LeasePeriod::get())) - } - } - /// Unreleased migrations. Add new ones here: - pub type Unreleased = (pallet_staking::migrations::v15::MigrateV14ToV15,); + pub type Unreleased = ( + // This is only needed for Westend. + pallet_delegated_staking::migration::unversioned::ProxyDelegatorMigration< + Runtime, + MaxAgentsToMigrate, + >, + ); } /// Unchecked extrinsic type as expected by this runtime. @@ -1680,25 +1806,26 @@ mod benches { // Polkadot // NOTE: Make sure to prefix these with `runtime_common::` so // the that path resolves correctly in the generated file. - [runtime_common::assigned_slots, AssignedSlots] - [runtime_common::auctions, Auctions] - [runtime_common::crowdloan, Crowdloan] - [runtime_common::identity_migrator, IdentityMigrator] - [runtime_common::paras_registrar, Registrar] - [runtime_common::slots, Slots] - [runtime_parachains::configuration, Configuration] - [runtime_parachains::disputes, ParasDisputes] - [runtime_parachains::disputes::slashing, ParasSlashing] - [runtime_parachains::hrmp, Hrmp] - [runtime_parachains::inclusion, ParaInclusion] - [runtime_parachains::initializer, Initializer] - [runtime_parachains::paras, Paras] - [runtime_parachains::paras_inherent, ParaInherent] - [runtime_parachains::assigner_on_demand, OnDemandAssignmentProvider] - [runtime_parachains::coretime, Coretime] + [polkadot_runtime_common::assigned_slots, AssignedSlots] + [polkadot_runtime_common::auctions, Auctions] + [polkadot_runtime_common::crowdloan, Crowdloan] + [polkadot_runtime_common::identity_migrator, IdentityMigrator] + [polkadot_runtime_common::paras_registrar, Registrar] + [polkadot_runtime_common::slots, Slots] + [polkadot_runtime_parachains::configuration, Configuration] + [polkadot_runtime_parachains::disputes, ParasDisputes] + [polkadot_runtime_parachains::disputes::slashing, ParasSlashing] + [polkadot_runtime_parachains::hrmp, Hrmp] + [polkadot_runtime_parachains::inclusion, ParaInclusion] + [polkadot_runtime_parachains::initializer, Initializer] + [polkadot_runtime_parachains::paras, Paras] + [polkadot_runtime_parachains::paras_inherent, ParaInherent] + [polkadot_runtime_parachains::on_demand, OnDemandAssignmentProvider] + [polkadot_runtime_parachains::coretime, Coretime] // Substrate [pallet_bags_list, VoterList] [pallet_balances, Balances] + [pallet_beefy_mmr, BeefyMmrLeaf] [pallet_conviction_voting, ConvictionVoting] [pallet_election_provider_multi_phase, ElectionProviderMultiPhase] [frame_election_provider_support, ElectionProviderBench::] @@ -1706,9 +1833,11 @@ mod benches { [pallet_identity, Identity] [pallet_indices, Indices] [pallet_message_queue, MessageQueue] + [pallet_mmr, Mmr] [pallet_multisig, Multisig] [pallet_nomination_pools, NominationPoolsBench::] [pallet_offences, OffencesBench::] + [pallet_parameters, Parameters] [pallet_preimage, Preimage] [pallet_proxy, Proxy] [pallet_recovery, Recovery] @@ -1756,12 +1885,12 @@ sp_api::impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } - impl block_builder_api::BlockBuilder for Runtime { + impl sp_block_builder::BlockBuilder for Runtime { fn apply_extrinsic(extrinsic: ::Extrinsic) -> ApplyExtrinsicResult { Executive::apply_extrinsic(extrinsic) } @@ -1770,19 +1899,19 @@ sp_api::impl_runtime_apis! { Executive::finalize_block() } - fn inherent_extrinsics(data: inherents::InherentData) -> Vec<::Extrinsic> { + fn inherent_extrinsics(data: sp_inherents::InherentData) -> Vec<::Extrinsic> { data.create_extrinsics() } fn check_inherents( block: Block, - data: inherents::InherentData, - ) -> inherents::CheckInherentsResult { + data: sp_inherents::InherentData, + ) -> sp_inherents::CheckInherentsResult { data.check_extrinsics(&block) } } - impl tx_pool_api::runtime_api::TaggedTransactionQueue for Runtime { + impl sp_transaction_pool::runtime_api::TaggedTransactionQueue for Runtime { fn validate_transaction( source: TransactionSource, tx: ::Extrinsic, @@ -1792,14 +1921,14 @@ sp_api::impl_runtime_apis! { } } - impl offchain_primitives::OffchainWorkerApi for Runtime { + impl sp_offchain::OffchainWorkerApi for Runtime { fn offchain_worker(header: &::Header) { Executive::offchain_worker(header) } } #[api_version(11)] - impl primitives::runtime_api::ParachainHost for Runtime { + impl polkadot_primitives::runtime_api::ParachainHost for Runtime { fn validators() -> Vec { parachains_runtime_api_impl::validators::() } @@ -1829,7 +1958,7 @@ sp_api::impl_runtime_apis! { fn check_validation_outputs( para_id: ParaId, - outputs: primitives::CandidateCommitments, + outputs: polkadot_primitives::CandidateCommitments, ) -> bool { parachains_runtime_api_impl::check_validation_outputs::(para_id, outputs) } @@ -1914,7 +2043,7 @@ sp_api::impl_runtime_apis! { fn key_ownership_proof( validator_id: ValidatorId, ) -> Option { - use parity_scale_codec::Encode; + use codec::Encode; Historical::prove((PARACHAIN_KEY_TYPE_ID, validator_id)) .map(|p| p.encode()) @@ -1935,11 +2064,11 @@ sp_api::impl_runtime_apis! { parachains_runtime_api_impl::minimum_backing_votes::() } - fn para_backing_state(para_id: ParaId) -> Option { + fn para_backing_state(para_id: ParaId) -> Option { parachains_runtime_api_impl::backing_state::(para_id) } - fn async_backing_params() -> primitives::AsyncBackingParams { + fn async_backing_params() -> polkadot_primitives::AsyncBackingParams { parachains_runtime_api_impl::async_backing_params::() } @@ -1964,40 +2093,77 @@ sp_api::impl_runtime_apis! { } } - impl beefy_primitives::BeefyApi for Runtime { + #[api_version(5)] + impl sp_consensus_beefy::BeefyApi for Runtime { fn beefy_genesis() -> Option { pallet_beefy::GenesisBlock::::get() } - fn validator_set() -> Option> { + fn validator_set() -> Option> { Beefy::validator_set() } - fn submit_report_equivocation_unsigned_extrinsic( - equivocation_proof: beefy_primitives::DoubleVotingProof< + fn submit_report_double_voting_unsigned_extrinsic( + equivocation_proof: sp_consensus_beefy::DoubleVotingProof< BlockNumber, BeefyId, BeefySignature, >, - key_owner_proof: beefy_primitives::OpaqueKeyOwnershipProof, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; - Beefy::submit_unsigned_equivocation_report( + Beefy::submit_unsigned_double_voting_report( equivocation_proof, key_owner_proof, ) } + fn submit_report_fork_voting_unsigned_extrinsic( + equivocation_proof: + sp_consensus_beefy::ForkVotingProof< + ::Header, + BeefyId, + sp_runtime::OpaqueValue + >, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_fork_voting_report( + equivocation_proof.try_into()?, + key_owner_proof.decode()?, + ) + } + + fn submit_report_future_block_voting_unsigned_extrinsic( + equivocation_proof: sp_consensus_beefy::FutureBlockVotingProof, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_future_block_voting_report( + equivocation_proof, + key_owner_proof.decode()?, + ) + } + fn generate_key_ownership_proof( - _set_id: beefy_primitives::ValidatorSetId, + _set_id: sp_consensus_beefy::ValidatorSetId, authority_id: BeefyId, - ) -> Option { - use parity_scale_codec::Encode; + ) -> Option { + use codec::Encode; + + Historical::prove((sp_consensus_beefy::KEY_TYPE, authority_id)) + .map(|p| p.encode()) + .map(sp_consensus_beefy::OpaqueKeyOwnershipProof::new) + } + + fn generate_ancestry_proof( + prev_block_number: BlockNumber, + best_known_block_number: Option, + ) -> Option { + use sp_consensus_beefy::AncestryHelper; - Historical::prove((beefy_primitives::KEY_TYPE, authority_id)) + BeefyMmrLeaf::generate_proof(prev_block_number, best_known_block_number) .map(|p| p.encode()) - .map(beefy_primitives::OpaqueKeyOwnershipProof::new) + .map(sp_runtime::OpaqueValue::new) } } @@ -2013,7 +2179,7 @@ sp_api::impl_runtime_apis! { fn generate_proof( block_numbers: Vec, best_known_block_number: Option, - ) -> Result<(Vec, mmr::Proof), mmr::Error> { + ) -> Result<(Vec, mmr::LeafProof), mmr::Error> { Mmr::generate_proof(block_numbers, best_known_block_number).map( |(leaves, proof)| { ( @@ -2027,7 +2193,7 @@ sp_api::impl_runtime_apis! { ) } - fn verify_proof(leaves: Vec, proof: mmr::Proof) + fn verify_proof(leaves: Vec, proof: mmr::LeafProof) -> Result<(), mmr::Error> { let leaves = leaves.into_iter().map(|leaf| @@ -2040,7 +2206,7 @@ sp_api::impl_runtime_apis! { fn verify_proof_stateless( root: mmr::Hash, leaves: Vec, - proof: mmr::Proof + proof: mmr::LeafProof ) -> Result<(), mmr::Error> { let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect(); pallet_mmr::verify_leaves_proof::(root, nodes, proof) @@ -2048,11 +2214,11 @@ sp_api::impl_runtime_apis! { } impl pallet_beefy_mmr::BeefyMmrApi for RuntimeApi { - fn authority_set_proof() -> beefy_primitives::mmr::BeefyAuthoritySet { + fn authority_set_proof() -> sp_consensus_beefy::mmr::BeefyAuthoritySet { BeefyMmrLeaf::authority_set_proof() } - fn next_authority_set_proof() -> beefy_primitives::mmr::BeefyNextAuthoritySet { + fn next_authority_set_proof() -> sp_consensus_beefy::mmr::BeefyNextAuthoritySet { BeefyMmrLeaf::next_authority_set_proof() } } @@ -2085,7 +2251,7 @@ sp_api::impl_runtime_apis! { _set_id: fg_primitives::SetId, authority_id: fg_primitives::AuthorityId, ) -> Option { - use parity_scale_codec::Encode; + use codec::Encode; Historical::prove((fg_primitives::KEY_TYPE, authority_id)) .map(|p| p.encode()) @@ -2093,10 +2259,10 @@ sp_api::impl_runtime_apis! { } } - impl babe_primitives::BabeApi for Runtime { - fn configuration() -> babe_primitives::BabeConfiguration { + impl sp_consensus_babe::BabeApi for Runtime { + fn configuration() -> sp_consensus_babe::BabeConfiguration { let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG); - babe_primitives::BabeConfiguration { + sp_consensus_babe::BabeConfiguration { slot_duration: Babe::slot_duration(), epoch_length: EpochDuration::get(), c: epoch_config.c, @@ -2106,32 +2272,32 @@ sp_api::impl_runtime_apis! { } } - fn current_epoch_start() -> babe_primitives::Slot { + fn current_epoch_start() -> sp_consensus_babe::Slot { Babe::current_epoch_start() } - fn current_epoch() -> babe_primitives::Epoch { + fn current_epoch() -> sp_consensus_babe::Epoch { Babe::current_epoch() } - fn next_epoch() -> babe_primitives::Epoch { + fn next_epoch() -> sp_consensus_babe::Epoch { Babe::next_epoch() } fn generate_key_ownership_proof( - _slot: babe_primitives::Slot, - authority_id: babe_primitives::AuthorityId, - ) -> Option { - use parity_scale_codec::Encode; + _slot: sp_consensus_babe::Slot, + authority_id: sp_consensus_babe::AuthorityId, + ) -> Option { + use codec::Encode; - Historical::prove((babe_primitives::KEY_TYPE, authority_id)) + Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id)) .map(|p| p.encode()) - .map(babe_primitives::OpaqueKeyOwnershipProof::new) + .map(sp_consensus_babe::OpaqueKeyOwnershipProof::new) } fn submit_report_equivocation_unsigned_extrinsic( - equivocation_proof: babe_primitives::EquivocationProof<::Header>, - key_owner_proof: babe_primitives::OpaqueKeyOwnershipProof, + equivocation_proof: sp_consensus_babe::EquivocationProof<::Header>, + key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof, ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; @@ -2142,7 +2308,7 @@ sp_api::impl_runtime_apis! { } } - impl authority_discovery_primitives::AuthorityDiscoveryApi for Runtime { + impl sp_authority_discovery::AuthorityDiscoveryApi for Runtime { fn authorities() -> Vec { parachains_runtime_api_impl::relevant_authority_ids::() } @@ -2201,17 +2367,10 @@ sp_api::impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi for Runtime { + impl xcm_runtime_apis::fees::XcmPaymentApi for Runtime { fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result, XcmPaymentApiError> { - let acceptable = vec![ - // native token - VersionedAssetId::from(AssetId(xcm_config::TokenLocation::get())) - ]; - - Ok(acceptable - .into_iter() - .filter_map(|asset| asset.into_version(xcm_version).ok()) - .collect()) + let acceptable_assets = vec![AssetId(xcm_config::TokenLocation::get())]; + XcmPallet::query_acceptable_payment_assets(xcm_version, acceptable_assets) } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { @@ -2221,11 +2380,11 @@ sp_api::impl_runtime_apis! { Ok(WeightToFee::weight_to_fee(&weight)) }, Ok(asset_id) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!"); Err(XcmPaymentApiError::AssetNotFound) }, Err(_) => { - log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); + log::trace!(target: "xcm::xcm_runtime_apis", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!"); Err(XcmPaymentApiError::VersionedConversionFailed) } } @@ -2240,63 +2399,25 @@ sp_api::impl_runtime_apis! { } } - impl xcm_fee_payment_runtime_api::dry_run::XcmDryRunApi for Runtime { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - use xcm_executor::RecordXcm; - pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; - let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + impl xcm_runtime_apis::dry_run::DryRunApi for Runtime { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { + XcmPallet::dry_run_call::(origin, call) } fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { - use xcm_builder::InspectMessageQueues; - let origin_location: Location = origin_location.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Location version conversion failed with error: {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let xcm: Xcm = xcm.try_into().map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", - "Xcm version conversion failed with error {:?}", - error, - ); - XcmDryRunApiError::VersionedConversionFailed - })?; - let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256); - let result = xcm_executor::XcmExecutor::::prepare_and_execute( - origin_location, - xcm, - &mut hash, - Weight::MAX, // Max limit available for execution. - Weight::zero(), - ); - let forwarded_xcms = xcm_config::XcmRouter::get_messages(); - let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); - Ok(XcmDryRunEffects { - forwarded_xcms, - emitted_events: events, - execution_result: result, - }) + XcmPallet::dry_run_xcm::(origin_location, xcm) + } + } + + impl xcm_runtime_apis::conversions::LocationToAccountApi for Runtime { + fn convert_location(location: VersionedLocation) -> Result< + AccountId, + xcm_runtime_apis::conversions::Error + > { + xcm_runtime_apis::conversions::LocationToAccountHelper::< + AccountId, + xcm_config::LocationConverter, + >::convert_location(location) } } @@ -2316,6 +2437,30 @@ sp_api::impl_runtime_apis! { fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance { NominationPools::api_balance_to_points(pool_id, new_funds) } + + fn pool_pending_slash(pool_id: pallet_nomination_pools::PoolId) -> Balance { + NominationPools::api_pool_pending_slash(pool_id) + } + + fn member_pending_slash(member: AccountId) -> Balance { + NominationPools::api_member_pending_slash(member) + } + + fn pool_needs_delegate_migration(pool_id: pallet_nomination_pools::PoolId) -> bool { + NominationPools::api_pool_needs_delegate_migration(pool_id) + } + + fn member_needs_delegate_migration(member: AccountId) -> bool { + NominationPools::api_member_needs_delegate_migration(member) + } + + fn member_total_balance(member: AccountId) -> Balance { + NominationPools::api_member_total_balance(member) + } + + fn pool_balance(pool_id: pallet_nomination_pools::PoolId) -> Balance { + NominationPools::api_pool_balance(pool_id) + } } impl pallet_staking_runtime_api::StakingApi for Runtime { @@ -2402,6 +2547,8 @@ sp_api::impl_runtime_apis! { use xcm_config::{AssetHub, TokenLocation}; + use alloc::boxed::Box; + parameter_types! { pub ExistentialDepositAsset: Option = Some(( TokenLocation::get(), @@ -2413,14 +2560,14 @@ sp_api::impl_runtime_apis! { impl pallet_xcm::benchmarking::Config for Runtime { type DeliveryHelper = ( - runtime_common::xcm_sender::ToParachainDeliveryHelper< + polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< xcm_config::XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, AssetHubParaId, (), >, - runtime_common::xcm_sender::ToParachainDeliveryHelper< + polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< xcm_config::XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, @@ -2476,7 +2623,7 @@ sp_api::impl_runtime_apis! { } impl frame_system_benchmarking::Config for Runtime {} impl pallet_nomination_pools_benchmarking::Config for Runtime {} - impl runtime_parachains::disputes::slashing::benchmarking::Config for Runtime {} + impl polkadot_runtime_parachains::disputes::slashing::benchmarking::Config for Runtime {} use xcm::latest::{ AssetId, Fungibility::*, InteriorLocation, Junction, Junctions::*, @@ -2486,7 +2633,7 @@ sp_api::impl_runtime_apis! { impl pallet_xcm_benchmarks::Config for Runtime { type XcmConfig = xcm_config::XcmConfig; type AccountIdConverter = xcm_config::LocationConverter; - type DeliveryHelper = runtime_common::xcm_sender::ToParachainDeliveryHelper< + type DeliveryHelper = polkadot_runtime_common::xcm_sender::ToParachainDeliveryHelper< xcm_config::XcmConfig, ExistentialDepositAsset, xcm_config::PriceForChildParachainDelivery, @@ -2614,45 +2761,6 @@ sp_api::impl_runtime_apis! { } } -#[cfg(all(test, feature = "try-runtime"))] -mod remote_tests { - use super::*; - use frame_try_runtime::{runtime_decl_for_try_runtime::TryRuntime, UpgradeCheckSelect}; - use remote_externalities::{ - Builder, Mode, OfflineConfig, OnlineConfig, SnapshotConfig, Transport, - }; - use std::env::var; - - #[tokio::test] - async fn run_migrations() { - if var("RUN_MIGRATION_TESTS").is_err() { - return; - } - - sp_tracing::try_init_simple(); - let transport: Transport = - var("WS").unwrap_or("wss://westend-rpc.polkadot.io:443".to_string()).into(); - let maybe_state_snapshot: Option = var("SNAP").map(|s| s.into()).ok(); - let mut ext = Builder::::default() - .mode(if let Some(state_snapshot) = maybe_state_snapshot { - Mode::OfflineOrElseOnline( - OfflineConfig { state_snapshot: state_snapshot.clone() }, - OnlineConfig { - transport, - state_snapshot: Some(state_snapshot), - ..Default::default() - }, - ) - } else { - Mode::Online(OnlineConfig { transport, ..Default::default() }) - }) - .build() - .await - .unwrap(); - ext.execute_with(|| Runtime::on_runtime_upgrade(UpgradeCheckSelect::PreAndPost)); - } -} - mod clean_state_migration { use super::Runtime; #[cfg(feature = "try-runtime")] diff --git a/polkadot/runtime/westend/src/tests.rs b/polkadot/runtime/westend/src/tests.rs index 4acb81e963b2165ee01881d189daf89c0c1a7924..dc8103ab52c474a8f24b288add5b0cd9880265fc 100644 --- a/polkadot/runtime/westend/src/tests.rs +++ b/polkadot/runtime/westend/src/tests.rs @@ -24,7 +24,7 @@ use sp_core::hexdisplay::HexDisplay; #[test] fn remove_keys_weight_is_sensible() { - use runtime_common::crowdloan::WeightInfo; + use polkadot_runtime_common::crowdloan::WeightInfo; let max_weight = ::WeightInfo::refund(RemoveKeysLimit::get()); // Max remove keys limit should be no more than half the total block weight. assert!((max_weight * 2).all_lt(BlockWeights::get().max_block)); @@ -32,7 +32,7 @@ fn remove_keys_weight_is_sensible() { #[test] fn sample_size_is_sensible() { - use runtime_common::auctions::WeightInfo; + use polkadot_runtime_common::auctions::WeightInfo; // Need to clean up all samples at the end of an auction. let samples: BlockNumber = EndingPeriod::get() / SampleLength::get(); let max_weight: frame_support::weights::Weight = @@ -99,3 +99,140 @@ fn check_treasury_pallet_id() { westend_runtime_constants::TREASURY_PALLET_ID ); } + +#[cfg(all(test, feature = "try-runtime"))] +mod remote_tests { + use super::*; + use frame_try_runtime::{runtime_decl_for_try_runtime::TryRuntime, UpgradeCheckSelect}; + use remote_externalities::{ + Builder, Mode, OfflineConfig, OnlineConfig, SnapshotConfig, Transport, + }; + use std::env::var; + + #[tokio::test] + async fn run_migrations() { + if var("RUN_MIGRATION_TESTS").is_err() { + return; + } + + sp_tracing::try_init_simple(); + let transport: Transport = + var("WS").unwrap_or("wss://westend-rpc.polkadot.io:443".to_string()).into(); + let maybe_state_snapshot: Option = var("SNAP").map(|s| s.into()).ok(); + let mut ext = Builder::::default() + .mode(if let Some(state_snapshot) = maybe_state_snapshot { + Mode::OfflineOrElseOnline( + OfflineConfig { state_snapshot: state_snapshot.clone() }, + OnlineConfig { + transport, + state_snapshot: Some(state_snapshot), + ..Default::default() + }, + ) + } else { + Mode::Online(OnlineConfig { transport, ..Default::default() }) + }) + .build() + .await + .unwrap(); + ext.execute_with(|| Runtime::on_runtime_upgrade(UpgradeCheckSelect::PreAndPost)); + } + + #[tokio::test] + async fn delegate_stake_migration() { + // Intended to be run only manually. + if var("RUN_MIGRATION_TESTS").is_err() { + return; + } + use frame_support::assert_ok; + sp_tracing::try_init_simple(); + + let transport: Transport = var("WS").unwrap_or("ws://127.0.0.1:9900".to_string()).into(); + let maybe_state_snapshot: Option = var("SNAP").map(|s| s.into()).ok(); + let mut ext = Builder::::default() + .mode(if let Some(state_snapshot) = maybe_state_snapshot { + Mode::OfflineOrElseOnline( + OfflineConfig { state_snapshot: state_snapshot.clone() }, + OnlineConfig { + transport, + state_snapshot: Some(state_snapshot), + pallets: vec![ + "staking".into(), + "system".into(), + "balances".into(), + "nomination-pools".into(), + "delegated-staking".into(), + ], + ..Default::default() + }, + ) + } else { + Mode::Online(OnlineConfig { transport, ..Default::default() }) + }) + .build() + .await + .unwrap(); + ext.execute_with(|| { + // create an account with some balance + let alice = AccountId::from([1u8; 32]); + use frame_support::traits::Currency; + let _ = Balances::deposit_creating(&alice, 100_000 * UNITS); + + // iterate over all pools + pallet_nomination_pools::BondedPools::::iter_keys().for_each(|k| { + if pallet_nomination_pools::Pallet::::api_pool_needs_delegate_migration(k) + { + assert_ok!( + pallet_nomination_pools::Pallet::::migrate_pool_to_delegate_stake( + RuntimeOrigin::signed(alice.clone()).into(), + k, + ) + ); + } + }); + + // member migration stats + let mut success = 0; + let mut direct_stakers = 0; + let mut unexpected_errors = 0; + + // iterate over all pool members + pallet_nomination_pools::PoolMembers::::iter_keys().for_each(|k| { + if pallet_nomination_pools::Pallet::::api_member_needs_delegate_migration( + k.clone(), + ) { + // reasons migrations can fail: + let is_direct_staker = pallet_staking::Bonded::::contains_key(&k); + + let migration = pallet_nomination_pools::Pallet::::migrate_delegation( + RuntimeOrigin::signed(alice.clone()).into(), + sp_runtime::MultiAddress::Id(k.clone()), + ); + + if is_direct_staker { + // if the member is a direct staker, the migration should fail until pool + // member unstakes all funds from pallet-staking. + direct_stakers += 1; + assert_eq!( + migration.unwrap_err(), + pallet_delegated_staking::Error::::AlreadyStaking.into() + ); + } else if migration.is_err() { + unexpected_errors += 1; + log::error!(target: "remote_test", "Unexpected error {:?} while migrating {:?}", migration.unwrap_err(), k); + } else { + success += 1; + } + } + }); + + log::info!( + target: "remote_test", + "Migration stats: success: {}, direct_stakers: {}, unexpected_errors: {}", + success, + direct_stakers, + unexpected_errors + ); + }); + } +} diff --git a/polkadot/runtime/westend/src/weights/mod.rs b/polkadot/runtime/westend/src/weights/mod.rs index f6a9008d71876726dda2ad240ecdb4588a1f82a3..1e7b01bc472b2227ce489b4477018d7b4fabde53 100644 --- a/polkadot/runtime/westend/src/weights/mod.rs +++ b/polkadot/runtime/westend/src/weights/mod.rs @@ -20,14 +20,17 @@ pub mod frame_system; pub mod pallet_asset_rate; pub mod pallet_bags_list; pub mod pallet_balances; +pub mod pallet_beefy_mmr; pub mod pallet_conviction_voting; pub mod pallet_election_provider_multi_phase; pub mod pallet_fast_unstake; pub mod pallet_identity; pub mod pallet_indices; pub mod pallet_message_queue; +pub mod pallet_mmr; pub mod pallet_multisig; pub mod pallet_nomination_pools; +pub mod pallet_parameters; pub mod pallet_preimage; pub mod pallet_proxy; pub mod pallet_referenda_fellowship_referenda; @@ -42,20 +45,20 @@ pub mod pallet_utility; pub mod pallet_vesting; pub mod pallet_whitelist; pub mod pallet_xcm; -pub mod runtime_common_assigned_slots; -pub mod runtime_common_auctions; -pub mod runtime_common_crowdloan; -pub mod runtime_common_identity_migrator; -pub mod runtime_common_paras_registrar; -pub mod runtime_common_slots; -pub mod runtime_parachains_assigner_on_demand; -pub mod runtime_parachains_configuration; -pub mod runtime_parachains_coretime; -pub mod runtime_parachains_disputes; -pub mod runtime_parachains_disputes_slashing; -pub mod runtime_parachains_hrmp; -pub mod runtime_parachains_inclusion; -pub mod runtime_parachains_initializer; -pub mod runtime_parachains_paras; -pub mod runtime_parachains_paras_inherent; +pub mod polkadot_runtime_common_assigned_slots; +pub mod polkadot_runtime_common_auctions; +pub mod polkadot_runtime_common_crowdloan; +pub mod polkadot_runtime_common_identity_migrator; +pub mod polkadot_runtime_common_paras_registrar; +pub mod polkadot_runtime_common_slots; +pub mod polkadot_runtime_parachains_configuration; +pub mod polkadot_runtime_parachains_coretime; +pub mod polkadot_runtime_parachains_disputes; +pub mod polkadot_runtime_parachains_disputes_slashing; +pub mod polkadot_runtime_parachains_hrmp; +pub mod polkadot_runtime_parachains_inclusion; +pub mod polkadot_runtime_parachains_initializer; +pub mod polkadot_runtime_parachains_on_demand; +pub mod polkadot_runtime_parachains_paras; +pub mod polkadot_runtime_parachains_paras_inherent; pub mod xcm; diff --git a/polkadot/runtime/westend/src/weights/pallet_beefy_mmr.rs b/polkadot/runtime/westend/src/weights/pallet_beefy_mmr.rs new file mode 100644 index 0000000000000000000000000000000000000000..5be207e3fcff484a789d209b3f3cdd7db7c49e15 --- /dev/null +++ b/polkadot/runtime/westend/src/weights/pallet_beefy_mmr.rs @@ -0,0 +1,89 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `pallet_beefy_mmr` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-13, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_beefy_mmr +// --chain=westend-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/westend/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_beefy_mmr`. +pub struct WeightInfo(PhantomData); +impl pallet_beefy_mmr::WeightInfo for WeightInfo { + /// Storage: `System::BlockHash` (r:1 w:0) + /// Proof: `System::BlockHash` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) + fn extract_validation_context() -> Weight { + // Proof Size summary in bytes: + // Measured: `92` + // Estimated: `3509` + // Minimum execution time: 7_850_000 picoseconds. + Weight::from_parts(8_169_000, 0) + .saturating_add(Weight::from_parts(0, 3509)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: `Mmr::Nodes` (r:1 w:0) + /// Proof: `Mmr::Nodes` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + fn read_peak() -> Weight { + // Proof Size summary in bytes: + // Measured: `201` + // Estimated: `3505` + // Minimum execution time: 6_852_000 picoseconds. + Weight::from_parts(7_448_000, 0) + .saturating_add(Weight::from_parts(0, 3505)) + .saturating_add(T::DbWeight::get().reads(1)) + } + /// Storage: `Mmr::RootHash` (r:1 w:0) + /// Proof: `Mmr::RootHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Mmr::NumberOfLeaves` (r:1 w:0) + /// Proof: `Mmr::NumberOfLeaves` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// The range of component `n` is `[2, 512]`. + fn n_items_proof_is_non_canonical(n: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `193` + // Estimated: `1517` + // Minimum execution time: 12_860_000 picoseconds. + Weight::from_parts(17_158_162, 0) + .saturating_add(Weight::from_parts(0, 1517)) + // Standard Error: 1_732 + .saturating_add(Weight::from_parts(1_489_410, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(2)) + } +} diff --git a/polkadot/runtime/westend/src/weights/pallet_mmr.rs b/polkadot/runtime/westend/src/weights/pallet_mmr.rs new file mode 100644 index 0000000000000000000000000000000000000000..1a410e7fc46ea4aa3944765ef662f4419c4cd16a --- /dev/null +++ b/polkadot/runtime/westend/src/weights/pallet_mmr.rs @@ -0,0 +1,76 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `pallet_mmr` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-07-17, STEPS: `5`, REPEAT: `1`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `am1max.local`, CPU: `` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/testnet/polkadot +// benchmark +// pallet +// --steps=5 +// --repeat=1 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --pallet=pallet_mmr +// --chain=westend-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/westend/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_mmr`. +pub struct WeightInfo(PhantomData); +impl pallet_mmr::WeightInfo for WeightInfo { + /// Storage: `Mmr::NumberOfLeaves` (r:1 w:1) + /// Proof: `Mmr::NumberOfLeaves` (`max_values`: Some(1), `max_size`: Some(8), added: 503, mode: `MaxEncodedLen`) + /// Storage: `System::ParentHash` (r:1 w:0) + /// Proof: `System::ParentHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `Paras::Heads` (r:1025 w:0) + /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `BeefyMmrLeaf::BeefyNextAuthorities` (r:1 w:0) + /// Proof: `BeefyMmrLeaf::BeefyNextAuthorities` (`max_values`: Some(1), `max_size`: Some(44), added: 539, mode: `MaxEncodedLen`) + /// Storage: `Mmr::Nodes` (r:8 w:4) + /// Proof: `Mmr::Nodes` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `System::Digest` (r:1 w:1) + /// Proof: `System::Digest` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Mmr::RootHash` (r:0 w:1) + /// Proof: `Mmr::RootHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// The range of component `x` is `[1, 1000]`. + fn on_initialize(x: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `1071043 + x * (39 ±0)` + // Estimated: `3608787 + x * (39 ±6)` + // Minimum execution time: 11_102_000_000 picoseconds. + Weight::from_parts(21_772_042_215, 0) + .saturating_add(Weight::from_parts(0, 3608787)) + .saturating_add(T::DbWeight::get().reads(1031)) + .saturating_add(T::DbWeight::get().writes(4)) + .saturating_add(Weight::from_parts(0, 39).saturating_mul(x.into())) + } +} diff --git a/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs b/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs index 6aa5ddd1ec8fb5251ac6bbd5059938e4bad93b22..35eef199fb7a974f7665a83c09318ee06b37fea2 100644 --- a/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs +++ b/polkadot/runtime/westend/src/weights/pallet_nomination_pools.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_nomination_pools` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-11-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-04-25, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-yprdrvc7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-dcu62vjg-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -54,7 +54,7 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) /// Storage: `NominationPools::BondedPools` (r:1 w:1) /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) - /// Storage: `Staking::Bonded` (r:1 w:0) + /// Storage: `Staking::Bonded` (r:2 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:1) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) @@ -62,7 +62,7 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`) /// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0) /// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:2 w:1) + /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `NominationPools::MaxPoolMembersPerPool` (r:1 w:0) /// Proof: `NominationPools::MaxPoolMembersPerPool` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -70,10 +70,16 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1) /// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:2 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListNodes` (r:3 w:3) /// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListBags` (r:2 w:2) @@ -82,13 +88,13 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) fn join() -> Weight { // Proof Size summary in bytes: - // Measured: `3355` + // Measured: `3606` // Estimated: `8877` - // Minimum execution time: 173_707_000 picoseconds. - Weight::from_parts(179_920_000, 0) + // Minimum execution time: 204_877_000 picoseconds. + Weight::from_parts(210_389_000, 0) .saturating_add(Weight::from_parts(0, 8877)) - .saturating_add(T::DbWeight::get().reads(20)) - .saturating_add(T::DbWeight::get().writes(13)) + .saturating_add(T::DbWeight::get().reads(24)) + .saturating_add(T::DbWeight::get().writes(15)) } /// Storage: `NominationPools::PoolMembers` (r:1 w:1) /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) @@ -98,16 +104,20 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`) /// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0) /// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:3 w:2) + /// Storage: `System::Account` (r:2 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - /// Storage: `Staking::Bonded` (r:1 w:0) + /// Storage: `Staking::Bonded` (r:2 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:1) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:2 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListNodes` (r:3 w:3) /// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListBags` (r:2 w:2) @@ -116,13 +126,13 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) fn bond_extra_transfer() -> Weight { // Proof Size summary in bytes: - // Measured: `3365` + // Measured: `3762` // Estimated: `8877` - // Minimum execution time: 174_414_000 picoseconds. - Weight::from_parts(178_068_000, 0) + // Minimum execution time: 203_362_000 picoseconds. + Weight::from_parts(209_899_000, 0) .saturating_add(Weight::from_parts(0, 8877)) - .saturating_add(T::DbWeight::get().reads(17)) - .saturating_add(T::DbWeight::get().writes(13)) + .saturating_add(T::DbWeight::get().reads(20)) + .saturating_add(T::DbWeight::get().writes(14)) } /// Storage: `NominationPools::ClaimPermissions` (r:1 w:0) /// Proof: `NominationPools::ClaimPermissions` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`) @@ -134,16 +144,20 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`) /// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0) /// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:3 w:3) + /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - /// Storage: `Staking::Bonded` (r:1 w:0) + /// Storage: `Staking::Bonded` (r:2 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:1) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:2 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListNodes` (r:2 w:2) /// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListBags` (r:2 w:2) @@ -152,13 +166,13 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) fn bond_extra_other() -> Weight { // Proof Size summary in bytes: - // Measured: `3312` - // Estimated: `8799` - // Minimum execution time: 198_864_000 picoseconds. - Weight::from_parts(203_783_000, 0) - .saturating_add(Weight::from_parts(0, 8799)) - .saturating_add(T::DbWeight::get().reads(17)) - .saturating_add(T::DbWeight::get().writes(13)) + // Measured: `3709` + // Estimated: `6248` + // Minimum execution time: 230_686_000 picoseconds. + Weight::from_parts(237_502_000, 0) + .saturating_add(Weight::from_parts(0, 6248)) + .saturating_add(T::DbWeight::get().reads(20)) + .saturating_add(T::DbWeight::get().writes(14)) } /// Storage: `NominationPools::ClaimPermissions` (r:1 w:0) /// Proof: `NominationPools::ClaimPermissions` (`max_values`: None, `max_size`: Some(41), added: 2516, mode: `MaxEncodedLen`) @@ -176,8 +190,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `1138` // Estimated: `4182` - // Minimum execution time: 70_250_000 picoseconds. - Weight::from_parts(72_231_000, 0) + // Minimum execution time: 70_821_000 picoseconds. + Weight::from_parts(72_356_000, 0) .saturating_add(Weight::from_parts(0, 4182)) .saturating_add(T::DbWeight::get().reads(6)) .saturating_add(T::DbWeight::get().writes(4)) @@ -194,7 +208,7 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) /// Storage: `NominationPools::GlobalMaxCommission` (r:1 w:0) /// Proof: `NominationPools::GlobalMaxCommission` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:2 w:1) + /// Storage: `System::Account` (r:1 w:0) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Staking::CurrentEra` (r:1 w:0) /// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -202,10 +216,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`) /// Storage: `Staking::MinNominatorBond` (r:1 w:0) /// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListNodes` (r:3 w:3) /// Proof: `VoterList::ListNodes` (`max_values`: None, `max_size`: Some(154), added: 2629, mode: `MaxEncodedLen`) /// Storage: `VoterList::ListBags` (r:2 w:2) @@ -216,13 +228,13 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn unbond() -> Weight { // Proof Size summary in bytes: - // Measured: `3545` + // Measured: `3341` // Estimated: `8877` - // Minimum execution time: 155_853_000 picoseconds. - Weight::from_parts(161_032_000, 0) + // Minimum execution time: 156_714_000 picoseconds. + Weight::from_parts(158_305_000, 0) .saturating_add(Weight::from_parts(0, 8877)) - .saturating_add(T::DbWeight::get().reads(20)) - .saturating_add(T::DbWeight::get().writes(13)) + .saturating_add(T::DbWeight::get().reads(18)) + .saturating_add(T::DbWeight::get().writes(11)) } /// Storage: `NominationPools::BondedPools` (r:1 w:0) /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) @@ -232,23 +244,25 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) /// Storage: `Staking::CurrentEra` (r:1 w:0) /// Proof: `Staking::CurrentEra` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:0) + /// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) /// Storage: `NominationPools::TotalValueLocked` (r:1 w:1) /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) /// The range of component `s` is `[0, 100]`. fn pool_withdraw_unbonded(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1744` - // Estimated: `4764` - // Minimum execution time: 62_933_000 picoseconds. - Weight::from_parts(65_847_171, 0) - .saturating_add(Weight::from_parts(0, 4764)) - // Standard Error: 1_476 - .saturating_add(Weight::from_parts(59_648, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(7)) + // Measured: `1767` + // Estimated: `4556` + // Minimum execution time: 56_836_000 picoseconds. + Weight::from_parts(59_738_398, 0) + .saturating_add(Weight::from_parts(0, 4556)) + // Standard Error: 1_478 + .saturating_add(Weight::from_parts(60_085, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(8)) .saturating_add(T::DbWeight::get().writes(3)) } /// Storage: `NominationPools::PoolMembers` (r:1 w:1) @@ -259,18 +273,24 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) /// Storage: `NominationPools::SubPoolsStorage` (r:1 w:1) /// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) /// Storage: `Staking::Bonded` (r:1 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:1) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:1 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:1 w:0) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:1 w:1) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:0) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:0) + /// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) /// Storage: `NominationPools::TotalValueLocked` (r:1 w:1) /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1) /// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::ClaimPermissions` (r:0 w:1) @@ -278,15 +298,15 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// The range of component `s` is `[0, 100]`. fn withdraw_unbonded_update(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2134` - // Estimated: `4764` - // Minimum execution time: 123_641_000 picoseconds. - Weight::from_parts(127_222_589, 0) - .saturating_add(Weight::from_parts(0, 4764)) - // Standard Error: 2_493 - .saturating_add(Weight::from_parts(83_361, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(11)) - .saturating_add(T::DbWeight::get().writes(9)) + // Measured: `2405` + // Estimated: `4556` + // Minimum execution time: 136_737_000 picoseconds. + Weight::from_parts(141_757_658, 0) + .saturating_add(Weight::from_parts(0, 4556)) + // Standard Error: 2_609 + .saturating_add(Weight::from_parts(84_538, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(14)) + .saturating_add(T::DbWeight::get().writes(11)) } /// Storage: `NominationPools::PoolMembers` (r:1 w:1) /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) @@ -296,28 +316,38 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) /// Storage: `NominationPools::SubPoolsStorage` (r:1 w:1) /// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) /// Storage: `Staking::Bonded` (r:1 w:1) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:1) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) /// Storage: `Staking::SlashingSpans` (r:1 w:0) /// Proof: `Staking::SlashingSpans` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Balances::Locks` (r:2 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:2 w:1) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) - /// Storage: `System::Account` (r:2 w:2) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:1) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1) + /// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `Staking::Validators` (r:1 w:0) /// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`) /// Storage: `Staking::Nominators` (r:1 w:0) /// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:1) + /// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) /// Storage: `NominationPools::TotalValueLocked` (r:1 w:1) /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1) /// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) - /// Storage: `NominationPools::ReversePoolIdLookup` (r:1 w:1) - /// Proof: `NominationPools::ReversePoolIdLookup` (`max_values`: None, `max_size`: Some(44), added: 2519, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForReversePoolIdLookup` (r:1 w:1) /// Proof: `NominationPools::CounterForReversePoolIdLookup` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::RewardPools` (r:1 w:1) @@ -326,6 +356,10 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::CounterForRewardPools` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForSubPoolsStorage` (r:1 w:1) /// Proof: `NominationPools::CounterForSubPoolsStorage` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:1) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:0) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) /// Storage: `NominationPools::Metadata` (r:1 w:1) /// Proof: `NominationPools::Metadata` (`max_values`: None, `max_size`: Some(270), added: 2745, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForBondedPools` (r:1 w:1) @@ -337,13 +371,13 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// The range of component `s` is `[0, 100]`. fn withdraw_unbonded_kill(_s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `2453` - // Estimated: `8538` - // Minimum execution time: 219_469_000 picoseconds. - Weight::from_parts(227_526_000, 0) - .saturating_add(Weight::from_parts(0, 8538)) - .saturating_add(T::DbWeight::get().reads(24)) - .saturating_add(T::DbWeight::get().writes(20)) + // Measured: `2809` + // Estimated: `6274` + // Minimum execution time: 241_043_000 picoseconds. + Weight::from_parts(250_578_253, 0) + .saturating_add(Weight::from_parts(0, 6274)) + .saturating_add(T::DbWeight::get().reads(29)) + .saturating_add(T::DbWeight::get().writes(26)) } /// Storage: `NominationPools::LastPoolId` (r:1 w:1) /// Proof: `NominationPools::LastPoolId` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) @@ -365,16 +399,30 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `NominationPools::MaxPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForPoolMembers` (r:1 w:1) /// Proof: `NominationPools::CounterForPoolMembers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Staking::Bonded` (r:2 w:1) + /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:2 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:2 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `System::Account` (r:2 w:2) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) - /// Storage: `Staking::Bonded` (r:1 w:1) - /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) - /// Storage: `Balances::Locks` (r:2 w:1) - /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) - /// Storage: `Balances::Freezes` (r:2 w:1) - /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:1) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1) + /// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) /// Storage: `NominationPools::TotalValueLocked` (r:1 w:1) /// Proof: `NominationPools::TotalValueLocked` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:1) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:0) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) /// Storage: `NominationPools::RewardPools` (r:1 w:1) /// Proof: `NominationPools::RewardPools` (`max_values`: None, `max_size`: Some(92), added: 2567, mode: `MaxEncodedLen`) /// Storage: `NominationPools::CounterForRewardPools` (r:1 w:1) @@ -391,22 +439,28 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) fn create() -> Weight { // Proof Size summary in bytes: - // Measured: `1102` - // Estimated: `8538` - // Minimum execution time: 166_466_000 picoseconds. - Weight::from_parts(171_425_000, 0) - .saturating_add(Weight::from_parts(0, 8538)) - .saturating_add(T::DbWeight::get().reads(23)) - .saturating_add(T::DbWeight::get().writes(17)) + // Measured: `1168` + // Estimated: `6196` + // Minimum execution time: 180_902_000 picoseconds. + Weight::from_parts(187_769_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(31)) + .saturating_add(T::DbWeight::get().writes(23)) } /// Storage: `NominationPools::BondedPools` (r:1 w:0) /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::PoolMembers` (r:1 w:0) + /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) /// Storage: `Staking::Bonded` (r:1 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:0) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) /// Storage: `Staking::MinNominatorBond` (r:1 w:0) /// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::MinCreateBond` (r:1 w:0) + /// Proof: `NominationPools::MinCreateBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::MinJoinBond` (r:1 w:0) + /// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) /// Storage: `Staking::Nominators` (r:1 w:1) /// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`) /// Storage: `Staking::MaxNominatorsCount` (r:1 w:0) @@ -426,14 +480,14 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// The range of component `n` is `[1, 16]`. fn nominate(n: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `1738` + // Measured: `1921` // Estimated: `4556 + n * (2520 ±0)` - // Minimum execution time: 59_650_000 picoseconds. - Weight::from_parts(60_620_077, 0) + // Minimum execution time: 78_369_000 picoseconds. + Weight::from_parts(79_277_958, 0) .saturating_add(Weight::from_parts(0, 4556)) - // Standard Error: 7_316 - .saturating_add(Weight::from_parts(1_467_406, 0).saturating_mul(n.into())) - .saturating_add(T::DbWeight::get().reads(12)) + // Standard Error: 8_343 + .saturating_add(Weight::from_parts(1_493_255, 0).saturating_mul(n.into())) + .saturating_add(T::DbWeight::get().reads(15)) .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(n.into()))) .saturating_add(T::DbWeight::get().writes(5)) .saturating_add(Weight::from_parts(0, 2520).saturating_mul(n.into())) @@ -446,10 +500,10 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) fn set_state() -> Weight { // Proof Size summary in bytes: - // Measured: `1363` + // Measured: `1406` // Estimated: `4556` - // Minimum execution time: 31_170_000 picoseconds. - Weight::from_parts(32_217_000, 0) + // Minimum execution time: 32_631_000 picoseconds. + Weight::from_parts(33_356_000, 0) .saturating_add(Weight::from_parts(0, 4556)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) @@ -465,11 +519,11 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `498` // Estimated: `3735` - // Minimum execution time: 12_603_000 picoseconds. - Weight::from_parts(13_241_702, 0) + // Minimum execution time: 12_514_000 picoseconds. + Weight::from_parts(13_232_732, 0) .saturating_add(Weight::from_parts(0, 3735)) - // Standard Error: 116 - .saturating_add(Weight::from_parts(1_428, 0).saturating_mul(n.into())) + // Standard Error: 150 + .saturating_add(Weight::from_parts(2_371, 0).saturating_mul(n.into())) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(2)) } @@ -489,8 +543,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `0` // Estimated: `0` - // Minimum execution time: 3_608_000 picoseconds. - Weight::from_parts(3_801_000, 0) + // Minimum execution time: 3_107_000 picoseconds. + Weight::from_parts(3_255_000, 0) .saturating_add(Weight::from_parts(0, 0)) .saturating_add(T::DbWeight::get().writes(6)) } @@ -500,18 +554,22 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `498` // Estimated: `3719` - // Minimum execution time: 16_053_000 picoseconds. - Weight::from_parts(16_473_000, 0) + // Minimum execution time: 16_568_000 picoseconds. + Weight::from_parts(17_019_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } /// Storage: `NominationPools::BondedPools` (r:1 w:0) /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::PoolMembers` (r:1 w:0) + /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) /// Storage: `Staking::Bonded` (r:1 w:0) /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) /// Storage: `Staking::Ledger` (r:1 w:0) /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) + /// Storage: `Staking::MinNominatorBond` (r:1 w:0) + /// Proof: `Staking::MinNominatorBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) /// Storage: `Staking::Validators` (r:1 w:0) /// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`) /// Storage: `Staking::Nominators` (r:1 w:1) @@ -526,12 +584,12 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `VoterList::CounterForListNodes` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) fn chill() -> Weight { // Proof Size summary in bytes: - // Measured: `1901` + // Measured: `2138` // Estimated: `4556` - // Minimum execution time: 57_251_000 picoseconds. - Weight::from_parts(59_390_000, 0) + // Minimum execution time: 73_717_000 picoseconds. + Weight::from_parts(77_030_000, 0) .saturating_add(Weight::from_parts(0, 4556)) - .saturating_add(T::DbWeight::get().reads(9)) + .saturating_add(T::DbWeight::get().reads(11)) .saturating_add(T::DbWeight::get().writes(5)) } /// Storage: `NominationPools::BondedPools` (r:1 w:1) @@ -546,8 +604,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `770` // Estimated: `3719` - // Minimum execution time: 29_888_000 picoseconds. - Weight::from_parts(31_056_000, 0) + // Minimum execution time: 30_770_000 picoseconds. + Weight::from_parts(31_556_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) @@ -560,8 +618,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `538` // Estimated: `3719` - // Minimum execution time: 15_769_000 picoseconds. - Weight::from_parts(16_579_000, 0) + // Minimum execution time: 16_257_000 picoseconds. + Weight::from_parts(16_891_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -572,8 +630,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `498` // Estimated: `3719` - // Minimum execution time: 15_385_000 picoseconds. - Weight::from_parts(16_402_000, 0) + // Minimum execution time: 16_548_000 picoseconds. + Weight::from_parts(18_252_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -584,8 +642,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `498` // Estimated: `3719` - // Minimum execution time: 14_965_000 picoseconds. - Weight::from_parts(15_548_000, 0) + // Minimum execution time: 16_085_000 picoseconds. + Weight::from_parts(17_218_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) @@ -598,8 +656,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `508` // Estimated: `4182` - // Minimum execution time: 13_549_000 picoseconds. - Weight::from_parts(14_307_000, 0) + // Minimum execution time: 13_648_000 picoseconds. + Weight::from_parts(13_990_000, 0) .saturating_add(Weight::from_parts(0, 4182)) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(1)) @@ -616,8 +674,8 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo // Proof Size summary in bytes: // Measured: `968` // Estimated: `3719` - // Minimum execution time: 60_153_000 picoseconds. - Weight::from_parts(61_369_000, 0) + // Minimum execution time: 60_321_000 picoseconds. + Weight::from_parts(61_512_000, 0) .saturating_add(Weight::from_parts(0, 3719)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) @@ -632,12 +690,135 @@ impl pallet_nomination_pools::WeightInfo for WeightInfo /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) fn adjust_pool_deposit() -> Weight { // Proof Size summary in bytes: - // Measured: `867` + // Measured: `876` // Estimated: `4764` - // Minimum execution time: 64_985_000 picoseconds. - Weight::from_parts(66_616_000, 0) + // Minimum execution time: 65_609_000 picoseconds. + Weight::from_parts(67_320_000, 0) .saturating_add(Weight::from_parts(0, 4764)) .saturating_add(T::DbWeight::get().reads(4)) .saturating_add(T::DbWeight::get().writes(2)) } + /// Storage: `NominationPools::PoolMembers` (r:1 w:0) + /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::BondedPools` (r:1 w:0) + /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) + /// Storage: `Staking::Bonded` (r:1 w:0) + /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `Staking::Ledger` (r:1 w:0) + /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0) + /// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + fn apply_slash() -> Weight { + // Proof Size summary in bytes: + // Measured: `3328` + // Estimated: `4556` + // Minimum execution time: 99_605_000 picoseconds. + Weight::from_parts(101_986_000, 0) + .saturating_add(Weight::from_parts(0, 4556)) + .saturating_add(T::DbWeight::get().reads(9)) + .saturating_add(T::DbWeight::get().writes(4)) + } + /// Storage: `NominationPools::PoolMembers` (r:1 w:0) + /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:0) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:1 w:0) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::BondedPools` (r:1 w:0) + /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) + /// Storage: `Staking::Bonded` (r:1 w:0) + /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `Staking::Ledger` (r:1 w:0) + /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0) + /// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`) + fn apply_slash_fail() -> Weight { + // Proof Size summary in bytes: + // Measured: `3070` + // Estimated: `4556` + // Minimum execution time: 58_103_000 picoseconds. + Weight::from_parts(59_680_000, 0) + .saturating_add(Weight::from_parts(0, 4556)) + .saturating_add(T::DbWeight::get().reads(7)) + } + /// Storage: `Staking::Bonded` (r:1 w:0) + /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `Staking::Validators` (r:1 w:0) + /// Proof: `Staking::Validators` (`max_values`: None, `max_size`: Some(45), added: 2520, mode: `MaxEncodedLen`) + /// Storage: `Staking::Nominators` (r:1 w:0) + /// Proof: `Staking::Nominators` (`max_values`: None, `max_size`: Some(558), added: 3033, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:1 w:1) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:2 w:1) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForAgents` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForAgents` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Staking::Ledger` (r:1 w:0) + /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) + /// Storage: `Balances::Locks` (r:1 w:1) + /// Proof: `Balances::Locks` (`max_values`: None, `max_size`: Some(1299), added: 3774, mode: `MaxEncodedLen`) + /// Storage: `Balances::Freezes` (r:1 w:0) + /// Proof: `Balances::Freezes` (`max_values`: None, `max_size`: Some(67), added: 2542, mode: `MaxEncodedLen`) + /// Storage: `Staking::VirtualStakers` (r:1 w:1) + /// Proof: `Staking::VirtualStakers` (`max_values`: None, `max_size`: Some(40), added: 2515, mode: `MaxEncodedLen`) + /// Storage: `Staking::CounterForVirtualStakers` (r:1 w:1) + /// Proof: `Staking::CounterForVirtualStakers` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:1 w:1) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `Staking::Payee` (r:0 w:1) + /// Proof: `Staking::Payee` (`max_values`: None, `max_size`: Some(73), added: 2548, mode: `MaxEncodedLen`) + fn pool_migrate() -> Weight { + // Proof Size summary in bytes: + // Measured: `1359` + // Estimated: `6196` + // Minimum execution time: 144_098_000 picoseconds. + Weight::from_parts(146_590_000, 0) + .saturating_add(Weight::from_parts(0, 6196)) + .saturating_add(T::DbWeight::get().reads(16)) + .saturating_add(T::DbWeight::get().writes(11)) + } + /// Storage: `NominationPools::PoolMembers` (r:1 w:0) + /// Proof: `NominationPools::PoolMembers` (`max_values`: None, `max_size`: Some(717), added: 3192, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::BondedPools` (r:1 w:0) + /// Proof: `NominationPools::BondedPools` (`max_values`: None, `max_size`: Some(254), added: 2729, mode: `MaxEncodedLen`) + /// Storage: `Staking::Bonded` (r:2 w:0) + /// Proof: `Staking::Bonded` (`max_values`: None, `max_size`: Some(72), added: 2547, mode: `MaxEncodedLen`) + /// Storage: `Staking::Ledger` (r:1 w:0) + /// Proof: `Staking::Ledger` (`max_values`: None, `max_size`: Some(1091), added: 3566, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::SubPoolsStorage` (r:1 w:0) + /// Proof: `NominationPools::SubPoolsStorage` (`max_values`: None, `max_size`: Some(261), added: 2736, mode: `MaxEncodedLen`) + /// Storage: `NominationPools::MinJoinBond` (r:1 w:0) + /// Proof: `NominationPools::MinJoinBond` (`max_values`: Some(1), `max_size`: Some(16), added: 511, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Delegators` (r:2 w:2) + /// Proof: `DelegatedStaking::Delegators` (`max_values`: None, `max_size`: Some(88), added: 2563, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::Agents` (r:2 w:0) + /// Proof: `DelegatedStaking::Agents` (`max_values`: None, `max_size`: Some(120), added: 2595, mode: `MaxEncodedLen`) + /// Storage: `Balances::Holds` (r:2 w:2) + /// Proof: `Balances::Holds` (`max_values`: None, `max_size`: Some(85), added: 2560, mode: `MaxEncodedLen`) + /// Storage: `DelegatedStaking::CounterForDelegators` (r:1 w:1) + /// Proof: `DelegatedStaking::CounterForDelegators` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + fn migrate_delegation() -> Weight { + // Proof Size summary in bytes: + // Measured: `2275` + // Estimated: `6180` + // Minimum execution time: 148_594_000 picoseconds. + Weight::from_parts(152_119_000, 0) + .saturating_add(Weight::from_parts(0, 6180)) + .saturating_add(T::DbWeight::get().reads(15)) + .saturating_add(T::DbWeight::get().writes(6)) + } } diff --git a/polkadot/runtime/westend/src/weights/pallet_parameters.rs b/polkadot/runtime/westend/src/weights/pallet_parameters.rs new file mode 100644 index 0000000000000000000000000000000000000000..2e131ce55f31961a5279f0be4c91eb7f92b9deec --- /dev/null +++ b/polkadot/runtime/westend/src/weights/pallet_parameters.rs @@ -0,0 +1,63 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `pallet_parameters` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-04-05, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-anb7yjbi-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=pallet_parameters +// --chain=westend +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/westend/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `pallet_parameters`. +pub struct WeightInfo(PhantomData); +impl pallet_parameters::WeightInfo for WeightInfo { + /// Storage: `Parameters::Parameters` (r:1 w:1) + /// Proof: `Parameters::Parameters` (`max_values`: None, `max_size`: Some(28), added: 2503, mode: `MaxEncodedLen`) + fn set_parameter() -> Weight { + // Proof Size summary in bytes: + // Measured: `4` + // Estimated: `3493` + // Minimum execution time: 6_937_000 picoseconds. + Weight::from_parts(7_242_000, 0) + .saturating_add(Weight::from_parts(0, 3493)) + .saturating_add(T::DbWeight::get().reads(1)) + .saturating_add(T::DbWeight::get().writes(1)) + } +} diff --git a/polkadot/runtime/westend/src/weights/pallet_treasury.rs b/polkadot/runtime/westend/src/weights/pallet_treasury.rs index 144e9d5b872382b7381e2d77c6fb08a8fbece4fa..06246ada72f16fb04623f3fc6534265cc1156b79 100644 --- a/polkadot/runtime/westend/src/weights/pallet_treasury.rs +++ b/polkadot/runtime/westend/src/weights/pallet_treasury.rs @@ -63,51 +63,6 @@ impl pallet_treasury::WeightInfo for WeightInfo { .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(3)) } - /// Storage: Treasury ProposalCount (r:1 w:1) - /// Proof: Treasury ProposalCount (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen) - /// Storage: Treasury Proposals (r:0 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - fn propose_spend() -> Weight { - // Proof Size summary in bytes: - // Measured: `143` - // Estimated: `1489` - // Minimum execution time: 354_000_000 picoseconds. - Weight::from_parts(376_000_000, 0) - .saturating_add(Weight::from_parts(0, 1489)) - .saturating_add(T::DbWeight::get().reads(1)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: Treasury Proposals (r:1 w:1) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: System Account (r:1 w:1) - /// Proof: System Account (max_values: None, max_size: Some(128), added: 2603, mode: MaxEncodedLen) - fn reject_proposal() -> Weight { - // Proof Size summary in bytes: - // Measured: `301` - // Estimated: `3593` - // Minimum execution time: 547_000_000 picoseconds. - Weight::from_parts(550_000_000, 0) - .saturating_add(Weight::from_parts(0, 3593)) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(2)) - } - /// Storage: Treasury Proposals (r:1 w:0) - /// Proof: Treasury Proposals (max_values: None, max_size: Some(108), added: 2583, mode: MaxEncodedLen) - /// Storage: Treasury Approvals (r:1 w:1) - /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) - /// The range of component `p` is `[0, 99]`. - fn approve_proposal(p: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `470 + p * (8 ±0)` - // Estimated: `3573` - // Minimum execution time: 104_000_000 picoseconds. - Weight::from_parts(121_184_402, 0) - .saturating_add(Weight::from_parts(0, 3573)) - // Standard Error: 42_854 - .saturating_add(Weight::from_parts(153_112, 0).saturating_mul(p.into())) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(1)) - } /// Storage: Treasury Approvals (r:1 w:1) /// Proof: Treasury Approvals (max_values: Some(1), max_size: Some(402), added: 897, mode: MaxEncodedLen) fn remove_approval() -> Weight { diff --git a/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_assigned_slots.rs similarity index 98% rename from polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_assigned_slots.rs index c3f1060a9ac0bce7f9bcaa36739f1d7199a8d737..08b0b0f34df13d2c92f9b9bde8bb11f6ba68a22b 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_assigned_slots.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_assigned_slots.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::assigned_slots`. pub struct WeightInfo(PhantomData); -impl runtime_common::assigned_slots::WeightInfo for WeightInfo { +impl polkadot_runtime_common::assigned_slots::WeightInfo for WeightInfo { /// Storage: `Registrar::Paras` (r:1 w:1) /// Proof: `Registrar::Paras` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Paras::ParaLifecycles` (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_auctions.rs similarity index 98% rename from polkadot/runtime/westend/src/weights/runtime_common_auctions.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_auctions.rs index a6f5bbe5a1da3054a0ab17c2a8c2db94471d17c9..58ca2a083b2cbf58669f46281f1ffee8d38dc0f4 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_auctions.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_auctions.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::auctions`. pub struct WeightInfo(PhantomData); -impl runtime_common::auctions::WeightInfo for WeightInfo { +impl polkadot_runtime_common::auctions::WeightInfo for WeightInfo { /// Storage: Auctions AuctionInfo (r:1 w:1) /// Proof: Auctions AuctionInfo (max_values: Some(1), max_size: Some(8), added: 503, mode: MaxEncodedLen) /// Storage: Auctions AuctionCounter (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_crowdloan.rs similarity index 99% rename from polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_crowdloan.rs index 97b0279544c761d2c344f189e16e7d7484242d57..47472406de1e5679872d07f45817ccc31a5d2476 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_crowdloan.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_crowdloan.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::crowdloan`. pub struct WeightInfo(PhantomData); -impl runtime_common::crowdloan::WeightInfo for WeightInfo { +impl polkadot_runtime_common::crowdloan::WeightInfo for WeightInfo { /// Storage: Crowdloan Funds (r:1 w:1) /// Proof Skipped: Crowdloan Funds (max_values: None, max_size: None, mode: Measured) /// Storage: Registrar Paras (r:1 w:1) diff --git a/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_identity_migrator.rs similarity index 97% rename from polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_identity_migrator.rs index cec357453b67be400c0191ac7d5c12e6961a4bee..4ea6f67968017e312562842c5f2400754ac83b95 100644 --- a/polkadot/runtime/rococo/src/weights/runtime_common_identity_migrator.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_identity_migrator.rs @@ -42,7 +42,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::identity_migrator`. pub struct WeightInfo(PhantomData); -impl runtime_common::identity_migrator::WeightInfo for WeightInfo { +impl polkadot_runtime_common::identity_migrator::WeightInfo for WeightInfo { /// Storage: `Identity::IdentityOf` (r:1 w:1) /// Proof: `Identity::IdentityOf` (`max_values`: None, `max_size`: Some(7538), added: 10013, mode: `MaxEncodedLen`) /// Storage: `Identity::SubsOf` (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_paras_registrar.rs similarity index 99% rename from polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_paras_registrar.rs index 50290c0fe59f64031258b2fe2d1ff16124d60701..befd89874411a4e004ebdcf07aa4cfb32c3fb243 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_paras_registrar.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_paras_registrar.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::paras_registrar`. pub struct WeightInfo(PhantomData); -impl runtime_common::paras_registrar::WeightInfo for WeightInfo { +impl polkadot_runtime_common::paras_registrar::WeightInfo for WeightInfo { /// Storage: Registrar NextFreeParaId (r:1 w:1) /// Proof Skipped: Registrar NextFreeParaId (max_values: Some(1), max_size: None, mode: Measured) /// Storage: Registrar Paras (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_common_slots.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_slots.rs similarity index 98% rename from polkadot/runtime/westend/src/weights/runtime_common_slots.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_common_slots.rs index c95859221fa726dd79f15d34bb3ed0c4083f37ec..b1422e506ab1d24770a14eef622d1c713d476f5f 100644 --- a/polkadot/runtime/westend/src/weights/runtime_common_slots.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_common_slots.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_common::slots`. pub struct WeightInfo(PhantomData); -impl runtime_common::slots::WeightInfo for WeightInfo { +impl polkadot_runtime_common::slots::WeightInfo for WeightInfo { /// Storage: Slots Leases (r:1 w:1) /// Proof Skipped: Slots Leases (max_values: None, max_size: None, mode: Measured) /// Storage: System Account (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_configuration.rs similarity index 98% rename from polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_configuration.rs index 8fa3207c6446082a97877f488913d9c063114fca..5130b04668b2072f658b247e0697facea6e801ba 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_configuration.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_configuration.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::configuration`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::configuration::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::configuration::WeightInfo for WeightInfo { /// Storage: `Configuration::PendingConfigs` (r:1 w:1) /// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0) diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_coretime.rs similarity index 64% rename from polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_coretime.rs index aa65a2e9034a7c9f10a3d596db9cf8d167f561ac..9df382875f5f12ddee62751eeca5feb16dfece41 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_coretime.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_coretime.rs @@ -17,9 +17,9 @@ //! Autogenerated weights for `runtime_parachains::coretime` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-02-15, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-06-01, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-1pho9goo-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -47,7 +47,29 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::coretime`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::coretime::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::coretime::WeightInfo for WeightInfo { + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0) + /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `XcmPallet::SupportedVersion` (r:1 w:0) + /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) + fn request_revenue_at() -> Weight { + // Proof Size summary in bytes: + // Measured: `2930` + // Estimated: `6395` + // Minimum execution time: 34_947_000 picoseconds. + Weight::from_parts(35_550_000, 0) + .saturating_add(Weight::from_parts(0, 6395)) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(3)) + } /// Storage: `Configuration::PendingConfigs` (r:1 w:1) /// Proof: `Configuration::PendingConfigs` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Configuration::BypassConsistencyCheck` (r:1 w:0) @@ -58,8 +80,8 @@ impl runtime_parachains::coretime::WeightInfo for Weigh // Proof Size summary in bytes: // Measured: `151` // Estimated: `1636` - // Minimum execution time: 7_486_000 picoseconds. - Weight::from_parts(7_889_000, 0) + // Minimum execution time: 7_519_000 picoseconds. + Weight::from_parts(7_803_000, 0) .saturating_add(Weight::from_parts(0, 1636)) .saturating_add(T::DbWeight::get().reads(3)) .saturating_add(T::DbWeight::get().writes(1)) @@ -73,11 +95,11 @@ impl runtime_parachains::coretime::WeightInfo for Weigh // Proof Size summary in bytes: // Measured: `147` // Estimated: `3612` - // Minimum execution time: 9_409_000 picoseconds. - Weight::from_parts(10_177_115, 0) + // Minimum execution time: 9_697_000 picoseconds. + Weight::from_parts(10_610_219, 0) .saturating_add(Weight::from_parts(0, 3612)) - // Standard Error: 259 - .saturating_add(Weight::from_parts(13_932, 0).saturating_mul(s.into())) + // Standard Error: 732 + .saturating_add(Weight::from_parts(10_364, 0).saturating_mul(s.into())) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(2)) } diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes.rs similarity index 95% rename from polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes.rs index 4a6a6079cf131a8d39ef3a812d2309b955762764..5beb82ec5944fc633eee924fd7f6fc887cef25ca 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::disputes`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::disputes::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::disputes::WeightInfo for WeightInfo { /// Storage: ParasDisputes Frozen (r:0 w:1) /// Proof Skipped: ParasDisputes Frozen (max_values: Some(1), max_size: None, mode: Measured) fn force_unfreeze() -> Weight { diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes_slashing.rs similarity index 97% rename from polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes_slashing.rs index 8600717fee1e222f587c19cc7cf44f36d2bde6d2..a035ea2b0b5e2e226a1a2a36f0a11e570c56839f 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_disputes_slashing.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_disputes_slashing.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::disputes::slashing`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::disputes::slashing::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::disputes::slashing::WeightInfo for WeightInfo { /// Storage: Session CurrentIndex (r:1 w:0) /// Proof Skipped: Session CurrentIndex (max_values: Some(1), max_size: None, mode: Measured) /// Storage: Historical HistoricalSessions (r:1 w:0) diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_hrmp.rs similarity index 99% rename from polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_hrmp.rs index f1d7932fe8b7c09d069144f624c0f29bce7c4e5b..8946261664befb8afc96c2ff3d21ed3d8d5d325a 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_hrmp.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_hrmp.rs @@ -47,7 +47,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::hrmp`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::hrmp::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::hrmp::WeightInfo for WeightInfo { /// Storage: `Paras::ParaLifecycles` (r:1 w:0) /// Proof: `Paras::ParaLifecycles` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Hrmp::HrmpOpenChannelRequests` (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_inclusion.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_inclusion.rs new file mode 100644 index 0000000000000000000000000000000000000000..36a4c5c24c9a18787e7a9d68393ef6c3fcbff2cb --- /dev/null +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_inclusion.rs @@ -0,0 +1,131 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Autogenerated weights for `polkadot_runtime_parachains::inclusion` +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-07, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! WORST CASE MAP SIZE: `1000000` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 + +// Executed Command: +// target/production/polkadot +// benchmark +// pallet +// --steps=50 +// --repeat=20 +// --extrinsic=* +// --wasm-execution=compiled +// --heap-pages=4096 +// --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json +// --pallet=polkadot_runtime_parachains::inclusion +// --chain=westend-dev +// --header=./polkadot/file_header.txt +// --output=./polkadot/runtime/westend/src/weights/ + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(missing_docs)] + +use frame_support::{traits::Get, weights::Weight}; +use core::marker::PhantomData; + +/// Weight functions for `polkadot_runtime_parachains::inclusion`. +pub struct WeightInfo(PhantomData); +impl polkadot_runtime_parachains::inclusion::WeightInfo for WeightInfo { + /// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0) + /// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaSessionInfo::AccountKeys` (r:1 w:0) + /// Proof: `ParaSessionInfo::AccountKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Session::Validators` (r:1 w:0) + /// Proof: `Session::Validators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Staking::ActiveEra` (r:1 w:0) + /// Proof: `Staking::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) + /// Storage: `Staking::ErasRewardPoints` (r:1 w:1) + /// Proof: `Staking::ErasRewardPoints` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::FutureCodeHash` (r:1 w:1) + /// Proof: `Paras::FutureCodeHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CurrentCodeHash` (r:1 w:0) + /// Proof: `Paras::CurrentCodeHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeCooldowns` (r:1 w:1) + /// Proof: `Paras::UpgradeCooldowns` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::PvfActiveVoteMap` (r:1 w:1) + /// Proof: `Paras::PvfActiveVoteMap` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CodeByHash` (r:1 w:1) + /// Proof: `Paras::CodeByHash` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorKeys` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorKeys` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::PvfActiveVoteList` (r:1 w:1) + /// Proof: `Paras::PvfActiveVoteList` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Paras::CodeByHashRefs` (r:1 w:1) + /// Proof: `Paras::CodeByHashRefs` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) + /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:1) + /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `MessageQueue::BookStateFor` (r:1 w:1) + /// Proof: `MessageQueue::BookStateFor` (`max_values`: None, `max_size`: Some(55), added: 2530, mode: `MaxEncodedLen`) + /// Storage: `MessageQueue::Pages` (r:1 w:32) + /// Proof: `MessageQueue::Pages` (`max_values`: None, `max_size`: Some(131122), added: 133597, mode: `MaxEncodedLen`) + /// Storage: `Hrmp::HrmpChannelDigests` (r:33 w:33) + /// Proof: `Hrmp::HrmpChannelDigests` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Hrmp::HrmpChannels` (r:32 w:32) + /// Proof: `Hrmp::HrmpChannels` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Hrmp::HrmpChannelContents` (r:32 w:32) + /// Proof: `Hrmp::HrmpChannelContents` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::FutureCodeUpgrades` (r:1 w:0) + /// Proof: `Paras::FutureCodeUpgrades` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: UNKNOWN KEY `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) + /// Proof: UNKNOWN KEY `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) + /// Storage: `Hrmp::HrmpWatermarks` (r:0 w:1) + /// Proof: `Hrmp::HrmpWatermarks` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::Heads` (r:0 w:1) + /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeGoAheadSignal` (r:0 w:1) + /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::MostRecentContext` (r:0 w:1) + /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `Paras::UpgradeRestrictionSignal` (r:0 w:1) + /// Proof: `Paras::UpgradeRestrictionSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: UNKNOWN KEY `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) + /// Proof: UNKNOWN KEY `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) + /// The range of component `u` is `[1, 32]`. + /// The range of component `h` is `[1, 32]`. + /// The range of component `c` is `[0, 1]`. + fn enact_candidate(u: u32, h: u32, c: u32, ) -> Weight { + // Proof Size summary in bytes: + // Measured: `132737 + c * (15992 ±0) + h * (75 ±0)` + // Estimated: `136202 + c * (76098 ±0) + h * (2551 ±0)` + // Minimum execution time: 18_868_930_000 picoseconds. + Weight::from_parts(6_899_601_016, 0) + .saturating_add(Weight::from_parts(0, 136202)) + // Standard Error: 1_952_665 + .saturating_add(Weight::from_parts(467_810_135, 0).saturating_mul(u.into())) + // Standard Error: 1_952_665 + .saturating_add(Weight::from_parts(551_226_340, 0).saturating_mul(h.into())) + .saturating_add(T::DbWeight::get().reads(11)) + .saturating_add(T::DbWeight::get().reads((3_u64).saturating_mul(h.into()))) + .saturating_add(T::DbWeight::get().reads((8_u64).saturating_mul(c.into()))) + .saturating_add(T::DbWeight::get().writes(11)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(u.into()))) + .saturating_add(T::DbWeight::get().writes((3_u64).saturating_mul(h.into()))) + .saturating_add(T::DbWeight::get().writes((7_u64).saturating_mul(c.into()))) + .saturating_add(Weight::from_parts(0, 76098).saturating_mul(c.into())) + .saturating_add(Weight::from_parts(0, 2551).saturating_mul(h.into())) + } +} diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_initializer.rs similarity index 96% rename from polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_initializer.rs index 81aca5c958d90d96c90dba0f30d8555e4332db59..8e501de6e67f3ed01e93c8dca3999d1c5cf0d83c 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_initializer.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_initializer.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::initializer`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::initializer::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::initializer::WeightInfo for WeightInfo { /// Storage: System Digest (r:1 w:1) /// Proof Skipped: System Digest (max_values: Some(1), max_size: None, mode: Measured) /// The range of component `d` is `[0, 65536]`. diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_on_demand.rs similarity index 63% rename from polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_on_demand.rs index acd1834f79ed8c35ed83bd56d75c0907b02f7f5d..fc7efa6edfcf361f51892ef809721d3c34e915dd 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_assigner_on_demand.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_on_demand.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! Autogenerated weights for `runtime_parachains::assigner_on_demand` +//! Autogenerated weights for `runtime_parachains::on_demand` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-05-31, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-1pho9goo-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -32,7 +32,7 @@ // --wasm-execution=compiled // --heap-pages=4096 // --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=runtime_parachains::assigner_on_demand +// --pallet=runtime_parachains::on_demand // --chain=westend-dev // --header=./polkadot/file_header.txt // --output=./polkadot/runtime/westend/src/weights/ @@ -45,11 +45,15 @@ use frame_support::{traits::Get, weights::Weight}; use core::marker::PhantomData; -/// Weight functions for `runtime_parachains::assigner_on_demand`. +/// Weight functions for `runtime_parachains::on_demand`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::assigner_on_demand::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::on_demand::WeightInfo for WeightInfo { /// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1) /// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0) /// Proof: `OnDemandAssignmentProvider::ParaIdAffinity` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::FreeEntries` (r:1 w:1) @@ -57,19 +61,23 @@ impl runtime_parachains::assigner_on_demand::WeightInfo /// The range of component `s` is `[1, 9999]`. fn place_order_keep_alive(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `218 + s * (8 ±0)` - // Estimated: `3681 + s * (8 ±0)` - // Minimum execution time: 21_396_000 picoseconds. - Weight::from_parts(20_585_695, 0) - .saturating_add(Weight::from_parts(0, 3681)) - // Standard Error: 127 - .saturating_add(Weight::from_parts(20_951, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `270 + s * (8 ±0)` + // Estimated: `3733 + s * (8 ±0)` + // Minimum execution time: 29_427_000 picoseconds. + Weight::from_parts(26_756_913, 0) + .saturating_add(Weight::from_parts(0, 3733)) + // Standard Error: 121 + .saturating_add(Weight::from_parts(20_849, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(s.into())) } /// Storage: `OnDemandAssignmentProvider::QueueStatus` (r:1 w:1) /// Proof: `OnDemandAssignmentProvider::QueueStatus` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:0) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) + /// Storage: `OnDemandAssignmentProvider::Revenue` (r:1 w:1) + /// Proof: `OnDemandAssignmentProvider::Revenue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::ParaIdAffinity` (r:1 w:0) /// Proof: `OnDemandAssignmentProvider::ParaIdAffinity` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `OnDemandAssignmentProvider::FreeEntries` (r:1 w:1) @@ -77,15 +85,15 @@ impl runtime_parachains::assigner_on_demand::WeightInfo /// The range of component `s` is `[1, 9999]`. fn place_order_allow_death(s: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `218 + s * (8 ±0)` - // Estimated: `3681 + s * (8 ±0)` - // Minimum execution time: 21_412_000 picoseconds. - Weight::from_parts(19_731_554, 0) - .saturating_add(Weight::from_parts(0, 3681)) - // Standard Error: 128 - .saturating_add(Weight::from_parts(21_055, 0).saturating_mul(s.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `270 + s * (8 ±0)` + // Estimated: `3733 + s * (8 ±0)` + // Minimum execution time: 29_329_000 picoseconds. + Weight::from_parts(26_415_340, 0) + .saturating_add(Weight::from_parts(0, 3733)) + // Standard Error: 129 + .saturating_add(Weight::from_parts(20_909, 0).saturating_mul(s.into())) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) .saturating_add(Weight::from_parts(0, 8).saturating_mul(s.into())) } } diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras.rs similarity index 99% rename from polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras.rs index 07623f60b01235e78549744f03a7e40784bd9e29..d96964e69c11404cc8f3181115c64d46afa3aea6 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_paras.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras.rs @@ -49,7 +49,7 @@ use core::marker::PhantomData; /// Weight functions for `runtime_parachains::paras`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::paras::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::paras::WeightInfo for WeightInfo { /// Storage: Paras CurrentCodeHash (r:1 w:1) /// Proof Skipped: Paras CurrentCodeHash (max_values: None, max_size: None, mode: Measured) /// Storage: Paras CodeByHashRefs (r:1 w:1) diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras_inherent.rs similarity index 82% rename from polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs rename to polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras_inherent.rs index aa99ac9438c404aad48715370badd821207f669c..32f6f28f242621f1cf496046fbdf94f3ba7b819c 100644 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_paras_inherent.rs +++ b/polkadot/runtime/westend/src/weights/polkadot_runtime_parachains_paras_inherent.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! Autogenerated weights for `runtime_parachains::paras_inherent` +//! Autogenerated weights for `polkadot_runtime_parachains::paras_inherent` //! //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 -//! DATE: 2024-03-18, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! DATE: 2024-08-23, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-h2rr8wx7-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-svzsllib-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: `Compiled`, CHAIN: `Some("westend-dev")`, DB CACHE: 1024 // Executed Command: @@ -32,7 +32,7 @@ // --wasm-execution=compiled // --heap-pages=4096 // --json-file=/builds/parity/mirrors/polkadot-sdk/.git/.artifacts/bench.json -// --pallet=runtime_parachains::paras_inherent +// --pallet=polkadot_runtime_parachains::paras_inherent // --chain=westend-dev // --header=./polkadot/file_header.txt // --output=./polkadot/runtime/westend/src/weights/ @@ -45,9 +45,49 @@ use frame_support::{traits::Get, weights::Weight}; use core::marker::PhantomData; -/// Weight functions for `runtime_parachains::paras_inherent`. +/// Weight functions for `polkadot_runtime_parachains::paras_inherent`. pub struct WeightInfo(PhantomData); -impl runtime_parachains::paras_inherent::WeightInfo for WeightInfo { +impl polkadot_runtime_parachains::paras_inherent::WeightInfo for WeightInfo { + /// Storage: `ParaInherent::Included` (r:1 w:1) + /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `System::ParentHash` (r:1 w:0) + /// Proof: `System::ParentHash` (`max_values`: Some(1), `max_size`: Some(32), added: 527, mode: `MaxEncodedLen`) + /// Storage: `ParasShared::AllowedRelayParents` (r:1 w:1) + /// Proof: `ParasShared::AllowedRelayParents` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::CurrentSessionIndex` (r:1 w:0) + /// Proof: `ParasShared::CurrentSessionIndex` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::AvailabilityCores` (r:1 w:1) + /// Proof: `ParaScheduler::AvailabilityCores` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorKeys` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorKeys` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Babe::AuthorVrfRandomness` (r:1 w:0) + /// Proof: `Babe::AuthorVrfRandomness` (`max_values`: Some(1), `max_size`: Some(33), added: 528, mode: `MaxEncodedLen`) + /// Storage: `ParaInherent::OnChainVotes` (r:1 w:1) + /// Proof: `ParaInherent::OnChainVotes` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasDisputes::Frozen` (r:1 w:0) + /// Proof: `ParasDisputes::Frozen` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaInclusion::V1` (r:1 w:0) + /// Proof: `ParaInclusion::V1` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::SessionStartBlock` (r:1 w:0) + /// Proof: `ParaScheduler::SessionStartBlock` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::ValidatorGroups` (r:1 w:0) + /// Proof: `ParaScheduler::ValidatorGroups` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParaScheduler::ClaimQueue` (r:1 w:1) + /// Proof: `ParaScheduler::ClaimQueue` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `ParasShared::ActiveValidatorIndices` (r:1 w:0) + /// Proof: `ParasShared::ActiveValidatorIndices` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + /// Storage: `Session::DisabledValidators` (r:1 w:0) + /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) + fn enter_empty() -> Weight { + // Proof Size summary in bytes: + // Measured: `37553` + // Estimated: `41018` + // Minimum execution time: 237_414_000 picoseconds. + Weight::from_parts(245_039_000, 0) + .saturating_add(Weight::from_parts(0, 41018)) + .saturating_add(T::DbWeight::get().reads(15)) + .saturating_add(T::DbWeight::get().writes(5)) + } /// Storage: `ParaInherent::Included` (r:1 w:1) /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `System::ParentHash` (r:1 w:0) @@ -112,19 +152,19 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Paras::MostRecentContext` (r:0 w:1) /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `v` is `[10, 200]`. + /// The range of component `v` is `[10, 1024]`. fn enter_variable_disputes(v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `67518` - // Estimated: `73458 + v * (23 ±0)` - // Minimum execution time: 844_022_000 picoseconds. - Weight::from_parts(456_682_337, 0) - .saturating_add(Weight::from_parts(0, 73458)) - // Standard Error: 16_403 - .saturating_add(Weight::from_parts(41_871_245, 0).saturating_mul(v.into())) + // Measured: `199504` + // Estimated: `205444 + v * (5 ±0)` + // Minimum execution time: 1_157_489_000 picoseconds. + Weight::from_parts(629_243_559, 0) + .saturating_add(Weight::from_parts(0, 205444)) + // Standard Error: 10_997 + .saturating_add(Weight::from_parts(50_752_930, 0).saturating_mul(v.into())) .saturating_add(T::DbWeight::get().reads(28)) .saturating_add(T::DbWeight::get().writes(16)) - .saturating_add(Weight::from_parts(0, 23).saturating_mul(v.into())) + .saturating_add(Weight::from_parts(0, 5).saturating_mul(v.into())) } /// Storage: `ParaInherent::Included` (r:1 w:1) /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) @@ -146,24 +186,6 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `ParasDisputes::Frozen` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParaInclusion::V1` (r:2 w:1) /// Proof: `ParaInclusion::V1` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `ParaSessionInfo::AccountKeys` (r:1 w:0) - /// Proof: `ParaSessionInfo::AccountKeys` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Session::Validators` (r:1 w:0) - /// Proof: `Session::Validators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - /// Storage: `Staking::ActiveEra` (r:1 w:0) - /// Proof: `Staking::ActiveEra` (`max_values`: Some(1), `max_size`: Some(13), added: 508, mode: `MaxEncodedLen`) - /// Storage: `Staking::ErasRewardPoints` (r:1 w:1) - /// Proof: `Staking::ErasRewardPoints` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) - /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:1) - /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Hrmp::HrmpChannelDigests` (r:1 w:1) - /// Proof: `Hrmp::HrmpChannelDigests` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::FutureCodeUpgrades` (r:1 w:0) - /// Proof: `Paras::FutureCodeUpgrades` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `ParasDisputes::Disputes` (r:1 w:0) - /// Proof: `ParasDisputes::Disputes` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `ParaScheduler::SessionStartBlock` (r:1 w:0) /// Proof: `ParaScheduler::SessionStartBlock` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `ParaScheduler::ValidatorGroups` (r:1 w:0) @@ -176,25 +198,15 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `ParasShared::ActiveValidatorIndices` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) /// Storage: `Session::DisabledValidators` (r:1 w:0) /// Proof: `Session::DisabledValidators` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) - /// Storage: `ParasDisputes::Included` (r:0 w:1) - /// Proof: `ParasDisputes::Included` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Hrmp::HrmpWatermarks` (r:0 w:1) - /// Proof: `Hrmp::HrmpWatermarks` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::Heads` (r:0 w:1) - /// Proof: `Paras::Heads` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::UpgradeGoAheadSignal` (r:0 w:1) - /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// Storage: `Paras::MostRecentContext` (r:0 w:1) - /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) fn enter_bitfields() -> Weight { // Proof Size summary in bytes: - // Measured: `43196` - // Estimated: `49136` - // Minimum execution time: 438_637_000 picoseconds. - Weight::from_parts(458_342_000, 0) - .saturating_add(Weight::from_parts(0, 49136)) - .saturating_add(T::DbWeight::get().reads(26)) - .saturating_add(T::DbWeight::get().writes(16)) + // Measured: `75131` + // Estimated: `81071` + // Minimum execution time: 466_928_000 picoseconds. + Weight::from_parts(494_342_000, 0) + .saturating_add(Weight::from_parts(0, 81071)) + .saturating_add(T::DbWeight::get().reads(17)) + .saturating_add(T::DbWeight::get().writes(7)) } /// Storage: `ParaInherent::Included` (r:1 w:1) /// Proof: `ParaInherent::Included` (`max_values`: Some(1), `max_size`: None, mode: `Measured`) @@ -262,16 +274,16 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `Paras::UpgradeGoAheadSignal` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Paras::MostRecentContext` (r:0 w:1) /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) - /// The range of component `v` is `[101, 200]`. + /// The range of component `v` is `[2, 5]`. fn enter_backed_candidates_variable(v: u32, ) -> Weight { // Proof Size summary in bytes: - // Measured: `43269` - // Estimated: `49209` - // Minimum execution time: 5_955_361_000 picoseconds. - Weight::from_parts(1_285_398_956, 0) - .saturating_add(Weight::from_parts(0, 49209)) - // Standard Error: 57_369 - .saturating_add(Weight::from_parts(47_073_853, 0).saturating_mul(v.into())) + // Measured: `76369` + // Estimated: `82309` + // Minimum execution time: 1_468_919_000 picoseconds. + Weight::from_parts(1_433_315_477, 0) + .saturating_add(Weight::from_parts(0, 82309)) + // Standard Error: 419_886 + .saturating_add(Weight::from_parts(42_880_485, 0).saturating_mul(v.into())) .saturating_add(T::DbWeight::get().reads(29)) .saturating_add(T::DbWeight::get().writes(16)) } @@ -347,11 +359,11 @@ impl runtime_parachains::paras_inherent::WeightInfo for /// Proof: `Paras::MostRecentContext` (`max_values`: None, `max_size`: None, mode: `Measured`) fn enter_backed_candidate_code_upgrade() -> Weight { // Proof Size summary in bytes: - // Measured: `43282` - // Estimated: `49222` - // Minimum execution time: 42_128_606_000 picoseconds. - Weight::from_parts(42_822_806_000, 0) - .saturating_add(Weight::from_parts(0, 49222)) + // Measured: `76382` + // Estimated: `82322` + // Minimum execution time: 34_577_233_000 picoseconds. + Weight::from_parts(39_530_352_000, 0) + .saturating_add(Weight::from_parts(0, 82322)) .saturating_add(T::DbWeight::get().reads(31)) .saturating_add(T::DbWeight::get().writes(16)) } diff --git a/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs b/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs deleted file mode 100644 index 767097f660e81c2fc411334389b351a6c38d8b6d..0000000000000000000000000000000000000000 --- a/polkadot/runtime/westend/src/weights/runtime_parachains_inclusion.rs +++ /dev/null @@ -1,75 +0,0 @@ -// Copyright (C) Parity Technologies (UK) Ltd. -// This file is part of Polkadot. - -// Polkadot 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. - -// Polkadot 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 Polkadot. If not, see . - -//! Autogenerated weights for `runtime_parachains::inclusion` -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-06-14, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner--ss9ysm1-project-163-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("westend-dev"), DB CACHE: 1024 - -// Executed Command: -// ./target/production/polkadot -// benchmark -// pallet -// --chain=westend-dev -// --steps=50 -// --repeat=20 -// --no-storage-info -// --no-median-slopes -// --no-min-squares -// --pallet=runtime_parachains::inclusion -// --extrinsic=* -// --execution=wasm -// --wasm-execution=compiled -// --header=./file_header.txt -// --output=./runtime/westend/src/weights/runtime_parachains_inclusion.rs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(missing_docs)] - -use frame_support::{traits::Get, weights::Weight}; -use core::marker::PhantomData; - -/// Weight functions for `runtime_parachains::inclusion`. -pub struct WeightInfo(PhantomData); -impl runtime_parachains::inclusion::WeightInfo for WeightInfo { - /// Storage: MessageQueue BookStateFor (r:1 w:1) - /// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(55), added: 2530, mode: MaxEncodedLen) - /// Storage: MessageQueue Pages (r:1 w:999) - /// Proof: MessageQueue Pages (max_values: None, max_size: Some(131122), added: 133597, mode: MaxEncodedLen) - /// Storage: unknown `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) - /// Proof Skipped: unknown `0x3a72656c61795f64697370617463685f71756575655f72656d61696e696e675f` (r:0 w:1) - /// Storage: unknown `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) - /// Proof Skipped: unknown `0xf5207f03cfdce586301014700e2c2593fad157e461d71fd4c1f936839a5f1f3e` (r:0 w:1) - /// The range of component `i` is `[1, 1000]`. - fn receive_upward_messages(i: u32, ) -> Weight { - // Proof Size summary in bytes: - // Measured: `131297` - // Estimated: `134587` - // Minimum execution time: 209_898_000 picoseconds. - Weight::from_parts(210_955_000, 0) - .saturating_add(Weight::from_parts(0, 134587)) - // Standard Error: 97_069 - .saturating_add(Weight::from_parts(207_030_437, 0).saturating_mul(i.into())) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(3)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(i.into()))) - } -} diff --git a/polkadot/runtime/westend/src/weights/xcm/mod.rs b/polkadot/runtime/westend/src/weights/xcm/mod.rs index 09e883a9f7af5820832e7db52a8eeba5148d3a48..cb5894ea51e3c5106e75e86bc35249f24e8a03b4 100644 --- a/polkadot/runtime/westend/src/weights/xcm/mod.rs +++ b/polkadot/runtime/westend/src/weights/xcm/mod.rs @@ -18,8 +18,8 @@ mod pallet_xcm_benchmarks_fungible; mod pallet_xcm_benchmarks_generic; use crate::Runtime; +use alloc::vec::Vec; use frame_support::weights::Weight; -use sp_std::prelude::*; use xcm::{ latest::{prelude::*, QueryResponseInfo}, DoubleEncoded, diff --git a/polkadot/runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs b/polkadot/runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs index 9939f16aa29f84fb0df68f658fc8cef44c52eea3..e0c61c8e2bf2583733954469f5cff132a8f49406 100644 --- a/polkadot/runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs +++ b/polkadot/runtime/westend/src/weights/xcm/pallet_xcm_benchmarks_fungible.rs @@ -16,10 +16,10 @@ //! Autogenerated weights for `pallet_xcm_benchmarks::fungible` //! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-10-03, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0 +//! DATE: 2024-08-08, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]` //! WORST CASE MAP SIZE: `1000000` -//! HOSTNAME: `runner-nbnwcyh-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` +//! HOSTNAME: `runner-696hpswk-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz` //! WASM-EXECUTION: Compiled, CHAIN: Some("westend-dev"), DB CACHE: 1024 // Executed Command: @@ -55,8 +55,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `3593` - // Minimum execution time: 24_815_000 picoseconds. - Weight::from_parts(25_098_000, 3593) + // Minimum execution time: 31_780_000 picoseconds. + Weight::from_parts(32_602_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -66,12 +66,12 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `101` // Estimated: `6196` - // Minimum execution time: 51_268_000 picoseconds. - Weight::from_parts(51_857_000, 6196) + // Minimum execution time: 41_818_000 picoseconds. + Weight::from_parts(42_902_000, 6196) .saturating_add(T::DbWeight::get().reads(2)) .saturating_add(T::DbWeight::get().writes(2)) } - /// Storage: `System::Account` (r:2 w:2) + /// Storage: `System::Account` (r:3 w:3) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0) /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -83,12 +83,12 @@ impl WeightInfo { /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn transfer_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `210` - // Estimated: `6196` - // Minimum execution time: 74_113_000 picoseconds. - Weight::from_parts(74_721_000, 6196) - .saturating_add(T::DbWeight::get().reads(6)) - .saturating_add(T::DbWeight::get().writes(4)) + // Measured: `351` + // Estimated: `8799` + // Minimum execution time: 101_949_000 picoseconds. + Weight::from_parts(104_190_000, 8799) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(5)) } /// Storage: `Benchmark::Override` (r:0 w:0) /// Proof: `Benchmark::Override` (`max_values`: None, `max_size`: None, mode: `Measured`) @@ -105,16 +105,18 @@ impl WeightInfo { /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:2 w:2) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn initiate_reserve_withdraw() -> Weight { // Proof Size summary in bytes: - // Measured: `109` - // Estimated: `3574` - // Minimum execution time: 28_919_000 picoseconds. - Weight::from_parts(29_703_000, 3574) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(2)) + // Measured: `351` + // Estimated: `6196` + // Minimum execution time: 70_123_000 picoseconds. + Weight::from_parts(72_564_000, 6196) + .saturating_add(T::DbWeight::get().reads(6)) + .saturating_add(T::DbWeight::get().writes(4)) } /// Storage: `System::Account` (r:1 w:1) /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) @@ -122,8 +124,8 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `103` // Estimated: `3593` - // Minimum execution time: 21_685_000 picoseconds. - Weight::from_parts(22_528_000, 3593) + // Minimum execution time: 31_868_000 picoseconds. + Weight::from_parts(32_388_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } @@ -133,27 +135,27 @@ impl WeightInfo { // Proof Size summary in bytes: // Measured: `0` // Estimated: `3593` - // Minimum execution time: 25_192_000 picoseconds. - Weight::from_parts(25_445_000, 3593) + // Minimum execution time: 24_532_000 picoseconds. + Weight::from_parts(25_166_000, 3593) .saturating_add(T::DbWeight::get().reads(1)) .saturating_add(T::DbWeight::get().writes(1)) } - /// Storage: `System::Account` (r:1 w:1) - /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DeliveryFeeFactor` (r:1 w:0) /// Proof: `Dmp::DeliveryFeeFactor` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `XcmPallet::SupportedVersion` (r:1 w:0) /// Proof: `XcmPallet::SupportedVersion` (`max_values`: None, `max_size`: None, mode: `Measured`) /// Storage: `Dmp::DownwardMessageQueues` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueues` (`max_values`: None, `max_size`: None, mode: `Measured`) + /// Storage: `System::Account` (r:1 w:1) + /// Proof: `System::Account` (`max_values`: None, `max_size`: Some(128), added: 2603, mode: `MaxEncodedLen`) /// Storage: `Dmp::DownwardMessageQueueHeads` (r:1 w:1) /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn deposit_reserve_asset() -> Weight { // Proof Size summary in bytes: - // Measured: `109` - // Estimated: `3593` - // Minimum execution time: 49_349_000 picoseconds. - Weight::from_parts(50_476_000, 3593) + // Measured: `147` + // Estimated: `3612` + // Minimum execution time: 63_378_000 picoseconds. + Weight::from_parts(65_002_000, 3612) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) } @@ -169,10 +171,10 @@ impl WeightInfo { /// Proof: `Dmp::DownwardMessageQueueHeads` (`max_values`: None, `max_size`: None, mode: `Measured`) pub(crate) fn initiate_teleport() -> Weight { // Proof Size summary in bytes: - // Measured: `109` - // Estimated: `3593` - // Minimum execution time: 51_386_000 picoseconds. - Weight::from_parts(52_141_000, 3593) + // Measured: `147` + // Estimated: `3612` + // Minimum execution time: 49_174_000 picoseconds. + Weight::from_parts(50_356_000, 3612) .saturating_add(T::DbWeight::get().reads(5)) .saturating_add(T::DbWeight::get().writes(3)) } diff --git a/polkadot/runtime/westend/src/xcm_config.rs b/polkadot/runtime/westend/src/xcm_config.rs index c6c5fb9e72a46afa70c6db09fd3a2b0f38d7e3a5..d75083929a04511e104d8c36d7628fa5e329ec84 100644 --- a/polkadot/runtime/westend/src/xcm_config.rs +++ b/polkadot/runtime/westend/src/xcm_config.rs @@ -28,7 +28,7 @@ use frame_support::{ }; use frame_system::EnsureRoot; use pallet_xcm::XcmPassthrough; -use runtime_common::{ +use polkadot_runtime_common::{ xcm_sender::{ChildParachainRouter, ExponentialPrice}, ToAuthor, }; @@ -42,10 +42,9 @@ use xcm_builder::{ AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, ChildParachainAsNative, ChildParachainConvertsVia, DescribeAllTerminal, DescribeFamily, FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsChildSystemParachain, IsConcrete, MintLocation, - OriginToPluralityVoice, SignedAccountId32AsNative, SignedToAccountId32, + OriginToPluralityVoice, SendXcmFeeToAccount, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, TrailingSetTopicAsId, UsingComponents, WeightInfoBounds, WithComputedOrigin, WithUniqueTopic, XcmFeeManagerFromComponents, - XcmFeeToAccount, }; use xcm_executor::XcmExecutor; @@ -211,7 +210,7 @@ impl xcm_executor::Config for XcmConfig { type MaxAssetsIntoHolding = MaxAssetsIntoHolding; type FeeManager = XcmFeeManagerFromComponents< WaivedLocations, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/polkadot/statement-table/Cargo.toml b/polkadot/statement-table/Cargo.toml index 37b8a99d640a2d23e0d7a532adc0c43b04bba1f2..53ea0b74463bc2466df2ff37f190f429d9b2973a 100644 --- a/polkadot/statement-table/Cargo.toml +++ b/polkadot/statement-table/Cargo.toml @@ -10,7 +10,7 @@ description = "Stores messages other authorities issue about candidates in Polka workspace = true [dependencies] -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -sp-core = { path = "../../substrate/primitives/core" } -primitives = { package = "polkadot-primitives", path = "../primitives" } -gum = { package = "tracing-gum", path = "../node/gum" } +codec = { features = ["derive"], workspace = true } +sp-core = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +gum = { workspace = true, default-features = true } diff --git a/polkadot/statement-table/src/generic.rs b/polkadot/statement-table/src/generic.rs index 2ee6f6a4f781842866728e2105d6c23e2fa1cd70..1e90338a0f18a803e572c8174de4460a3b888e33 100644 --- a/polkadot/statement-table/src/generic.rs +++ b/polkadot/statement-table/src/generic.rs @@ -30,12 +30,12 @@ use std::{ hash::Hash, }; -use primitives::{ +use polkadot_primitives::{ effective_minimum_backing_votes, ValidatorSignature, ValidityAttestation as PrimitiveValidityAttestation, }; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; const LOG_TARGET: &str = "parachain::statement-table"; /// Context for the statement table. @@ -477,10 +477,7 @@ impl Table { if !context.is_member_of(&from, &votes.group_id) { let sig = match vote { ValidityVote::Valid(s) => s, - ValidityVote::Issued(_) => panic!( - "implicit issuance vote only cast from `import_candidate` after \ - checking group membership of issuer; qed" - ), + ValidityVote::Issued(s) => s, }; return Err(Misbehavior::UnauthorizedStatement(UnauthorizedStatement { diff --git a/polkadot/statement-table/src/lib.rs b/polkadot/statement-table/src/lib.rs index 3740d15cc4f326962b962557e61ca14e9163de7d..469c877eafc9fa4d56e6eae3187c2fb29b14a07a 100644 --- a/polkadot/statement-table/src/lib.rs +++ b/polkadot/statement-table/src/lib.rs @@ -34,7 +34,7 @@ pub use generic::{Config, Context, Table}; /// Concrete instantiations suitable for v2 primitives. pub mod v2 { use crate::generic; - use primitives::{ + use polkadot_primitives::{ CandidateHash, CommittedCandidateReceipt, CompactStatement as PrimitiveStatement, CoreIndex, ValidatorIndex, ValidatorSignature, }; diff --git a/polkadot/utils/generate-bags/Cargo.toml b/polkadot/utils/generate-bags/Cargo.toml index ad6d7259d2483e11e9df8c121bab75461a71c525..16205b0f51f57a62b923eff0952a45795c6cb3b6 100644 --- a/polkadot/utils/generate-bags/Cargo.toml +++ b/polkadot/utils/generate-bags/Cargo.toml @@ -10,9 +10,9 @@ description = "CLI to generate voter bags for Polkadot runtimes" workspace = true [dependencies] -clap = { version = "4.5.3", features = ["derive"] } +clap = { features = ["derive"], workspace = true } -generate-bags = { path = "../../../substrate/utils/frame/generate-bags" } -sp-io = { path = "../../../substrate/primitives/io" } +generate-bags = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } -westend-runtime = { path = "../../runtime/westend" } +westend-runtime = { workspace = true } diff --git a/polkadot/utils/remote-ext-tests/bags-list/Cargo.toml b/polkadot/utils/remote-ext-tests/bags-list/Cargo.toml index 20e4130f888bcb1f826dab81fb7e5a721a53a225..206ca8cf19a90df9bc2becd0c65039f35d714191 100644 --- a/polkadot/utils/remote-ext-tests/bags-list/Cargo.toml +++ b/polkadot/utils/remote-ext-tests/bags-list/Cargo.toml @@ -10,14 +10,14 @@ license.workspace = true workspace = true [dependencies] -westend-runtime = { path = "../../../runtime/westend" } -westend-runtime-constants = { path = "../../../runtime/westend/constants" } +westend-runtime = { workspace = true } +westend-runtime-constants = { workspace = true, default-features = true } -pallet-bags-list-remote-tests = { path = "../../../../substrate/frame/bags-list/remote-tests" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -frame-system = { path = "../../../../substrate/frame/system" } -sp-core = { path = "../../../../substrate/primitives/core" } +pallet-bags-list-remote-tests = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } -clap = { version = "4.5.3", features = ["derive"] } +clap = { features = ["derive"], workspace = true } log = { workspace = true, default-features = true } -tokio = { version = "1.24.2", features = ["macros"] } +tokio = { features = ["macros"], workspace = true, default-features = true } diff --git a/polkadot/xcm/Cargo.toml b/polkadot/xcm/Cargo.toml index f10f45b0b4fafa4ad59eb075aff0a9e94fc9aefc..862f5557a012a9bd1953607e774b36009c87d9e5 100644 --- a/polkadot/xcm/Cargo.toml +++ b/polkadot/xcm/Cargo.toml @@ -10,34 +10,40 @@ license.workspace = true workspace = true [dependencies] -array-bytes = "6.2.2" -bounded-collections = { version = "0.2.0", default-features = false, features = ["serde"] } -derivative = { version = "2.2.0", default-features = false, features = ["use_core"] } -impl-trait-for-tuples = "0.2.2" +array-bytes = { workspace = true, default-features = true } +bounded-collections = { features = ["serde"], workspace = true } +derivative = { features = ["use_core"], workspace = true } +impl-trait-for-tuples = { workspace = true } log = { workspace = true } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive", "max-encoded-len"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] } -sp-weights = { path = "../../substrate/primitives/weights", default-features = false, features = ["serde"] } +codec = { features = ["derive", "max-encoded-len"], workspace = true } +scale-info = { features = ["derive", "serde"], workspace = true } +sp-runtime = { workspace = true } +sp-weights = { features = ["serde"], workspace = true } serde = { features = ["alloc", "derive", "rc"], workspace = true } -schemars = { version = "0.8.13", default-features = true, optional = true } -xcm-procedural = { path = "procedural" } -environmental = { version = "1.1.4", default-features = false } +schemars = { default-features = true, optional = true, workspace = true } +xcm-procedural = { workspace = true, default-features = true } +environmental = { workspace = true } [dev-dependencies] -sp-io = { path = "../../substrate/primitives/io" } -hex = "0.4.3" -hex-literal = "0.4.1" +sp-io = { workspace = true, default-features = true } +hex = { workspace = true, default-features = true } +hex-literal = { workspace = true, default-features = true } [features] default = ["std"] wasm-api = [] std = [ "bounded-collections/std", + "codec/std", "environmental/std", "log/std", - "parity-scale-codec/std", "scale-info/std", "serde/std", + "sp-runtime/std", "sp-weights/std", ] -json-schema = ["bounded-collections/json-schema", "dep:schemars", "sp-weights/json-schema"] +json-schema = [ + "bounded-collections/json-schema", + "dep:schemars", + "sp-weights/json-schema", +] diff --git a/polkadot/xcm/docs/Cargo.toml b/polkadot/xcm/docs/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..9d8f4c0a6430b71e2b2d1ba09719a8c397b4e4d5 --- /dev/null +++ b/polkadot/xcm/docs/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = "xcm-docs" +description = "Documentation and guides for XCM" +version = "0.1.0" +license = "GPL-3.0-or-later WITH Classpath-exception-2.0" +repository.workspace = true +authors.workspace = true +edition.workspace = true +publish = false + +[dependencies] +# For XCM stuff +xcm = { workspace = true, default-features = true } +xcm-executor = { workspace = true, default-features = true } +xcm-builder = { workspace = true, default-features = true } +xcm-simulator = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } + +# For building FRAME runtimes +frame = { features = ["experimental", "runtime"], workspace = true, default-features = true } +codec = { workspace = true, default-features = true } +scale-info = { workspace = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } + +# Some pallets +pallet-message-queue = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } + +# For building docs +simple-mermaid = { git = "https://github.com/kianenigma/simple-mermaid.git", branch = "main" } +docify = { workspace = true } + +[dev-dependencies] +test-log = { workspace = true } diff --git a/polkadot/xcm/docs/mermaid/location_hierarchy.mmd b/polkadot/xcm/docs/mermaid/location_hierarchy.mmd new file mode 100644 index 0000000000000000000000000000000000000000..54fcfc8072a9aa08032da54f3b4332ef7db5d7c1 --- /dev/null +++ b/polkadot/xcm/docs/mermaid/location_hierarchy.mmd @@ -0,0 +1,9 @@ +flowchart + relay[Relaychain] --> paraA["Parachain(1000)"] + relay --> paraB["Parachain(2000)"] + + paraA --> pallet[Pallet] + pallet --> indexA[Index 1] + pallet --> indexB[Index 2] + + paraA --> account[Account] diff --git a/polkadot/xcm/docs/mermaid/structure.mmd b/polkadot/xcm/docs/mermaid/structure.mmd new file mode 100644 index 0000000000000000000000000000000000000000..17f60467241a351ab3c623b451b8ff4d79df2b9b --- /dev/null +++ b/polkadot/xcm/docs/mermaid/structure.mmd @@ -0,0 +1,4 @@ +flowchart + docs[xcm_docs] --> fundamentals + docs --> guides + docs --> cookbook diff --git a/polkadot/xcm/docs/mermaid/transport_protocols.mmd b/polkadot/xcm/docs/mermaid/transport_protocols.mmd new file mode 100644 index 0000000000000000000000000000000000000000..c0340db0651a3f273bbd35dd5fa51afe15a11c24 --- /dev/null +++ b/polkadot/xcm/docs/mermaid/transport_protocols.mmd @@ -0,0 +1,6 @@ +flowchart + relay[Relaychain] --"DMP"--> paraA["Parachain(2000)"] + relay --"DMP"--> paraB["Parachain(2001)"] + + paraA --"UMP"--> relay + paraB --"UMP"--> relay diff --git a/polkadot/xcm/docs/mermaid/universal_location.mmd b/polkadot/xcm/docs/mermaid/universal_location.mmd new file mode 100644 index 0000000000000000000000000000000000000000..97bfa747319db21dfe07032a3e7fea4d7a54f056 --- /dev/null +++ b/polkadot/xcm/docs/mermaid/universal_location.mmd @@ -0,0 +1,3 @@ +flowchart + universe[Universal Location] --> polkadot[Polkadot] + universe --> ethereum[Ethereum] diff --git a/polkadot/xcm/docs/mermaid/usdt_location.mmd b/polkadot/xcm/docs/mermaid/usdt_location.mmd new file mode 100644 index 0000000000000000000000000000000000000000..5e9222f6098ec900ed18b99a16a51c9e2584ee6e --- /dev/null +++ b/polkadot/xcm/docs/mermaid/usdt_location.mmd @@ -0,0 +1,6 @@ +flowchart + relay[Polkadot] --> assetHub["Asset Hub"] + relay --> anotherPara["Another parachain"] + + assetHub --> assetsPallet["Assets Pallet"] + assetsPallet --> usdt[1984] diff --git a/polkadot/xcm/docs/src/cookbook/mod.rs b/polkadot/xcm/docs/src/cookbook/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1c69bf0ead6f81e4a11010cbf314f9638dda9ccb --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/mod.rs @@ -0,0 +1,27 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # XCM Cookbook +//! +//! A collection of XCM recipes. +//! +//! Each recipe is tested and explains all the code necessary to run it -- they're not just snippets +//! to copy and paste. + +/// Configuring a parachain that only uses the Relay Chain native token. +/// In the case of Polkadot, this recipe will show you how to launch a parachain with no native +/// token -- dealing only on DOT. +pub mod relay_token_transactor; diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/mod.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..279dd71a35f7410b6a6899e5c018c4f55ca18d15 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/mod.rs @@ -0,0 +1,51 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # Relay Asset Transactor +//! +//! This example shows how to configure a parachain to only deal with the Relay Chain token. +//! +//! The first step is using the [`xcm_builder::FungibleAdapter`] to create an `AssetTransactor` that +//! can handle the relay chain token. +#![doc = docify::embed!("src/cookbook/relay_token_transactor/parachain/xcm_config.rs", asset_transactor)] +//! +//! The second step is to configure `IsReserve` to recognize the relay chain as a reserve for its +//! own asset. +//! With this, you'll be able to easily mint a derivative asset, backed one-to-one from the Relay +//! Chain, by using the xcm pallet's `transfer_assets` extrinsic. +//! +//! The `IsReserve` type takes a type that implements `ContainsPair`. +//! In this case, we want a type that contains the pair `(relay_chain_native_token, relay_chain)`. +#![doc = docify::embed!("src/cookbook/relay_token_transactor/parachain/xcm_config.rs", is_reserve)] +//! +//! With this setup, we are able to do a reserve asset transfer to and from the parachain and relay +//! chain. +#![doc = docify::embed!("src/cookbook/relay_token_transactor/tests.rs", reserve_asset_transfers_work)] +//! +//! For the rest of the code, be sure to check the contents of this module. + +/// The parachain runtime for this example +pub mod parachain; + +/// The relay chain runtime for this example. +pub mod relay_chain; + +/// The network for this example. +pub mod network; + +/// Tests for this example. +#[cfg(test)] +pub mod tests; diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/network.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/network.rs new file mode 100644 index 0000000000000000000000000000000000000000..46ac0e5df6372babf84b3494436e554353ba2820 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/network.rs @@ -0,0 +1,90 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Mock network + +use frame::deps::{ + frame_system, + sp_io::TestExternalities, + sp_runtime::{AccountId32, BuildStorage}, +}; +use xcm_simulator::{decl_test_network, decl_test_parachain, decl_test_relay_chain, TestExt}; + +use super::{parachain, relay_chain}; + +pub const ALICE: AccountId32 = AccountId32::new([0u8; 32]); +pub const BOB: AccountId32 = AccountId32::new([1u8; 32]); +pub const UNITS: u64 = 10_000_000_000; +pub const CENTS: u64 = 100_000_000; +pub const INITIAL_BALANCE: u64 = UNITS; + +decl_test_parachain! { + pub struct ParaA { + Runtime = parachain::Runtime, + XcmpMessageHandler = parachain::MessageQueue, + DmpMessageHandler = parachain::MessageQueue, + new_ext = para_ext(), + } +} + +decl_test_relay_chain! { + pub struct Relay { + Runtime = relay_chain::Runtime, + RuntimeCall = relay_chain::RuntimeCall, + RuntimeEvent = relay_chain::RuntimeEvent, + XcmConfig = relay_chain::XcmConfig, + MessageQueue = relay_chain::MessageQueue, + System = relay_chain::System, + new_ext = relay_ext(), + } +} + +decl_test_network! { + pub struct MockNet { + relay_chain = Relay, + parachains = vec![ + (2222, ParaA), + ], + } +} + +pub fn para_ext() -> TestExternalities { + use parachain::{MessageQueue, Runtime, System}; + + let t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + let mut ext = frame::deps::sp_io::TestExternalities::new(t); + ext.execute_with(|| { + System::set_block_number(1); + MessageQueue::set_para_id(2222.into()); + }); + ext +} + +pub fn relay_ext() -> TestExternalities { + use relay_chain::{Runtime, System}; + + let mut t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + + pallet_balances::GenesisConfig:: { balances: vec![(ALICE, INITIAL_BALANCE)] } + .assimilate_storage(&mut t) + .unwrap(); + + let mut ext = TestExternalities::new(t); + ext.execute_with(|| { + System::set_block_number(1); + }); + ext +} diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..23d6664bdafcbc147f63c3a99ce2d788277679b5 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/mod.rs @@ -0,0 +1,55 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # Runtime + +use frame::{deps::frame_system, runtime::prelude::*, traits::IdentityLookup}; +use xcm_executor::XcmExecutor; +use xcm_simulator::mock_message_queue; + +mod xcm_config; +use xcm_config::XcmConfig; + +pub type Block = frame_system::mocking::MockBlock; +pub type AccountId = frame::deps::sp_runtime::AccountId32; +pub type Balance = u64; + +construct_runtime! { + pub struct Runtime { + System: frame_system, + MessageQueue: mock_message_queue, + Balances: pallet_balances, + XcmPallet: pallet_xcm, + } +} + +#[derive_impl(frame_system::config_preludes::TestDefaultConfig)] +impl frame_system::Config for Runtime { + type Block = Block; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type AccountData = pallet_balances::AccountData; +} + +impl mock_message_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type XcmExecutor = XcmExecutor; +} + +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] +impl pallet_balances::Config for Runtime { + type AccountStore = System; +} diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/xcm_config.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/xcm_config.rs new file mode 100644 index 0000000000000000000000000000000000000000..99f17693093e7f0472d78caf54f842847a8a3e84 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/parachain/xcm_config.rs @@ -0,0 +1,189 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # XCM Configuration + +use frame::{ + deps::frame_system, + runtime::prelude::*, + traits::{Everything, Nothing}, +}; +use xcm::v4::prelude::*; +use xcm_builder::{ + AccountId32Aliases, DescribeAllTerminal, DescribeFamily, EnsureXcmOrigin, + FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsConcrete, + SignedToAccountId32, +}; +use xcm_executor::XcmExecutor; + +use super::{AccountId, Balances, MessageQueue, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin}; + +parameter_types! { + pub RelayLocation: Location = Location::parent(); + pub ThisNetwork: NetworkId = NetworkId::Polkadot; +} + +pub type LocationToAccountId = ( + HashedDescription>, + AccountId32Aliases, +); + +/// Configuration related to asset transactors +#[docify::export] +mod asset_transactor { + use super::*; + + parameter_types! { + pub ParentRelayLocation: Location = Location::parent(); + } + + /// AssetTransactor for handling the relay chain token + pub type FungibleTransactor = FungibleAdapter< + // Use this implementation of the `fungible::*` traits. + // `Balances` is the name given to the balances pallet in this particular recipe. + // Any implementation of the traits would suffice. + Balances, + // This transactor deals with the native token of the Relay Chain. + // This token is referenced by the Location of the Relay Chain relative to this chain + // -- Location::parent(). + IsConcrete, + // How to convert an XCM Location into a local account id. + // This is also something that's configured in the XCM executor. + LocationToAccountId, + // The type for account ids, only needed because `fungible` is generic over it. + AccountId, + // Not tracking teleports. + // This recipe only uses reserve asset transfers to handle the Relay Chain token. + (), + >; + + /// Actual configuration item that'll be set in the XCM config. + /// A tuple could be used here to have multiple transactors, each (potentially) handling + /// different assets. + /// In this recipe, we only have one. + pub type AssetTransactor = FungibleTransactor; +} + +/// Configuration related to token reserves +#[docify::export] +mod is_reserve { + use super::*; + + parameter_types! { + /// Reserves are specified using a pair `(AssetFilter, Location)`. + /// Each pair means that the specified Location is a reserve for all the assets in AssetsFilter. + /// Here, we are specifying that the Relay Chain is the reserve location for its native token. + pub RelayTokenForRelay: (AssetFilter, Location) = + (Wild(AllOf { id: AssetId(Parent.into()), fun: WildFungible }), Parent.into()); + } + + /// The wrapper type xcm_builder::Case is needed in order to use this in the configuration. + pub type IsReserve = xcm_builder::Case; +} + +mod weigher { + use super::*; + use xcm_builder::FixedWeightBounds; + + parameter_types! { + pub const WeightPerInstruction: Weight = Weight::from_parts(1, 1); + pub const MaxInstructions: u32 = 100; + } + + pub type Weigher = FixedWeightBounds; +} + +parameter_types! { + pub UniversalLocation: InteriorLocation = [GlobalConsensus(NetworkId::Polkadot), Parachain(2222)].into(); +} + +pub struct XcmConfig; +impl xcm_executor::Config for XcmConfig { + type RuntimeCall = RuntimeCall; + type XcmSender = (); + type AssetTransactor = asset_transactor::AssetTransactor; + type OriginConverter = (); + // The declaration of which Locations are reserves for which Assets. + type IsReserve = is_reserve::IsReserve; + type IsTeleporter = (); + type UniversalLocation = UniversalLocation; + // This is not safe, you should use `xcm_builder::AllowTopLevelPaidExecutionFrom` in a + // production chain + type Barrier = xcm_builder::AllowUnpaidExecutionFrom; + type Weigher = weigher::Weigher; + type Trader = (); + type ResponseHandler = (); + type AssetTrap = (); + type AssetLocker = (); + type AssetExchanger = (); + type AssetClaims = (); + type SubscriptionService = (); + type PalletInstancesInfo = (); + type FeeManager = (); + type MaxAssetsIntoHolding = frame::traits::ConstU32<1>; + type MessageExporter = (); + type UniversalAliases = Nothing; + type CallDispatcher = RuntimeCall; + type SafeCallFilter = Everything; + type Aliasers = Nothing; + type TransactionalProcessor = FrameTransactionalProcessor; + type HrmpNewChannelOpenRequestHandler = (); + type HrmpChannelAcceptedHandler = (); + type HrmpChannelClosingHandler = (); + type XcmRecorder = (); +} + +pub type LocalOriginToLocation = SignedToAccountId32; + +impl pallet_xcm::Config for Runtime { + // We turn off sending for these tests + type SendXcmOrigin = EnsureXcmOrigin; + type XcmRouter = super::super::network::ParachainXcmRouter; // Provided by xcm-simulator + // Anyone can execute XCM programs + type ExecuteXcmOrigin = EnsureXcmOrigin; + // We execute any type of program + type XcmExecuteFilter = Everything; + // How we execute programs + type XcmExecutor = XcmExecutor; + // We don't allow teleports + type XcmTeleportFilter = Nothing; + // We allow all reserve transfers + type XcmReserveTransferFilter = Everything; + // Same weigher executor uses to weigh XCM programs + type Weigher = weigher::Weigher; + // Same universal location + type UniversalLocation = UniversalLocation; + // No version discovery needed + const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 0; + type AdvertisedXcmVersion = frame::traits::ConstU32<3>; + type AdminOrigin = frame_system::EnsureRoot; + // No locking + type TrustedLockers = (); + type MaxLockers = frame::traits::ConstU32<0>; + type MaxRemoteLockConsumers = frame::traits::ConstU32<0>; + type RemoteLockConsumerIdentifier = (); + // How to turn locations into accounts + type SovereignAccountOf = LocationToAccountId; + // A currency to pay for things and its matcher, we are using the relay token + type Currency = Balances; + type CurrencyMatcher = IsConcrete; + // Pallet benchmarks, no need for this recipe + type WeightInfo = pallet_xcm::TestWeightInfo; + // Runtime types + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type RuntimeEvent = RuntimeEvent; +} diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..686f86b37b73204e877ab3c935797ce92540816e --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/mod.rs @@ -0,0 +1,103 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Relay chain runtime mock. + +use frame::{ + deps::{frame_support::weights::WeightMeter, sp_runtime::AccountId32}, + prelude::*, + runtime::prelude::*, + traits::{IdentityLookup, ProcessMessage, ProcessMessageError}, +}; +use polkadot_runtime_parachains::inclusion::{AggregateMessageOrigin, UmpQueueId}; +use xcm::v4::prelude::*; + +mod xcm_config; +pub use xcm_config::LocationToAccountId; +use xcm_config::XcmConfig; + +pub type AccountId = AccountId32; +pub type Balance = u64; + +parameter_types! { + pub const BlockHashCount: u64 = 250; +} + +#[derive_impl(frame_system::config_preludes::TestDefaultConfig)] +impl frame_system::Config for Runtime { + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Block = Block; + type AccountData = pallet_balances::AccountData; +} + +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] +impl pallet_balances::Config for Runtime { + type AccountStore = System; +} + +type Block = frame_system::mocking::MockBlock; + +parameter_types! { + /// Amount of weight that can be spent per block to service messages. + pub MessageQueueServiceWeight: Weight = Weight::from_parts(1_000_000_000, 1_000_000); + pub const MessageQueueHeapSize: u32 = 65_536; + pub const MessageQueueMaxStale: u32 = 16; +} + +/// Message processor to handle any messages that were enqueued into the `MessageQueue` pallet. +pub struct MessageProcessor; +impl ProcessMessage for MessageProcessor { + type Origin = AggregateMessageOrigin; + + fn process_message( + message: &[u8], + origin: Self::Origin, + meter: &mut WeightMeter, + id: &mut [u8; 32], + ) -> Result { + let para = match origin { + AggregateMessageOrigin::Ump(UmpQueueId::Para(para)) => para, + }; + xcm_builder::ProcessXcmMessage::< + Junction, + xcm_executor::XcmExecutor, + RuntimeCall, + >::process_message(message, Junction::Parachain(para.into()), meter, id) + } +} + +impl pallet_message_queue::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Size = u32; + type HeapSize = MessageQueueHeapSize; + type MaxStale = MessageQueueMaxStale; + type ServiceWeight = MessageQueueServiceWeight; + type MessageProcessor = MessageProcessor; + type QueueChangeHandler = (); + type QueuePausedQuery = (); + type WeightInfo = (); + type IdleMaxServiceWeight = MessageQueueServiceWeight; +} + +construct_runtime! { + pub struct Runtime { + System: frame_system, + Balances: pallet_balances, + MessageQueue: pallet_message_queue, + XcmPallet: pallet_xcm, + } +} diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/xcm_config.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/xcm_config.rs new file mode 100644 index 0000000000000000000000000000000000000000..987bb3f9ab6649bc299edafa97dc1d06166db440 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/relay_chain/xcm_config.rs @@ -0,0 +1,163 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Relay chain XCM configuration + +use frame::{ + deps::frame_system, + runtime::prelude::*, + traits::{Everything, Nothing}, +}; +use xcm::v4::prelude::*; +use xcm_builder::{ + AccountId32Aliases, DescribeAllTerminal, DescribeFamily, EnsureXcmOrigin, + FrameTransactionalProcessor, FungibleAdapter, HashedDescription, IsConcrete, + SignedToAccountId32, +}; +use xcm_executor::XcmExecutor; + +use super::{AccountId, Balances, Runtime, RuntimeCall, RuntimeEvent, RuntimeOrigin}; + +parameter_types! { + pub HereLocation: Location = Location::here(); + pub ThisNetwork: NetworkId = NetworkId::Polkadot; +} + +/// Converter from XCM Locations to accounts. +/// This generates sovereign accounts for Locations and converts +/// local AccountId32 junctions to local accounts. +pub type LocationToAccountId = ( + HashedDescription>, + AccountId32Aliases, +); + +mod asset_transactor { + use super::*; + + /// AssetTransactor for handling the Relay Chain token. + pub type FungibleTransactor = FungibleAdapter< + // Use this `fungible` implementation. + Balances, + // This transactor handles the native token. + IsConcrete, + // How to convert an XCM Location into a local account id. + // Whenever assets are handled, the location is turned into an account. + // This account is the one where balances are withdrawn/deposited. + LocationToAccountId, + // The account id type, needed because `fungible` is generic over it. + AccountId, + // Not tracking teleports. + (), + >; + + /// All asset transactors, in this case only one + pub type AssetTransactor = FungibleTransactor; +} + +mod weigher { + use super::*; + use xcm_builder::FixedWeightBounds; + + parameter_types! { + pub const WeightPerInstruction: Weight = Weight::from_parts(1, 1); + pub const MaxInstructions: u32 = 100; + } + + pub type Weigher = FixedWeightBounds; +} + +parameter_types! { + pub UniversalLocation: InteriorLocation = [GlobalConsensus(NetworkId::Polkadot)].into(); +} + +pub struct XcmConfig; +impl xcm_executor::Config for XcmConfig { + type RuntimeCall = RuntimeCall; + type XcmSender = (); + type AssetTransactor = asset_transactor::AssetTransactor; + type OriginConverter = (); + // We don't need to recognize anyone as a reserve + type IsReserve = (); + type IsTeleporter = (); + type UniversalLocation = UniversalLocation; + // This is not safe, you should use `xcm_builder::AllowTopLevelPaidExecutionFrom` in a + // production chain + type Barrier = xcm_builder::AllowUnpaidExecutionFrom; + type Weigher = weigher::Weigher; + type Trader = (); + type ResponseHandler = (); + type AssetTrap = (); + type AssetLocker = (); + type AssetExchanger = (); + type AssetClaims = (); + type SubscriptionService = (); + type PalletInstancesInfo = (); + type FeeManager = (); + type MaxAssetsIntoHolding = frame::traits::ConstU32<1>; + type MessageExporter = (); + type UniversalAliases = Nothing; + type CallDispatcher = RuntimeCall; + type SafeCallFilter = Everything; + type Aliasers = Nothing; + type TransactionalProcessor = FrameTransactionalProcessor; + type HrmpNewChannelOpenRequestHandler = (); + type HrmpChannelAcceptedHandler = (); + type HrmpChannelClosingHandler = (); + type XcmRecorder = (); +} + +pub type LocalOriginToLocation = SignedToAccountId32; + +impl pallet_xcm::Config for Runtime { + // No one can call `send` + type SendXcmOrigin = EnsureXcmOrigin; + type XcmRouter = super::super::network::RelayChainXcmRouter; // Provided by xcm-simulator + // Anyone can execute XCM programs + type ExecuteXcmOrigin = EnsureXcmOrigin; + // We execute any type of program + type XcmExecuteFilter = Everything; + // How we execute programs + type XcmExecutor = XcmExecutor; + // We don't allow teleports + type XcmTeleportFilter = Nothing; + // We allow all reserve transfers. + // This is so it can act as a reserve for its native token. + type XcmReserveTransferFilter = Everything; + // Same weigher executor uses to weigh XCM programs + type Weigher = weigher::Weigher; + // Same universal location + type UniversalLocation = UniversalLocation; + // No version discovery needed + const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 0; + type AdvertisedXcmVersion = frame::traits::ConstU32<3>; + type AdminOrigin = frame_system::EnsureRoot; + // No locking + type TrustedLockers = (); + type MaxLockers = frame::traits::ConstU32<0>; + type MaxRemoteLockConsumers = frame::traits::ConstU32<0>; + type RemoteLockConsumerIdentifier = (); + // How to turn locations into accounts + type SovereignAccountOf = LocationToAccountId; + // A currency to pay for things and its matcher, we are using the relay token + type Currency = Balances; + type CurrencyMatcher = IsConcrete; + // Pallet benchmarks, no need for this example + type WeightInfo = pallet_xcm::TestWeightInfo; + // Runtime types + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type RuntimeEvent = RuntimeEvent; +} diff --git a/polkadot/xcm/docs/src/cookbook/relay_token_transactor/tests.rs b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/tests.rs new file mode 100644 index 0000000000000000000000000000000000000000..792cf6149e7cb418f5ffa5720f41ae44956ff036 --- /dev/null +++ b/polkadot/xcm/docs/src/cookbook/relay_token_transactor/tests.rs @@ -0,0 +1,128 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +use frame::testing_prelude::*; +use test_log::test; +use xcm::prelude::*; +use xcm_executor::traits::ConvertLocation; +use xcm_simulator::TestExt; + +use super::{ + network::{MockNet, ParaA, Relay, ALICE, BOB, CENTS, INITIAL_BALANCE}, + parachain, relay_chain, +}; + +#[docify::export] +#[test] +fn reserve_asset_transfers_work() { + // Scenario: + // ALICE on the relay chain holds some of Relay Chain's native tokens. + // She transfers them to BOB's account on the parachain using a reserve transfer. + // BOB receives Relay Chain native token derivatives on the parachain, + // which are backed one-to-one with the real tokens on the Relay Chain. + // + // NOTE: We could've used ALICE on both chains because it's a different account, + // but using ALICE and BOB makes it clearer. + + // We restart the mock network. + MockNet::reset(); + + // ALICE starts with INITIAL_BALANCE on the relay chain + Relay::execute_with(|| { + assert_eq!(relay_chain::Balances::free_balance(&ALICE), INITIAL_BALANCE); + }); + + // BOB starts with 0 on the parachain + ParaA::execute_with(|| { + assert_eq!(parachain::Balances::free_balance(&BOB), 0); + }); + + // ALICE on the Relay Chain sends some Relay Chain native tokens to BOB on the parachain. + // The transfer is done with the `transfer_assets` extrinsic in the XCM pallet. + // The extrinsic figures out it should do a reserve asset transfer + // with the local chain as reserve. + Relay::execute_with(|| { + // The parachain id is specified in the network.rs file in this recipe. + let destination: Location = Parachain(2222).into(); + let beneficiary: Location = + AccountId32 { id: BOB.clone().into(), network: Some(NetworkId::Polkadot) }.into(); + // We need to use `u128` here for the conversion to work properly. + // If we don't specify anything, it will be a `u64`, which the conversion + // will turn into a non-fungible token instead of a fungible one. + let assets: Assets = (Here, 50u128 * CENTS as u128).into(); + assert_ok!(relay_chain::XcmPallet::transfer_assets( + relay_chain::RuntimeOrigin::signed(ALICE), + Box::new(VersionedLocation::V4(destination.clone())), + Box::new(VersionedLocation::V4(beneficiary)), + Box::new(VersionedAssets::V4(assets)), + 0, + WeightLimit::Unlimited, + )); + + // ALICE now has less Relay Chain tokens. + assert_eq!(relay_chain::Balances::free_balance(&ALICE), INITIAL_BALANCE - 50 * CENTS); + + // The funds of the sovereign account of the parachain increase by 50 cents, + // the ones transferred over to BOB. + // The funds in this sovereign account represent how many Relay Chain tokens + // have been sent to this parachain. + // If the parachain wants to send those assets somewhere else they have to go + // via the reserve, and this balance is updated accordingly. + // This is why the derivatives are backed one-to-one. + let parachains_sovereign_account = + relay_chain::LocationToAccountId::convert_location(&destination).unwrap(); + assert_eq!(relay_chain::Balances::free_balance(parachains_sovereign_account), 50 * CENTS); + }); + + ParaA::execute_with(|| { + // On the parachain, BOB has received the derivative tokens + assert_eq!(parachain::Balances::free_balance(&BOB), 50 * CENTS); + + // BOB gives back half to ALICE in the relay chain + let destination: Location = Parent.into(); + let beneficiary: Location = + AccountId32 { id: ALICE.clone().into(), network: Some(NetworkId::Polkadot) }.into(); + // We specify `Parent` because we are referencing the Relay Chain token. + // This chain doesn't have a token of its own, so we always refer to this token, + // and we do so by the Location of the Relay Chain. + let assets: Assets = (Parent, 25u128 * CENTS as u128).into(); + assert_ok!(parachain::XcmPallet::transfer_assets( + parachain::RuntimeOrigin::signed(BOB), + Box::new(VersionedLocation::V4(destination)), + Box::new(VersionedLocation::V4(beneficiary)), + Box::new(VersionedAssets::V4(assets)), + 0, + WeightLimit::Unlimited, + )); + + // BOB's balance decreased + assert_eq!(parachain::Balances::free_balance(&BOB), 25 * CENTS); + }); + + Relay::execute_with(|| { + // ALICE's balance increases + assert_eq!( + relay_chain::Balances::free_balance(&ALICE), + INITIAL_BALANCE - 50 * CENTS + 25 * CENTS + ); + + // The funds in the parachain's sovereign account decrease. + let parachain: Location = Parachain(2222).into(); + let parachains_sovereign_account = + relay_chain::LocationToAccountId::convert_location(¶chain).unwrap(); + assert_eq!(relay_chain::Balances::free_balance(parachains_sovereign_account), 25 * CENTS); + }); +} diff --git a/polkadot/xcm/docs/src/fundamentals.rs b/polkadot/xcm/docs/src/fundamentals.rs new file mode 100644 index 0000000000000000000000000000000000000000..28899df801aa4f533cdfedaea8815804dc8bd7c2 --- /dev/null +++ b/polkadot/xcm/docs/src/fundamentals.rs @@ -0,0 +1,177 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # XCM Fundamentals +//! +//! XCM standardizes usual actions users take in consensus systems, for example +//! dealing with assets locally, on other chains, and locking them. +//! XCM programs can both be executed locally or sent to a different consensus system. +//! Examples of consensus systems are blockchains and smart contracts. +//! +//! The goal of XCM is to allow multi-chain ecosystems to thrive via specialization. +//! Very specific functionalities can be abstracted away and standardized in this common language. +//! Then, every member of the ecosystem can implement the subset of the language that makes sense +//! for them. +//! +//! The language evolves over time to accomodate the needs of the community +//! via the [RFC process](https://github.com/paritytech/xcm-format/blob/master/proposals/0032-process.md). +//! +//! XCM is the language, it deals with interpreting and executing programs. +//! It does not deal with actually **sending** these programs from one consensus system to another. +//! This responsibility falls to a transport protocol. +//! XCM can even be interpreted on the local system, with no need of a transport protocol. +//! However, automatic and composable workflows can be achieved via the use of one. +//! +//! At the core of XCM lies the XCVM, the Cross-Consensus Virtual Machine. +//! It's the virtual machine that executes XCM programs. +//! It is a specification that comes with the language. +//! +//! For these docs, we'll use a Rust implementation of XCM and the XCVM, consisting of the following +//! parts: +//! - [`XCM`](xcm): Holds the definition of an XCM program, the instructions and main concepts. +//! - [`Executor`](xcm_executor): Implements the XCVM, capable of executing XCMs. Highly +//! configurable. +//! - [`Builder`](xcm_builder): A collection of types used to configure the executor. +//! - [`XCM Pallet`](pallet_xcm): A FRAME pallet for interacting with the executor. +//! - [`Simulator`](xcm_simulator): A playground to tinker with different XCM programs and executor +//! configurations. +//! +//! XCM programs are composed of Instructions, which reference Locations and Assets. +//! +//! ## Locations +//! +//! Locations are XCM's vocabulary of places we want to talk about in our XCM programs. +//! They are used to reference things like 32-byte accounts, governance bodies, smart contracts, +//! blockchains and more. +//! +//! Locations are hierarchical. +//! This means some places in consensus are wholly encapsulated in other places. +//! Say we have two systems A and B. +//! If any change in A's state implies a change in B's state, then we say A is interior to B. +#![doc = simple_mermaid::mermaid!("../mermaid/location_hierarchy.mmd")] +//! +//! Parachains are interior to their Relay Chain, since a change in their state implies a change in +//! the Relay Chain's state. +//! +//! Because of this hierarchy, the way we represent locations is with both a number of **parents**, +//! times we move __up__ the hierarchy, and a sequence of **junctions**, the steps we take __down__ +//! the hierarchy after going up the specified number of parents. +//! +//! In Rust, this is specified with the following datatype: +//! ```ignore +//! pub struct Location { +//! parents: u8, +//! interior: Junctions, +//! } +//! ``` +//! +//! Many junctions are available; parachains, pallets, 32 and 20 byte accounts, governance bodies, +//! and arbitrary indices are the most common. +//! A full list of available junctions can be found in the [format](https://github.com/paritytech/xcm-format#interior-locations--junctions) +//! and [Junction enum](xcm::v4::prelude::Junction). +//! +//! We'll use a file system notation to represent locations, and start with relative locations. +//! In the diagram, the location of parachain 1000 as seen from all other locations is as follows: +//! - From the relaychain: `Parachain(1000)` +//! - From parachain 1000 itself: `Here` +//! - From parachain 2000: `../Parachain(1000)` +//! +//! Relative locations are interpreted by the system that is executing an XCM program, which is the +//! receiver of a message in the case where it's sent. +//! +//! Locations can also be absolute. +//! Keeping in line with our filesystem analogy, we can imagine the root of our filesystem to exist. +//! This would be a location with no parents, that is also the parent of all systems that derive +//! their own consensus, say Polkadot or Ethereum or Bitcoin. +//! Such a location does not exist concretely, but we can still use this definition for it. +//! This is the **universal location**. +//! We need the universal location to be able to describe locations in an absolute way. +#![doc = simple_mermaid::mermaid!("../mermaid/universal_location.mmd")] +//! +//! Here, the absolute location of parachain 1000 would be +//! `GlobalConsensus(Polkadot)/Parachain(1000)`. +//! +//! ## Assets +//! +//! We want to be able to reference assets in our XCM programs, if only to be able to pay for fees. +//! Assets are represented using locations. +//! +//! The native asset of a chain is represented by the location of that chain. +//! For example, DOT is represented by the location of the Polkadot relaychain. +//! If the interpreting chain has its own asset, it would be represented by `Here`. +//! +//! How do we represent other assets? +//! The asset hub system parachain in Polkadot, for example, holds a lot of assets. +//! To represent each of them, it uses the indices we mentioned, and it makes them interior to the +//! assets pallet instance it uses. +//! USDT, an example asset that lives on asset hub, is identified by the location +//! `Parachain(1000)/PalletInstance(53)/GeneralIndex(1984)`, when seen from the Polkadot relaychain. +#![doc = simple_mermaid::mermaid!("../mermaid/usdt_location.mmd")] +//! +//! Asset Hub also has another type of assets called `ForeignAssets`. +//! These assets are identified by the XCM Location to their origin. +//! Two such assets are a Parachain asset, like Moonbeam's GLMR, and KSM, from the cousin Kusama +//! network. These are represented as `../Parachain(2004)/PalletInstance(10)` and +//! `../../GlobalConsensus(Kusama)` respectively. +//! +//! The whole type can be seen in the [format](https://github.com/paritytech/xcm-format#6-universal-asset-identifiers) +//! and [rust docs](xcm::v4::prelude::Asset). +//! +//! ## Instructions +//! +//! Given the vocabulary to talk about both locations -- chains and accounts -- and assets, we now +//! need a way to express what we want the consensus system to do when executing our programs. +//! We need a way of writing our programs. +//! +//! XCM programs are composed of a sequence of instructions. +//! +//! All available instructions can be seen in the [format](https://github.com/paritytech/xcm-format#5-the-xcvm-instruction-set) +//! and the [Instruction enum](xcm::v4::prelude::Instruction). +//! +//! A very simple example is the following: +//! +//! ```ignore +//! let message = Xcm(vec![ +//! TransferAsset { assets, beneficiary }, +//! ]); +//! ``` +//! +//! This instruction is enough to transfer `assets` from the account of the **origin** of a message +//! to the `beneficiary` account. However, because of XCM's generality, fees need to be paid +//! explicitly. This next example sheds more light on this: +//! +//! ```ignore +//! let message = Xcm(vec![ +//! WithdrawAsset(assets), +//! BuyExecution { fees: assets, weight_limit }, +//! DepositAsset { assets: AssetFilter(Wild(All)), beneficiary }, +//! ]); +//! ``` +//! +//! Here we see the process of transferring assets was broken down into smaller instructions, and we +//! add the explicit fee payment step in the middle. +//! `WithdrawAsset` withdraws assets from the account of the **origin** of the message for usage +//! inside this message's execution. `BuyExecution` explicitly buys execution for this program using +//! the assets specified in `fees`, with a sanity check of `weight_limit`. `DepositAsset` uses a +//! wildcard, specifying all remaining `assets` after subtracting the fees and a `beneficiary` +//! account. +//! +//! ## Next steps +//! +//! Continue with the [guides](crate::guides) for step-by-step tutorials on XCM, +//! or jump to the [cookbook](crate::cookbook) to see examples. +//! +//! The [glossary](crate::glossary) can be useful if some of the terms are confusing. diff --git a/polkadot/xcm/docs/src/glossary.rs b/polkadot/xcm/docs/src/glossary.rs new file mode 100644 index 0000000000000000000000000000000000000000..6035888ab733b2751a4f24d51336132111d6ef57 --- /dev/null +++ b/polkadot/xcm/docs/src/glossary.rs @@ -0,0 +1,123 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # Glossary +//! +//! ## XCM (Cross-Consensus Messaging) +//! +//! A messaging format meant to communicate intentions between consensus systems. +//! XCM could also refer to a single message. +//! +//! ## Instructions +//! +//! XCMs are composed of a sequence of instructions. +//! Each instruction aims to convey a particular intention. +//! There are instructions for transferring and locking assets, handling fees, calling arbitrary +//! blobs, and more. +//! +//! ## Consensus system +//! +//! A system that can reach any kind of consensus. +//! For example, relay chains, parachains, smart contracts. +//! Most messaging between consensus systems has to be done asynchronously, for this, XCM is used. +//! Between two smart contracts on the same parachain, however, communication can be done +//! synchronously. +//! +//! ## [`Location`](xcm::v4::prelude::Location) +//! +//! A way of addressing consensus systems. +//! These could be relative or absolute. +//! +//! ## [`Junction`](xcm::v4::prelude::Junction) +//! +//! The different ways of descending down a [`Location`](xcm::v4::prelude::Location) hierarchy. +//! A junction can be a Parachain, an Account, or more. +//! +//! ## [`Asset`](xcm::v4::prelude::Asset) +//! +//! A way of identifying assets in the same or another consensus system, by using a +//! [`Location`](xcm::v4::prelude::Location). +//! +//! ## Sovereign account +//! +//! An account in a consensus system that is controlled by an account in another consensus system. +//! +//! Runtimes use a converter between a [`Location`](xcm::v4::prelude::Location) and an account. +//! These converters implement the [`ConvertLocation`](xcm_executor::traits::ConvertLocation) trait. +//! +//! ## Teleport +//! +//! A way of transferring assets between two consensus systems without the need of a third party. +//! It consists of the sender system burning the asset that wants to be sent over and the recipient +//! minting an equivalent amount of that asset. It requires a lot of trust between the two systems, +//! since failure to mint or burn will reduce or increase the total issuance of the token. +//! +//! ## Reserve asset transfer +//! +//! A way of transferring assets between two consensus systems that don't trust each other, by using +//! a third system they both trust, called the reserve. The real asset only exists on the reserve, +//! both sender and recipient only deal with derivatives. It consists of the sender burning a +//! certain amount of derivatives, telling the reserve to move real assets from its sovereign +//! account to the destination's sovereign account, and then telling the recipient to mint the right +//! amount of derivatives. +//! In practice, the reserve chain can also be one of the source or destination. +//! +//! ## XCVM +//! +//! The virtual machine behind XCM. +//! Every XCM is an XCVM programme. +//! Holds state in registers. +//! +//! An implementation of the virtual machine is the [`xcm-executor`](xcm_executor::XcmExecutor). +//! +//! ## Holding register +//! +//! An XCVM register used to hold arbitrary `Asset`s during the execution of an XCVM programme. +//! +//! ## Barrier +//! +//! An XCM executor configuration item that works as a firewall for incoming XCMs. +//! All XCMs have to pass the barrier to be executed, else they are dropped. +//! It can be used for whitelisting only certain types or messages or messages from certain senders. +//! +//! Lots of barrier definitions exist in [`xcm-builder`](xcm_builder). +//! +//! ## VMP (Vertical Message Passing) +//! +//! Umbrella term for both UMP (Upward Message Passing) and DMP (Downward Message Passing). +//! +//! The following diagram shows the uses of both protocols: +#![doc = simple_mermaid::mermaid!("../mermaid/transport_protocols.mmd")] +//! +//! ## UMP (Upward Message Passing) +//! +//! Transport-layer protocol that allows parachains to send messages upwards to their relay chain. +//! +//! ## DMP (Downward Message Passing) +//! +//! Transport-layer protocol that allows the relay chain to send messages downwards to one of their +//! parachains. +//! +//! ## XCMP (Cross-Consensus Message Passing) +//! +//! Transport-layer protocol that allows parachains to send messages between themselves, without +//! going through the relay chain. +//! +//! ## HRMP (Horizontal Message Passing) +//! +//! Transport-layer protocol that allows a parachain to send messages to a sibling parachain going +//! through the relay chain. It's a precursor to XCMP, also known as XCMP-lite. +//! It uses a mixture of UMP and DMP. diff --git a/polkadot/xcm/docs/src/guides/mod.rs b/polkadot/xcm/docs/src/guides/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5af89428d9a4c570831c17f48b5974e5ded5fd58 --- /dev/null +++ b/polkadot/xcm/docs/src/guides/mod.rs @@ -0,0 +1,25 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # XCM Guides +//! +//! These guides aim to get you up and running with XCM. +//! +//! Coming soon. +//! +//! ## Next steps +//! +//! Jump to the [cookbook](crate::cookbook) for different examples. diff --git a/polkadot/xcm/docs/src/lib.rs b/polkadot/xcm/docs/src/lib.rs new file mode 100644 index 0000000000000000000000000000000000000000..287c97140c91b371765257475b0d7a3ade2e2f06 --- /dev/null +++ b/polkadot/xcm/docs/src/lib.rs @@ -0,0 +1,63 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! # XCM Docs +//! +//! Documentation and guides for XCM +//! +//! Welcome to the Cross-Consensus Messaging documentation! +//! +//! XCM is a **language** for communicating **intentions** between **consensus systems**. +//! Whether you're a developer, a blockchain enthusiast, or just interested in Polkadot, this guide +//! aims to provide you with an easy-to-understand and comprehensive introduction to XCM. +//! +//! ## Getting started +//! +//! Head over to the [fundamentals](fundamentals) section. +//! Then, go to the [guides](guides), to learn about how to do things with XCM. +//! +//! ## Cookbook +//! +//! There's also the [cookbook](cookbook) for useful recipes for XCM. +//! +//! ## Glossary +//! +//! There's a [glossary](glossary) with common terms used throughout the docs. +//! +//! ## Contribute +//! +//! To contribute to the format, check out the [RFC process](https://github.com/paritytech/xcm-format/blob/master/proposals/0032-process.md). +//! To contribute to these docs, [make a PR](https://github.com/paritytech/polkadot-sdk). +//! +//! ## Why Rust Docs? +//! +//! Rust Docs allow docs to be as close to the source as possible. +//! They're also available offline automatically for anyone who has the `polkadot-sdk` repo locally. +//! +//! ## Docs structure +#![doc = simple_mermaid::mermaid!("../mermaid/structure.mmd")] + +/// Fundamentals of the XCM language. The virtual machine, instructions, locations and assets. +pub mod fundamentals; + +/// Step-by-step guides to set up an XCM environment and start hacking. +pub mod guides; + +/// Useful recipes for programs and configurations. +pub mod cookbook; + +/// Glossary +pub mod glossary; diff --git a/polkadot/xcm/pallet-xcm-benchmarks/Cargo.toml b/polkadot/xcm/pallet-xcm-benchmarks/Cargo.toml index 9691ddd48168e5e8339353a10c475ad263ce5f14..b07bdfdca3d196095a45370a9b2d622dd2a1636a 100644 --- a/polkadot/xcm/pallet-xcm-benchmarks/Cargo.toml +++ b/polkadot/xcm/pallet-xcm-benchmarks/Cargo.toml @@ -13,29 +13,28 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -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 } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor", default-features = false } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false } -xcm = { package = "staging-xcm", path = "..", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../xcm-builder", default-features = false } +codec = { workspace = true } +scale-info = { features = ["derive"], workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-runtime = { workspace = true } +sp-io = { workspace = true } +xcm-executor = { workspace = true } +frame-benchmarking = { workspace = true } +xcm = { workspace = true } +xcm-builder = { workspace = true } log = { workspace = true, default-features = true } [dev-dependencies] -pallet-balances = { path = "../../../substrate/frame/balances" } -pallet-assets = { path = "../../../substrate/frame/assets" } -sp-tracing = { path = "../../../substrate/primitives/tracing" } -xcm = { package = "staging-xcm", path = ".." } +pallet-balances = { workspace = true, default-features = true } +pallet-assets = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +xcm = { workspace = true, default-features = true } # temp -pallet-xcm = { path = "../pallet-xcm" } -polkadot-runtime-common = { path = "../../runtime/common" } +pallet-xcm = { workspace = true, default-features = true } +polkadot-runtime-common = { workspace = true, default-features = true } # westend-runtime = { path = "../../runtime/westend", features = ["runtime-benchmarks"] } -polkadot-primitives = { path = "../../primitives" } +polkadot-primitives = { workspace = true, default-features = true } [features] default = ["std"] @@ -48,7 +47,6 @@ std = [ "scale-info/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", ] diff --git a/polkadot/xcm/pallet-xcm-benchmarks/src/fungible/benchmarking.rs b/polkadot/xcm/pallet-xcm-benchmarks/src/fungible/benchmarking.rs index d99da9184b5d8c7f2680b23140df1083d487b452..6ce49074a6e2b1fa02dd0f1fbe4f90db1058e560 100644 --- a/polkadot/xcm/pallet-xcm-benchmarks/src/fungible/benchmarking.rs +++ b/polkadot/xcm/pallet-xcm-benchmarks/src/fungible/benchmarking.rs @@ -16,6 +16,7 @@ use super::*; use crate::{account_and_location, new_executor, AssetTransactorOf, EnsureDelivery, XcmCallOf}; +use alloc::{vec, vec::Vec}; use frame_benchmarking::{benchmarks_instance_pallet, BenchmarkError, BenchmarkResult}; use frame_support::{ pallet_prelude::Get, @@ -23,7 +24,6 @@ use frame_support::{ weights::Weight, }; use sp_runtime::traits::{Bounded, Zero}; -use sp_std::{prelude::*, vec}; use xcm::latest::{prelude::*, MAX_ITEMS_IN_ASSETS}; use xcm_executor::traits::{ConvertLocation, FeeReason, TransactAsset}; @@ -37,7 +37,7 @@ benchmarks_instance_pallet! { >::Balance as TryInto - >::Error: sp_std::fmt::Debug, + >::Error: core::fmt::Debug, } withdraw_asset { diff --git a/polkadot/xcm/pallet-xcm-benchmarks/src/generic/benchmarking.rs b/polkadot/xcm/pallet-xcm-benchmarks/src/generic/benchmarking.rs index 760b21f93566e12b77a00f2c7b9b744f6db91d68..40a7da58a687c186664404e0a00734b457b60e51 100644 --- a/polkadot/xcm/pallet-xcm-benchmarks/src/generic/benchmarking.rs +++ b/polkadot/xcm/pallet-xcm-benchmarks/src/generic/benchmarking.rs @@ -16,10 +16,10 @@ use super::*; use crate::{account_and_location, new_executor, EnsureDelivery, XcmCallOf}; +use alloc::{vec, vec::Vec}; use codec::Encode; use frame_benchmarking::{benchmarks, BenchmarkError}; use frame_support::{dispatch::GetDispatchInfo, traits::fungible::Inspect}; -use sp_std::{prelude::*, vec}; use xcm::{ latest::{prelude::*, MaxDispatchErrorLen, MaybeErrorCode, Weight, MAX_ITEMS_IN_ASSETS}, DoubleEncoded, diff --git a/polkadot/xcm/pallet-xcm-benchmarks/src/lib.rs b/polkadot/xcm/pallet-xcm-benchmarks/src/lib.rs index a43f27bf47e7242308adc1b53d146508f14e36b2..4a12bb7f47c665ed6f302d5e665cf9c2b0e911a2 100644 --- a/polkadot/xcm/pallet-xcm-benchmarks/src/lib.rs +++ b/polkadot/xcm/pallet-xcm-benchmarks/src/lib.rs @@ -18,9 +18,11 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::vec::Vec; use codec::Encode; use frame_benchmarking::{account, BenchmarkError}; -use sp_std::prelude::*; use xcm::latest::prelude::*; use xcm_builder::EnsureDelivery; use xcm_executor::{traits::ConvertLocation, Config as XcmConfig}; diff --git a/polkadot/xcm/pallet-xcm/Cargo.toml b/polkadot/xcm/pallet-xcm/Cargo.toml index fc4d23426fbcce3f5da855c4bc157b6dd986376d..ed4b441d7c33c347cccda054b8bc7019b3d11388 100644 --- a/polkadot/xcm/pallet-xcm/Cargo.toml +++ b/polkadot/xcm/pallet-xcm/Cargo.toml @@ -10,32 +10,31 @@ license.workspace = true workspace = true [dependencies] -bounded-collections = { version = "0.2.0", default-features = false } -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } +bounded-collections = { workspace = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } serde = { optional = true, features = ["derive"], workspace = true, default-features = true } log = { workspace = true } -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-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 } +frame-support = { workspace = true } +frame-system = { workspace = true } +sp-core = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } -xcm = { package = "staging-xcm", path = "..", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../xcm-builder", default-features = false } -xcm-fee-payment-runtime-api = { path = "../xcm-fee-payment-runtime-api", default-features = false } +xcm = { workspace = true } +xcm-executor = { workspace = true } +xcm-builder = { workspace = true } +xcm-runtime-apis = { workspace = true } # marked optional, used in benchmarking -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false, optional = true } +frame-benchmarking = { optional = true, workspace = true } +pallet-balances = { optional = true, workspace = true } [dev-dependencies] -pallet-assets = { path = "../../../substrate/frame/assets" } -polkadot-runtime-parachains = { path = "../../runtime/parachains" } -polkadot-parachain-primitives = { path = "../../parachain" } +pallet-assets = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } [features] default = ["std"] @@ -52,10 +51,9 @@ std = [ "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "xcm-builder/std", "xcm-executor/std", - "xcm-fee-payment-runtime-api/std", + "xcm-runtime-apis/std", "xcm/std", ] runtime-benchmarks = [ @@ -69,7 +67,7 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", "xcm-builder/runtime-benchmarks", "xcm-executor/runtime-benchmarks", - "xcm-fee-payment-runtime-api/runtime-benchmarks", + "xcm-runtime-apis/runtime-benchmarks", ] try-runtime = [ "frame-support/try-runtime", diff --git a/polkadot/xcm/pallet-xcm/src/benchmarking.rs b/polkadot/xcm/pallet-xcm/src/benchmarking.rs index 081a4235b7794b72beda33895c2e5e5c9577d219..d09c81bf434e2ce843b55fc5b05baee121e562c8 100644 --- a/polkadot/xcm/pallet-xcm/src/benchmarking.rs +++ b/polkadot/xcm/pallet-xcm/src/benchmarking.rs @@ -15,12 +15,10 @@ // along with Polkadot. If not, see . use super::*; -use bounded_collections::{ConstU32, WeakBoundedVec}; use frame_benchmarking::{benchmarks, whitelisted_caller, BenchmarkError, BenchmarkResult}; use frame_support::{assert_ok, weights::Weight}; use frame_system::RawOrigin; -use sp_std::prelude::*; -use xcm::{latest::prelude::*, v2}; +use xcm::latest::prelude::*; use xcm_builder::EnsureDelivery; use xcm_executor::traits::FeeReason; @@ -313,15 +311,17 @@ benchmarks! { } notify_target_migration_fail { - let bad_loc: v2::MultiLocation = v2::Junction::Plurality { - id: v2::BodyId::Named(WeakBoundedVec::>::try_from(vec![0; 32]) - .expect("vec has a length of 32 bits; qed")), - part: v2::BodyPart::Voice, - } - .into(); - let bad_loc = VersionedLocation::from(bad_loc); + let newer_xcm_version = xcm::prelude::XCM_VERSION; + let older_xcm_version = newer_xcm_version - 1; + let bad_location: Location = Plurality { + id: BodyId::Unit, + part: BodyPart::Voice, + }.into(); + let bad_location = VersionedLocation::from(bad_location) + .into_version(older_xcm_version) + .expect("Version convertion should work"); let current_version = T::AdvertisedXcmVersion::get(); - VersionNotifyTargets::::insert(current_version, bad_loc, (0, Weight::zero(), current_version)); + VersionNotifyTargets::::insert(current_version, bad_location, (0, Weight::zero(), current_version)); }: { crate::Pallet::::check_xcm_version_change(VersionMigrationStage::MigrateAndNotifyOldTargets, Weight::zero()); } diff --git a/polkadot/xcm/pallet-xcm/src/lib.rs b/polkadot/xcm/pallet-xcm/src/lib.rs index 37fc121ba2174c95f3a8ac82131d525ff8279f48..6451901279b166e116dd8dcf1d204da74db98d35 100644 --- a/polkadot/xcm/pallet-xcm/src/lib.rs +++ b/polkadot/xcm/pallet-xcm/src/lib.rs @@ -27,9 +27,15 @@ mod tests; pub mod migration; +extern crate alloc; + +use alloc::{boxed::Box, vec, vec::Vec}; use codec::{Decode, Encode, EncodeLike, MaxEncodedLen}; +use core::{marker::PhantomData, result::Result}; use frame_support::{ - dispatch::{DispatchErrorWithPostInfo, GetDispatchInfo, WithPostDispatchInfo}, + dispatch::{ + DispatchErrorWithPostInfo, GetDispatchInfo, PostDispatchInfo, WithPostDispatchInfo, + }, pallet_prelude::*, traits::{ Contains, ContainsPair, Currency, Defensive, EnsureOrigin, Get, LockableCurrency, @@ -47,21 +53,24 @@ use sp_runtime::{ }, Either, RuntimeDebug, }; -use sp_std::{boxed::Box, marker::PhantomData, prelude::*, result::Result, vec}; use xcm::{latest::QueryResponseInfo, prelude::*}; use xcm_builder::{ - ExecuteController, ExecuteControllerWeightInfo, QueryController, QueryControllerWeightInfo, - SendController, SendControllerWeightInfo, + ExecuteController, ExecuteControllerWeightInfo, InspectMessageQueues, QueryController, + QueryControllerWeightInfo, SendController, SendControllerWeightInfo, }; use xcm_executor::{ traits::{ AssetTransferError, CheckSuspension, ClaimAssets, ConvertLocation, ConvertOrigin, DropAssets, MatchesFungible, OnResponse, Properties, QueryHandler, QueryResponseStatus, - TransactAsset, TransferType, VersionChangeNotifier, WeightBounds, XcmAssetTransfers, + RecordXcm, TransactAsset, TransferType, VersionChangeNotifier, WeightBounds, + XcmAssetTransfers, }, AssetsInHolding, }; -use xcm_fee_payment_runtime_api::fees::Error as XcmPaymentApiError; +use xcm_runtime_apis::{ + dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects}, + fees::Error as XcmPaymentApiError, +}; #[cfg(any(feature = "try-runtime", test))] use sp_runtime::TryRuntimeError; @@ -786,7 +795,7 @@ pub mod pallet { #[pallet::genesis_config] pub struct GenesisConfig { #[serde(skip)] - pub _config: sp_std::marker::PhantomData, + pub _config: core::marker::PhantomData, /// The default version to encode outgoing XCM messages with. pub safe_xcm_version: Option, } @@ -1370,7 +1379,7 @@ pub mod pallet { /// - `assets`: The assets to be withdrawn. This should include the assets used to pay the /// fee on the `dest` (and possibly reserve) chains. /// - `assets_transfer_type`: The XCM `TransferType` used to transfer the `assets`. - /// - `remote_fees_id`: One of the included `assets` to be be used to pay fees. + /// - `remote_fees_id`: One of the included `assets` to be used to pay fees. /// - `fees_transfer_type`: The XCM `TransferType` used to transfer the `fees` assets. /// - `custom_xcm_on_dest`: The XCM to be executed on `dest` chain as the last step of the /// transfer, which also determines what happens to the assets on the destination chain. @@ -1432,8 +1441,8 @@ enum FeesHandling { Separate { local_xcm: Xcm<::RuntimeCall>, remote_xcm: Xcm<()> }, } -impl sp_std::fmt::Debug for FeesHandling { - fn fmt(&self, f: &mut sp_std::fmt::Formatter<'_>) -> sp_std::fmt::Result { +impl core::fmt::Debug for FeesHandling { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { Self::Batched { fees } => write!(f, "FeesHandling::Batched({:?})", fees), Self::Separate { local_xcm, remote_xcm } => write!( @@ -1834,8 +1843,8 @@ impl Pallet { FeesHandling::Separate { local_xcm: mut local_fees, remote_xcm: mut remote_fees } => { // fees are handled by separate XCM instructions, prepend fees instructions (for // remote XCM they have to be prepended instead of appended to pass barriers). - sp_std::mem::swap(local, &mut local_fees); - sp_std::mem::swap(remote, &mut remote_fees); + core::mem::swap(local, &mut local_fees); + core::mem::swap(remote, &mut remote_fees); // these are now swapped so fees actually go first local.inner_mut().append(&mut local_fees.into_inner()); remote.inner_mut().append(&mut remote_fees.into_inner()); @@ -2432,6 +2441,100 @@ impl Pallet { AccountIdConversion::::into_account_truncating(&ID) } + /// Dry-runs `call` with the given `origin`. + /// + /// Returns not only the call result and events, but also the local XCM, if any, + /// and any XCMs forwarded to other locations. + /// Meant to be used in the `xcm_runtime_apis::dry_run::DryRunApi` runtime API. + pub fn dry_run_call( + origin: OriginCaller, + call: RuntimeCall, + ) -> Result::RuntimeEvent>, XcmDryRunApiError> + where + Runtime: crate::Config, + Router: InspectMessageQueues, + RuntimeCall: Dispatchable, + ::RuntimeOrigin: From, + { + crate::Pallet::::set_record_xcm(true); + frame_system::Pallet::::reset_events(); // To make sure we only record events from current call. + let result = call.dispatch(origin.into()); + crate::Pallet::::set_record_xcm(false); + let local_xcm = crate::Pallet::::recorded_xcm(); + let forwarded_xcms = Router::get_messages(); + let events: Vec<::RuntimeEvent> = + frame_system::Pallet::::read_events_no_consensus() + .map(|record| record.event.clone()) + .collect(); + Ok(CallDryRunEffects { + local_xcm: local_xcm.map(VersionedXcm::<()>::from), + forwarded_xcms, + emitted_events: events, + execution_result: result, + }) + } + + /// Dry-runs `xcm` with the given `origin_location`. + /// + /// Returns execution result, events, and any forwarded XCMs to other locations. + /// Meant to be used in the `xcm_runtime_apis::dry_run::DryRunApi` runtime API. + pub fn dry_run_xcm( + origin_location: VersionedLocation, + xcm: VersionedXcm, + ) -> Result::RuntimeEvent>, XcmDryRunApiError> + where + Runtime: frame_system::Config, + Router: InspectMessageQueues, + XcmConfig: xcm_executor::Config, + { + let origin_location: Location = origin_location.try_into().map_err(|error| { + log::error!( + target: "xcm::DryRunApi::dry_run_xcm", + "Location version conversion failed with error: {:?}", + error, + ); + XcmDryRunApiError::VersionedConversionFailed + })?; + let xcm: Xcm = xcm.try_into().map_err(|error| { + log::error!( + target: "xcm::DryRunApi::dry_run_xcm", + "Xcm version conversion failed with error {:?}", + error, + ); + XcmDryRunApiError::VersionedConversionFailed + })?; + let mut hash = xcm.using_encoded(sp_io::hashing::blake2_256); + frame_system::Pallet::::reset_events(); // To make sure we only record events from current call. + let result = xcm_executor::XcmExecutor::::prepare_and_execute( + origin_location, + xcm, + &mut hash, + Weight::MAX, // Max limit available for execution. + Weight::zero(), + ); + let forwarded_xcms = Router::get_messages(); + let events: Vec<::RuntimeEvent> = + frame_system::Pallet::::read_events_no_consensus() + .map(|record| record.event.clone()) + .collect(); + Ok(XcmDryRunEffects { forwarded_xcms, emitted_events: events, execution_result: result }) + } + + /// Given a list of asset ids, returns the correct API response for + /// `XcmPaymentApi::query_acceptable_payment_assets`. + /// + /// The assets passed in have to be supported for fee payment. + pub fn query_acceptable_payment_assets( + version: xcm::Version, + asset_ids: Vec, + ) -> Result, XcmPaymentApiError> { + Ok(asset_ids + .into_iter() + .map(|asset_id| VersionedAssetId::from(asset_id)) + .filter_map(|asset_id| asset_id.into_version(version).ok()) + .collect()) + } + pub fn query_xcm_weight(message: VersionedXcm<()>) -> Result { let message = Xcm::<()>::try_from(message) .map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?; @@ -3126,7 +3229,7 @@ impl CheckSuspension for Pallet { } } -impl xcm_executor::traits::RecordXcm for Pallet { +impl RecordXcm for Pallet { fn should_record() -> bool { ShouldRecordXcm::::get() } diff --git a/polkadot/xcm/pallet-xcm/src/migration.rs b/polkadot/xcm/pallet-xcm/src/migration.rs index b157e6b5c3d5f27d206b73a1b040ca5d7944b8f2..0aec97ab410516c35860f397d41ede599768c5c6 100644 --- a/polkadot/xcm/pallet-xcm/src/migration.rs +++ b/polkadot/xcm/pallet-xcm/src/migration.rs @@ -34,7 +34,7 @@ pub mod v1 { /// enacted on-chain. /// /// Use experimental [`MigrateToV1`] instead. - pub struct VersionUncheckedMigrateToV1(sp_std::marker::PhantomData); + pub struct VersionUncheckedMigrateToV1(core::marker::PhantomData); impl UncheckedOnRuntimeUpgrade for VersionUncheckedMigrateToV1 { fn on_runtime_upgrade() -> Weight { let mut weight = T::DbWeight::get().reads(1); @@ -81,7 +81,7 @@ pub mod v1 { /// `XCM_VERSION`. /// /// NOTE: This migration can be permanently added to the runtime migrations. -pub struct MigrateToLatestXcmVersion(sp_std::marker::PhantomData); +pub struct MigrateToLatestXcmVersion(core::marker::PhantomData); impl OnRuntimeUpgrade for MigrateToLatestXcmVersion { fn on_runtime_upgrade() -> Weight { CurrentMigration::::put(VersionMigrationStage::default()); diff --git a/polkadot/xcm/pallet-xcm/src/mock.rs b/polkadot/xcm/pallet-xcm/src/mock.rs index b3b7529217f5a4929ce7beedcc1ffa423227112a..8d0476b0e70d77f7cc1d63033392eb274dbb337c 100644 --- a/polkadot/xcm/pallet-xcm/src/mock.rs +++ b/polkadot/xcm/pallet-xcm/src/mock.rs @@ -15,6 +15,7 @@ // along with Polkadot. If not, see . use codec::Encode; +pub use core::cell::RefCell; use frame_support::{ construct_runtime, derive_impl, parameter_types, traits::{ @@ -28,16 +29,15 @@ use polkadot_parachain_primitives::primitives::Id as ParaId; use polkadot_runtime_parachains::origin; use sp_core::H256; use sp_runtime::{traits::IdentityLookup, AccountId32, BuildStorage}; -pub use sp_std::cell::RefCell; use xcm::prelude::*; use xcm_builder::{ AccountId32Aliases, AllowKnownQueryResponses, AllowSubscriptionsFrom, AllowTopLevelPaidExecutionFrom, Case, ChildParachainAsNative, ChildParachainConvertsVia, ChildSystemParachainAsSuperuser, DescribeAllTerminal, EnsureDecodableXcm, FixedRateOfFungible, FixedWeightBounds, FrameTransactionalProcessor, FungibleAdapter, FungiblesAdapter, - HashedDescription, IsConcrete, MatchedConvertedConcreteId, NoChecking, + HashedDescription, IsConcrete, MatchedConvertedConcreteId, NoChecking, SendXcmFeeToAccount, SignedAccountId32AsNative, SignedToAccountId32, SovereignSignedViaLocation, TakeWeightCredit, - XcmFeeManagerFromComponents, XcmFeeToAccount, + XcmFeeManagerFromComponents, }; use xcm_executor::{ traits::{Identity, JustTry}, @@ -238,10 +238,6 @@ impl SendXcm for TestPaidForPara3000SendXcm { } } -parameter_types! { - pub const BlockHashCount: u64 = 250; -} - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Test { type RuntimeOrigin = RuntimeOrigin; @@ -253,7 +249,6 @@ impl frame_system::Config for Test { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type BlockWeights = (); type BlockLength = (); type Version = (); @@ -271,24 +266,13 @@ impl frame_system::Config for Test { parameter_types! { pub ExistentialDeposit: Balance = 1; - pub const MaxLocks: u32 = 50; - pub const MaxReserves: u32 = 50; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Test { - type MaxLocks = MaxLocks; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } #[cfg(feature = "runtime-benchmarks")] @@ -520,7 +504,7 @@ impl xcm_executor::Config for XcmConfig { type MaxAssetsIntoHolding = MaxAssetsIntoHolding; type FeeManager = XcmFeeManagerFromComponents< EverythingBut, - XcmFeeToAccount, + SendXcmFeeToAccount, >; type MessageExporter = (); type UniversalAliases = Nothing; diff --git a/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs b/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs index f42e220d693203f7fa6e1391676f36a84feb9be0..af81ac9cf43a978f08c4cee86adf4d72cee3a64b 100644 --- a/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs +++ b/polkadot/xcm/pallet-xcm/src/tests/assets_transfer.rs @@ -76,7 +76,7 @@ fn limited_teleport_assets_works() { )] ); let versioned_sent = VersionedXcm::from(sent_xcm().into_iter().next().unwrap().1); - let _check_v2_ok: xcm::v2::Xcm<()> = versioned_sent.try_into().unwrap(); + let _check_v3_ok: xcm::v3::Xcm<()> = versioned_sent.try_into().unwrap(); let mut last_events = last_events(3).into_iter(); assert_eq!( diff --git a/polkadot/xcm/pallet-xcm/src/tests/mod.rs b/polkadot/xcm/pallet-xcm/src/tests/mod.rs index 02aeafd68e83dffd01a7630ce357a4e9cd78cdf1..c16c1a1ba986e5c95da3ce63dd58c52393408464 100644 --- a/polkadot/xcm/pallet-xcm/src/tests/mod.rs +++ b/polkadot/xcm/pallet-xcm/src/tests/mod.rs @@ -602,11 +602,11 @@ fn basic_subscription_works() { let weight = BaseXcmWeight::get(); let mut message = Xcm::<()>(vec![ - // Remote supports XCM v2 + // Remote supports XCM v3 QueryResponse { query_id: 0, max_weight: Weight::zero(), - response: Response::Version(1), + response: Response::Version(3), querier: None, }, ]); @@ -764,14 +764,14 @@ fn subscription_side_upgrades_work_with_notify() { new_test_ext_with_balances(vec![]).execute_with(|| { AdvertisedXcmVersion::set(1); - // An entry from a previous runtime with v2 XCM. - let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into()); - VersionNotifyTargets::::insert(1, v2_location, (70, Weight::zero(), 2)); - let v3_location = Parachain(1003).into_versioned(); - VersionNotifyTargets::::insert(3, v3_location, (72, Weight::zero(), 2)); + // An entry from a previous runtime with v3 XCM. + let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into()); + VersionNotifyTargets::::insert(3, v3_location, (70, Weight::zero(), 3)); + let v4_location = Parachain(1003).into_versioned(); + VersionNotifyTargets::::insert(4, v4_location, (72, Weight::zero(), 3)); // New version. - AdvertisedXcmVersion::set(3); + AdvertisedXcmVersion::set(4); // A runtime upgrade which alters the version does send notifications. CurrentMigration::::put(VersionMigrationStage::default()); @@ -780,13 +780,13 @@ fn subscription_side_upgrades_work_with_notify() { let instr1 = QueryResponse { query_id: 70, max_weight: Weight::zero(), - response: Response::Version(3), + response: Response::Version(4), querier: None, }; let instr3 = QueryResponse { query_id: 72, max_weight: Weight::zero(), - response: Response::Version(3), + response: Response::Version(4), querier: None, }; let mut sent = take_sent_xcm(); @@ -807,8 +807,8 @@ fn subscription_side_upgrades_work_with_notify() { assert_eq!( contents, vec![ - (XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 3)), - (XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 3)), + (XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 4)), + (XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 4)), ] ); }); @@ -817,11 +817,11 @@ fn subscription_side_upgrades_work_with_notify() { #[test] fn subscription_side_upgrades_work_without_notify() { new_test_ext_with_balances(vec![]).execute_with(|| { - // An entry from a previous runtime with v2 XCM. - let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into()); - VersionNotifyTargets::::insert(1, v2_location, (70, Weight::zero(), 2)); - let v3_location = Parachain(1003).into_versioned(); - VersionNotifyTargets::::insert(3, v3_location, (72, Weight::zero(), 2)); + // An entry from a previous runtime with v3 XCM. + let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into()); + VersionNotifyTargets::::insert(3, v3_location, (70, Weight::zero(), 3)); + let v4_location = Parachain(1003).into_versioned(); + VersionNotifyTargets::::insert(4, v4_location, (72, Weight::zero(), 3)); // A runtime upgrade which alters the version does send notifications. CurrentMigration::::put(VersionMigrationStage::default()); @@ -854,11 +854,11 @@ fn subscriber_side_subscription_works() { let weight = BaseXcmWeight::get(); let message = Xcm(vec![ - // Remote supports XCM v2 + // Remote supports XCM v3 QueryResponse { query_id: 0, max_weight: Weight::zero(), - response: Response::Version(1), + response: Response::Version(3), querier: None, }, ]); @@ -872,18 +872,21 @@ fn subscriber_side_subscription_works() { ); assert_eq!(r, Outcome::Complete { used: weight }); assert_eq!(take_sent_xcm(), vec![]); - assert_eq!(XcmPallet::get_version_for(&remote), Some(1)); + assert_eq!(XcmPallet::get_version_for(&remote), Some(3)); - // This message cannot be sent to a v2 remote. - let v2_msg = xcm::v2::Xcm::<()>(vec![xcm::v2::Instruction::Trap(0)]); - assert_eq!(XcmPallet::wrap_version(&remote, v2_msg.clone()), Err(())); + // This message will be sent as v3. + let v4_msg = xcm::v4::Xcm::<()>(vec![xcm::v4::Instruction::Trap(0)]); + assert_eq!( + XcmPallet::wrap_version(&remote, v4_msg.clone()), + Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::Trap(0)]))) + ); let message = Xcm(vec![ - // Remote upgraded to XCM v2 + // Remote upgraded to XCM v4 QueryResponse { query_id: 0, max_weight: Weight::zero(), - response: Response::Version(2), + response: Response::Version(4), querier: None, }, ]); @@ -897,12 +900,12 @@ fn subscriber_side_subscription_works() { ); assert_eq!(r, Outcome::Complete { used: weight }); assert_eq!(take_sent_xcm(), vec![]); - assert_eq!(XcmPallet::get_version_for(&remote), Some(2)); + assert_eq!(XcmPallet::get_version_for(&remote), Some(4)); - // This message can now be sent to remote as it's v2. + // This message is now sent as v4. assert_eq!( - XcmPallet::wrap_version(&remote, v2_msg.clone()), - Ok(VersionedXcm::from(v2_msg)) + XcmPallet::wrap_version(&remote, v4_msg.clone()), + Ok(VersionedXcm::from(v4_msg)) ); }); } @@ -911,30 +914,36 @@ fn subscriber_side_subscription_works() { #[test] fn auto_subscription_works() { new_test_ext_with_balances_and_xcm_version(vec![], None).execute_with(|| { - let remote_v2: Location = Parachain(1000).into(); + let remote_v3: Location = Parachain(1000).into(); let remote_v4: Location = Parachain(1001).into(); - assert_ok!(XcmPallet::force_default_xcm_version(RuntimeOrigin::root(), Some(2))); + assert_ok!(XcmPallet::force_default_xcm_version(RuntimeOrigin::root(), Some(3))); // Wrapping a version for a destination we don't know elicits a subscription. - let msg_v2 = xcm::v2::Xcm::<()>(vec![xcm::v2::Instruction::Trap(0)]); + let msg_v3 = xcm::v3::Xcm::<()>(vec![xcm::v3::Instruction::Trap(0)]); let msg_v4 = xcm::v4::Xcm::<()>(vec![xcm::v4::Instruction::ClearTopic]); assert_eq!( - XcmPallet::wrap_version(&remote_v2, msg_v2.clone()), - Ok(VersionedXcm::from(msg_v2.clone())), + XcmPallet::wrap_version(&remote_v3, msg_v3.clone()), + Ok(VersionedXcm::from(msg_v3.clone())), + ); + assert_eq!( + XcmPallet::wrap_version(&remote_v3, msg_v4.clone()), + Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic]))) ); - assert_eq!(XcmPallet::wrap_version(&remote_v2, msg_v4.clone()), Err(())); - let expected = vec![(remote_v2.clone().into(), 2)]; + let expected = vec![(remote_v3.clone().into(), 2)]; assert_eq!(VersionDiscoveryQueue::::get().into_inner(), expected); assert_eq!( - XcmPallet::wrap_version(&remote_v4, msg_v2.clone()), - Ok(VersionedXcm::from(msg_v2.clone())), + XcmPallet::wrap_version(&remote_v4, msg_v3.clone()), + Ok(VersionedXcm::from(msg_v3.clone())), + ); + assert_eq!( + XcmPallet::wrap_version(&remote_v4, msg_v4.clone()), + Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic]))) ); - assert_eq!(XcmPallet::wrap_version(&remote_v4, msg_v4.clone()), Err(())); - let expected = vec![(remote_v2.clone().into(), 2), (remote_v4.clone().into(), 2)]; + let expected = vec![(remote_v3.clone().into(), 2), (remote_v4.clone().into(), 2)]; assert_eq!(VersionDiscoveryQueue::::get().into_inner(), expected); XcmPallet::on_initialize(1); @@ -968,10 +977,10 @@ fn auto_subscription_works() { ); assert_eq!(r, Outcome::Complete { used: weight }); - // V2 messages can be sent to remote_v4 under XCM v4. + // V3 messages can be sent to remote_v4 under XCM v4. assert_eq!( - XcmPallet::wrap_version(&remote_v4, msg_v2.clone()), - Ok(VersionedXcm::from(msg_v2.clone()).into_version(4).unwrap()), + XcmPallet::wrap_version(&remote_v4, msg_v3.clone()), + Ok(VersionedXcm::from(msg_v3.clone()).into_version(4).unwrap()), ); // This message can now be sent to remote_v4 as it's v4. assert_eq!( @@ -983,26 +992,26 @@ fn auto_subscription_works() { assert_eq!( take_sent_xcm(), vec![( - remote_v2.clone(), + remote_v3.clone(), Xcm(vec![SubscribeVersion { query_id: 1, max_response_weight: Weight::zero() }]), )] ); - // Assume remote_v2 is working ok and XCM version 2. + // Assume remote_v3 is working ok and XCM version 3. let weight = BaseXcmWeight::get(); let message = Xcm(vec![ - // Remote supports XCM v2 + // Remote supports XCM v3 QueryResponse { query_id: 1, max_weight: Weight::zero(), - response: Response::Version(2), + response: Response::Version(3), querier: None, }, ]); let mut hash = fake_message_hash(&message); let r = XcmExecutor::::prepare_and_execute( - remote_v2.clone(), + remote_v3.clone(), message, &mut hash, weight, @@ -1010,12 +1019,15 @@ fn auto_subscription_works() { ); assert_eq!(r, Outcome::Complete { used: weight }); - // v4 messages cannot be sent to remote_v2... + // v4 messages cannot be sent to remote_v3... + assert_eq!( + XcmPallet::wrap_version(&remote_v3, msg_v3.clone()), + Ok(VersionedXcm::V3(msg_v3)) + ); assert_eq!( - XcmPallet::wrap_version(&remote_v2, msg_v2.clone()), - Ok(VersionedXcm::V2(msg_v2)) + XcmPallet::wrap_version(&remote_v3, msg_v4.clone()), + Ok(VersionedXcm::V3(xcm::v3::Xcm(vec![xcm::v3::Instruction::ClearTopic]))) ); - assert_eq!(XcmPallet::wrap_version(&remote_v2, msg_v4.clone()), Err(())); }) } @@ -1025,15 +1037,15 @@ fn subscription_side_upgrades_work_with_multistage_notify() { AdvertisedXcmVersion::set(1); // An entry from a previous runtime with v0 XCM. - let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1001).into()); - VersionNotifyTargets::::insert(1, v2_location, (70, Weight::zero(), 1)); - let v2_location = VersionedLocation::V2(xcm::v2::Junction::Parachain(1002).into()); - VersionNotifyTargets::::insert(2, v2_location, (71, Weight::zero(), 1)); - let v3_location = Parachain(1003).into_versioned(); - VersionNotifyTargets::::insert(3, v3_location, (72, Weight::zero(), 1)); + let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1001).into()); + VersionNotifyTargets::::insert(3, v3_location, (70, Weight::zero(), 3)); + let v3_location = VersionedLocation::V3(xcm::v3::Junction::Parachain(1002).into()); + VersionNotifyTargets::::insert(3, v3_location, (71, Weight::zero(), 3)); + let v4_location = Parachain(1003).into_versioned(); + VersionNotifyTargets::::insert(4, v4_location, (72, Weight::zero(), 3)); // New version. - AdvertisedXcmVersion::set(3); + AdvertisedXcmVersion::set(4); // A runtime upgrade which alters the version does send notifications. CurrentMigration::::put(VersionMigrationStage::default()); @@ -1049,19 +1061,19 @@ fn subscription_side_upgrades_work_with_multistage_notify() { let instr1 = QueryResponse { query_id: 70, max_weight: Weight::zero(), - response: Response::Version(3), + response: Response::Version(4), querier: None, }; let instr2 = QueryResponse { query_id: 71, max_weight: Weight::zero(), - response: Response::Version(3), + response: Response::Version(4), querier: None, }; let instr3 = QueryResponse { query_id: 72, max_weight: Weight::zero(), - response: Response::Version(3), + response: Response::Version(4), querier: None, }; let mut sent = take_sent_xcm(); @@ -1083,9 +1095,9 @@ fn subscription_side_upgrades_work_with_multistage_notify() { assert_eq!( contents, vec![ - (XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 3)), - (XCM_VERSION, Parachain(1002).into_versioned(), (71, Weight::zero(), 3)), - (XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 3)), + (XCM_VERSION, Parachain(1001).into_versioned(), (70, Weight::zero(), 4)), + (XCM_VERSION, Parachain(1002).into_versioned(), (71, Weight::zero(), 4)), + (XCM_VERSION, Parachain(1003).into_versioned(), (72, Weight::zero(), 4)), ] ); }); diff --git a/polkadot/xcm/procedural/Cargo.toml b/polkadot/xcm/procedural/Cargo.toml index ca9fb351bd3cad1f805106e405cfdcc496c9d8a8..83b35d19cf7eee67ef47f9af507d4a61b75fa9dc 100644 --- a/polkadot/xcm/procedural/Cargo.toml +++ b/polkadot/xcm/procedural/Cargo.toml @@ -14,11 +14,13 @@ workspace = true proc-macro = true [dependencies] -proc-macro2 = "1.0.56" +proc-macro2 = { workspace = true } quote = { workspace = true } syn = { workspace = true } -Inflector = "0.11.4" +Inflector = { workspace = true } [dev-dependencies] -trybuild = { version = "1.0.88", features = ["diff"] } -xcm = { package = "staging-xcm", path = ".." } +trybuild = { features = ["diff"], workspace = true } +# NOTE: we have to explicitly specify `std` because of trybuild +# https://github.com/paritytech/polkadot-sdk/pull/5167 +xcm = { workspace = true, default-features = true, features = ["std"] } diff --git a/polkadot/xcm/procedural/src/builder_pattern.rs b/polkadot/xcm/procedural/src/builder_pattern.rs index 0a33d52580fca02166990c72258fa77bcfb21d45..09ead1389d19da15f167793b041b9ef849c0e741 100644 --- a/polkadot/xcm/procedural/src/builder_pattern.rs +++ b/polkadot/xcm/procedural/src/builder_pattern.rs @@ -233,6 +233,32 @@ fn generate_builder_impl(name: &Ident, data_enum: &DataEnum) -> Result = data_enum + .variants + .iter() + .filter(|variant| variant.ident == "ClearOrigin") + .map(|variant| { + let variant_name = &variant.ident; + let method_name_string = &variant_name.to_string().to_snake_case(); + let method_name = syn::Ident::new(method_name_string, variant_name.span()); + let docs = get_doc_comments(variant); + let method = match &variant.fields { + Fields::Unit => { + quote! { + #(#docs)* + pub fn #method_name(mut self) -> XcmBuilder { + self.instructions.push(#name::::#variant_name); + self + } + } + }, + _ => return Err(Error::new_spanned(variant, "ClearOrigin should have no fields")), + }; + Ok(method) + }) + .collect::, _>>()?; + // Then we require fees to be paid let buy_execution_method = data_enum .variants @@ -276,6 +302,7 @@ fn generate_builder_impl(name: &Ident, data_enum: &DataEnum) -> Result XcmBuilder { + #(#allowed_after_load_holding_methods)* #buy_execution_method } }; diff --git a/polkadot/xcm/procedural/tests/builder_pattern.rs b/polkadot/xcm/procedural/tests/builder_pattern.rs index 96b16fb7e4565c2e3e891ccf8ee3ac2bedc68b0b..4202309bf3f71cb6a6a81968ad19eea2cc999515 100644 --- a/polkadot/xcm/procedural/tests/builder_pattern.rs +++ b/polkadot/xcm/procedural/tests/builder_pattern.rs @@ -79,3 +79,24 @@ fn default_builder_requires_buy_execution() { ]) ); } + +#[test] +fn default_builder_allows_clear_origin_before_buy_execution() { + let asset: Asset = (Here, 100u128).into(); + let beneficiary: Location = [0u8; 32].into(); + let message: Xcm<()> = Xcm::builder() + .receive_teleported_asset(asset.clone()) + .clear_origin() + .buy_execution(asset.clone(), Unlimited) + .deposit_asset(asset.clone(), beneficiary.clone()) + .build(); + assert_eq!( + message, + Xcm(vec![ + ReceiveTeleportedAsset(asset.clone().into()), + ClearOrigin, + BuyExecution { fees: asset.clone(), weight_limit: Unlimited }, + DepositAsset { assets: asset.into(), beneficiary }, + ]) + ); +} diff --git a/polkadot/xcm/procedural/tests/conversion_functions.rs b/polkadot/xcm/procedural/tests/conversion_functions.rs index 5b6965167fcd318d3a7b10b3e56deeebf13ba7cb..7d2698d2cd776fe13f03a2a361edd32b552482ea 100644 --- a/polkadot/xcm/procedural/tests/conversion_functions.rs +++ b/polkadot/xcm/procedural/tests/conversion_functions.rs @@ -14,10 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use xcm::v2::prelude::*; +use xcm::v3::prelude::*; #[test] -fn slice_syntax_in_v2_works() { +fn slice_syntax_in_v3_works() { let old_junctions = Junctions::X2(Parachain(1), PalletInstance(1)); let new_junctions = Junctions::from([Parachain(1), PalletInstance(1)]); assert_eq!(old_junctions, new_junctions); diff --git a/polkadot/xcm/src/double_encoded.rs b/polkadot/xcm/src/double_encoded.rs index 320cccf9b1f08dafa58497995a74943233d26c4b..a5eecdee97963530e29a37655ca4d153c6eae5c8 100644 --- a/polkadot/xcm/src/double_encoded.rs +++ b/polkadot/xcm/src/double_encoded.rs @@ -16,7 +16,7 @@ use crate::MAX_XCM_DECODE_DEPTH; use alloc::vec::Vec; -use parity_scale_codec::{Decode, DecodeLimit, Encode}; +use codec::{Decode, DecodeLimit, Encode}; /// Wrapper around the encoded and decoded versions of a value. /// Caches the decoded value once computed. diff --git a/polkadot/xcm/src/lib.rs b/polkadot/xcm/src/lib.rs index 513dfe5501ba6c6ee8c233717c86b7f24f6eeb5f..1f5191c23407d7b88c52f872025583e4f701674d 100644 --- a/polkadot/xcm/src/lib.rs +++ b/polkadot/xcm/src/lib.rs @@ -21,13 +21,18 @@ // // Hence, `no_std` rather than sp-runtime. #![cfg_attr(not(feature = "std"), no_std)] +// Because of XCMv2. +#![allow(deprecated)] extern crate alloc; +use codec::{Decode, DecodeLimit, Encode, Error as CodecError, Input, MaxEncodedLen}; use derivative::Derivative; -use parity_scale_codec::{Decode, DecodeLimit, Encode, Error as CodecError, Input, MaxEncodedLen}; use scale_info::TypeInfo; +#[deprecated( + note = "XCMv2 will be removed once XCMv5 is released. Please use XCMv3 or XCMv4 instead." +)] pub mod v2; pub mod v3; pub mod v4; @@ -425,6 +430,7 @@ pub type VersionedMultiAssets = VersionedAssets; #[scale_info(replace_segment("staging_xcm", "xcm"))] pub enum VersionedXcm { #[codec(index = 2)] + #[deprecated] V2(v2::Xcm), #[codec(index = 3)] V3(v3::Xcm), diff --git a/polkadot/xcm/src/tests.rs b/polkadot/xcm/src/tests.rs index 1aabbcef281d6638b4eabf3c077b5091514d07f0..4c666063f3f4706e77869b7aea5e16000f6dbc1d 100644 --- a/polkadot/xcm/src/tests.rs +++ b/polkadot/xcm/src/tests.rs @@ -158,18 +158,6 @@ fn encode_decode_versioned_multi_assets_v3() { assert_eq!(assets, decoded); } -#[test] -fn encode_decode_versioned_xcm_v2() { - let xcm = VersionedXcm::V2(v2::Xcm::<()>::new()); - let encoded = xcm.encode(); - - assert_eq!(encoded, hex_literal::hex!("0200"), "encode format changed"); - assert_eq!(encoded[0], 2, "bad version number"); - - let decoded = VersionedXcm::decode(&mut &encoded[..]).unwrap(); - assert_eq!(xcm, decoded); -} - #[test] fn encode_decode_versioned_xcm_v3() { let xcm = VersionedXcm::V3(v3::Xcm::<()>::new()); diff --git a/polkadot/xcm/src/v2/junction.rs b/polkadot/xcm/src/v2/junction.rs index 771931f4b566678829ebf07049842bab0232afc2..68a7886f303937870bb42aaee3e1f971a29e7044 100644 --- a/polkadot/xcm/src/v2/junction.rs +++ b/polkadot/xcm/src/v2/junction.rs @@ -19,7 +19,7 @@ use super::{BodyId, BodyPart, Junctions, MultiLocation, NetworkId}; use crate::v3::Junction as NewJunction; use bounded_collections::{ConstU32, WeakBoundedVec}; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; +use codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A single item in a path to describe the relative location of a consensus system. diff --git a/polkadot/xcm/src/v2/mod.rs b/polkadot/xcm/src/v2/mod.rs index 347f3f2c29206222ca546b7d543409da83cbedcf..1afc120f500c65253e462762e2e69e6e3338210a 100644 --- a/polkadot/xcm/src/v2/mod.rs +++ b/polkadot/xcm/src/v2/mod.rs @@ -15,6 +15,9 @@ // along with Cumulus. If not, see . //! # XCM Version 2 +//! +//! WARNING: DEPRECATED, please use version 3 or 4. +//! //! Version 2 of the Cross-Consensus Message format data structures. The comprehensive list of //! changes can be found in //! [this PR description](https://github.com/paritytech/polkadot/pull/3629#issue-968428279). @@ -52,16 +55,19 @@ use super::{ v3::{ BodyId as NewBodyId, BodyPart as NewBodyPart, Instruction as NewInstruction, - NetworkId as NewNetworkId, Response as NewResponse, WeightLimit as NewWeightLimit, - Xcm as NewXcm, + NetworkId as NewNetworkId, OriginKind as NewOriginKind, Response as NewResponse, + WeightLimit as NewWeightLimit, Xcm as NewXcm, }, DoubleEncoded, }; use alloc::{vec, vec::Vec}; use bounded_collections::{ConstU32, WeakBoundedVec}; +use codec::{ + self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput, + MaxEncodedLen, +}; use core::{fmt::Debug, result}; use derivative::Derivative; -use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; mod junction; @@ -104,6 +110,18 @@ pub enum OriginKind { Xcm, } +impl From for OriginKind { + fn from(new: NewOriginKind) -> Self { + use NewOriginKind::*; + match new { + Native => Self::Native, + SovereignAccount => Self::SovereignAccount, + Superuser => Self::Superuser, + Xcm => Self::Xcm, + } + } +} + /// A global identifier of an account-bearing consensus system. #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] #[cfg_attr(feature = "std", derive(serde::Serialize, serde::Deserialize))] @@ -222,7 +240,7 @@ pub enum BodyPart { #[codec(compact)] denom: u32, }, - /// More than than the given proportion of members of the body. + /// More than the given proportion of members of the body. MoreThanProportion { #[codec(compact)] nom: u32, @@ -262,7 +280,8 @@ pub const VERSION: super::Version = 2; /// An identifier for a query. pub type QueryId = u64; -#[derive(Derivative, Default, Encode, Decode, TypeInfo)] +/// DEPRECATED. Please use XCMv3 or XCMv4 instead. +#[derive(Derivative, Default, Encode, TypeInfo)] #[derivative(Clone(bound = ""), Eq(bound = ""), PartialEq(bound = ""), Debug(bound = ""))] #[codec(encode_bound())] #[codec(decode_bound())] @@ -270,6 +289,31 @@ pub type QueryId = u64; #[scale_info(replace_segment("staging_xcm", "xcm"))] pub struct Xcm(pub Vec>); +environmental::environmental!(instructions_count: u8); + +impl Decode for Xcm { + fn decode(input: &mut I) -> core::result::Result { + instructions_count::using_once(&mut 0, || { + let number_of_instructions: u32 = >::decode(input)?.into(); + instructions_count::with(|count| { + *count = count.saturating_add(number_of_instructions as u8); + if *count > MAX_INSTRUCTIONS_TO_DECODE { + return Err(CodecError::from("Max instructions exceeded")) + } + Ok(()) + }) + .unwrap_or(Ok(()))?; + let decoded_instructions = decode_vec_with_len(input, number_of_instructions as usize)?; + Ok(Self(decoded_instructions)) + }) + } +} + +/// The maximal number of instructions in an XCM before decoding fails. +/// +/// This is a deliberate limit - not a technical one. +pub const MAX_INSTRUCTIONS_TO_DECODE: u8 = 100; + impl Xcm { /// Create an empty instance. pub fn new() -> Self { @@ -1065,7 +1109,7 @@ impl TryFrom> for Instruction Self::HrmpChannelClosing { initiator, sender, recipient }, Transact { origin_kind, require_weight_at_most, call } => Self::Transact { - origin_type: origin_kind, + origin_type: origin_kind.into(), require_weight_at_most: require_weight_at_most.ref_time(), call: call.into(), }, @@ -1141,3 +1185,38 @@ impl TryFrom> for Instruction(vec![ClearOrigin; MAX_INSTRUCTIONS_TO_DECODE as usize]); + let encoded = max_xcm.encode(); + assert!(Xcm::<()>::decode(&mut &encoded[..]).is_ok()); + + let big_xcm = Xcm::<()>(vec![ClearOrigin; MAX_INSTRUCTIONS_TO_DECODE as usize + 1]); + let encoded = big_xcm.encode(); + assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err()); + + let nested_xcm = Xcm::<()>(vec![ + DepositReserveAsset { + assets: All.into(), + dest: Here.into(), + xcm: max_xcm, + max_assets: 1, + }; + (MAX_INSTRUCTIONS_TO_DECODE / 2) as usize + ]); + let encoded = nested_xcm.encode(); + assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err()); + + let even_more_nested_xcm = Xcm::<()>(vec![SetAppendix(nested_xcm); 64]); + let encoded = even_more_nested_xcm.encode(); + assert_eq!(encoded.len(), 345730); + // This should not decode since the limit is 100 + assert_eq!(MAX_INSTRUCTIONS_TO_DECODE, 100, "precondition"); + assert!(Xcm::<()>::decode(&mut &encoded[..]).is_err()); + } +} diff --git a/polkadot/xcm/src/v2/multiasset.rs b/polkadot/xcm/src/v2/multiasset.rs index 5681e9ef8a447cfaf67c6e65c75adc1e1337120f..7090ef138ca2d3ef71ec9743722b85d9459bd3dc 100644 --- a/polkadot/xcm/src/v2/multiasset.rs +++ b/polkadot/xcm/src/v2/multiasset.rs @@ -34,8 +34,8 @@ use crate::v3::{ WildMultiAsset as NewWildMultiAsset, }; use alloc::{vec, vec::Vec}; +use codec::{self as codec, Decode, Encode}; use core::cmp::Ordering; -use parity_scale_codec::{self as codec, Decode, Encode}; use scale_info::TypeInfo; /// A general identifier for an instance of a non-fungible asset class. @@ -317,7 +317,7 @@ impl TryFrom for MultiAsset { pub struct MultiAssets(Vec); impl Decode for MultiAssets { - fn decode(input: &mut I) -> Result { + fn decode(input: &mut I) -> Result { Self::from_sorted_and_deduplicated(Vec::::decode(input)?) .map_err(|()| "Out of order".into()) } diff --git a/polkadot/xcm/src/v2/multilocation.rs b/polkadot/xcm/src/v2/multilocation.rs index ac98da8d08c910160a099e92eeef3eacd7e56513..9399ca6619c0d6c2842cfa6ab312936d727d6518 100644 --- a/polkadot/xcm/src/v2/multilocation.rs +++ b/polkadot/xcm/src/v2/multilocation.rs @@ -18,8 +18,8 @@ use super::Junction; use crate::v3::MultiLocation as NewMultiLocation; +use codec::{Decode, Encode, MaxEncodedLen}; use core::{mem, result}; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A relative path between state-bearing consensus systems. @@ -883,7 +883,7 @@ impl TryFrom for Junctions { mod tests { use super::{Ancestor, AncestorThen, Junctions::*, MultiLocation, Parent, ParentThen}; use crate::opaque::v2::{Junction::*, NetworkId::*}; - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; #[test] fn inverted_works() { diff --git a/polkadot/xcm/src/v2/traits.rs b/polkadot/xcm/src/v2/traits.rs index 9cfb9b051ab2a92f3cf0e405795fdd31460b2681..4dcb4c50c68cd7d727588988d32b0f514a15dfb5 100644 --- a/polkadot/xcm/src/v2/traits.rs +++ b/polkadot/xcm/src/v2/traits.rs @@ -17,8 +17,8 @@ //! Cross-Consensus Message format data structures. use crate::v3::Error as NewError; +use codec::{Decode, Encode}; use core::result; -use parity_scale_codec::{Decode, Encode}; use scale_info::TypeInfo; use super::*; @@ -282,7 +282,7 @@ pub type SendResult = result::Result<(), SendError>; /// # Example /// ```rust /// # use staging_xcm::v2::prelude::*; -/// # use parity_scale_codec::Encode; +/// # use codec::Encode; /// /// /// A sender that only passes the message through and does nothing. /// struct Sender1; diff --git a/polkadot/xcm/src/v3/junction.rs b/polkadot/xcm/src/v3/junction.rs index 32ce352c5c02b0a7a3dd31fa02854767cf483efa..24348bf2e67213e9396a3120dfab8816695ba497 100644 --- a/polkadot/xcm/src/v3/junction.rs +++ b/polkadot/xcm/src/v3/junction.rs @@ -26,7 +26,7 @@ use crate::{ VersionedLocation, }; use bounded_collections::{BoundedSlice, BoundedVec, ConstU32}; -use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen}; +use codec::{self, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use serde::{Deserialize, Serialize}; @@ -241,7 +241,7 @@ pub enum BodyPart { #[codec(compact)] denom: u32, }, - /// More than than the given proportion of members of the body. + /// More than the given proportion of members of the body. MoreThanProportion { #[codec(compact)] nom: u32, diff --git a/polkadot/xcm/src/v3/junctions.rs b/polkadot/xcm/src/v3/junctions.rs index 7b014304fdaf7826861ad9e8ea469390bc0513b9..56f5326fe97c6f260d53f66a9bc8ec7b3f169537 100644 --- a/polkadot/xcm/src/v3/junctions.rs +++ b/polkadot/xcm/src/v3/junctions.rs @@ -17,8 +17,8 @@ //! XCM `Junctions`/`InteriorMultiLocation` datatype. use super::{Junction, MultiLocation, NetworkId}; +use codec::{Decode, Encode, MaxEncodedLen}; use core::{mem, result}; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// Maximum number of `Junction`s that a `Junctions` can contain. diff --git a/polkadot/xcm/src/v3/mod.rs b/polkadot/xcm/src/v3/mod.rs index e7c57f414eb786a50f3689a3d3706632bdc4f902..880520cfedc2a82d94d01d936cfc7a00b77ade14 100644 --- a/polkadot/xcm/src/v3/mod.rs +++ b/polkadot/xcm/src/v3/mod.rs @@ -16,25 +16,24 @@ //! Version 3 of the Cross-Consensus Message format data structures. -use super::{ - v2::{ - Instruction as OldInstruction, Response as OldResponse, WeightLimit as OldWeightLimit, - Xcm as OldXcm, - }, - v4::{ - Instruction as NewInstruction, PalletInfo as NewPalletInfo, - QueryResponseInfo as NewQueryResponseInfo, Response as NewResponse, Xcm as NewXcm, - }, +#[allow(deprecated)] +use super::v2::{ + Instruction as OldInstruction, OriginKind as OldOriginKind, Response as OldResponse, + WeightLimit as OldWeightLimit, Xcm as OldXcm, +}; +use super::v4::{ + Instruction as NewInstruction, PalletInfo as NewPalletInfo, + QueryResponseInfo as NewQueryResponseInfo, Response as NewResponse, Xcm as NewXcm, }; use crate::DoubleEncoded; use alloc::{vec, vec::Vec}; use bounded_collections::{parameter_types, BoundedVec}; -use core::{fmt::Debug, result}; -use derivative::Derivative; -use parity_scale_codec::{ +use codec::{ self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput, MaxEncodedLen, }; +use core::{fmt::Debug, result}; +use derivative::Derivative; use scale_info::TypeInfo; mod junction; @@ -53,11 +52,46 @@ pub use multilocation::{ Ancestor, AncestorThen, InteriorMultiLocation, Location, MultiLocation, Parent, ParentThen, }; pub use traits::{ - send_xcm, validate_send, Error, ExecuteXcm, Outcome, PreparedMessage, Result, SendError, - SendResult, SendXcm, Weight, XcmHash, + send_xcm, validate_send, Error, ExecuteXcm, GetWeight, Outcome, PreparedMessage, Result, + SendError, SendResult, SendXcm, Weight, XcmHash, }; -// These parts of XCM v2 are unchanged in XCM v3, and are re-imported here. -pub use super::v2::{GetWeight, OriginKind}; + +/// Basically just the XCM (more general) version of `ParachainDispatchOrigin`. +#[derive(Copy, Clone, Eq, PartialEq, Encode, Decode, Debug, TypeInfo)] +#[scale_info(replace_segment("staging_xcm", "xcm"))] +#[cfg_attr(feature = "json-schema", derive(schemars::JsonSchema))] +pub enum OriginKind { + /// Origin should just be the native dispatch origin representation for the sender in the + /// local runtime framework. For Cumulus/Frame chains this is the `Parachain` or `Relay` origin + /// if coming from a chain, though there may be others if the `MultiLocation` XCM origin has a + /// primary/native dispatch origin form. + Native, + + /// Origin should just be the standard account-based origin with the sovereign account of + /// the sender. For Cumulus/Frame chains, this is the `Signed` origin. + SovereignAccount, + + /// Origin should be the super-user. For Cumulus/Frame chains, this is the `Root` origin. + /// This will not usually be an available option. + Superuser, + + /// Origin should be interpreted as an XCM native origin and the `MultiLocation` should be + /// encoded directly in the dispatch origin unchanged. For Cumulus/Frame chains, this will be + /// the `pallet_xcm::Origin::Xcm` type. + Xcm, +} + +impl From for OriginKind { + fn from(old: OldOriginKind) -> Self { + use OldOriginKind::*; + match old { + Native => Self::Native, + SovereignAccount => Self::SovereignAccount, + Superuser => Self::Superuser, + Xcm => Self::Xcm, + } + } +} /// This module's XCM version. pub const VERSION: super::Version = 3; @@ -1310,6 +1344,7 @@ impl TryFrom for Response { } // Convert from a v2 XCM to a v3 XCM. +#[allow(deprecated)] impl TryFrom> for Xcm { type Error = (); fn try_from(old_xcm: OldXcm) -> result::Result { @@ -1500,7 +1535,7 @@ impl TryFrom> for Instruction { HrmpChannelClosing { initiator, sender, recipient } => Self::HrmpChannelClosing { initiator, sender, recipient }, Transact { origin_type, require_weight_at_most, call } => Self::Transact { - origin_kind: origin_type, + origin_kind: origin_type.into(), require_weight_at_most: Weight::from_parts( require_weight_at_most, DEFAULT_PROOF_SIZE, @@ -1572,118 +1607,6 @@ impl TryFrom> for Instruction { #[cfg(test)] mod tests { use super::{prelude::*, *}; - use crate::v2::{ - Junctions::Here as OldHere, MultiAssetFilter as OldMultiAssetFilter, - WildMultiAsset as OldWildMultiAsset, - }; - - #[test] - fn basic_roundtrip_works() { - let xcm = Xcm::<()>(vec![TransferAsset { - assets: (Here, 1u128).into(), - beneficiary: Here.into(), - }]); - let old_xcm = OldXcm::<()>(vec![OldInstruction::TransferAsset { - assets: (OldHere, 1).into(), - beneficiary: OldHere.into(), - }]); - assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap()); - let new_xcm: Xcm<()> = old_xcm.try_into().unwrap(); - assert_eq!(new_xcm, xcm); - } - - #[test] - fn teleport_roundtrip_works() { - let xcm = Xcm::<()>(vec![ - ReceiveTeleportedAsset((Here, 1u128).into()), - ClearOrigin, - DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() }, - ]); - let old_xcm: OldXcm<()> = OldXcm::<()>(vec![ - OldInstruction::ReceiveTeleportedAsset((OldHere, 1).into()), - OldInstruction::ClearOrigin, - OldInstruction::DepositAsset { - assets: crate::v2::MultiAssetFilter::Wild(crate::v2::WildMultiAsset::All), - max_assets: 1, - beneficiary: OldHere.into(), - }, - ]); - assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap()); - let new_xcm: Xcm<()> = old_xcm.try_into().unwrap(); - assert_eq!(new_xcm, xcm); - } - - #[test] - fn reserve_deposit_roundtrip_works() { - let xcm = Xcm::<()>(vec![ - ReserveAssetDeposited((Here, 1u128).into()), - ClearOrigin, - BuyExecution { - fees: (Here, 1u128).into(), - weight_limit: Some(Weight::from_parts(1, DEFAULT_PROOF_SIZE)).into(), - }, - DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() }, - ]); - let old_xcm = OldXcm::<()>(vec![ - OldInstruction::ReserveAssetDeposited((OldHere, 1).into()), - OldInstruction::ClearOrigin, - OldInstruction::BuyExecution { - fees: (OldHere, 1).into(), - weight_limit: Some(1).into(), - }, - OldInstruction::DepositAsset { - assets: crate::v2::MultiAssetFilter::Wild(crate::v2::WildMultiAsset::All), - max_assets: 1, - beneficiary: OldHere.into(), - }, - ]); - assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap()); - let new_xcm: Xcm<()> = old_xcm.try_into().unwrap(); - assert_eq!(new_xcm, xcm); - } - - #[test] - fn deposit_asset_roundtrip_works() { - let xcm = Xcm::<()>(vec![ - WithdrawAsset((Here, 1u128).into()), - DepositAsset { assets: Wild(AllCounted(1)), beneficiary: Here.into() }, - ]); - let old_xcm = OldXcm::<()>(vec![ - OldInstruction::WithdrawAsset((OldHere, 1).into()), - OldInstruction::DepositAsset { - assets: OldMultiAssetFilter::Wild(OldWildMultiAsset::All), - max_assets: 1, - beneficiary: OldHere.into(), - }, - ]); - assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap()); - let new_xcm: Xcm<()> = old_xcm.try_into().unwrap(); - assert_eq!(new_xcm, xcm); - } - - #[test] - fn deposit_reserve_asset_roundtrip_works() { - let xcm = Xcm::<()>(vec![ - WithdrawAsset((Here, 1u128).into()), - DepositReserveAsset { - assets: Wild(AllCounted(1)), - dest: Here.into(), - xcm: Xcm::<()>(vec![]), - }, - ]); - let old_xcm = OldXcm::<()>(vec![ - OldInstruction::WithdrawAsset((OldHere, 1).into()), - OldInstruction::DepositReserveAsset { - assets: OldMultiAssetFilter::Wild(OldWildMultiAsset::All), - max_assets: 1, - dest: OldHere.into(), - xcm: OldXcm::<()>(vec![]), - }, - ]); - assert_eq!(old_xcm, OldXcm::<()>::try_from(xcm.clone()).unwrap()); - let new_xcm: Xcm<()> = old_xcm.try_into().unwrap(); - assert_eq!(new_xcm, xcm); - } #[test] fn decoding_respects_limit() { diff --git a/polkadot/xcm/src/v3/multiasset.rs b/polkadot/xcm/src/v3/multiasset.rs index 9a67b0e4986caf1a52eaa108e77f9394537d7553..7db0fa7369028f94fe080437299835c7537f0f56 100644 --- a/polkadot/xcm/src/v3/multiasset.rs +++ b/polkadot/xcm/src/v3/multiasset.rs @@ -42,8 +42,8 @@ use crate::{ }; use alloc::{vec, vec::Vec}; use bounded_collections::{BoundedVec, ConstU32}; +use codec::{self as codec, Decode, Encode, MaxEncodedLen}; use core::cmp::Ordering; -use parity_scale_codec::{self as codec, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A general identifier for an instance of a non-fungible asset class. @@ -302,7 +302,7 @@ enum UncheckedFungibility { } impl Decode for Fungibility { - fn decode(input: &mut I) -> Result { + fn decode(input: &mut I) -> Result { match UncheckedFungibility::decode(input)? { UncheckedFungibility::Fungible(a) if a != 0 => Ok(Self::Fungible(a)), UncheckedFungibility::NonFungible(i) => Ok(Self::NonFungible(i)), diff --git a/polkadot/xcm/src/v3/multilocation.rs b/polkadot/xcm/src/v3/multilocation.rs index 731e277b29d8897d46406a1c7a8927461bcf889b..e51981204d96ce709991007c91c6a52e133711fe 100644 --- a/polkadot/xcm/src/v3/multilocation.rs +++ b/polkadot/xcm/src/v3/multilocation.rs @@ -20,8 +20,8 @@ use super::{Junction, Junctions}; use crate::{ v2::MultiLocation as OldMultiLocation, v4::Location as NewMultiLocation, VersionedLocation, }; +use codec::{Decode, Encode, MaxEncodedLen}; use core::result; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A relative path between state-bearing consensus systems. @@ -531,7 +531,7 @@ xcm_procedural::impl_conversion_functions_for_multilocation_v3!(); #[cfg(test)] mod tests { use crate::v3::prelude::*; - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; #[test] fn conversion_works() { diff --git a/polkadot/xcm/src/v3/traits.rs b/polkadot/xcm/src/v3/traits.rs index cfe387df1a86c3aa21da69ce37eadb307df1c51b..7fa8824c3568ac0a16571c826648af013da48b26 100644 --- a/polkadot/xcm/src/v3/traits.rs +++ b/polkadot/xcm/src/v3/traits.rs @@ -17,14 +17,19 @@ //! Cross-Consensus Message format data structures. use crate::v2::Error as OldError; +use codec::{Decode, Encode, MaxEncodedLen}; use core::result; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; pub use sp_weights::Weight; use super::*; +// A simple trait to get the weight of some object. +pub trait GetWeight { + fn weight(&self) -> sp_weights::Weight; +} + /// Error codes used in XCM. The first errors codes have explicit indices and are part of the XCM /// format. Those trailing are merely part of the XCM implementation; there is no expectation that /// they will retain the same index over time. @@ -402,7 +407,7 @@ pub type SendResult = result::Result<(T, MultiAssets), SendError>; /// /// # Example /// ```rust -/// # use parity_scale_codec::Encode; +/// # use codec::Encode; /// # use staging_xcm::v3::{prelude::*, Weight}; /// # use staging_xcm::VersionedXcm; /// # use std::convert::Infallible; diff --git a/polkadot/xcm/src/v4/asset.rs b/polkadot/xcm/src/v4/asset.rs index 6b6d200f32febca6ef5cb208bfed95d50724e58b..a081b595adb1b77085dc232034ccc7f961922d1a 100644 --- a/polkadot/xcm/src/v4/asset.rs +++ b/polkadot/xcm/src/v4/asset.rs @@ -34,8 +34,8 @@ use crate::v3::{ }; use alloc::{vec, vec::Vec}; use bounded_collections::{BoundedVec, ConstU32}; +use codec::{self as codec, Decode, Encode, MaxEncodedLen}; use core::cmp::Ordering; -use parity_scale_codec::{self as codec, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A general identifier for an instance of a non-fungible asset class. @@ -274,7 +274,7 @@ enum UncheckedFungibility { } impl Decode for Fungibility { - fn decode(input: &mut I) -> Result { + fn decode(input: &mut I) -> Result { match UncheckedFungibility::decode(input)? { UncheckedFungibility::Fungible(a) if a != 0 => Ok(Self::Fungible(a)), UncheckedFungibility::NonFungible(i) => Ok(Self::NonFungible(i)), @@ -559,7 +559,7 @@ impl MaxEncodedLen for Assets { } impl Decode for Assets { - fn decode(input: &mut I) -> Result { + fn decode(input: &mut I) -> Result { let bounded_instructions = BoundedVec::>::decode(input)?; Self::from_sorted_and_deduplicated(bounded_instructions.into_inner()) diff --git a/polkadot/xcm/src/v4/junction.rs b/polkadot/xcm/src/v4/junction.rs index 3ae97de5e9b83336c10e0c20e865ddbebfef8b50..36fb616d2dc549a05c71531e0ac63cf63c7d78d0 100644 --- a/polkadot/xcm/src/v4/junction.rs +++ b/polkadot/xcm/src/v4/junction.rs @@ -23,7 +23,7 @@ use crate::{ VersionedLocation, }; use bounded_collections::{BoundedSlice, BoundedVec, ConstU32}; -use parity_scale_codec::{self, Decode, Encode, MaxEncodedLen}; +use codec::{self, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use serde::{Deserialize, Serialize}; diff --git a/polkadot/xcm/src/v4/junctions.rs b/polkadot/xcm/src/v4/junctions.rs index 6d1af59e13dcb179399379010d037e1c5a112c3c..e5c54ecb21a5fd61772a011f6a34d359138a30dd 100644 --- a/polkadot/xcm/src/v4/junctions.rs +++ b/polkadot/xcm/src/v4/junctions.rs @@ -18,8 +18,8 @@ use super::{Junction, Location, NetworkId}; use alloc::sync::Arc; +use codec::{Decode, Encode, MaxEncodedLen}; use core::{mem, ops::Range, result}; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// Maximum number of `Junction`s that a `Junctions` can contain. diff --git a/polkadot/xcm/src/v4/location.rs b/polkadot/xcm/src/v4/location.rs index cee76b6894076cc1ba9ddf960b2ad68a0693351e..f2c302495c73d2ebb96c53774c6cd98387242504 100644 --- a/polkadot/xcm/src/v4/location.rs +++ b/polkadot/xcm/src/v4/location.rs @@ -18,8 +18,8 @@ use super::{traits::Reanchorable, Junction, Junctions}; use crate::{v3::MultiLocation as OldLocation, VersionedLocation}; +use codec::{Decode, Encode, MaxEncodedLen}; use core::result; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; /// A relative path between state-bearing consensus systems. @@ -534,12 +534,18 @@ impl From<[u8; 32]> for Location { } } +impl From for Location { + fn from(id: sp_runtime::AccountId32) -> Self { + Junction::AccountId32 { network: None, id: id.into() }.into() + } +} + xcm_procedural::impl_conversion_functions_for_location_v4!(); #[cfg(test)] mod tests { use crate::v4::prelude::*; - use parity_scale_codec::{Decode, Encode}; + use codec::{Decode, Encode}; #[test] fn conversion_works() { diff --git a/polkadot/xcm/src/v4/mod.rs b/polkadot/xcm/src/v4/mod.rs index 77b6d915fcb5fa902e5168e46b38cdb677f98cbf..2a279f989e9b23084925c1484f7f366c08325080 100644 --- a/polkadot/xcm/src/v4/mod.rs +++ b/polkadot/xcm/src/v4/mod.rs @@ -16,7 +16,7 @@ //! Version 4 of the Cross-Consensus Message format data structures. -pub use super::v2::GetWeight; +pub use super::v3::GetWeight; use super::v3::{ Instruction as OldInstruction, PalletInfo as OldPalletInfo, QueryResponseInfo as OldQueryResponseInfo, Response as OldResponse, Xcm as OldXcm, @@ -24,12 +24,12 @@ use super::v3::{ use crate::DoubleEncoded; use alloc::{vec, vec::Vec}; use bounded_collections::{parameter_types, BoundedVec}; -use core::{fmt::Debug, result}; -use derivative::Derivative; -use parity_scale_codec::{ +use codec::{ self, decode_vec_with_len, Compact, Decode, Encode, Error as CodecError, Input as CodecInput, MaxEncodedLen, }; +use core::{fmt::Debug, result}; +use derivative::Derivative; use scale_info::TypeInfo; mod asset; @@ -231,15 +231,15 @@ parameter_types! { #[derive(Clone, Eq, PartialEq, Encode, Decode, Debug, TypeInfo, MaxEncodedLen)] pub struct PalletInfo { #[codec(compact)] - index: u32, - name: BoundedVec, - module_name: BoundedVec, + pub index: u32, + pub name: BoundedVec, + pub module_name: BoundedVec, #[codec(compact)] - major: u32, + pub major: u32, #[codec(compact)] - minor: u32, + pub minor: u32, #[codec(compact)] - patch: u32, + pub patch: u32, } impl TryInto for PalletInfo { diff --git a/polkadot/xcm/src/v4/traits.rs b/polkadot/xcm/src/v4/traits.rs index f6136c76d808f1708bcf5c6c9f8db2e49b15b232..351de92c80edd169cfa1498a76597ef0b976e6ef 100644 --- a/polkadot/xcm/src/v4/traits.rs +++ b/polkadot/xcm/src/v4/traits.rs @@ -17,8 +17,8 @@ //! Cross-Consensus Message format data structures. pub use crate::v3::{Error, Result, SendError, XcmHash}; +use codec::{Decode, Encode}; use core::result; -use parity_scale_codec::{Decode, Encode}; use scale_info::TypeInfo; pub use sp_weights::Weight; @@ -161,7 +161,7 @@ pub type SendResult = result::Result<(T, Assets), SendError>; /// /// # Example /// ```rust -/// # use parity_scale_codec::Encode; +/// # use codec::Encode; /// # use staging_xcm::v4::{prelude::*, Weight}; /// # use staging_xcm::VersionedXcm; /// # use std::convert::Infallible; diff --git a/polkadot/xcm/xcm-builder/Cargo.toml b/polkadot/xcm/xcm-builder/Cargo.toml index 997ca99fb12c831ea63d7dbb199f2c029dabb495..671f0181277ae905a0ab6f3d69bb13f0dc512616 100644 --- a/polkadot/xcm/xcm-builder/Cargo.toml +++ b/polkadot/xcm/xcm-builder/Cargo.toml @@ -10,63 +10,66 @@ version = "7.0.0" workspace = true [dependencies] -impl-trait-for-tuples = "0.2.1" -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive"] } -xcm = { package = "staging-xcm", path = "..", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-weights = { path = "../../../substrate/primitives/weights", default-features = false } -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 } +impl-trait-for-tuples = { workspace = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive"], workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } +sp-arithmetic = { workspace = true } +sp-io = { workspace = true } +sp-runtime = { workspace = true } +sp-weights = { workspace = true } +frame-support = { workspace = true } +frame-system = { workspace = true } +pallet-transaction-payment = { workspace = true } +pallet-asset-conversion = { workspace = true } log = { workspace = true } # Polkadot dependencies -polkadot-parachain-primitives = { path = "../../parachain", default-features = false } +polkadot-parachain-primitives = { workspace = true } [dev-dependencies] -primitive-types = "0.12.1" -pallet-balances = { path = "../../../substrate/frame/balances" } -pallet-xcm = { path = "../pallet-xcm" } -pallet-salary = { path = "../../../substrate/frame/salary" } -pallet-assets = { path = "../../../substrate/frame/assets" } -primitives = { package = "polkadot-primitives", path = "../../primitives" } -polkadot-runtime-parachains = { path = "../../runtime/parachains" } -assert_matches = "1.5.0" -polkadot-test-runtime = { path = "../../runtime/test-runtime" } +sp-core = { workspace = true, default-features = true } +primitive-types = { features = ["codec", "num-traits", "scale-info"], workspace = true } +pallet-balances = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } +pallet-salary = { workspace = true, default-features = true } +pallet-assets = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +assert_matches = { workspace = true } +polkadot-test-runtime = { workspace = true } [features] default = ["std"] runtime-benchmarks = [ "frame-support/runtime-benchmarks", "frame-system/runtime-benchmarks", + "pallet-asset-conversion/runtime-benchmarks", "pallet-assets/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-salary/runtime-benchmarks", "pallet-xcm/runtime-benchmarks", "polkadot-parachain-primitives/runtime-benchmarks", + "polkadot-primitives/runtime-benchmarks", "polkadot-runtime-parachains/runtime-benchmarks", "polkadot-test-runtime/runtime-benchmarks", - "primitives/runtime-benchmarks", "sp-runtime/runtime-benchmarks", "xcm-executor/runtime-benchmarks", ] std = [ + "codec/std", "frame-support/std", "frame-system/std", "log/std", + "pallet-asset-conversion/std", "pallet-transaction-payment/std", - "parity-scale-codec/std", "polkadot-parachain-primitives/std", + "primitive-types/std", "scale-info/std", "sp-arithmetic/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "sp-weights/std", "xcm-executor/std", "xcm/std", diff --git a/polkadot/xcm/xcm-builder/src/asset_conversion.rs b/polkadot/xcm/xcm-builder/src/asset_conversion.rs index 520ce87448ea4f868fbb62130a7da45353d220b6..16ae05c20795e27a9aa6b4d2ec78d47b7665bbb2 100644 --- a/polkadot/xcm/xcm-builder/src/asset_conversion.rs +++ b/polkadot/xcm/xcm-builder/src/asset_conversion.rs @@ -16,9 +16,9 @@ //! Adapters to work with [`frame_support::traits::fungibles`] through XCM. +use core::{marker::PhantomData, result}; use frame_support::traits::{Contains, Get}; use sp_runtime::traits::MaybeEquivalence; -use sp_std::{marker::PhantomData, prelude::*, result}; use xcm::latest::prelude::*; use xcm_executor::traits::{Error as MatchError, MatchesFungibles, MatchesNonFungibles}; diff --git a/polkadot/xcm/xcm-builder/src/asset_exchange/mod.rs b/polkadot/xcm/xcm-builder/src/asset_exchange/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d42a443c9be1d57b3e12747ebde9b8a147d54b09 --- /dev/null +++ b/polkadot/xcm/xcm-builder/src/asset_exchange/mod.rs @@ -0,0 +1,22 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Adapters for the AssetExchanger config item. +//! +//! E.g. types that implement the [`xcm_executor::traits::AssetExchange`] trait. + +mod single_asset_adapter; +pub use single_asset_adapter::SingleAssetExchangeAdapter; diff --git a/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/adapter.rs b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/adapter.rs new file mode 100644 index 0000000000000000000000000000000000000000..fa94ee5f1caaa1fa16a7568086a42edc82aafee1 --- /dev/null +++ b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/adapter.rs @@ -0,0 +1,210 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Single asset exchange adapter. + +extern crate alloc; +use alloc::vec; +use core::marker::PhantomData; +use frame_support::{ensure, traits::tokens::fungibles}; +use pallet_asset_conversion::{QuotePrice, SwapCredit}; +use xcm::prelude::*; +use xcm_executor::{ + traits::{AssetExchange, MatchesFungibles}, + AssetsInHolding, +}; + +/// An adapter from [`pallet_asset_conversion::SwapCredit`] and +/// [`pallet_asset_conversion::QuotePrice`] to [`xcm_executor::traits::AssetExchange`]. +/// +/// This adapter takes just one fungible asset in `give` and allows only one fungible asset in +/// `want`. If you need to handle more assets in either `give` or `want`, then you should use +/// another type that implements [`xcm_executor::traits::AssetExchange`] or build your own. +/// +/// This adapter also only works for fungible assets. +/// +/// `exchange_asset` and `quote_exchange_price` will both return an error if there's +/// more than one asset in `give` or `want`. +pub struct SingleAssetExchangeAdapter( + PhantomData<(AssetConversion, Fungibles, Matcher, AccountId)>, +); +impl AssetExchange + for SingleAssetExchangeAdapter +where + AssetConversion: SwapCredit< + AccountId, + Balance = u128, + AssetKind = Fungibles::AssetId, + Credit = fungibles::Credit, + > + QuotePrice, + Fungibles: fungibles::Balanced, + Matcher: MatchesFungibles, +{ + fn exchange_asset( + _: Option<&Location>, + give: AssetsInHolding, + want: &Assets, + maximal: bool, + ) -> Result { + let mut give_iter = give.fungible_assets_iter(); + let give_asset = give_iter.next().ok_or_else(|| { + log::trace!( + target: "xcm::SingleAssetExchangeAdapter::exchange_asset", + "No fungible asset was in `give`.", + ); + give.clone() + })?; + ensure!(give_iter.next().is_none(), give.clone()); // We only support 1 asset in `give`. + ensure!(give.non_fungible_assets_iter().next().is_none(), give.clone()); // We don't allow non-fungible assets. + ensure!(want.len() == 1, give.clone()); // We only support 1 asset in `want`. + let want_asset = want.get(0).ok_or_else(|| give.clone())?; + let (give_asset_id, give_amount) = + Matcher::matches_fungibles(&give_asset).map_err(|error| { + log::trace!( + target: "xcm::SingleAssetExchangeAdapter::exchange_asset", + "Could not map XCM asset give {:?} to FRAME asset. Error: {:?}", + give_asset, + error, + ); + give.clone() + })?; + let (want_asset_id, want_amount) = + Matcher::matches_fungibles(&want_asset).map_err(|error| { + log::trace!( + target: "xcm::SingleAssetExchangeAdapter::exchange_asset", + "Could not map XCM asset want {:?} to FRAME asset. Error: {:?}", + want_asset, + error, + ); + give.clone() + })?; + + // We have to do this to convert the XCM assets into credit the pool can use. + let swap_asset = give_asset_id.clone().into(); + let credit_in = Fungibles::issue(give_asset_id, give_amount); + + // Do the swap. + let (credit_out, maybe_credit_change) = if maximal { + // If `maximal`, then we swap exactly `credit_in` to get as much of `want_asset_id` as + // we can, with a minimum of `want_amount`. + let credit_out = >::swap_exact_tokens_for_tokens( + vec![swap_asset, want_asset_id], + credit_in, + Some(want_amount), + ) + .map_err(|(credit_in, error)| { + log::error!( + target: "xcm::SingleAssetExchangeAdapter::exchange_asset", + "Could not perform the swap, error: {:?}.", + error + ); + drop(credit_in); + give.clone() + })?; + + // We don't have leftover assets if exchange was maximal. + (credit_out, None) + } else { + // If `minimal`, then we swap as little of `credit_in` as we can to get exactly + // `want_amount` of `want_asset_id`. + let (credit_out, credit_change) = + >::swap_tokens_for_exact_tokens( + vec![swap_asset, want_asset_id], + credit_in, + want_amount, + ) + .map_err(|(credit_in, error)| { + log::error!( + target: "xcm::SingleAssetExchangeAdapter::exchange_asset", + "Could not perform the swap, error: {:?}.", + error + ); + drop(credit_in); + give.clone() + })?; + + (credit_out, Some(credit_change)) + }; + + // We create an `AssetsInHolding` instance by putting in the resulting asset + // of the exchange. + let resulting_asset: Asset = (want_asset.id.clone(), credit_out.peek()).into(); + let mut result: AssetsInHolding = resulting_asset.into(); + + // If we have some leftover assets from the exchange, also put them in the result. + if let Some(credit_change) = maybe_credit_change { + let leftover_asset: Asset = (give_asset.id.clone(), credit_change.peek()).into(); + result.subsume(leftover_asset); + } + + Ok(result.into()) + } + + fn quote_exchange_price(give: &Assets, want: &Assets, maximal: bool) -> Option { + if give.len() != 1 || want.len() != 1 { + return None; + } // We only support 1 asset in `give` or `want`. + let give_asset = give.get(0)?; + let want_asset = want.get(0)?; + // We first match both XCM assets to the asset ID types `AssetConversion` can handle. + let (give_asset_id, give_amount) = Matcher::matches_fungibles(give_asset) + .map_err(|error| { + log::trace!( + target: "xcm::SingleAssetExchangeAdapter::quote_exchange_price", + "Could not map XCM asset {:?} to FRAME asset. Error: {:?}.", + give_asset, + error, + ); + () + }) + .ok()?; + let (want_asset_id, want_amount) = Matcher::matches_fungibles(want_asset) + .map_err(|error| { + log::trace!( + target: "xcm::SingleAssetExchangeAdapter::quote_exchange_price", + "Could not map XCM asset {:?} to FRAME asset. Error: {:?}.", + want_asset, + error, + ); + () + }) + .ok()?; + // We quote the price. + if maximal { + // The amount of `want` resulting from swapping `give`. + let resulting_want = + ::quote_price_exact_tokens_for_tokens( + give_asset_id, + want_asset_id, + give_amount, + true, // Include fee. + )?; + + Some((want_asset.id.clone(), resulting_want).into()) + } else { + // The `give` amount required to obtain `want`. + let necessary_give = + ::quote_price_tokens_for_exact_tokens( + give_asset_id, + want_asset_id, + want_amount, + true, // Include fee. + )?; + + Some((give_asset.id.clone(), necessary_give).into()) + } + } +} diff --git a/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mock.rs b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mock.rs new file mode 100644 index 0000000000000000000000000000000000000000..4d9809e84f8821d120bd9f83e6f48eb24f7aa607 --- /dev/null +++ b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mock.rs @@ -0,0 +1,370 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Mock to test [`SingleAssetExchangeAdapter`]. + +use core::marker::PhantomData; +use frame_support::{ + assert_ok, construct_runtime, derive_impl, ord_parameter_types, parameter_types, + traits::{ + fungible::{self, NativeFromLeft, NativeOrWithId}, + fungibles::Mutate, + tokens::imbalance::ResolveAssetTo, + AsEnsureOriginWithArg, Equals, Everything, Nothing, OriginTrait, PalletInfoAccess, + }, + PalletId, +}; +use sp_core::{ConstU128, ConstU32, Get}; +use sp_runtime::{ + traits::{AccountIdConversion, IdentityLookup, MaybeEquivalence, TryConvert, TryConvertInto}, + BuildStorage, Permill, +}; +use xcm::prelude::*; +use xcm_executor::{traits::ConvertLocation, XcmExecutor}; + +use crate::{FungibleAdapter, IsConcrete, MatchedConvertedConcreteId, StartsWith}; + +pub type Block = frame_system::mocking::MockBlock; +pub type AccountId = u64; +pub type Balance = u128; + +construct_runtime! { + pub struct Runtime { + System: frame_system, + Balances: pallet_balances, + AssetsPallet: pallet_assets::, + PoolAssets: pallet_assets::, + XcmPallet: pallet_xcm, + AssetConversion: pallet_asset_conversion, + } +} + +#[derive_impl(frame_system::config_preludes::TestDefaultConfig)] +impl frame_system::Config for Runtime { + type Block = Block; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type AccountData = pallet_balances::AccountData; +} + +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] +impl pallet_balances::Config for Runtime { + type Balance = Balance; + type AccountStore = System; + type ExistentialDeposit = ConstU128<1>; +} + +pub type TrustBackedAssetsInstance = pallet_assets::Instance1; +pub type PoolAssetsInstance = pallet_assets::Instance2; + +#[derive_impl(pallet_assets::config_preludes::TestDefaultConfig)] +impl pallet_assets::Config for Runtime { + type Currency = Balances; + type Balance = Balance; + type AssetDeposit = ConstU128<1>; + type AssetAccountDeposit = ConstU128<10>; + type MetadataDepositBase = ConstU128<1>; + type MetadataDepositPerByte = ConstU128<1>; + type ApprovalDeposit = ConstU128<1>; + type CreateOrigin = AsEnsureOriginWithArg>; + type ForceOrigin = frame_system::EnsureRoot; + type Freezer = (); + type CallbackHandle = (); +} + +#[derive_impl(pallet_assets::config_preludes::TestDefaultConfig)] +impl pallet_assets::Config for Runtime { + type Currency = Balances; + type Balance = Balance; + type AssetDeposit = ConstU128<1>; + type AssetAccountDeposit = ConstU128<10>; + type MetadataDepositBase = ConstU128<1>; + type MetadataDepositPerByte = ConstU128<1>; + type ApprovalDeposit = ConstU128<1>; + type CreateOrigin = AsEnsureOriginWithArg>; + type ForceOrigin = frame_system::EnsureRoot; + type Freezer = (); + type CallbackHandle = (); +} + +/// Union fungibles implementation for `Assets` and `Balances`. +pub type NativeAndAssets = + fungible::UnionOf, AccountId>; + +parameter_types! { + pub const AssetConversionPalletId: PalletId = PalletId(*b"py/ascon"); + pub const Native: NativeOrWithId = NativeOrWithId::Native; + pub const LiquidityWithdrawalFee: Permill = Permill::from_percent(0); +} + +ord_parameter_types! { + pub const AssetConversionOrigin: AccountId = + AccountIdConversion::::into_account_truncating(&AssetConversionPalletId::get()); +} + +pub type PoolIdToAccountId = pallet_asset_conversion::AccountIdConverter< + AssetConversionPalletId, + (NativeOrWithId, NativeOrWithId), +>; + +impl pallet_asset_conversion::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Balance = Balance; + type HigherPrecisionBalance = sp_core::U256; + type AssetKind = NativeOrWithId; + type Assets = NativeAndAssets; + type PoolId = (Self::AssetKind, Self::AssetKind); + type PoolLocator = pallet_asset_conversion::WithFirstAsset< + Native, + AccountId, + Self::AssetKind, + PoolIdToAccountId, + >; + type PoolAssetId = u32; + type PoolAssets = PoolAssets; + type PoolSetupFee = ConstU128<100>; // Asset class deposit fees are sufficient to prevent spam + type PoolSetupFeeAsset = Native; + type PoolSetupFeeTarget = ResolveAssetTo; + type LiquidityWithdrawalFee = LiquidityWithdrawalFee; + type LPFee = ConstU32<3>; + type PalletId = AssetConversionPalletId; + type MaxSwapPathLength = ConstU32<3>; + type MintMinLiquidity = ConstU128<100>; + type WeightInfo = (); + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = (); +} + +/// We only alias local accounts. +pub type LocationToAccountId = AccountIndex64Aliases; + +parameter_types! { + pub HereLocation: Location = Here.into_location(); + pub WeightPerInstruction: Weight = Weight::from_parts(1, 1); + pub MaxInstructions: u32 = 100; + pub UniversalLocation: InteriorLocation = [GlobalConsensus(Polkadot), Parachain(1000)].into(); + pub TrustBackedAssetsPalletIndex: u8 = ::index() as u8; + pub TrustBackedAssetsPalletLocation: Location = PalletInstance(TrustBackedAssetsPalletIndex::get()).into(); +} + +/// Adapter for the native token. +pub type FungibleTransactor = FungibleAdapter< + // Use this implementation of the `fungible::*` traits. + // `Balances` is the name given to the balances pallet + Balances, + // This transactor deals with the native token. + IsConcrete, + // How to convert an XCM Location into a local account id. + // This is also something that's configured in the XCM executor. + LocationToAccountId, + // The type for account ids, only needed because `fungible` is generic over it. + AccountId, + // Not tracking teleports. + (), +>; + +pub type Weigher = crate::FixedWeightBounds; + +pub struct LocationToAssetId; +impl MaybeEquivalence> for LocationToAssetId { + fn convert(location: &Location) -> Option> { + let pallet_instance = TrustBackedAssetsPalletIndex::get(); + match location.unpack() { + (0, [PalletInstance(instance), GeneralIndex(index)]) + if *instance == pallet_instance => + Some(NativeOrWithId::WithId(*index as u32)), + (0, []) => Some(NativeOrWithId::Native), + _ => None, + } + } + + fn convert_back(asset_id: &NativeOrWithId) -> Option { + let pallet_instance = TrustBackedAssetsPalletIndex::get(); + Some(match asset_id { + NativeOrWithId::WithId(id) => + Location::new(0, [PalletInstance(pallet_instance), GeneralIndex((*id).into())]), + NativeOrWithId::Native => Location::new(0, []), + }) + } +} + +pub type PoolAssetsExchanger = crate::SingleAssetExchangeAdapter< + AssetConversion, + NativeAndAssets, + MatchedConvertedConcreteId< + NativeOrWithId, + Balance, + (StartsWith, Equals), + LocationToAssetId, + TryConvertInto, + >, + AccountId, +>; + +pub struct XcmConfig; +impl xcm_executor::Config for XcmConfig { + type RuntimeCall = RuntimeCall; + type XcmSender = (); + type AssetTransactor = FungibleTransactor; + type OriginConverter = (); + type IsReserve = (); + type IsTeleporter = (); + type UniversalLocation = UniversalLocation; + // This is not safe, you should use `crate::AllowTopLevelPaidExecutionFrom` in a + // production chain + type Barrier = crate::AllowUnpaidExecutionFrom; + type Weigher = Weigher; + type Trader = (); + type ResponseHandler = (); + type AssetTrap = (); + type AssetLocker = (); + type AssetExchanger = PoolAssetsExchanger; + type AssetClaims = (); + type SubscriptionService = (); + type PalletInstancesInfo = (); + type FeeManager = (); + type MaxAssetsIntoHolding = ConstU32<1>; + type MessageExporter = (); + type UniversalAliases = Nothing; + type CallDispatcher = RuntimeCall; + type SafeCallFilter = Everything; + type Aliasers = Nothing; + type TransactionalProcessor = crate::FrameTransactionalProcessor; + type HrmpNewChannelOpenRequestHandler = (); + type HrmpChannelAcceptedHandler = (); + type HrmpChannelClosingHandler = (); + type XcmRecorder = (); +} + +/// Simple converter from a [`Location`] with an [`AccountIndex64`] junction and no parent to a +/// `u64`. +pub struct AccountIndex64Aliases; +impl ConvertLocation for AccountIndex64Aliases { + fn convert_location(location: &Location) -> Option { + let index = match location.unpack() { + (0, [AccountIndex64 { index, network: None }]) => index, + _ => return None, + }; + Some((*index).into()) + } +} + +/// `Convert` implementation to convert from some a `Signed` (system) `Origin` into an +/// `AccountIndex64`. +/// +/// Typically used when configuring `pallet-xcm` in tests to allow `u64` accounts to dispatch an XCM +/// from an `AccountIndex64` origin. +pub struct SignedToAccountIndex64( + PhantomData<(RuntimeOrigin, AccountId, Network)>, +); +impl, Network: Get>> + TryConvert for SignedToAccountIndex64 +where + RuntimeOrigin::PalletsOrigin: From> + + TryInto, Error = RuntimeOrigin::PalletsOrigin>, +{ + fn try_convert(o: RuntimeOrigin) -> Result { + o.try_with_caller(|caller| match caller.try_into() { + Ok(frame_system::RawOrigin::Signed(who)) => + Ok(Junction::AccountIndex64 { network: Network::get(), index: who.into() }.into()), + Ok(other) => Err(other.into()), + Err(other) => Err(other), + }) + } +} + +parameter_types! { + pub const NoNetwork: Option = None; +} + +pub type LocalOriginToLocation = SignedToAccountIndex64; + +impl pallet_xcm::Config for Runtime { + // We turn off sending for these tests + type SendXcmOrigin = crate::EnsureXcmOrigin; + type XcmRouter = (); + // Anyone can execute XCM programs + type ExecuteXcmOrigin = crate::EnsureXcmOrigin; + // We execute any type of program + type XcmExecuteFilter = Everything; + // How we execute programs + type XcmExecutor = XcmExecutor; + // We don't allow teleports + type XcmTeleportFilter = Nothing; + // We don't allow reserve transfers + type XcmReserveTransferFilter = Nothing; + // Same weigher executor uses to weigh XCM programs + type Weigher = Weigher; + // Same universal location + type UniversalLocation = UniversalLocation; + // No version discovery needed + const VERSION_DISCOVERY_QUEUE_SIZE: u32 = 0; + type AdvertisedXcmVersion = frame_support::traits::ConstU32<3>; + type AdminOrigin = frame_system::EnsureRoot; + // No locking + type TrustedLockers = (); + type MaxLockers = frame_support::traits::ConstU32<0>; + type MaxRemoteLockConsumers = frame_support::traits::ConstU32<0>; + type RemoteLockConsumerIdentifier = (); + // How to turn locations into accounts + type SovereignAccountOf = LocationToAccountId; + // A currency to pay for things and its matcher, we are using the relay token + type Currency = Balances; + type CurrencyMatcher = crate::IsConcrete; + // Pallet benchmarks, no need for this recipe + type WeightInfo = pallet_xcm::TestWeightInfo; + // Runtime types + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type RuntimeEvent = RuntimeEvent; +} + +pub const INITIAL_BALANCE: Balance = 1_000_000_000; + +pub fn new_test_ext() -> sp_io::TestExternalities { + let mut t = frame_system::GenesisConfig::::default().build_storage().unwrap(); + + pallet_balances::GenesisConfig:: { + balances: vec![(0, INITIAL_BALANCE), (1, INITIAL_BALANCE), (2, INITIAL_BALANCE)], + } + .assimilate_storage(&mut t) + .unwrap(); + + let owner = 0; + + let mut ext = sp_io::TestExternalities::new(t); + ext.execute_with(|| { + System::set_block_number(1); + assert_ok!(AssetsPallet::force_create(RuntimeOrigin::root(), 1, owner, false, 1,)); + assert_ok!(AssetsPallet::mint_into(1, &owner, INITIAL_BALANCE,)); + assert_ok!(AssetConversion::create_pool( + RuntimeOrigin::signed(owner), + Box::new(NativeOrWithId::Native), + Box::new(NativeOrWithId::WithId(1)), + )); + assert_ok!(AssetConversion::add_liquidity( + RuntimeOrigin::signed(owner), + Box::new(NativeOrWithId::Native), + Box::new(NativeOrWithId::WithId(1)), + 50_000_000, + 100_000_000, + 0, + 0, + owner, + )); + }); + ext +} diff --git a/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mod.rs b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2a47832923f7dadbbac5d2a0d496cdbc380aa7a2 --- /dev/null +++ b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/mod.rs @@ -0,0 +1,25 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! SingleAssetExchangeAdapter. + +mod adapter; +pub use adapter::SingleAssetExchangeAdapter; + +#[cfg(test)] +mod mock; +#[cfg(test)] +mod tests; diff --git a/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/tests.rs b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/tests.rs new file mode 100644 index 0000000000000000000000000000000000000000..83f57f32822f0305409250a3b221ebb5c9101e91 --- /dev/null +++ b/polkadot/xcm/xcm-builder/src/asset_exchange/single_asset_adapter/tests.rs @@ -0,0 +1,233 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Tests for the [`SingleAssetExchangeAdapter`] type. + +use super::mock::*; +use xcm::prelude::*; +use xcm_executor::{traits::AssetExchange, AssetsInHolding}; + +// ========== Happy path ========== + +/// Scenario: +/// Account #3 wants to use the local liquidity pool between two custom assets, +/// 1 and 2. +#[test] +fn maximal_exchange() { + new_test_ext().execute_with(|| { + let assets = PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 10_000_000).into()].into(), + &vec![(Here, 2_000_000).into()].into(), + true, // Maximal + ) + .unwrap(); + let amount = get_amount_from_first_fungible(&assets); + assert_eq!(amount, 4_533_054); + }); +} + +#[test] +fn minimal_exchange() { + new_test_ext().execute_with(|| { + let assets = PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 10_000_000).into()].into(), + &vec![(Here, 2_000_000).into()].into(), + false, // Minimal + ) + .unwrap(); + let (first_amount, second_amount) = get_amount_from_fungibles(&assets); + assert_eq!(first_amount, 2_000_000); + assert_eq!(second_amount, 5_820_795); + }); +} + +#[test] +fn maximal_quote() { + new_test_ext().execute_with(|| { + let assets = quote( + &([PalletInstance(2), GeneralIndex(1)], 10_000_000).into(), + &(Here, 2_000_000).into(), + true, + ) + .unwrap(); + let amount = get_amount_from_first_fungible(&assets.into()); + // The amount of the native token resulting from swapping all `10_000_000` of the custom + // token. + assert_eq!(amount, 4_533_054); + }); +} + +#[test] +fn minimal_quote() { + new_test_ext().execute_with(|| { + let assets = quote( + &([PalletInstance(2), GeneralIndex(1)], 10_000_000).into(), + &(Here, 2_000_000).into(), + false, + ) + .unwrap(); + let amount = get_amount_from_first_fungible(&assets.into()); + // The amount of the custom token needed to get `2_000_000` of the native token. + assert_eq!(amount, 4_179_205); + }); +} + +// ========== Unhappy path ========== + +#[test] +fn no_asset_in_give() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![].into(), + &vec![(Here, 2_000_000).into()].into(), + true + ) + .is_err()); + }); +} + +#[test] +fn more_than_one_asset_in_give() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 1).into(), (Here, 2).into()].into(), + &vec![(Here, 2_000_000).into()].into(), + true + ) + .is_err()); + }); +} + +#[test] +fn no_asset_in_want() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 10_000_000).into()].into(), + &vec![].into(), + true + ) + .is_err()); + }); +} + +#[test] +fn more_than_one_asset_in_want() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 10_000_000).into()].into(), + &vec![(Here, 2_000_000).into(), ([PalletInstance(2), GeneralIndex(1)], 1).into()] + .into(), + true + ) + .is_err()); + }); +} + +#[test] +fn give_asset_does_not_match() { + new_test_ext().execute_with(|| { + let nonexistent_asset_id = 1000; + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(nonexistent_asset_id)], 10_000_000).into()] + .into(), + &vec![(Here, 2_000_000).into()].into(), + true + ) + .is_err()); + }); +} + +#[test] +fn want_asset_does_not_match() { + new_test_ext().execute_with(|| { + let nonexistent_asset_id = 1000; + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![(Here, 2_000_000).into()].into(), + &vec![([PalletInstance(2), GeneralIndex(nonexistent_asset_id)], 10_000_000).into()] + .into(), + true + ) + .is_err()); + }); +} + +#[test] +fn exchange_fails() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + vec![([PalletInstance(2), GeneralIndex(1)], 10_000_000).into()].into(), + // We're asking for too much of the native token... + &vec![(Here, 200_000_000).into()].into(), + false, // Minimal + ) + .is_err()); + }); +} + +#[test] +fn non_fungible_asset_in_give() { + new_test_ext().execute_with(|| { + assert!(PoolAssetsExchanger::exchange_asset( + None, + // Using `u64` here will give us a non-fungible instead of a fungible. + vec![([PalletInstance(2), GeneralIndex(2)], 10_000_000u64).into()].into(), + &vec![(Here, 10_000_000).into()].into(), + false, // Minimal + ) + .is_err()); + }); +} + +// ========== Helper functions ========== + +fn get_amount_from_first_fungible(assets: &AssetsInHolding) -> u128 { + let mut fungibles_iter = assets.fungible_assets_iter(); + let first_fungible = fungibles_iter.next().unwrap(); + let Fungible(amount) = first_fungible.fun else { + unreachable!("Asset should be fungible"); + }; + amount +} + +fn get_amount_from_fungibles(assets: &AssetsInHolding) -> (u128, u128) { + let mut fungibles_iter = assets.fungible_assets_iter(); + let first_fungible = fungibles_iter.next().unwrap(); + let Fungible(first_amount) = first_fungible.fun else { + unreachable!("Asset should be fungible"); + }; + let second_fungible = fungibles_iter.next().unwrap(); + let Fungible(second_amount) = second_fungible.fun else { + unreachable!("Asset should be fungible"); + }; + (first_amount, second_amount) +} + +fn quote(asset_1: &Asset, asset_2: &Asset, maximal: bool) -> Option { + PoolAssetsExchanger::quote_exchange_price( + &asset_1.clone().into(), + &asset_2.clone().into(), + maximal, + ) +} diff --git a/polkadot/xcm/xcm-builder/src/barriers.rs b/polkadot/xcm/xcm-builder/src/barriers.rs index 11e9122f9a121b1b08db7a5aec2fd423d63c98cf..5d95005eb663097b8130cd01640d6dd29a4f2307 100644 --- a/polkadot/xcm/xcm-builder/src/barriers.rs +++ b/polkadot/xcm/xcm-builder/src/barriers.rs @@ -17,12 +17,12 @@ //! Various implementations for `ShouldExecute`. use crate::{CreateMatcher, MatchXcm}; +use core::{cell::Cell, marker::PhantomData, ops::ControlFlow, result::Result}; use frame_support::{ ensure, traits::{Contains, Get, ProcessMessageError}, }; use polkadot_parachain_primitives::primitives::IsSystem; -use sp_std::{cell::Cell, marker::PhantomData, ops::ControlFlow, result::Result}; use xcm::prelude::*; use xcm_executor::traits::{CheckSuspension, OnResponse, Properties, ShouldExecute}; diff --git a/polkadot/xcm/xcm-builder/src/controller.rs b/polkadot/xcm/xcm-builder/src/controller.rs index 04b19eaa587009aa118e7c7d51ce69b159e4d948..d4ce2ca5b353c94b8d4e512236008eae9a6dd28e 100644 --- a/polkadot/xcm/xcm-builder/src/controller.rs +++ b/polkadot/xcm/xcm-builder/src/controller.rs @@ -18,11 +18,11 @@ //! Controller traits defined in this module are high-level traits that will rely on other traits //! from `xcm-executor` to perform their tasks. +use alloc::boxed::Box; use frame_support::{ dispatch::{DispatchErrorWithPostInfo, WithPostDispatchInfo}, pallet_prelude::DispatchError, }; -use sp_std::boxed::Box; use xcm::prelude::*; pub use xcm_executor::traits::QueryHandler; diff --git a/polkadot/xcm/xcm-builder/src/currency_adapter.rs b/polkadot/xcm/xcm-builder/src/currency_adapter.rs index 24261ac06583c4ca284f52071a4ee80afae2a6ec..355d6ad85388cb1709139112384890354eb8da7a 100644 --- a/polkadot/xcm/xcm-builder/src/currency_adapter.rs +++ b/polkadot/xcm/xcm-builder/src/currency_adapter.rs @@ -19,9 +19,9 @@ #![allow(deprecated)] use super::MintLocation; +use core::{marker::PhantomData, result}; use frame_support::traits::{ExistenceRequirement::AllowDeath, Get, WithdrawReasons}; use sp_runtime::traits::CheckedSub; -use sp_std::{marker::PhantomData, result}; use xcm::latest::{Asset, Error as XcmError, Location, Result, XcmContext}; use xcm_executor::{ traits::{ConvertLocation, MatchesFungible, TransactAsset}, @@ -51,7 +51,7 @@ impl From for XcmError { /// /// # Example /// ``` -/// use parity_scale_codec::Decode; +/// use codec::Decode; /// use frame_support::{parameter_types, PalletId}; /// use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput}; /// use xcm::latest::prelude::*; diff --git a/polkadot/xcm/xcm-builder/src/fee_handling.rs b/polkadot/xcm/xcm-builder/src/fee_handling.rs index e114b3601c84a45cc0400114b7aaff2bfdae4bb8..17e9e64e00c9d2aa2cecb73c7355416b2d6ce6ac 100644 --- a/polkadot/xcm/xcm-builder/src/fee_handling.rs +++ b/polkadot/xcm/xcm-builder/src/fee_handling.rs @@ -68,36 +68,20 @@ impl, FeeHandler: HandleFee> FeeManager } } -/// Try to deposit the given fee in the specified account. -/// Burns the fee in case of a failure. -pub fn deposit_or_burn_fee>( - fee: Assets, - context: Option<&XcmContext>, - receiver: AccountId, -) { - let dest = AccountId32 { network: None, id: receiver.into() }.into(); - for asset in fee.into_inner() { - if let Err(e) = AssetTransactor::deposit_asset(&asset, &dest, context) { - log::trace!( - target: "xcm::fees", - "`AssetTransactor::deposit_asset` returned error: {:?}. Burning fee: {:?}. \ - They might be burned.", - e, asset, - ); - } - } -} - /// A `HandleFee` implementation that simply deposits the fees into a specific on-chain /// `ReceiverAccount`. /// /// It reuses the `AssetTransactor` configured on the XCM executor to deposit fee assets. If /// the `AssetTransactor` returns an error while calling `deposit_asset`, then a warning will be /// logged and the fee burned. +#[deprecated( + note = "`XcmFeeToAccount` will be removed in January 2025. Use `SendXcmFeeToAccount` instead." +)] pub struct XcmFeeToAccount( PhantomData<(AssetTransactor, AccountId, ReceiverAccount)>, ); +#[allow(deprecated)] impl< AssetTransactor: TransactAsset, AccountId: Clone + Into<[u8; 32]>, @@ -105,8 +89,49 @@ impl< > HandleFee for XcmFeeToAccount { fn handle_fee(fee: Assets, context: Option<&XcmContext>, _reason: FeeReason) -> Assets { - deposit_or_burn_fee::(fee, context, ReceiverAccount::get()); + let dest = AccountId32 { network: None, id: ReceiverAccount::get().into() }.into(); + deposit_or_burn_fee::(fee, context, dest); + + Assets::new() + } +} + +/// A `HandleFee` implementation that simply deposits the fees into a specific on-chain +/// `ReceiverAccount`. +/// +/// It reuses the `AssetTransactor` configured on the XCM executor to deposit fee assets. If +/// the `AssetTransactor` returns an error while calling `deposit_asset`, then a warning will be +/// logged and the fee burned. +/// +/// `ReceiverAccount` should implement `Get`. +pub struct SendXcmFeeToAccount( + PhantomData<(AssetTransactor, ReceiverAccount)>, +); + +impl> HandleFee + for SendXcmFeeToAccount +{ + fn handle_fee(fee: Assets, context: Option<&XcmContext>, _reason: FeeReason) -> Assets { + deposit_or_burn_fee::(fee, context, ReceiverAccount::get()); Assets::new() } } + +/// Try to deposit the given fee in the specified account. +/// Burns the fee in case of a failure. +pub fn deposit_or_burn_fee( + fee: Assets, + context: Option<&XcmContext>, + dest: Location, +) { + for asset in fee.into_inner() { + if let Err(e) = AssetTransactor::deposit_asset(&asset, &dest, context) { + log::trace!( + target: "xcm::fees", + "`AssetTransactor::deposit_asset` returned error: {e:?}. Burning fee: {asset:?}. \ + They might be burned.", + ); + } + } +} diff --git a/polkadot/xcm/xcm-builder/src/filter_asset_location.rs b/polkadot/xcm/xcm-builder/src/filter_asset_location.rs index d80c5d70deea8c00fbe32af758e8986cc8c6fa7a..16b7be7f3ba98432b75035e99dbc674dc9a26201 100644 --- a/polkadot/xcm/xcm-builder/src/filter_asset_location.rs +++ b/polkadot/xcm/xcm-builder/src/filter_asset_location.rs @@ -17,8 +17,9 @@ //! Various implementations of `ContainsPair` or //! `Contains<(Location, Vec)>`. +use alloc::vec::Vec; +use core::marker::PhantomData; use frame_support::traits::{Contains, ContainsPair, Get}; -use sp_std::{marker::PhantomData, vec::Vec}; use xcm::latest::{Asset, AssetFilter, AssetId, Location, WildAsset}; /// Accepts an asset iff it is a native asset. @@ -44,7 +45,7 @@ impl> ContainsPair for Case /// implementation of the given `Location` and if every asset from `assets` matches at least one of /// the `AssetFilter` instances provided by the `Get` implementation of `AssetFilters`. pub struct LocationWithAssetFilters( - sp_std::marker::PhantomData<(LocationFilter, AssetFilters)>, + core::marker::PhantomData<(LocationFilter, AssetFilters)>, ); impl, AssetFilters: Get>> Contains<(Location, Vec)> for LocationWithAssetFilters @@ -75,7 +76,7 @@ impl, AssetFilters: Get>> pub struct AllAssets; impl Get> for AllAssets { fn get() -> Vec { - sp_std::vec![AssetFilter::Wild(WildAsset::All)] + alloc::vec![AssetFilter::Wild(WildAsset::All)] } } @@ -96,11 +97,11 @@ mod tests { pub AssetYLocation: Location = Location::new(1, [GeneralIndex(2222)]); pub AssetZLocation: Location = Location::new(1, [GeneralIndex(3333)]); - pub OnlyAssetXOrAssetY: sp_std::vec::Vec = sp_std::vec![ + pub OnlyAssetXOrAssetY: alloc::vec::Vec = alloc::vec![ Wild(AllOf { fun: WildFungible, id: AssetId(AssetXLocation::get()) }), Wild(AllOf { fun: WildFungible, id: AssetId(AssetYLocation::get()) }), ]; - pub OnlyAssetZ: sp_std::vec::Vec = sp_std::vec![ + pub OnlyAssetZ: alloc::vec::Vec = alloc::vec![ Wild(AllOf { fun: WildFungible, id: AssetId(AssetZLocation::get()) }) ]; } diff --git a/polkadot/xcm/xcm-builder/src/fungible_adapter.rs b/polkadot/xcm/xcm-builder/src/fungible_adapter.rs index 45a0e2bdca2862c2142f3ecae17ae19ac6ec1839..25a705a39eb73906ca4c7ececfe4526e7450d712 100644 --- a/polkadot/xcm/xcm-builder/src/fungible_adapter.rs +++ b/polkadot/xcm/xcm-builder/src/fungible_adapter.rs @@ -17,6 +17,7 @@ //! Adapters to work with [`frame_support::traits::fungible`] through XCM. use super::MintLocation; +use core::{marker::PhantomData, result}; use frame_support::traits::{ tokens::{ fungible, @@ -27,7 +28,6 @@ use frame_support::traits::{ }, Get, }; -use sp_std::{marker::PhantomData, prelude::*, result}; use xcm::latest::prelude::*; use xcm_executor::{ traits::{ConvertLocation, Error as MatchError, MatchesFungible, TransactAsset}, diff --git a/polkadot/xcm/xcm-builder/src/fungibles_adapter.rs b/polkadot/xcm/xcm-builder/src/fungibles_adapter.rs index 88bbf01d9e1f8c35d2b884be6a0c5a43f24c1073..a259afc6e682565718b86210a746e39928b140ab 100644 --- a/polkadot/xcm/xcm-builder/src/fungibles_adapter.rs +++ b/polkadot/xcm/xcm-builder/src/fungibles_adapter.rs @@ -16,6 +16,7 @@ //! Adapters to work with [`frame_support::traits::fungibles`] through XCM. +use core::{marker::PhantomData, result}; use frame_support::traits::{ tokens::{ fungibles, @@ -26,7 +27,6 @@ use frame_support::traits::{ }, Contains, Get, }; -use sp_std::{marker::PhantomData, prelude::*, result}; use xcm::latest::prelude::*; use xcm_executor::traits::{ConvertLocation, Error as MatchError, MatchesFungibles, TransactAsset}; @@ -101,7 +101,7 @@ impl AssetChecking for NoChecking { /// Implementation of `AssetChecking` which subjects a given set of assets `T` to having their /// teleportations recorded with a `MintLocation::Local`. -pub struct LocalMint(sp_std::marker::PhantomData); +pub struct LocalMint(core::marker::PhantomData); impl> AssetChecking for LocalMint { fn asset_checking(asset: &AssetId) -> Option { match T::contains(asset) { @@ -113,7 +113,7 @@ impl> AssetChecking for LocalMint { /// Implementation of `AssetChecking` which subjects a given set of assets `T` to having their /// teleportations recorded with a `MintLocation::NonLocal`. -pub struct NonLocalMint(sp_std::marker::PhantomData); +pub struct NonLocalMint(core::marker::PhantomData); impl> AssetChecking for NonLocalMint { fn asset_checking(asset: &AssetId) -> Option { match T::contains(asset) { @@ -126,7 +126,7 @@ impl> AssetChecking for NonLocalMint { /// Implementation of `AssetChecking` which subjects a given set of assets `L` to having their /// teleportations recorded with a `MintLocation::Local` and a second set of assets `R` to having /// their teleportations recorded with a `MintLocation::NonLocal`. -pub struct DualMint(sp_std::marker::PhantomData<(L, R)>); +pub struct DualMint(core::marker::PhantomData<(L, R)>); impl, R: Contains> AssetChecking for DualMint { diff --git a/polkadot/xcm/xcm-builder/src/lib.rs b/polkadot/xcm/xcm-builder/src/lib.rs index cc06c298a418d56f6a70d58b5f24bf8ccb14db5d..bec3bdcb05a0b0adeaabc13024be4d657bbdd807 100644 --- a/polkadot/xcm/xcm-builder/src/lib.rs +++ b/polkadot/xcm/xcm-builder/src/lib.rs @@ -20,6 +20,8 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + #[cfg(test)] mod tests; @@ -33,6 +35,9 @@ pub use asset_conversion::{ AsPrefixedGeneralIndex, ConvertedConcreteId, MatchedConvertedConcreteId, }; +mod asset_exchange; +pub use asset_exchange::SingleAssetExchangeAdapter; + mod barriers; pub use barriers::{ AllowExplicitUnpaidExecutionFrom, AllowHrmpNotificationsFromRelayChain, @@ -54,7 +59,7 @@ pub use currency_adapter::CurrencyAdapter; mod fee_handling; pub use fee_handling::{ - deposit_or_burn_fee, HandleFee, XcmFeeManagerFromComponents, XcmFeeToAccount, + deposit_or_burn_fee, HandleFee, SendXcmFeeToAccount, XcmFeeManagerFromComponents, }; mod filter_asset_location; diff --git a/polkadot/xcm/xcm-builder/src/location_conversion.rs b/polkadot/xcm/xcm-builder/src/location_conversion.rs index c9553030817a1a314022efd17dab00eef17cbe3c..1d840e9c0dde45cd2bb47024b713656b91051392 100644 --- a/polkadot/xcm/xcm-builder/src/location_conversion.rs +++ b/polkadot/xcm/xcm-builder/src/location_conversion.rs @@ -15,11 +15,12 @@ // along with Polkadot. If not, see . use crate::universal_exports::ensure_is_remote; +use alloc::vec::Vec; +use codec::{Compact, Decode, Encode}; +use core::marker::PhantomData; use frame_support::traits::Get; -use parity_scale_codec::{Compact, Decode, Encode}; use sp_io::hashing::blake2_256; use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput, TryConvert}; -use sp_std::{marker::PhantomData, prelude::*}; use xcm::latest::prelude::*; use xcm_executor::traits::ConvertLocation; @@ -460,7 +461,9 @@ impl #[cfg(test)] mod tests { use super::*; - use primitives::AccountId; + use alloc::vec; + use polkadot_primitives::AccountId; + pub type ForeignChainAliasAccount = HashedDescription; diff --git a/polkadot/xcm/xcm-builder/src/matches_location.rs b/polkadot/xcm/xcm-builder/src/matches_location.rs index b6c2807e6b29db302e2d1182729c5acb4426b24b..71c5ec1efd6f95cc177e931cd7e774d291f71fc2 100644 --- a/polkadot/xcm/xcm-builder/src/matches_location.rs +++ b/polkadot/xcm/xcm-builder/src/matches_location.rs @@ -17,14 +17,14 @@ //! Various implementations and utilities for matching and filtering `Location` and //! `InteriorLocation` types. +use core::marker::PhantomData; use frame_support::traits::{Contains, Get}; use sp_runtime::traits::MaybeEquivalence; -use sp_std::marker::PhantomData; use xcm::latest::{InteriorLocation, Location, NetworkId}; /// An implementation of `Contains` that checks for `Location` or /// `InteriorLocation` if starts with the provided type `T`. -pub struct StartsWith(sp_std::marker::PhantomData<(T, L)>); +pub struct StartsWith(core::marker::PhantomData<(T, L)>); impl, L: TryInto + Clone> Contains for StartsWith { fn contains(location: &L) -> bool { let latest_location: Location = @@ -42,7 +42,7 @@ impl> Contains for StartsWith { /// An implementation of `Contains` that checks for `Location` or /// `InteriorLocation` if starts with expected `GlobalConsensus(NetworkId)` provided as type /// `T`. -pub struct StartsWithExplicitGlobalConsensus(sp_std::marker::PhantomData); +pub struct StartsWithExplicitGlobalConsensus(core::marker::PhantomData); impl> Contains for StartsWithExplicitGlobalConsensus { fn contains(location: &Location) -> bool { matches!(location.interior().global_consensus(), Ok(requested_network) if requested_network.eq(&T::get())) diff --git a/polkadot/xcm/xcm-builder/src/matches_token.rs b/polkadot/xcm/xcm-builder/src/matches_token.rs index e49fd18f88d806b09614696040fab29ead657ee2..095c50a5a25b006e44fdf3baf7fa911209b6dd5d 100644 --- a/polkadot/xcm/xcm-builder/src/matches_token.rs +++ b/polkadot/xcm/xcm-builder/src/matches_token.rs @@ -16,8 +16,8 @@ //! Various implementations for the `MatchesFungible` trait. +use core::marker::PhantomData; use frame_support::traits::Get; -use sp_std::marker::PhantomData; use xcm::latest::{ Asset, AssetId, AssetInstance, Fungibility::{Fungible, NonFungible}, diff --git a/polkadot/xcm/xcm-builder/src/nonfungible_adapter.rs b/polkadot/xcm/xcm-builder/src/nonfungible_adapter.rs index b69002eafc5b9945c9991a0fd3c981dd3d922338..8e6232ea64d271a9142a07adea573a59f4c17312 100644 --- a/polkadot/xcm/xcm-builder/src/nonfungible_adapter.rs +++ b/polkadot/xcm/xcm-builder/src/nonfungible_adapter.rs @@ -17,11 +17,11 @@ //! Adapters to work with [`frame_support::traits::tokens::nonfungible`] through XCM. use crate::MintLocation; +use core::{marker::PhantomData, result}; use frame_support::{ ensure, traits::{tokens::nonfungible, Get}, }; -use sp_std::{marker::PhantomData, prelude::*, result}; use xcm::latest::prelude::*; use xcm_executor::traits::{ ConvertLocation, Error as MatchError, MatchesNonFungible, TransactAsset, diff --git a/polkadot/xcm/xcm-builder/src/nonfungibles_adapter.rs b/polkadot/xcm/xcm-builder/src/nonfungibles_adapter.rs index 3fce953848ebdaf0021d84a333fdb00c346b5096..b111a05a4f1fc2a9c0559c42f672a9734fd110fe 100644 --- a/polkadot/xcm/xcm-builder/src/nonfungibles_adapter.rs +++ b/polkadot/xcm/xcm-builder/src/nonfungibles_adapter.rs @@ -17,11 +17,11 @@ //! Adapters to work with [`frame_support::traits::tokens::nonfungibles`] through XCM. use crate::{AssetChecking, MintLocation}; +use core::{marker::PhantomData, result}; use frame_support::{ ensure, traits::{tokens::nonfungibles, Get}, }; -use sp_std::{marker::PhantomData, prelude::*, result}; use xcm::latest::prelude::*; use xcm_executor::traits::{ ConvertLocation, Error as MatchError, MatchesNonFungibles, TransactAsset, diff --git a/polkadot/xcm/xcm-builder/src/origin_aliases.rs b/polkadot/xcm/xcm-builder/src/origin_aliases.rs index bbf810463a7c5054b368207774c977a49e3232aa..d568adc3127ce0c83207e04c87a27294f45c34fa 100644 --- a/polkadot/xcm/xcm-builder/src/origin_aliases.rs +++ b/polkadot/xcm/xcm-builder/src/origin_aliases.rs @@ -16,8 +16,8 @@ //! Implementation for `ContainsPair`. +use core::marker::PhantomData; use frame_support::traits::{Contains, ContainsPair}; -use sp_std::marker::PhantomData; use xcm::latest::prelude::*; /// Alias a Foreign `AccountId32` with a local `AccountId32` if the foreign `AccountId32` matches diff --git a/polkadot/xcm/xcm-builder/src/origin_conversion.rs b/polkadot/xcm/xcm-builder/src/origin_conversion.rs index f64b5660f66748458b6eec7cc3eb02625525de14..6e73c0dae7b698e151b67763e03a3f6dc2ea45b8 100644 --- a/polkadot/xcm/xcm-builder/src/origin_conversion.rs +++ b/polkadot/xcm/xcm-builder/src/origin_conversion.rs @@ -16,11 +16,11 @@ //! Various implementations for `ConvertOrigin`. +use core::marker::PhantomData; use frame_support::traits::{EnsureOrigin, Get, GetBacking, OriginTrait}; use frame_system::RawOrigin as SystemRawOrigin; use polkadot_parachain_primitives::primitives::IsSystem; use sp_runtime::traits::TryConvert; -use sp_std::marker::PhantomData; use xcm::latest::{BodyId, BodyPart, Junction, Junctions::*, Location, NetworkId, OriginKind}; use xcm_executor::traits::{ConvertLocation, ConvertOrigin}; diff --git a/polkadot/xcm/xcm-builder/src/pay.rs b/polkadot/xcm/xcm-builder/src/pay.rs index 35b624b041539e3d89fdb98a56d0910d5033417f..978c6870cdaf1e65ffc74adb175fd2e80ba53031 100644 --- a/polkadot/xcm/xcm-builder/src/pay.rs +++ b/polkadot/xcm/xcm-builder/src/pay.rs @@ -16,12 +16,13 @@ //! `PayOverXcm` struct for paying through XCM and getting the status back. +use alloc::vec; +use core::marker::PhantomData; use frame_support::traits::{ tokens::{Pay, PaymentStatus}, Get, }; use sp_runtime::traits::TryConvert; -use sp_std::{marker::PhantomData, vec}; use xcm::{opaque::lts::Weight, prelude::*}; use xcm_executor::traits::{QueryHandler, QueryResponseStatus}; @@ -199,7 +200,7 @@ pub struct LocatableAssetId { /// Adapter `struct` which implements a conversion from any `AssetKind` into a [`LocatableAssetId`] /// value using a fixed `Location` for the `location` field. -pub struct FixedLocation(sp_std::marker::PhantomData); +pub struct FixedLocation(core::marker::PhantomData); impl, AssetKind: Into> TryConvert for FixedLocation { diff --git a/polkadot/xcm/xcm-builder/src/process_xcm_message.rs b/polkadot/xcm/xcm-builder/src/process_xcm_message.rs index 7760274f6e2451f1b5f695884086a31cd36f3209..2e6f8c5fb566166f600bd9d9a7ef20f8a39fae40 100644 --- a/polkadot/xcm/xcm-builder/src/process_xcm_message.rs +++ b/polkadot/xcm/xcm-builder/src/process_xcm_message.rs @@ -16,10 +16,10 @@ //! Implementation of `ProcessMessage` for an `ExecuteXcm` implementation. +use codec::{Decode, FullCodec, MaxEncodedLen}; +use core::{fmt::Debug, marker::PhantomData}; use frame_support::traits::{ProcessMessage, ProcessMessageError}; -use parity_scale_codec::{Decode, FullCodec, MaxEncodedLen}; use scale_info::TypeInfo; -use sp_std::{fmt::Debug, marker::PhantomData}; use sp_weights::{Weight, WeightMeter}; use xcm::prelude::*; @@ -118,13 +118,14 @@ impl< #[cfg(test)] mod tests { use super::*; + use alloc::vec; + use codec::Encode; use frame_support::{ assert_err, assert_ok, traits::{ProcessMessageError, ProcessMessageError::*}, }; - use parity_scale_codec::Encode; use polkadot_test_runtime::*; - use xcm::{v2, v3, VersionedXcm}; + use xcm::{v3, v4, VersionedXcm}; const ORIGIN: Junction = Junction::OnlyChild; /// The processor to use for tests. @@ -134,8 +135,8 @@ mod tests { #[test] fn process_message_trivial_works() { // ClearOrigin works. - assert!(process(v2_xcm(true)).unwrap()); assert!(process(v3_xcm(true)).unwrap()); + assert!(process(v4_xcm(true)).unwrap()); } #[test] @@ -194,7 +195,7 @@ mod tests { #[test] fn process_message_overweight_fails() { - for msg in [v3_xcm(true), v3_xcm(false), v3_xcm(false), v2_xcm(false)] { + for msg in [v4_xcm(true), v4_xcm(false), v4_xcm(false), v3_xcm(false)] { let msg = &msg.encode()[..]; // Errors if we stay below a weight limit of 1000. @@ -216,7 +217,7 @@ mod tests { } } - fn v2_xcm(success: bool) -> VersionedXcm { + fn v3_xcm(success: bool) -> VersionedXcm { let instr = if success { v3::Instruction::::ClearOrigin } else { @@ -225,13 +226,13 @@ mod tests { VersionedXcm::V3(v3::Xcm::(vec![instr])) } - fn v3_xcm(success: bool) -> VersionedXcm { + fn v4_xcm(success: bool) -> VersionedXcm { let instr = if success { - v2::Instruction::::ClearOrigin + v4::Instruction::::ClearOrigin } else { - v2::Instruction::::Trap(1) + v4::Instruction::::Trap(1) }; - VersionedXcm::V2(v2::Xcm::(vec![instr])) + VersionedXcm::V4(v4::Xcm::(vec![instr])) } fn process(msg: VersionedXcm) -> Result { diff --git a/polkadot/xcm/xcm-builder/src/routing.rs b/polkadot/xcm/xcm-builder/src/routing.rs index 5c284aaf1475fce0fba7e5cfa042428ceff8268d..03ef780ef0325c24e4f53b1013e558a3e0d3990b 100644 --- a/polkadot/xcm/xcm-builder/src/routing.rs +++ b/polkadot/xcm/xcm-builder/src/routing.rs @@ -16,9 +16,10 @@ //! Various implementations for `SendXcm`. +use alloc::vec::Vec; +use codec::Encode; +use core::{marker::PhantomData, result::Result}; use frame_system::unique; -use parity_scale_codec::Encode; -use sp_std::{marker::PhantomData, result::Result, vec::Vec}; use xcm::prelude::*; use xcm_executor::{traits::FeeReason, FeesMode}; @@ -173,7 +174,7 @@ impl InspectMessageQueues for Tuple { /// `Inner::Ticket`. Therefore, this router aims to validate at least the passed `message`. /// /// NOTE: For use in mock runtimes which don't have the DMP/UMP/HRMP XCM validations. -pub struct EnsureDecodableXcm(sp_std::marker::PhantomData); +pub struct EnsureDecodableXcm(core::marker::PhantomData); impl SendXcm for EnsureDecodableXcm { type Ticket = Inner::Ticket; diff --git a/polkadot/xcm/xcm-builder/src/test_utils.rs b/polkadot/xcm/xcm-builder/src/test_utils.rs index 3131dece37570ecda2650c9e03ba44e5346b5f43..90afb2c9a3d3e1fefa3db3d0ea81f9e5811d9b01 100644 --- a/polkadot/xcm/xcm-builder/src/test_utils.rs +++ b/polkadot/xcm/xcm-builder/src/test_utils.rs @@ -16,11 +16,11 @@ // Shared test utilities and implementations for the XCM Builder. +use alloc::vec::Vec; use frame_support::{ parameter_types, traits::{Contains, CrateVersion, PalletInfoData, PalletsInfoAccess}, }; -use sp_std::vec::Vec; pub use xcm::latest::{prelude::*, Weight}; use xcm_executor::traits::{ClaimAssets, DropAssets, VersionChangeNotifier}; pub use xcm_executor::{ @@ -109,6 +109,10 @@ impl AssetExchange for TestAssetExchanger { ) -> Result { Ok(want.clone().into()) } + + fn quote_exchange_price(give: &Assets, _want: &Assets, _maximal: bool) -> Option { + Some(give.clone()) + } } pub struct TestPalletsInfo; diff --git a/polkadot/xcm/xcm-builder/src/tests/mock.rs b/polkadot/xcm/xcm-builder/src/tests/mock.rs index f45650ec5404d14780a3bff3d9bbef0d72a57a25..9f42aee87c9fa44b0b73c93b0b4475c009dab26a 100644 --- a/polkadot/xcm/xcm-builder/src/tests/mock.rs +++ b/polkadot/xcm/xcm-builder/src/tests/mock.rs @@ -26,6 +26,12 @@ pub use crate::{ AllowTopLevelPaidExecutionFrom, AllowUnpaidExecutionFrom, FixedRateOfFungible, FixedWeightBounds, TakeWeightCredit, }; +pub use alloc::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; +pub use codec::{Decode, Encode}; +pub use core::{ + cell::{Cell, RefCell}, + fmt::Debug, +}; use frame_support::traits::{ContainsPair, Everything}; pub use frame_support::{ dispatch::{DispatchInfo, DispatchResultWithPostInfo, GetDispatchInfo, PostDispatchInfo}, @@ -33,12 +39,6 @@ pub use frame_support::{ sp_runtime::{traits::Dispatchable, DispatchError, DispatchErrorWithPostInfo}, traits::{Contains, Get, IsInVec}, }; -pub use parity_scale_codec::{Decode, Encode}; -pub use sp_std::{ - cell::{Cell, RefCell}, - collections::{btree_map::BTreeMap, btree_set::BTreeSet}, - fmt::Debug, -}; pub use xcm::latest::{prelude::*, QueryId, Weight}; use xcm_executor::traits::{Properties, QueryHandler, QueryResponseStatus}; pub use xcm_executor::{ @@ -695,6 +695,20 @@ impl AssetExchange for TestAssetExchange { EXCHANGE_ASSETS.with(|l| l.replace(have)); Ok(get) } + + fn quote_exchange_price(give: &Assets, want: &Assets, maximal: bool) -> Option { + let mut have = EXCHANGE_ASSETS.with(|l| l.borrow().clone()); + if !have.contains_assets(want) { + return None; + } + let get = if maximal { + have.saturating_take(give.clone().into()) + } else { + have.saturating_take(want.clone().into()) + }; + let result: Vec = get.fungible_assets_iter().collect(); + Some(result.into()) + } } pub struct SiblingPrefix; diff --git a/polkadot/xcm/xcm-builder/src/tests/mod.rs b/polkadot/xcm/xcm-builder/src/tests/mod.rs index 16ce3d2cf8ffef68d1f218fb1082cee8dc122b4b..379baaf5e37678a712a6ee337993b37bcbc2ecf5 100644 --- a/polkadot/xcm/xcm-builder/src/tests/mod.rs +++ b/polkadot/xcm/xcm-builder/src/tests/mod.rs @@ -15,6 +15,7 @@ // along with Polkadot. If not, see . use super::{test_utils::*, *}; +use alloc::{vec, vec::Vec}; use frame_support::{ assert_err, traits::{ConstU32, ContainsPair, ProcessMessageError}, diff --git a/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs b/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs index 34b204b434d6e3e547a8b1f5ec48d787bb1fded5..18bde3aab485a9660892ab1f5dc7c3de4b508338 100644 --- a/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs +++ b/polkadot/xcm/xcm-builder/src/tests/pay/mock.rs @@ -25,8 +25,8 @@ use frame_support::{ traits::{ConstU32, Everything}, }; use frame_system::{EnsureRoot, EnsureSigned}; +use polkadot_primitives::{AccountIndex, BlakeTwo256, Signature}; use polkadot_test_runtime::SignedExtra; -use primitives::{AccountIndex, BlakeTwo256, Signature}; use sp_runtime::{generic, traits::MaybeEquivalence, AccountId32, BuildStorage}; use xcm_executor::{traits::ConvertLocation, XcmExecutor}; @@ -54,7 +54,6 @@ impl frame_system::Config for Test { type Block = Block; type AccountData = pallet_balances::AccountData; type AccountId = AccountId; - type BlockHashCount = ConstU32<256>; type Lookup = sp_runtime::traits::IdentityLookup; } @@ -300,6 +299,7 @@ pub fn new_test_ext() -> sp_io::TestExternalities { (1, TreasuryAccountId::get(), INITIAL_BALANCE), (100, TreasuryAccountId::get(), INITIAL_BALANCE), ], + next_asset_id: None, } .assimilate_storage(&mut t) .unwrap(); diff --git a/polkadot/xcm/xcm-builder/src/universal_exports.rs b/polkadot/xcm/xcm-builder/src/universal_exports.rs index 04ceb7e51688994b65701419020ffd5fd5bfdcd7..8aa9602fcc297e9a402f7df11188773466b6ac90 100644 --- a/polkadot/xcm/xcm-builder/src/universal_exports.rs +++ b/polkadot/xcm/xcm-builder/src/universal_exports.rs @@ -17,9 +17,10 @@ //! Traits and utilities to help with origin mutation and bridging. use crate::InspectMessageQueues; +use alloc::{vec, vec::Vec}; +use codec::{Decode, Encode}; +use core::{convert::TryInto, marker::PhantomData}; use frame_support::{ensure, traits::Get}; -use parity_scale_codec::{Decode, Encode}; -use sp_std::{convert::TryInto, marker::PhantomData, prelude::*}; use xcm::prelude::*; use xcm_executor::traits::{validate_export, ExportXcm}; use SendError::*; @@ -149,7 +150,7 @@ impl NetworkExportTableItem { /// An adapter for the implementation of `ExporterFor`, which attempts to find the /// `(bridge_location, payment)` for the requested `network` and `remote_location` in the provided /// `T` table containing various exporters. -pub struct NetworkExportTable(sp_std::marker::PhantomData); +pub struct NetworkExportTable(core::marker::PhantomData); impl>> ExporterFor for NetworkExportTable { fn exporter_for( network: &NetworkId, @@ -649,7 +650,7 @@ mod tests { pub PaymentForNetworkAAndParachain2000: Asset = (Location::parent(), 150).into(); - pub BridgeTable: sp_std::vec::Vec = sp_std::vec![ + pub BridgeTable: alloc::vec::Vec = alloc::vec![ // NetworkA allows `Parachain(1000)` as remote location WITHOUT payment. NetworkExportTableItem::new( NetworkA::get(), diff --git a/polkadot/xcm/xcm-builder/src/weight.rs b/polkadot/xcm/xcm-builder/src/weight.rs index 6141b0142eed00fa8fb3a3e834b71fae51cffe86..7861fdcc2e579b54b03fe509956c9a46e3405c2c 100644 --- a/polkadot/xcm/xcm-builder/src/weight.rs +++ b/polkadot/xcm/xcm-builder/src/weight.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use codec::Decode; +use core::{marker::PhantomData, result::Result}; use frame_support::{ dispatch::GetDispatchInfo, traits::{ @@ -25,9 +27,7 @@ use frame_support::{ WeightToFee as WeightToFeeT, }, }; -use parity_scale_codec::Decode; use sp_runtime::traits::{SaturatedConversion, Saturating, Zero}; -use sp_std::{marker::PhantomData, result::Result}; use xcm::latest::{prelude::*, GetWeight, Weight}; use xcm_executor::{ traits::{WeightBounds, WeightTrader}, diff --git a/polkadot/xcm/xcm-builder/tests/mock/mod.rs b/polkadot/xcm/xcm-builder/tests/mock/mod.rs index 45bfba2355630e4e5b40d1bb9e00114c889811a1..0468b0a5410c416a0703502cc38a13dba2a79853 100644 --- a/polkadot/xcm/xcm-builder/tests/mock/mod.rs +++ b/polkadot/xcm/xcm-builder/tests/mock/mod.rs @@ -14,16 +14,16 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use codec::Encode; +use core::cell::RefCell; use frame_support::{ construct_runtime, derive_impl, parameter_types, - traits::{ConstU32, Everything, Nothing}, + traits::{Everything, Nothing}, weights::Weight, }; use frame_system::EnsureRoot; -use parity_scale_codec::Encode; use primitive_types::H256; use sp_runtime::{traits::IdentityLookup, AccountId32, BuildStorage}; -use sp_std::cell::RefCell; use polkadot_parachain_primitives::primitives::Id as ParaId; use polkadot_runtime_parachains::{configuration, origin, shared}; @@ -74,10 +74,6 @@ pub type TestXcmRouter = EnsureDecodableXcm; pub const UNITS: Balance = 1_000_000_000_000; pub const CENTS: Balance = UNITS / 30_000; -parameter_types! { - pub const BlockHashCount: u64 = 250; -} - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for Runtime { type RuntimeOrigin = RuntimeOrigin; @@ -89,7 +85,6 @@ impl frame_system::Config for Runtime { type Lookup = IdentityLookup; type Block = Block; type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; type BlockWeights = (); type BlockLength = (); type Version = (); @@ -107,24 +102,14 @@ impl frame_system::Config for Runtime { parameter_types! { pub ExistentialDeposit: Balance = 1 * CENTS; - pub const MaxLocks: u32 = 50; - pub const MaxReserves: u32 = 50; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Runtime { - type MaxLocks = MaxLocks; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxReserves = MaxReserves; type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } impl shared::Config for Runtime { diff --git a/polkadot/xcm/xcm-executor/Cargo.toml b/polkadot/xcm/xcm-executor/Cargo.toml index aebc768bb906fd38d372d6d735a9e6bc0390ae9b..cc966f91fe4db948c38a9d4faeff267aefc7e59c 100644 --- a/polkadot/xcm/xcm-executor/Cargo.toml +++ b/polkadot/xcm/xcm-executor/Cargo.toml @@ -10,20 +10,19 @@ version = "7.0.0" workspace = true [dependencies] -impl-trait-for-tuples = "0.2.2" -environmental = { version = "1.1.4", default-features = false } -parity-scale-codec = { version = "3.6.1", default-features = false, features = ["derive"] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] } -xcm = { package = "staging-xcm", path = "..", default-features = false } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -sp-arithmetic = { path = "../../../substrate/primitives/arithmetic", default-features = false } -sp-core = { path = "../../../substrate/primitives/core", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-weights = { path = "../../../substrate/primitives/weights", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } -log = { workspace = true } -frame-benchmarking = { path = "../../../substrate/frame/benchmarking", default-features = false, optional = true } +impl-trait-for-tuples = { workspace = true } +environmental = { workspace = true } +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive", "serde"], workspace = true } +xcm = { workspace = true } +sp-io = { workspace = true } +sp-arithmetic = { workspace = true } +sp-core = { workspace = true } +sp-runtime = { workspace = true } +sp-weights = { workspace = true } +frame-support = { workspace = true } +tracing = { workspace = true } +frame-benchmarking = { optional = true, workspace = true } [features] default = ["std"] @@ -33,17 +32,16 @@ runtime-benchmarks = [ "sp-runtime/runtime-benchmarks", ] std = [ + "codec/std", "environmental/std", "frame-benchmarking/std", "frame-support/std", - "log/std", - "parity-scale-codec/std", "scale-info/std", "sp-arithmetic/std", "sp-core/std", "sp-io/std", "sp-runtime/std", - "sp-std/std", "sp-weights/std", + "tracing/std", "xcm/std", ] diff --git a/polkadot/xcm/xcm-executor/integration-tests/Cargo.toml b/polkadot/xcm/xcm-executor/integration-tests/Cargo.toml index 9c9c53f0ee1ba497f044477ec857afb6774a1f05..e669e5d2b2312fbba56a86a6b8518506ba350543 100644 --- a/polkadot/xcm/xcm-executor/integration-tests/Cargo.toml +++ b/polkadot/xcm/xcm-executor/integration-tests/Cargo.toml @@ -11,24 +11,24 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -frame-support = { path = "../../../../substrate/frame/support", default-features = false } -frame-system = { path = "../../../../substrate/frame/system" } -futures = "0.3.30" -pallet-transaction-payment = { path = "../../../../substrate/frame/transaction-payment" } -pallet-xcm = { path = "../../pallet-xcm" } -polkadot-test-client = { path = "../../../node/test/client" } -polkadot-test-runtime = { path = "../../../runtime/test-runtime" } -polkadot-test-service = { path = "../../../node/test/service" } -polkadot-service = { path = "../../../node/service" } -sp-consensus = { path = "../../../../substrate/primitives/consensus/common" } -sp-keyring = { path = "../../../../substrate/primitives/keyring" } -sp-runtime = { path = "../../../../substrate/primitives/runtime", default-features = false } -sp-state-machine = { path = "../../../../substrate/primitives/state-machine" } -xcm = { package = "staging-xcm", path = "../..", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = ".." } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } -sp-core = { path = "../../../../substrate/primitives/core" } +codec = { workspace = true, default-features = true } +frame-support = { workspace = true } +frame-system = { workspace = true, default-features = true } +futures = { workspace = true } +pallet-transaction-payment = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } +polkadot-test-client = { workspace = true } +polkadot-test-runtime = { workspace = true } +polkadot-test-service = { workspace = true } +polkadot-service = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-state-machine = { workspace = true, default-features = true } +xcm = { workspace = true } +xcm-executor = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } [features] default = ["std"] diff --git a/polkadot/xcm/xcm-executor/integration-tests/src/lib.rs b/polkadot/xcm/xcm-executor/integration-tests/src/lib.rs index 279d7118f8cf90cd5b8666ada2c7a8fbc5d4c94a..7683c6025392a824200afc779f4e5ec1a700dc53 100644 --- a/polkadot/xcm/xcm-executor/integration-tests/src/lib.rs +++ b/polkadot/xcm/xcm-executor/integration-tests/src/lib.rs @@ -34,7 +34,7 @@ use xcm_executor::traits::WeightBounds; #[test] fn basic_buy_fees_message_executes() { sp_tracing::try_init_simple(); - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let msg = Xcm(vec![ WithdrawAsset((Parent, 100).into()), @@ -75,7 +75,7 @@ fn basic_buy_fees_message_executes() { #[test] fn transact_recursion_limit_works() { sp_tracing::try_init_simple(); - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let base_xcm = |call: polkadot_test_runtime::RuntimeCall| { Xcm(vec![ @@ -174,7 +174,7 @@ fn query_response_fires() { use polkadot_test_runtime::RuntimeEvent::TestNotifier; sp_tracing::try_init_simple(); - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let mut block_builder = client.init_polkadot_block_builder(); @@ -256,7 +256,7 @@ fn query_response_elicits_handler() { use polkadot_test_runtime::RuntimeEvent::TestNotifier; sp_tracing::try_init_simple(); - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let mut block_builder = client.init_polkadot_block_builder(); @@ -332,7 +332,7 @@ fn query_response_elicits_handler() { #[test] fn deposit_reserve_asset_works_for_any_xcm_sender() { sp_tracing::try_init_simple(); - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); // Init values for the simulated origin Parachain let amount_to_send: u128 = 1_000_000_000_000; diff --git a/polkadot/xcm/xcm-executor/src/assets.rs b/polkadot/xcm/xcm-executor/src/assets.rs index 4407752f7024273a28883b695d895bcd6a9e7d35..09e7535ebf81d09f07a119224dad42647d4bc366 100644 --- a/polkadot/xcm/xcm-executor/src/assets.rs +++ b/polkadot/xcm/xcm-executor/src/assets.rs @@ -14,12 +14,12 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use sp_runtime::{traits::Saturating, RuntimeDebug}; -use sp_std::{ +use alloc::{ collections::{btree_map::BTreeMap, btree_set::BTreeSet}, - mem, - prelude::*, + vec::Vec, }; +use core::mem; +use sp_runtime::{traits::Saturating, RuntimeDebug}; use xcm::latest::{ Asset, AssetFilter, AssetId, AssetInstance, Assets, Fungibility::{Fungible, NonFungible}, @@ -520,7 +520,9 @@ impl AssetsInHolding { #[cfg(test)] mod tests { use super::*; + use alloc::vec; use xcm::latest::prelude::*; + #[allow(non_snake_case)] /// Concrete fungible constructor fn CF(amount: u128) -> Asset { diff --git a/polkadot/xcm/xcm-executor/src/lib.rs b/polkadot/xcm/xcm-executor/src/lib.rs index e0b8a8a9c73e4aba1274993d23ac27a77c2a6c78..74561e931e7e14931aeac42e73b0cd9cb8790b6b 100644 --- a/polkadot/xcm/xcm-executor/src/lib.rs +++ b/polkadot/xcm/xcm-executor/src/lib.rs @@ -16,15 +16,18 @@ #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +use alloc::{vec, vec::Vec}; +use codec::{Decode, Encode}; +use core::{fmt::Debug, marker::PhantomData}; use frame_support::{ dispatch::GetDispatchInfo, ensure, traits::{Contains, ContainsPair, Defensive, Get, PalletsInfoAccess}, }; -use parity_scale_codec::{Decode, Encode}; use sp_core::defer; use sp_io::hashing::blake2_128; -use sp_std::{fmt::Debug, marker::PhantomData, prelude::*}; use sp_weights::Weight; use xcm::latest::prelude::*; @@ -208,9 +211,12 @@ impl ExecuteXcm for XcmExecutor Outcome { let origin = origin.into(); - log::trace!( + tracing::trace!( target: "xcm::execute", - "origin: {origin:?}, message: {message:?}, weight_credit: {weight_credit:?}", + ?origin, + ?message, + ?weight_credit, + "Executing message", ); let mut properties = Properties { weight_credit, message_id: None }; @@ -226,10 +232,13 @@ impl ExecuteXcm for XcmExecutor ExecuteXcm for XcmExecutor for frame_benchmarking::BenchmarkError { fn from(error: ExecutorError) -> Self { - log::error!( - "XCM ERROR >> Index: {:?}, Error: {:?}, Weight: {:?}", - error.index, - error.xcm_error, - error.weight + tracing::error!( + index = ?error.index, + xcm_error = ?error.xcm_error, + weight = ?error.weight, + "XCM ERROR", ); Self::Stop("xcm executor error: see error logs") } @@ -326,10 +335,12 @@ impl XcmExecutor { let mut weight_used = xcm_weight.saturating_sub(self.total_surplus); if !self.holding.is_empty() { - log::trace!( + tracing::trace!( target: "xcm::post_process", - "Trapping assets in holding register: {:?}, context: {:?} (original_origin: {:?})", - self.holding, self.context, self.original_origin, + holding_register = ?self.holding, + context = ?self.context, + original_origin = ?self.original_origin, + "Trapping assets in holding register", ); let effective_origin = self.context.origin.as_ref().unwrap_or(&self.original_origin); let trap_weight = @@ -342,7 +353,13 @@ impl XcmExecutor { // TODO: #2841 #REALWEIGHT We should deduct the cost of any instructions following // the error which didn't end up being executed. Some((_i, e)) => { - log::trace!(target: "xcm::post_process", "Execution errored at {:?}: {:?} (original_origin: {:?})", _i, e, self.original_origin); + tracing::trace!( + target: "xcm::post_process", + instruction = ?_i, + error = ?e, + original_origin = ?self.original_origin, + "Execution failed", + ); Outcome::Incomplete { used: weight_used, error: e } }, } @@ -363,8 +380,12 @@ impl XcmExecutor { msg: Xcm<()>, reason: FeeReason, ) -> Result { - log::trace!( - target: "xcm::send", "Sending msg: {msg:?}, to destination: {dest:?}, (reason: {reason:?})" + tracing::trace!( + target: "xcm::send", + ?msg, + destination = ?dest, + reason = ?reason, + "Sending msg", ); let (ticket, fee) = validate_send::(dest, msg)?; self.take_fee(fee, reason)?; @@ -374,7 +395,7 @@ impl XcmExecutor { /// Remove the registered error handler and return it. Do not refund its weight. fn take_error_handler(&mut self) -> Xcm { let mut r = Xcm::(vec![]); - sp_std::mem::swap(&mut self.error_handler, &mut r); + core::mem::swap(&mut self.error_handler, &mut r); self.error_handler_weight = Weight::zero(); r } @@ -389,7 +410,7 @@ impl XcmExecutor { /// Remove the registered appendix and return it. fn take_appendix(&mut self) -> Xcm { let mut r = Xcm::(vec![]); - sp_std::mem::swap(&mut self.appendix, &mut r); + core::mem::swap(&mut self.appendix, &mut r); self.appendix_weight = Weight::zero(); r } @@ -400,7 +421,12 @@ impl XcmExecutor { // `holding_limit` items (which has a best case outcome of holding.len() == holding_limit), // then the operation is guaranteed to succeed. let worst_case_holding_len = self.holding.len() + assets_length; - log::trace!(target: "xcm::ensure_can_subsume_assets", "worst_case_holding_len: {:?}, holding_limit: {:?}", worst_case_holding_len, self.holding_limit); + tracing::trace!( + target: "xcm::ensure_can_subsume_assets", + ?worst_case_holding_len, + holding_limit = ?self.holding_limit, + "Ensuring subsume assets work", + ); ensure!(worst_case_holding_len <= self.holding_limit * 2, XcmError::HoldingWouldOverflow); Ok(()) } @@ -408,12 +434,12 @@ impl XcmExecutor { /// Refund any unused weight. fn refund_surplus(&mut self) -> Result<(), XcmError> { let current_surplus = self.total_surplus.saturating_sub(self.total_refunded); - log::trace!( + tracing::trace!( target: "xcm::refund_surplus", - "total_surplus: {:?}, total_refunded: {:?}, current_surplus: {:?}", - self.total_surplus, - self.total_refunded, - current_surplus, + total_surplus = ?self.total_surplus, + total_refunded = ?self.total_refunded, + ?current_surplus, + "Refunding surplus", ); if current_surplus.any_gt(Weight::zero()) { if let Some(w) = self.trader.refund_weight(current_surplus, &self.context) { @@ -426,7 +452,7 @@ impl XcmExecutor { .defensive_proof( "refund_weight returned an asset capable of buying weight; qed", ); - log::error!( + tracing::error!( target: "xcm::refund_surplus", "error: HoldingWouldOverflow", ); @@ -436,10 +462,9 @@ impl XcmExecutor { self.holding.subsume_assets(w.into()); } } - log::trace!( + tracing::trace!( target: "xcm::refund_surplus", - "total_refunded: {:?}", - self.total_refunded, + total_refunded = ?self.total_refunded, ); Ok(()) } @@ -448,13 +473,13 @@ impl XcmExecutor { if Config::FeeManager::is_waived(self.origin_ref(), reason.clone()) { return Ok(()) } - log::trace!( + tracing::trace!( target: "xcm::fees", - "taking fee: {:?} from origin_ref: {:?} in fees_mode: {:?} for a reason: {:?}", - fee, - self.origin_ref(), - self.fees_mode, - reason, + ?fee, + origin_ref = ?self.origin_ref(), + fees_mode = ?self.fees_mode, + ?reason, + "Taking fees", ); let paid = if self.fees_mode.jit_withdraw { let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?; @@ -507,7 +532,7 @@ impl XcmExecutor { let reanchor_context = Config::UniversalLocation::get(); let reanchored = reanchorable.reanchored(&destination, &reanchor_context).map_err(|error| { - log::error!(target: "xcm::reanchor", "Failed reanchoring with error {error:?}"); + tracing::error!(target: "xcm::reanchor", ?error, "Failed reanchoring with error"); XcmError::ReanchorFailed })?; Ok((reanchored, reanchor_context)) @@ -530,13 +555,12 @@ impl XcmExecutor { } fn process(&mut self, xcm: Xcm) -> Result<(), ExecutorError> { - log::trace!( + tracing::trace!( target: "xcm::process", - "origin: {:?}, total_surplus/refunded: {:?}/{:?}, error_handler_weight: {:?}", - self.origin_ref(), - self.total_surplus, - self.total_refunded, - self.error_handler_weight, + origin = ?self.origin_ref(), + total_surplus = ?self.total_surplus, + total_refunded = ?self.total_refunded, + error_handler_weight = ?self.error_handler_weight, ); let mut result = Ok(()); for (i, instr) in xcm.0.into_iter().enumerate() { @@ -566,7 +590,7 @@ impl XcmExecutor { self.process_instruction(instr) }); if let Err(e) = inst_res { - log::trace!(target: "xcm::execute", "!!! ERROR: {:?}", e); + tracing::trace!(target: "xcm::execute", "!!! ERROR: {:?}", e); *r = Err(ExecutorError { index: i as u32, xcm_error: e, @@ -588,11 +612,12 @@ impl XcmExecutor { &mut self, instr: Instruction, ) -> Result<(), XcmError> { - log::trace!( + tracing::trace!( target: "xcm::process_instruction", - "=== {:?}", - instr + instruction = ?instr, + "Processing instruction", ); + match instr { WithdrawAsset(assets) => { let origin = self.origin_ref().ok_or(XcmError::BadOrigin)?; @@ -694,7 +719,7 @@ impl XcmExecutor { Transact { origin_kind, require_weight_at_most, mut call } => { // We assume that the Relay-chain is allowed to use transact on this parachain. let origin = self.cloned_origin().ok_or_else(|| { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", "No origin provided", ); @@ -704,7 +729,7 @@ impl XcmExecutor { // TODO: #2841 #TRANSACTFILTER allow the trait to issue filters for the relay-chain let message_call = call.take_decoded().map_err(|_| { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", "Failed to decode call", ); @@ -712,13 +737,14 @@ impl XcmExecutor { XcmError::FailedToDecode })?; - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Processing call: {message_call:?}", + ?call, + "Processing call", ); if !Config::SafeCallFilter::contains(&message_call) { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", "Call filtered by `SafeCallFilter`", ); @@ -729,26 +755,31 @@ impl XcmExecutor { let dispatch_origin = Config::OriginConverter::convert_origin(origin.clone(), origin_kind).map_err( |_| { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Failed to convert origin {origin:?} and origin kind {origin_kind:?} to a local origin." + ?origin, + ?origin_kind, + "Failed to convert origin to a local origin." ); XcmError::BadOrigin }, )?; - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Dispatching with origin: {dispatch_origin:?}", + origin = ?dispatch_origin, + "Dispatching with origin", ); let weight = message_call.get_dispatch_info().weight; if !weight.all_lte(require_weight_at_most) { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Max {weight} bigger than require at most {require_weight_at_most}", + %weight, + %require_weight_at_most, + "Max weight bigger than require at most", ); return Err(XcmError::MaxWeightInvalid) @@ -757,17 +788,19 @@ impl XcmExecutor { let maybe_actual_weight = match Config::CallDispatcher::dispatch(message_call, dispatch_origin) { Ok(post_info) => { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Dispatch successful: {post_info:?}" + ?post_info, + "Dispatch successful" ); self.transact_status = MaybeErrorCode::Success; post_info.actual_weight }, Err(error_and_info) => { - log::trace!( + tracing::trace!( target: "xcm::process_instruction::transact", - "Dispatch failed {error_and_info:?}" + ?error_and_info, + "Dispatch failed" ); self.transact_status = error_and_info.error.encode().into(); @@ -776,7 +809,7 @@ impl XcmExecutor { }; let actual_weight = maybe_actual_weight.unwrap_or(weight); let surplus = weight.saturating_sub(actual_weight); - // We assume that the `Config::Weigher` will counts the `require_weight_at_most` + // We assume that the `Config::Weigher` will count the `require_weight_at_most` // for the estimate of how much weight this instruction will take. Now that we know // that it's less, we credit it. // @@ -825,14 +858,7 @@ impl XcmExecutor { let old_holding = self.holding.clone(); let result = Config::TransactionalProcessor::process(|| { let deposited = self.holding.saturating_take(assets); - for asset in deposited.into_assets_iter() { - Config::AssetTransactor::deposit_asset( - &asset, - &beneficiary, - Some(&self.context), - )?; - } - Ok(()) + self.deposit_assets_with_retry(&deposited, &beneficiary) }); if Config::TransactionalProcessor::IS_TRANSACTIONAL && result.is_err() { self.holding = old_holding; @@ -857,9 +883,7 @@ impl XcmExecutor { // now take assets to deposit (excluding transport_fee) let deposited = self.holding.saturating_take(assets); - for asset in deposited.assets_iter() { - Config::AssetTransactor::deposit_asset(&asset, &dest, Some(&self.context))?; - } + self.deposit_assets_with_retry(&deposited, &dest)?; // Note that we pass `None` as `maybe_failed_bin` and drop any assets which // cannot be reanchored because we have already called `deposit_asset` on all // assets. @@ -1249,4 +1273,46 @@ impl XcmExecutor { }), } } + + /// Deposit `to_deposit` assets to `beneficiary`, without giving up on the first (transient) + /// error, and retrying once just in case one of the subsequently deposited assets satisfy some + /// requirement. + /// + /// Most common transient error is: `beneficiary` account does not yet exist and the first + /// asset(s) in the (sorted) list does not satisfy ED, but a subsequent one in the list does. + /// + /// This function can write into storage and also return an error at the same time, it should + /// always be called within a transactional context. + fn deposit_assets_with_retry( + &mut self, + to_deposit: &AssetsInHolding, + beneficiary: &Location, + ) -> Result<(), XcmError> { + let mut failed_deposits = Vec::with_capacity(to_deposit.len()); + + let mut deposit_result = Ok(()); + for asset in to_deposit.assets_iter() { + deposit_result = + Config::AssetTransactor::deposit_asset(&asset, &beneficiary, Some(&self.context)); + // if deposit failed for asset, mark it for retry after depositing the others. + if deposit_result.is_err() { + failed_deposits.push(asset); + } + } + if failed_deposits.len() == to_deposit.len() { + tracing::debug!( + target: "xcm::execute", + ?deposit_result, + "Deposit for each asset failed, returning the last error as there is no point in retrying any of them", + ); + return deposit_result; + } + tracing::trace!(target: "xcm::execute", ?failed_deposits, "Deposits to retry"); + + // retry previously failed deposits, this time short-circuiting on any error. + for asset in failed_deposits { + Config::AssetTransactor::deposit_asset(&asset, &beneficiary, Some(&self.context))?; + } + Ok(()) + } } diff --git a/polkadot/xcm/xcm-executor/src/traits/asset_exchange.rs b/polkadot/xcm/xcm-executor/src/traits/asset_exchange.rs index 432a7498ed4cf9b700649ed987c8050041e7de08..f4b7135d4206d1638e23260951ea78099e55fcc4 100644 --- a/polkadot/xcm/xcm-executor/src/traits/asset_exchange.rs +++ b/polkadot/xcm/xcm-executor/src/traits/asset_exchange.rs @@ -37,6 +37,27 @@ pub trait AssetExchange { want: &Assets, maximal: bool, ) -> Result; + + /// Handler for quoting the exchange price of two asset collections. + /// + /// It's useful before calling `exchange_asset`, to get some information on whether or not the + /// exchange will be successful. + /// + /// Arguments: + /// - `give` The asset(s) that are going to be given. + /// - `want` The asset(s) that are wanted. + /// - `maximal`: + /// - If `true`, then the return value is the resulting amount of `want` obtained by swapping + /// `give`. + /// - If `false`, then the return value is the required amount of `give` needed to get `want`. + /// + /// The return value is `Assets` since it comprises both which assets and how much of them. + /// + /// The relationship between this function and `exchange_asset` is the following: + /// - quote(give, want, maximal) = resulting_want -> exchange(give, resulting_want, maximal) ✅ + /// - quote(give, want, minimal) = required_give -> exchange(required_give_amount, want, + /// minimal) ✅ + fn quote_exchange_price(_give: &Assets, _want: &Assets, _maximal: bool) -> Option; } #[impl_trait_for_tuples::impl_for_tuples(30)] @@ -55,4 +76,14 @@ impl AssetExchange for Tuple { )* ); Err(give) } + + fn quote_exchange_price(give: &Assets, want: &Assets, maximal: bool) -> Option { + for_tuples!( #( + match Tuple::quote_exchange_price(give, want, maximal) { + Some(assets) => return Some(assets), + None => {} + } + )* ); + None + } } diff --git a/polkadot/xcm/xcm-executor/src/traits/asset_lock.rs b/polkadot/xcm/xcm-executor/src/traits/asset_lock.rs index b6270c529452133c011fef24b9ac63e057acb91a..b4e9f32983fd52f27eb66d31bb7098d780389de9 100644 --- a/polkadot/xcm/xcm-executor/src/traits/asset_lock.rs +++ b/polkadot/xcm/xcm-executor/src/traits/asset_lock.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use sp_std::convert::Infallible; +use core::convert::Infallible; use xcm::prelude::*; #[derive(Debug)] diff --git a/polkadot/xcm/xcm-executor/src/traits/conversion.rs b/polkadot/xcm/xcm-executor/src/traits/conversion.rs index 9e2f4c83997ac2b370536822454bcfbea41c4896..bc62ad655669756793327d23d3d24f5f2da1be9c 100644 --- a/polkadot/xcm/xcm-executor/src/traits/conversion.rs +++ b/polkadot/xcm/xcm-executor/src/traits/conversion.rs @@ -14,9 +14,9 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use core::{marker::PhantomData, result::Result}; use frame_support::traits::{Contains, OriginTrait}; use sp_runtime::{traits::Dispatchable, DispatchErrorWithPostInfo}; -use sp_std::{marker::PhantomData, result::Result}; use xcm::latest::prelude::*; /// Means of converting a location into an account identifier. @@ -88,19 +88,45 @@ pub trait ConvertOrigin { #[impl_trait_for_tuples::impl_for_tuples(30)] impl ConvertOrigin for Tuple { fn convert_origin(origin: impl Into, kind: OriginKind) -> Result { + let origin = origin.into(); + + tracing::trace!( + target: "xcm::convert_origin", + ?origin, + ?kind, + "Converting origin", + ); + for_tuples!( #( + let convert_origin = core::any::type_name::(); + let origin = match Tuple::convert_origin(origin, kind) { - Err(o) => o, - r => return r + Err(o) => { + tracing::trace!( + target: "xcm::convert_origin", + %convert_origin, + "Convert origin step failed", + ); + + o + }, + Ok(o) => { + tracing::trace!( + target: "xcm::convert_origin", + %convert_origin, + "Convert origin step succeeded", + ); + + return Ok(o) + } }; )* ); - let origin = origin.into(); - log::trace!( + + tracing::trace!( target: "xcm::convert_origin", - "could not convert: origin: {:?}, kind: {:?}", - origin, - kind, + "Converting origin failed", ); + Err(origin) } } diff --git a/polkadot/xcm/xcm-executor/src/traits/on_response.rs b/polkadot/xcm/xcm-executor/src/traits/on_response.rs index 1049bacdca5f9eee964cf810835c69b7ba1ba1ea..a4ed6014b4fc8bc423bbc5cceb20cee15fe7890f 100644 --- a/polkadot/xcm/xcm-executor/src/traits/on_response.rs +++ b/polkadot/xcm/xcm-executor/src/traits/on_response.rs @@ -15,11 +15,10 @@ // along with Polkadot. If not, see . use crate::{Junctions::Here, Xcm}; -use core::result; +use codec::{Decode, Encode}; +use core::{fmt::Debug, result}; use frame_support::{pallet_prelude::Get, parameter_types}; -use parity_scale_codec::{Decode, Encode}; use sp_arithmetic::traits::Zero; -use sp_std::fmt::Debug; use xcm::latest::{ Error as XcmError, InteriorLocation, Location, QueryId, Response, Result as XcmResult, Weight, XcmContext, diff --git a/polkadot/xcm/xcm-executor/src/traits/should_execute.rs b/polkadot/xcm/xcm-executor/src/traits/should_execute.rs index e76d56bfe6164d16487f65ed79c1a1a58a9949fe..ec9ef70cc817e5a230ae843581fb736ce06770ee 100644 --- a/polkadot/xcm/xcm-executor/src/traits/should_execute.rs +++ b/polkadot/xcm/xcm-executor/src/traits/should_execute.rs @@ -14,8 +14,8 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . +use core::result::Result; use frame_support::traits::ProcessMessageError; -use sp_std::result::Result; use xcm::latest::{Instruction, Location, Weight, XcmHash}; /// Properties of an XCM message and its imminent execution. @@ -59,19 +59,35 @@ impl ShouldExecute for Tuple { properties: &mut Properties, ) -> Result<(), ProcessMessageError> { for_tuples!( #( - match Tuple::should_execute(origin, instructions, max_weight, properties) { - Ok(()) => return Ok(()), - _ => (), + let barrier = core::any::type_name::(); + match Tuple::should_execute(origin, instructions, max_weight, properties) { + Ok(()) => { + tracing::trace!( + target: "xcm::should_execute", + ?origin, + ?instructions, + ?max_weight, + ?properties, + %barrier, + "pass barrier", + ); + return Ok(()) + }, + Err(error) => { + tracing::trace!( + target: "xcm::should_execute", + ?origin, + ?instructions, + ?max_weight, + ?properties, + ?error, + %barrier, + "did not pass barrier", + ); + }, } )* ); - log::trace!( - target: "xcm::should_execute", - "did not pass barrier: origin: {:?}, instructions: {:?}, max_weight: {:?}, properties: {:?}", - origin, - instructions, - max_weight, - properties, - ); + Err(ProcessMessageError::Unsupported) } } diff --git a/polkadot/xcm/xcm-executor/src/traits/token_matching.rs b/polkadot/xcm/xcm-executor/src/traits/token_matching.rs index e9a7e3ad845daf2f3f0a8da05c7d9d3d3711a291..aa44aee4f9de39cd7bcda09e3ce3b4e294d8ee6d 100644 --- a/polkadot/xcm/xcm-executor/src/traits/token_matching.rs +++ b/polkadot/xcm/xcm-executor/src/traits/token_matching.rs @@ -14,7 +14,7 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use sp_std::result; +use core::result; use xcm::latest::prelude::*; pub trait MatchesFungible { @@ -27,7 +27,7 @@ impl MatchesFungible for Tuple { for_tuples!( #( match Tuple::matches_fungible(a) { o @ Some(_) => return o, _ => () } )* ); - log::trace!(target: "xcm::matches_fungible", "did not match fungible asset: {:?}", &a); + tracing::trace!(target: "xcm::matches_fungible", asset = ?a, "did not match fungible asset"); None } } @@ -42,7 +42,7 @@ impl MatchesNonFungible for Tuple { for_tuples!( #( match Tuple::matches_nonfungible(a) { o @ Some(_) => return o, _ => () } )* ); - log::trace!(target: "xcm::matches_non_fungible", "did not match non-fungible asset: {:?}", &a); + tracing::trace!(target: "xcm::matches_non_fungible", asset = ?a, "did not match non-fungible asset"); None } } @@ -86,7 +86,7 @@ impl MatchesFungibles for Tuple { for_tuples!( #( match Tuple::matches_fungibles(a) { o @ Ok(_) => return o, _ => () } )* ); - log::trace!(target: "xcm::matches_fungibles", "did not match fungibles asset: {:?}", &a); + tracing::trace!(target: "xcm::matches_fungibles", asset = ?a, "did not match fungibles asset"); Err(Error::AssetNotHandled) } } @@ -101,7 +101,7 @@ impl MatchesNonFungibles for Tuple { for_tuples!( #( match Tuple::matches_nonfungibles(a) { o @ Ok(_) => return o, _ => () } )* ); - log::trace!(target: "xcm::matches_non_fungibles", "did not match fungibles asset: {:?}", &a); + tracing::trace!(target: "xcm::matches_non_fungibles", asset = ?a, "did not match fungibles asset"); Err(Error::AssetNotHandled) } } diff --git a/polkadot/xcm/xcm-executor/src/traits/transact_asset.rs b/polkadot/xcm/xcm-executor/src/traits/transact_asset.rs index e8a52d8256851b4baf9565ba5ddeb47ae28667a7..c2331f805b4bddd51493fa7d9ec8c384baa20f14 100644 --- a/polkadot/xcm/xcm-executor/src/traits/transact_asset.rs +++ b/polkadot/xcm/xcm-executor/src/traits/transact_asset.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::AssetsInHolding; -use sp_std::result::Result; +use core::result::Result; use xcm::latest::{Asset, Error as XcmError, Location, Result as XcmResult, XcmContext}; /// Facility for asset transacting. @@ -148,12 +148,12 @@ impl TransactAsset for Tuple { r => return r, } )* ); - log::trace!( + tracing::trace!( target: "xcm::TransactAsset::can_check_in", - "asset not found: what: {:?}, origin: {:?}, context: {:?}", - what, - origin, - context, + ?what, + ?origin, + ?context, + "asset not found", ); Err(XcmError::AssetNotFound) } @@ -171,12 +171,12 @@ impl TransactAsset for Tuple { r => return r, } )* ); - log::trace!( + tracing::trace!( target: "xcm::TransactAsset::can_check_out", - "asset not found: what: {:?}, dest: {:?}, context: {:?}", - what, - dest, - context, + ?what, + ?dest, + ?context, + "asset not found", ); Err(XcmError::AssetNotFound) } @@ -194,12 +194,12 @@ impl TransactAsset for Tuple { r => return r, } )* ); - log::trace!( + tracing::trace!( target: "xcm::TransactAsset::deposit_asset", - "did not deposit asset: what: {:?}, who: {:?}, context: {:?}", - what, - who, - context, + ?what, + ?who, + ?context, + "did not deposit asset", ); Err(XcmError::AssetNotFound) } @@ -215,12 +215,12 @@ impl TransactAsset for Tuple { r => return r, } )* ); - log::trace!( + tracing::trace!( target: "xcm::TransactAsset::withdraw_asset", - "did not withdraw asset: what: {:?}, who: {:?}, maybe_context: {:?}", - what, - who, - maybe_context, + ?what, + ?who, + ?maybe_context, + "did not withdraw asset", ); Err(XcmError::AssetNotFound) } @@ -237,13 +237,13 @@ impl TransactAsset for Tuple { r => return r, } )* ); - log::trace!( + tracing::trace!( target: "xcm::TransactAsset::internal_transfer_asset", - "did not transfer asset: what: {:?}, from: {:?}, to: {:?}, context: {:?}", - what, - from, - to, - context, + ?what, + ?from, + ?to, + ?context, + "did not transfer asset", ); Err(XcmError::AssetNotFound) } diff --git a/polkadot/xcm/xcm-executor/src/traits/weight.rs b/polkadot/xcm/xcm-executor/src/traits/weight.rs index efb9a2dfb6efdf65a074f631c691c0bfec88d600..72de3e0f433b96ed1718be70e3c0feb20340453a 100644 --- a/polkadot/xcm/xcm-executor/src/traits/weight.rs +++ b/polkadot/xcm/xcm-executor/src/traits/weight.rs @@ -15,7 +15,7 @@ // along with Polkadot. If not, see . use crate::AssetsInHolding; -use sp_std::result::Result; +use core::result::Result; use xcm::latest::{prelude::*, Weight}; /// Determine the weight of an XCM message. @@ -80,18 +80,38 @@ impl WeightTrader for Tuple { let mut too_expensive_error_found = false; let mut last_error = None; for_tuples!( #( + let weight_trader = core::any::type_name::(); + match Tuple.buy_weight(weight, payment.clone(), context) { - Ok(assets) => return Ok(assets), - Err(e) => { - if let XcmError::TooExpensive = e { + Ok(assets) => { + tracing::trace!( + target: "xcm::buy_weight", + %weight_trader, + "Buy weight succeeded", + ); + + return Ok(assets) + }, + Err(error) => { + if let XcmError::TooExpensive = error { too_expensive_error_found = true; } - last_error = Some(e) + last_error = Some(error); + + tracing::trace!( + target: "xcm::buy_weight", + ?error, + %weight_trader, + "Weight trader failed", + ); } } )* ); - log::trace!(target: "xcm::buy_weight", "last_error: {:?}, too_expensive_error_found: {}", last_error, too_expensive_error_found); + tracing::trace!( + target: "xcm::buy_weight", + "Buy weight failed", + ); // if we have multiple traders, and first one returns `TooExpensive` and others fail e.g. // `AssetNotFound` then it is more accurate to return `TooExpensive` then `AssetNotFound` diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/Cargo.toml b/polkadot/xcm/xcm-fee-payment-runtime-api/Cargo.toml deleted file mode 100644 index cec76e7327ec6145e8513a33264c9419414b0991..0000000000000000000000000000000000000000 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/Cargo.toml +++ /dev/null @@ -1,71 +0,0 @@ -[package] -name = "xcm-fee-payment-runtime-api" -version = "0.1.0" -authors.workspace = true -edition.workspace = true -license = "Apache-2.0" -repository.workspace = true -description = "XCM fee payment runtime API" - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ - "derive", -] } - -sp-api = { path = "../../../substrate/primitives/api", default-features = false } -scale-info = { version = "2.11.1", default-features = false, features = [ - "derive", - "serde", -] } -sp-std = { path = "../../../substrate/primitives/std", default-features = false } -sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false } -sp-weights = { path = "../../../substrate/primitives/weights", default-features = false } -xcm = { package = "staging-xcm", path = "../", default-features = false } -frame-support = { path = "../../../substrate/frame/support", default-features = false } - -[dev-dependencies] -frame-system = { path = "../../../substrate/frame/system", default-features = false } -pallet-xcm = { path = "../pallet-xcm", default-features = false } -xcm-builder = { package = "staging-xcm-builder", path = "../xcm-builder", default-features = false } -sp-io = { path = "../../../substrate/primitives/io", default-features = false } -pallet-balances = { path = "../../../substrate/frame/balances", default-features = false } -pallet-assets = { path = "../../../substrate/frame/assets", default-features = false } -xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor", default-features = false } -frame-executive = { path = "../../../substrate/frame/executive", default-features = false } -log = { workspace = true } -env_logger = "0.9.0" - -[features] -default = ["std"] -std = [ - "codec/std", - "frame-executive/std", - "frame-support/std", - "frame-system/std", - "log/std", - "pallet-assets/std", - "pallet-balances/std", - "pallet-xcm/std", - "scale-info/std", - "sp-api/std", - "sp-io/std", - "sp-runtime/std", - "sp-std/std", - "sp-weights/std", - "xcm-builder/std", - "xcm-executor/std", - "xcm/std", -] -runtime-benchmarks = [ - "frame-support/runtime-benchmarks", - "frame-system/runtime-benchmarks", - "pallet-assets/runtime-benchmarks", - "pallet-balances/runtime-benchmarks", - "pallet-xcm/runtime-benchmarks", - "sp-runtime/runtime-benchmarks", - "xcm-builder/runtime-benchmarks", - "xcm-executor/runtime-benchmarks", -] diff --git a/polkadot/xcm/xcm-runtime-apis/Cargo.toml b/polkadot/xcm/xcm-runtime-apis/Cargo.toml new file mode 100644 index 0000000000000000000000000000000000000000..9ccca76c321cc031e0fcaf0a0f6486ea238f0068 --- /dev/null +++ b/polkadot/xcm/xcm-runtime-apis/Cargo.toml @@ -0,0 +1,63 @@ +[package] +name = "xcm-runtime-apis" +version = "0.1.0" +authors.workspace = true +edition.workspace = true +license = "Apache-2.0" +repository.workspace = true +description = "XCM runtime APIs" + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { features = ["derive"], workspace = true } +scale-info = { features = ["derive", "serde"], workspace = true } + +frame-support = { workspace = true } +sp-api = { workspace = true } +sp-weights = { workspace = true } +xcm = { workspace = true } +xcm-executor = { workspace = true } + +[dev-dependencies] +frame-system = { workspace = true } +sp-io = { workspace = true } +xcm-builder = { workspace = true } +hex-literal = { workspace = true } +pallet-xcm = { workspace = true } +pallet-balances = { workspace = true } +pallet-assets = { workspace = true } +xcm-executor = { workspace = true } +frame-executive = { workspace = true } +log = { workspace = true } +sp-tracing = { workspace = true, default-features = true } + +[features] +default = ["std"] +std = [ + "codec/std", + "frame-executive/std", + "frame-support/std", + "frame-system/std", + "log/std", + "pallet-assets/std", + "pallet-balances/std", + "pallet-xcm/std", + "scale-info/std", + "sp-api/std", + "sp-io/std", + "sp-weights/std", + "xcm-builder/std", + "xcm-executor/std", + "xcm/std", +] +runtime-benchmarks = [ + "frame-support/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-assets/runtime-benchmarks", + "pallet-balances/runtime-benchmarks", + "pallet-xcm/runtime-benchmarks", + "xcm-builder/runtime-benchmarks", + "xcm-executor/runtime-benchmarks", +] diff --git a/polkadot/xcm/xcm-runtime-apis/src/conversions.rs b/polkadot/xcm/xcm-runtime-apis/src/conversions.rs new file mode 100644 index 0000000000000000000000000000000000000000..e5eeac013fee6e8b7222429dfd0ed93afa9384c9 --- /dev/null +++ b/polkadot/xcm/xcm-runtime-apis/src/conversions.rs @@ -0,0 +1,56 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Substrate 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. + +// Substrate 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 Polkadot. If not, see . + +//! Contains runtime APIs for useful conversions, such as between XCM `Location` and `AccountId`. + +use codec::{Decode, Encode}; +use scale_info::TypeInfo; +use xcm::VersionedLocation; +use xcm_executor::traits::ConvertLocation; + +sp_api::decl_runtime_apis! { + /// API for useful conversions between XCM `Location` and `AccountId`. + pub trait LocationToAccountApi where AccountId: Decode { + /// Converts `Location` to `AccountId`. + fn convert_location(location: VersionedLocation) -> Result; + } +} + +#[derive(Copy, Clone, Encode, Decode, Eq, PartialEq, Debug, TypeInfo)] +pub enum Error { + /// Requested `Location` is not supported by the local conversion. + #[codec(index = 0)] + Unsupported, + + /// Converting a versioned data structure from one version to another failed. + #[codec(index = 1)] + VersionedConversionFailed, +} + +/// A helper implementation that can be used for `LocationToAccountApi` implementations. +/// It is useful when you already have a `ConvertLocation` implementation and a default +/// `Ss58Prefix`. +pub struct LocationToAccountHelper( + core::marker::PhantomData<(AccountId, Conversion)>, +); +impl> + LocationToAccountHelper +{ + pub fn convert_location(location: VersionedLocation) -> Result { + let location = location.try_into().map_err(|_| Error::VersionedConversionFailed)?; + Conversion::convert_location(&location).ok_or(Error::Unsupported) + } +} diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs b/polkadot/xcm/xcm-runtime-apis/src/dry_run.rs similarity index 82% rename from polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs rename to polkadot/xcm/xcm-runtime-apis/src/dry_run.rs index 62a422d6efeb0928e4f279798382dd139d95ee0a..2a1a0daf0d5d5d0bae868e973df56f7e35b41592 100644 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/src/dry_run.rs +++ b/polkadot/xcm/xcm-runtime-apis/src/dry_run.rs @@ -18,17 +18,16 @@ //! This API can be used to simulate XCMs and, for example, find the fees //! that need to be paid. +use alloc::vec::Vec; use codec::{Decode, Encode}; -use frame_support::pallet_prelude::{DispatchResult, TypeInfo}; -use sp_runtime::traits::Block as BlockT; -use sp_std::vec::Vec; +use frame_support::pallet_prelude::{DispatchResultWithPostInfo, TypeInfo}; use xcm::prelude::*; /// Effects of dry-running an extrinsic. #[derive(Encode, Decode, Debug, TypeInfo)] -pub struct ExtrinsicDryRunEffects { +pub struct CallDryRunEffects { /// The result of executing the extrinsic. - pub execution_result: DispatchResult, + pub execution_result: DispatchResultWithPostInfo, /// The list of events fired by the extrinsic. pub emitted_events: Vec, /// The local XCM that was attempted to be executed, if any. @@ -55,12 +54,12 @@ sp_api::decl_runtime_apis! { /// If there's local execution, the location will be "Here". /// This vector can be used to calculate both execution and delivery fees. /// - /// Extrinsics or XCMs might fail when executed, this doesn't mean the result of these calls will be an `Err`. + /// Calls or XCMs might fail when executed, this doesn't mean the result of these calls will be an `Err`. /// In those cases, there might still be a valid result, with the execution error inside it. /// The only reasons why these calls might return an error are listed in the [`Error`] enum. - pub trait XcmDryRunApi { - /// Dry run extrinsic. - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, Error>; + pub trait DryRunApi { + /// Dry run call. + fn dry_run_call(origin: OriginCaller, call: Call) -> Result, Error>; /// Dry run XCM program fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, Error>; @@ -76,8 +75,4 @@ pub enum Error { /// Converting a versioned data structure from one version to another failed. #[codec(index = 1)] VersionedConversionFailed, - - /// Extrinsic was invalid. - #[codec(index = 2)] - InvalidExtrinsic, } diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/src/fees.rs b/polkadot/xcm/xcm-runtime-apis/src/fees.rs similarity index 99% rename from polkadot/xcm/xcm-fee-payment-runtime-api/src/fees.rs rename to polkadot/xcm/xcm-runtime-apis/src/fees.rs index 572d4edf533865e66299eba7bd0d22a890547603..3445d42ecab3bda1a212e60f2be5583a31e04b58 100644 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/src/fees.rs +++ b/polkadot/xcm/xcm-runtime-apis/src/fees.rs @@ -16,9 +16,9 @@ //! Runtime API definition for getting XCM fees. +use alloc::vec::Vec; use codec::{Decode, Encode}; use frame_support::pallet_prelude::TypeInfo; -use sp_std::vec::Vec; use sp_weights::Weight; use xcm::{Version, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm}; diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/src/lib.rs b/polkadot/xcm/xcm-runtime-apis/src/lib.rs similarity index 74% rename from polkadot/xcm/xcm-fee-payment-runtime-api/src/lib.rs rename to polkadot/xcm/xcm-runtime-apis/src/lib.rs index 616ee4c2eccb0aeed1cdb5e2aa524855d8b2df82..b106836c1132b253acdc01e8b9fd63a7c4ff828b 100644 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/src/lib.rs +++ b/polkadot/xcm/xcm-runtime-apis/src/lib.rs @@ -14,19 +14,19 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -//! Runtime APIs for estimating xcm fee payment. -//! This crate offers two APIs, one for estimating fees, -//! which can be used for any type of message, and another one -//! for returning the specific messages used for transfers, a common -//! feature. -//! Users of these APIs should call the transfers API and pass the result to the -//! fees API. +//! Various runtime APIs to support XCM processing and manipulation. #![cfg_attr(not(feature = "std"), no_std)] +extern crate alloc; + +/// Exposes runtime APIs for various XCM-related conversions. +pub mod conversions; + /// Dry-run API. /// Given an extrinsic or an XCM program, it returns the outcome of its execution. pub mod dry_run; + /// Fee estimation API. /// Given an XCM program, it will return the fees needed to execute it properly or send it. pub mod fees; diff --git a/polkadot/xcm/xcm-runtime-apis/tests/conversions.rs b/polkadot/xcm/xcm-runtime-apis/tests/conversions.rs new file mode 100644 index 0000000000000000000000000000000000000000..7f0f0923b092116e0ad10f4b287dda8c93f5357f --- /dev/null +++ b/polkadot/xcm/xcm-runtime-apis/tests/conversions.rs @@ -0,0 +1,83 @@ +// Copyright (C) Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Substrate 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. + +// Substrate 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 Polkadot. If not, see . + +mod mock; + +use frame_support::{ + assert_err, assert_ok, + sp_runtime::{ + testing::H256, + traits::{IdentifyAccount, Verify}, + AccountId32, MultiSignature, + }, +}; +use mock::*; +use sp_api::ProvideRuntimeApi; +use xcm::prelude::*; +use xcm_runtime_apis::conversions::{ + Error as LocationToAccountApiError, LocationToAccountApi, LocationToAccountHelper, +}; + +#[test] +fn convert_location_to_account_works() { + sp_io::TestExternalities::default().execute_with(|| { + let client = TestClient {}; + let runtime_api = client.runtime_api(); + + // Test unknown conversion for `Here` location + assert_err!( + runtime_api + .convert_location(H256::zero(), VersionedLocation::from(Location::here())) + .unwrap(), + LocationToAccountApiError::Unsupported + ); + + // Test known conversion for sibling parachain location + assert_ok!( + runtime_api + .convert_location(H256::zero(), VersionedLocation::from((Parent, Parachain(1000)))) + .unwrap(), + 1000_u64 + ); + }) +} + +#[test] +fn location_to_account_helper_with_multi_signature_works() { + type Signature = MultiSignature; + type AccountIdForConversions = <::Signer as IdentifyAccount>::AccountId; + // We alias only `Location::parent()` + pub type LocationToAccountIdForConversions = + (xcm_builder::ParentIsPreset,); + + // Test unknown conversion for `Here` location + assert_err!( + LocationToAccountHelper::< + AccountIdForConversions, + LocationToAccountIdForConversions, + >::convert_location(Location::here().into_versioned()), + LocationToAccountApiError::Unsupported + ); + + // Test known conversion for `Parent` location + assert_ok!( + LocationToAccountHelper::< + AccountIdForConversions, + LocationToAccountIdForConversions, + >::convert_location(Location::parent().into_versioned()), + AccountId32::from(hex_literal::hex!("506172656e740000000000000000000000000000000000000000000000000000")) + ); +} diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs b/polkadot/xcm/xcm-runtime-apis/tests/fee_estimation.rs similarity index 76% rename from polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs rename to polkadot/xcm/xcm-runtime-apis/tests/fee_estimation.rs index 7a9bfa4a7968129a13395f2520b6ca1a7b14ff69..e5dac7c7a04edaed341274d79690b09e7c987b42 100644 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/fee_estimation.rs +++ b/polkadot/xcm/xcm-runtime-apis/tests/fee_estimation.rs @@ -16,19 +16,17 @@ //! Tests for using both the XCM fee payment API and the dry-run API. -use frame_support::{ - dispatch::DispatchInfo, - pallet_prelude::{DispatchClass, Pays}, -}; +use frame_support::sp_runtime::testing::H256; +use frame_system::RawOrigin; use sp_api::ProvideRuntimeApi; -use sp_runtime::testing::H256; use xcm::prelude::*; -use xcm_fee_payment_runtime_api::{dry_run::XcmDryRunApi, fees::XcmPaymentApi}; +use xcm_runtime_apis::{dry_run::DryRunApi, fees::XcmPaymentApi}; mod mock; use mock::{ - extra, fake_message_hash, new_test_ext_with_balances, new_test_ext_with_balances_and_assets, - DeliveryFees, ExistentialDeposit, HereLocation, RuntimeCall, RuntimeEvent, TestClient, TestXt, + fake_message_hash, new_test_ext_with_balances, new_test_ext_with_balances_and_assets, + DeliveryFees, ExistentialDeposit, HereLocation, OriginCaller, RuntimeCall, RuntimeEvent, + TestClient, }; // Scenario: User `1` in the local chain (id 2000) wants to transfer assets to account `[0u8; 32]` @@ -43,33 +41,33 @@ use mock::{ // Parachain(2000) -------------------------------------------> Parachain(1000) #[test] fn fee_estimation_for_teleport() { - let _ = env_logger::builder().is_test(true).try_init(); + sp_tracing::init_for_tests(); let who = 1; // AccountId = u64. let balances = vec![(who, 100 + DeliveryFees::get() + ExistentialDeposit::get())]; let assets = vec![(1, who, 50)]; new_test_ext_with_balances_and_assets(balances, assets).execute_with(|| { let client = TestClient; let runtime_api = client.runtime_api(); - let extrinsic = TestXt::new( - RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets { - dest: Box::new(VersionedLocation::V4((Parent, Parachain(1000)).into())), - beneficiary: Box::new(VersionedLocation::V4( - AccountId32 { id: [0u8; 32], network: None }.into(), - )), - assets: Box::new(VersionedAssets::V4( - vec![(Here, 100u128).into(), (Parent, 20u128).into()].into(), - )), - fee_asset_item: 1, // Fees are paid with the RelayToken - weight_limit: Unlimited, - }), - Some((who, extra())), - ); + let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets { + dest: Box::new(VersionedLocation::from((Parent, Parachain(1000)))), + beneficiary: Box::new(VersionedLocation::from(AccountId32 { + id: [0u8; 32], + network: None, + })), + assets: Box::new(VersionedAssets::from(vec![ + (Here, 100u128).into(), + (Parent, 20u128).into(), + ])), + fee_asset_item: 1, // Fees are paid with the RelayToken + weight_limit: Unlimited, + }); + let origin = OriginCaller::system(RawOrigin::Signed(who)); let dry_run_effects = - runtime_api.dry_run_extrinsic(H256::zero(), extrinsic).unwrap().unwrap(); + runtime_api.dry_run_call(H256::zero(), origin, call).unwrap().unwrap(); assert_eq!( dry_run_effects.local_xcm, - Some(VersionedXcm::V4( + Some(VersionedXcm::from( Xcm::builder_unsafe() .withdraw_asset((Parent, 20u128)) .burn_asset((Parent, 20u128)) @@ -89,8 +87,8 @@ fn fee_estimation_for_teleport() { assert_eq!( dry_run_effects.forwarded_xcms, vec![( - VersionedLocation::V4(send_destination.clone()), - vec![VersionedXcm::V4(send_message.clone())], + VersionedLocation::from(send_destination.clone()), + vec![VersionedXcm::from(send_message.clone())], ),], ); @@ -128,14 +126,6 @@ fn fee_estimation_for_teleport() { message: send_message.clone(), message_id: fake_message_hash(&send_message), }), - RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess { - dispatch_info: DispatchInfo { - weight: Weight::from_parts(107074070, 0), /* Will break if weights get - * updated. */ - class: DispatchClass::Normal, - pays_fee: Pays::Yes, - } - }), ] ); @@ -153,7 +143,7 @@ fn fee_estimation_for_teleport() { .query_weight_to_asset_fee( H256::zero(), weight, - VersionedAssetId::V4(HereLocation::get().into()), + VersionedAssetId::from(AssetId(HereLocation::get())), ) .unwrap() .unwrap(); @@ -168,7 +158,7 @@ fn fee_estimation_for_teleport() { .query_delivery_fees(H256::zero(), destination.clone(), remote_message.clone()) .unwrap() .unwrap(); - assert_eq!(delivery_fees, VersionedAssets::V4((Here, 20u128).into())); + assert_eq!(delivery_fees, VersionedAssets::from((Here, 20u128))); // This would have to be the runtime API of the destination, // which we have the location for. @@ -182,7 +172,7 @@ fn fee_estimation_for_teleport() { .query_weight_to_asset_fee( H256::zero(), remote_execution_weight, - VersionedAssetId::V4(HereLocation::get().into()), + VersionedAssetId::from(AssetId(HereLocation::get())), ) .unwrap() .unwrap(); @@ -205,7 +195,7 @@ fn fee_estimation_for_teleport() { // Parachain(2000) -------------------------------------------> Parachain(1000) #[test] fn dry_run_reserve_asset_transfer() { - let _ = env_logger::builder().is_test(true).try_init(); + sp_tracing::init_for_tests(); let who = 1; // AccountId = u64. // Native token used for fees. let balances = vec![(who, DeliveryFees::get() + ExistentialDeposit::get())]; @@ -214,24 +204,23 @@ fn dry_run_reserve_asset_transfer() { new_test_ext_with_balances_and_assets(balances, assets).execute_with(|| { let client = TestClient; let runtime_api = client.runtime_api(); - let extrinsic = TestXt::new( - RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets { - dest: Box::new(VersionedLocation::V4((Parent, Parachain(1000)).into())), - beneficiary: Box::new(VersionedLocation::V4( - AccountId32 { id: [0u8; 32], network: None }.into(), - )), - assets: Box::new(VersionedAssets::V4((Parent, 100u128).into())), - fee_asset_item: 0, - weight_limit: Unlimited, - }), - Some((who, extra())), - ); + let call = RuntimeCall::XcmPallet(pallet_xcm::Call::transfer_assets { + dest: Box::new(VersionedLocation::from((Parent, Parachain(1000)))), + beneficiary: Box::new(VersionedLocation::from(AccountId32 { + id: [0u8; 32], + network: None, + })), + assets: Box::new(VersionedAssets::from((Parent, 100u128))), + fee_asset_item: 0, + weight_limit: Unlimited, + }); + let origin = OriginCaller::system(RawOrigin::Signed(who)); let dry_run_effects = - runtime_api.dry_run_extrinsic(H256::zero(), extrinsic).unwrap().unwrap(); + runtime_api.dry_run_call(H256::zero(), origin, call).unwrap().unwrap(); assert_eq!( dry_run_effects.local_xcm, - Some(VersionedXcm::V4( + Some(VersionedXcm::from( Xcm::builder_unsafe() .withdraw_asset((Parent, 100u128)) .burn_asset((Parent, 100u128)) @@ -251,8 +240,8 @@ fn dry_run_reserve_asset_transfer() { assert_eq!( dry_run_effects.forwarded_xcms, vec![( - VersionedLocation::V4(send_destination.clone()), - vec![VersionedXcm::V4(send_message.clone())], + VersionedLocation::from(send_destination.clone()), + vec![VersionedXcm::from(send_message.clone())], ),], ); @@ -278,14 +267,6 @@ fn dry_run_reserve_asset_transfer() { message: send_message.clone(), message_id: fake_message_hash(&send_message), }), - RuntimeEvent::System(frame_system::Event::ExtrinsicSuccess { - dispatch_info: DispatchInfo { - weight: Weight::from_parts(107074066, 0), /* Will break if weights get - * updated. */ - class: DispatchClass::Normal, - pays_fee: Pays::Yes, - } - }), ] ); }); @@ -293,7 +274,7 @@ fn dry_run_reserve_asset_transfer() { #[test] fn dry_run_xcm() { - let _ = env_logger::builder().is_test(true).try_init(); + sp_tracing::init_for_tests(); let who = 1; // AccountId = u64. let transfer_amount = 100u128; // We need to build the XCM to weigh it and then build the real XCM that can pay for fees. @@ -310,11 +291,15 @@ fn dry_run_xcm() { let client = TestClient; let runtime_api = client.runtime_api(); let xcm_weight = runtime_api - .query_xcm_weight(H256::zero(), VersionedXcm::V4(xcm_to_weigh.clone().into())) + .query_xcm_weight(H256::zero(), VersionedXcm::from(xcm_to_weigh.clone().into())) .unwrap() .unwrap(); let execution_fees = runtime_api - .query_weight_to_asset_fee(H256::zero(), xcm_weight, VersionedAssetId::V4(Here.into())) + .query_weight_to_asset_fee( + H256::zero(), + xcm_weight, + VersionedAssetId::from(AssetId(Here.into())), + ) .unwrap() .unwrap(); let xcm = Xcm::::builder_unsafe() @@ -331,16 +316,16 @@ fn dry_run_xcm() { let dry_run_effects = runtime_api .dry_run_xcm( H256::zero(), - VersionedLocation::V4(AccountIndex64 { index: 1, network: None }.into()), - VersionedXcm::V4(xcm), + VersionedLocation::from([AccountIndex64 { index: 1, network: None }]), + VersionedXcm::from(xcm), ) .unwrap() .unwrap(); assert_eq!( dry_run_effects.forwarded_xcms, vec![( - VersionedLocation::V4((Parent, Parachain(2100)).into()), - vec![VersionedXcm::V4( + VersionedLocation::from((Parent, Parachain(2100))), + vec![VersionedXcm::from( Xcm::<()>::builder_unsafe() .reserve_asset_deposited(( (Parent, Parachain(2000)), diff --git a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs b/polkadot/xcm/xcm-runtime-apis/tests/mock.rs similarity index 86% rename from polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs rename to polkadot/xcm/xcm-runtime-apis/tests/mock.rs index d7b18d90a501815018fde21e25481872e33753a6..c76b26fcd2a337545450da4d77cb0103c3e8eb8c 100644 --- a/polkadot/xcm/xcm-fee-payment-runtime-api/tests/mock.rs +++ b/polkadot/xcm/xcm-runtime-apis/tests/mock.rs @@ -18,8 +18,13 @@ //! Implements both runtime APIs for fee estimation and getting the messages for transfers. use codec::Encode; +use core::{cell::RefCell, marker::PhantomData}; use frame_support::{ - construct_runtime, derive_impl, parameter_types, + construct_runtime, derive_impl, parameter_types, sp_runtime, + sp_runtime::{ + traits::{Dispatchable, Get, IdentityLookup, MaybeEquivalence, TryConvert}, + BuildStorage, SaturatedConversion, + }, traits::{ AsEnsureOriginWithArg, ConstU128, ConstU32, Contains, ContainsPair, Everything, Nothing, OriginTrait, @@ -28,11 +33,6 @@ use frame_support::{ }; use frame_system::{EnsureRoot, RawOrigin as SystemRawOrigin}; use pallet_xcm::TestWeightInfo; -use sp_runtime::{ - traits::{Block as BlockT, Get, IdentityLookup, MaybeEquivalence, TryConvert}, - BuildStorage, SaturatedConversion, -}; -use sp_std::{cell::RefCell, marker::PhantomData}; use xcm::{prelude::*, Version as XcmVersion}; use xcm_builder::{ AllowTopLevelPaidExecutionFrom, ConvertedConcreteId, EnsureXcmOrigin, FixedRateOfFungible, @@ -44,8 +44,9 @@ use xcm_executor::{ XcmExecutor, }; -use xcm_fee_payment_runtime_api::{ - dry_run::{Error as XcmDryRunApiError, ExtrinsicDryRunEffects, XcmDryRunApi, XcmDryRunEffects}, +use xcm_runtime_apis::{ + conversions::{Error as LocationToAccountApiError, LocationToAccountApi}, + dry_run::{CallDryRunEffects, DryRunApi, Error as XcmDryRunApiError, XcmDryRunEffects}, fees::{Error as XcmPaymentApiError, XcmPaymentApi}, }; @@ -58,30 +59,13 @@ construct_runtime! { } } -pub type SignedExtra = ( - // frame_system::CheckEra, - // frame_system::CheckNonce, - frame_system::CheckWeight, -); +pub type SignedExtra = (frame_system::CheckWeight,); pub type TestXt = sp_runtime::testing::TestXt; type Block = sp_runtime::testing::Block; type Balance = u128; type AssetIdForAssetsPallet = u32; type AccountId = u64; -pub fn extra() -> SignedExtra { - (frame_system::CheckWeight::new(),) -} - -type Executive = frame_executive::Executive< - TestRuntime, - Block, - frame_system::ChainContext, - TestRuntime, - AllPalletsWithSystem, - (), ->; - #[derive_impl(frame_system::config_preludes::TestDefaultConfig)] impl frame_system::Config for TestRuntime { type Block = Block; @@ -369,6 +353,7 @@ impl pallet_xcm::Config for TestRuntime { type WeightInfo = TestWeightInfo; } +#[allow(dead_code)] pub fn new_test_ext_with_balances(balances: Vec<(AccountId, Balance)>) -> sp_io::TestExternalities { let mut t = frame_system::GenesisConfig::::default().build_storage().unwrap(); @@ -381,6 +366,7 @@ pub fn new_test_ext_with_balances(balances: Vec<(AccountId, Balance)>) -> sp_io: ext } +#[allow(dead_code)] pub fn new_test_ext_with_balances_and_assets( balances: Vec<(AccountId, Balance)>, assets: Vec<(AssetIdForAssetsPallet, AccountId, Balance)>, @@ -403,6 +389,7 @@ pub fn new_test_ext_with_balances_and_assets( (1, "Relay Token".into(), "RLY".into(), 12), ], accounts: assets, + next_asset_id: None, } .assimilate_storage(&mut t) .unwrap(); @@ -427,10 +414,21 @@ impl sp_api::ProvideRuntimeApi for TestClient { } sp_api::mock_impl_runtime_apis! { + impl LocationToAccountApi for RuntimeApi { + fn convert_location(location: VersionedLocation) -> Result { + let location = location.try_into().map_err(|_| LocationToAccountApiError::VersionedConversionFailed)?; + LocationToAccountId::convert_location(&location) + .ok_or(LocationToAccountApiError::Unsupported) + } + } + impl XcmPaymentApi for RuntimeApi { fn query_acceptable_payment_assets(xcm_version: XcmVersion) -> Result, XcmPaymentApiError> { - if xcm_version != 4 { return Err(XcmPaymentApiError::UnhandledXcmVersion) }; - Ok(vec![VersionedAssetId::V4(HereLocation::get().into())]) + Ok(vec![ + VersionedAssetId::from(AssetId(HereLocation::get())) + .into_version(xcm_version) + .map_err(|_| XcmPaymentApiError::VersionedConversionFailed)? + ]) } fn query_xcm_weight(message: VersionedXcm<()>) -> Result { @@ -438,14 +436,25 @@ sp_api::mock_impl_runtime_apis! { } fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result { - let local_asset = VersionedAssetId::V4(HereLocation::get().into()); - let asset = asset - .into_version(4) - .map_err(|_| XcmPaymentApiError::VersionedConversionFailed)?; - - if asset != local_asset { return Err(XcmPaymentApiError::AssetNotFound); } - - Ok(WeightToFee::weight_to_fee(&weight)) + match asset.try_as::() { + Ok(asset_id) if asset_id.0 == HereLocation::get() => { + Ok(WeightToFee::weight_to_fee(&weight)) + }, + Ok(asset_id) => { + log::trace!( + target: "xcm::XcmPaymentApi::query_weight_to_asset_fee", + "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!" + ); + Err(XcmPaymentApiError::AssetNotFound) + }, + Err(_) => { + log::trace!( + target: "xcm::XcmPaymentApi::query_weight_to_asset_fee", + "query_weight_to_asset_fee - failed to convert asset: {asset:?}!" + ); + Err(XcmPaymentApiError::VersionedConversionFailed) + } + } } fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result { @@ -453,30 +462,22 @@ sp_api::mock_impl_runtime_apis! { } } - impl XcmDryRunApi for RuntimeApi { - fn dry_run_extrinsic(extrinsic: ::Extrinsic) -> Result, XcmDryRunApiError> { + impl DryRunApi for RuntimeApi { + fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result, XcmDryRunApiError> { use xcm_executor::RecordXcm; - // We want to record the XCM that's executed, so we can return it. pallet_xcm::Pallet::::set_record_xcm(true); - let result = Executive::apply_extrinsic(extrinsic).map_err(|error| { - log::error!( - target: "xcm::XcmDryRunApi::dry_run_extrinsic", - "Applying extrinsic failed with error {:?}", - error, - ); - XcmDryRunApiError::InvalidExtrinsic - })?; - // Nothing gets committed to storage in runtime APIs, so there's no harm in leaving the flag as true. + let result = call.dispatch(origin.into()); + pallet_xcm::Pallet::::set_record_xcm(false); let local_xcm = pallet_xcm::Pallet::::recorded_xcm(); let forwarded_xcms = sent_xcm() - .into_iter() - .map(|(location, message)| ( - VersionedLocation::V4(location), - vec![VersionedXcm::V4(message)], - )).collect(); - let events: Vec = System::events().iter().map(|record| record.event.clone()).collect(); - Ok(ExtrinsicDryRunEffects { - local_xcm: local_xcm.map(VersionedXcm::<()>::V4), + .into_iter() + .map(|(location, message)| ( + VersionedLocation::from(location), + vec![VersionedXcm::from(message)], + )).collect(); + let events: Vec = System::read_events_no_consensus().map(|record| record.event.clone()).collect(); + Ok(CallDryRunEffects { + local_xcm: local_xcm.map(VersionedXcm::<()>::from), forwarded_xcms, emitted_events: events, execution_result: result, @@ -486,7 +487,7 @@ sp_api::mock_impl_runtime_apis! { fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm) -> Result, XcmDryRunApiError> { let origin_location: Location = origin_location.try_into().map_err(|error| { log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", + target: "xcm::DryRunApi::dry_run_xcm", "Location version conversion failed with error: {:?}", error, ); @@ -494,7 +495,7 @@ sp_api::mock_impl_runtime_apis! { })?; let xcm: Xcm = xcm.try_into().map_err(|error| { log::error!( - target: "xcm::XcmDryRunApi::dry_run_xcm", + target: "xcm::DryRunApi::dry_run_xcm", "Xcm version conversion failed with error {:?}", error, ); @@ -511,8 +512,8 @@ sp_api::mock_impl_runtime_apis! { let forwarded_xcms = sent_xcm() .into_iter() .map(|(location, message)| ( - VersionedLocation::V4(location), - vec![VersionedXcm::V4(message)], + VersionedLocation::from(location), + vec![VersionedXcm::from(message)], )).collect(); let events: Vec = System::events().iter().map(|record| record.event.clone()).collect(); Ok(XcmDryRunEffects { diff --git a/polkadot/xcm/xcm-simulator/Cargo.toml b/polkadot/xcm/xcm-simulator/Cargo.toml index c1c48b6d4c5eb6195a60152f29bdb61e2ad80a79..c7caa49393ed5c7fa505b38d1a2eaac208d63465 100644 --- a/polkadot/xcm/xcm-simulator/Cargo.toml +++ b/polkadot/xcm/xcm-simulator/Cargo.toml @@ -10,16 +10,20 @@ license.workspace = true workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -paste = "1.0.7" +codec = { workspace = true, default-features = true } +scale-info = { workspace = true } +paste = { workspace = true, default-features = true } -frame-support = { path = "../../../substrate/frame/support" } -sp-io = { path = "../../../substrate/primitives/io" } -sp-std = { path = "../../../substrate/primitives/std" } +frame-support = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } -xcm = { package = "staging-xcm", path = ".." } -xcm-executor = { package = "staging-xcm-executor", path = "../xcm-executor" } -xcm-builder = { package = "staging-xcm-builder", path = "../xcm-builder" } -polkadot-core-primitives = { path = "../../core-primitives" } -polkadot-parachain-primitives = { path = "../../parachain" } -polkadot-runtime-parachains = { path = "../../runtime/parachains" } +xcm = { workspace = true, default-features = true } +xcm-executor = { workspace = true, default-features = true } +xcm-builder = { workspace = true, default-features = true } +polkadot-primitives = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } diff --git a/polkadot/xcm/xcm-simulator/example/Cargo.toml b/polkadot/xcm/xcm-simulator/example/Cargo.toml index 0e13a10a14106c92d56d288d210b57f3888068b2..e0aff9b7782a7e4fa8c73dc5cfaae51af2035533 100644 --- a/polkadot/xcm/xcm-simulator/example/Cargo.toml +++ b/polkadot/xcm/xcm-simulator/example/Cargo.toml @@ -10,29 +10,29 @@ version = "7.0.0" workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -scale-info = { version = "2.11.1", features = ["derive"] } +codec = { workspace = true, default-features = true } +scale-info = { features = ["derive"], workspace = true, default-features = true } log = { workspace = true } -frame-system = { path = "../../../../substrate/frame/system" } -frame-support = { path = "../../../../substrate/frame/support" } -pallet-balances = { path = "../../../../substrate/frame/balances" } -pallet-message-queue = { path = "../../../../substrate/frame/message-queue" } -pallet-uniques = { path = "../../../../substrate/frame/uniques" } -sp-std = { path = "../../../../substrate/primitives/std" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-io = { path = "../../../../substrate/primitives/io" } -sp-tracing = { path = "../../../../substrate/primitives/tracing" } +frame-system = { workspace = true, default-features = true } +frame-support = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-message-queue = { workspace = true, default-features = true } +pallet-uniques = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } -xcm = { package = "staging-xcm", path = "../.." } -xcm-simulator = { path = ".." } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm-executor" } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm-builder" } -pallet-xcm = { path = "../../pallet-xcm" } -polkadot-core-primitives = { path = "../../../core-primitives" } -polkadot-runtime-parachains = { path = "../../../runtime/parachains" } -polkadot-parachain-primitives = { path = "../../../parachain" } +xcm = { workspace = true, default-features = true } +xcm-simulator = { workspace = true, default-features = true } +xcm-executor = { workspace = true, default-features = true } +xcm-builder = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } [features] default = [] diff --git a/polkadot/xcm/xcm-simulator/example/src/parachain/mod.rs b/polkadot/xcm/xcm-simulator/example/src/parachain/mod.rs index 8021f9551658075fa672c02306ade1bd12298e4d..bfb455aba3f9302200d58bcd6b7c074d1053468f 100644 --- a/polkadot/xcm/xcm-simulator/example/src/parachain/mod.rs +++ b/polkadot/xcm/xcm-simulator/example/src/parachain/mod.rs @@ -16,7 +16,6 @@ //! Parachain runtime mock. -mod mock_msg_queue; mod xcm_config; pub use xcm_config::*; @@ -32,10 +31,10 @@ use sp_runtime::{ traits::{Get, IdentityLookup}, AccountId32, }; -use sp_std::prelude::*; use xcm::latest::prelude::*; use xcm_builder::{EnsureXcmOrigin, SignedToAccountId32}; use xcm_executor::{traits::ConvertLocation, XcmExecutor}; +use xcm_simulator::mock_message_queue; pub type AccountId = AccountId32; pub type Balance = u128; @@ -101,7 +100,7 @@ impl EnsureOriginWithArg for ForeignCreators { fn try_origin( o: RuntimeOrigin, a: &Location, - ) -> sp_std::result::Result { + ) -> core::result::Result { let origin_location = pallet_xcm::EnsureXcm::::try_origin(o.clone())?; if !a.starts_with(&origin_location) { return Err(o); @@ -121,7 +120,7 @@ parameter_types! { pub const ReservedDmpWeight: Weight = Weight::from_parts(WEIGHT_REF_TIME_PER_SECOND.saturating_div(4), 0); } -impl mock_msg_queue::Config for Runtime { +impl mock_message_queue::Config for Runtime { type RuntimeEvent = RuntimeEvent; type XcmExecutor = XcmExecutor; } @@ -175,7 +174,7 @@ construct_runtime!( pub struct Runtime { System: frame_system, Balances: pallet_balances, - MsgQueue: mock_msg_queue, + MsgQueue: mock_message_queue, PolkadotXcm: pallet_xcm, ForeignUniques: pallet_uniques, } diff --git a/polkadot/xcm/xcm-simulator/example/src/parachain/xcm_config/constants.rs b/polkadot/xcm/xcm-simulator/example/src/parachain/xcm_config/constants.rs index f6d0174def8f40162f8f2c75231f9b2bad7df0fd..0769507ec37b70e5f6d60886c4db7db9a866dc0d 100644 --- a/polkadot/xcm/xcm-simulator/example/src/parachain/xcm_config/constants.rs +++ b/polkadot/xcm/xcm-simulator/example/src/parachain/xcm_config/constants.rs @@ -14,9 +14,10 @@ // You should have received a copy of the GNU General Public License // along with Polkadot. If not, see . -use crate::parachain::MsgQueue; +use crate::parachain::Runtime; use frame_support::parameter_types; use xcm::latest::prelude::*; +use xcm_simulator::mock_message_queue::ParachainId; parameter_types! { pub KsmPerSecondPerByte: (AssetId, u128, u128) = (AssetId(Parent.into()), 1, 1); @@ -26,5 +27,5 @@ parameter_types! { parameter_types! { pub const KsmLocation: Location = Location::parent(); pub const RelayNetwork: NetworkId = NetworkId::Kusama; - pub UniversalLocation: InteriorLocation = [GlobalConsensus(RelayNetwork::get()), Parachain(MsgQueue::parachain_id().into())].into(); + pub UniversalLocation: InteriorLocation = [GlobalConsensus(RelayNetwork::get()), Parachain(ParachainId::::get().into())].into(); } diff --git a/polkadot/xcm/xcm-simulator/example/src/tests.rs b/polkadot/xcm/xcm-simulator/example/src/tests.rs index 6486a849af363af6b41bb40ff440efa5424e92eb..34c1feb6e946876bb62a5624915e414df65ed35e 100644 --- a/polkadot/xcm/xcm-simulator/example/src/tests.rs +++ b/polkadot/xcm/xcm-simulator/example/src/tests.rs @@ -19,7 +19,7 @@ use crate::*; use codec::Encode; use frame_support::{assert_ok, weights::Weight}; use xcm::latest::QueryResponseInfo; -use xcm_simulator::TestExt; +use xcm_simulator::{mock_message_queue::ReceivedDmp, TestExt}; // Helper function for forming buy execution message fn buy_execution(fees: impl Into) -> Instruction { @@ -171,7 +171,7 @@ fn remote_locking_and_unlocking() { ParaA::execute_with(|| { assert_eq!( - parachain::MsgQueue::received_dmp(), + ReceivedDmp::::get(), vec![Xcm(vec![NoteUnlockable { owner: (Parent, Parachain(2)).into(), asset: (Parent, locked_amount).into() @@ -501,7 +501,7 @@ fn query_holding() { // Check that QueryResponse message was received ParaA::execute_with(|| { assert_eq!( - parachain::MsgQueue::received_dmp(), + ReceivedDmp::::get(), vec![Xcm(vec![QueryResponse { query_id: query_id_set, response: Response::Assets(Assets::new()), diff --git a/polkadot/xcm/xcm-simulator/fuzzer/Cargo.toml b/polkadot/xcm/xcm-simulator/fuzzer/Cargo.toml index ca794a07bfb0c73df251d49c2e08a970ea5cf994..04f8ba115173465b14127cb277bcc74776ea1a5b 100644 --- a/polkadot/xcm/xcm-simulator/fuzzer/Cargo.toml +++ b/polkadot/xcm/xcm-simulator/fuzzer/Cargo.toml @@ -11,30 +11,30 @@ publish = false workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -honggfuzz = "0.5.55" -arbitrary = "1.3.2" -scale-info = { version = "2.11.1", features = ["derive"] } +codec = { workspace = true, default-features = true } +honggfuzz = { workspace = true } +arbitrary = { workspace = true } +scale-info = { features = ["derive"], workspace = true, default-features = true } -frame-system = { path = "../../../../substrate/frame/system" } -frame-support = { path = "../../../../substrate/frame/support" } -frame-executive = { path = "../../../../substrate/frame/executive" } -frame-try-runtime = { path = "../../../../substrate/frame/try-runtime" } -pallet-balances = { path = "../../../../substrate/frame/balances" } -pallet-message-queue = { path = "../../../../substrate/frame/message-queue" } -sp-std = { path = "../../../../substrate/primitives/std" } -sp-core = { path = "../../../../substrate/primitives/core" } -sp-runtime = { path = "../../../../substrate/primitives/runtime" } -sp-io = { path = "../../../../substrate/primitives/io" } +frame-system = { workspace = true, default-features = true } +frame-support = { workspace = true, default-features = true } +frame-executive = { workspace = true, default-features = true } +frame-try-runtime = { workspace = true, default-features = true } +pallet-balances = { workspace = true, default-features = true } +pallet-message-queue = { workspace = true, default-features = true } +sp-std = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } -xcm = { package = "staging-xcm", path = "../.." } -xcm-simulator = { path = ".." } -xcm-executor = { package = "staging-xcm-executor", path = "../../xcm-executor" } -xcm-builder = { package = "staging-xcm-builder", path = "../../xcm-builder" } -pallet-xcm = { path = "../../pallet-xcm" } -polkadot-core-primitives = { path = "../../../core-primitives" } -polkadot-runtime-parachains = { path = "../../../runtime/parachains" } -polkadot-parachain-primitives = { path = "../../../parachain" } +xcm = { workspace = true, default-features = true } +xcm-simulator = { workspace = true, default-features = true } +xcm-executor = { workspace = true, default-features = true } +xcm-builder = { workspace = true, default-features = true } +pallet-xcm = { workspace = true, default-features = true } +polkadot-core-primitives = { workspace = true, default-features = true } +polkadot-runtime-parachains = { workspace = true, default-features = true } +polkadot-parachain-primitives = { workspace = true, default-features = true } [features] try-runtime = [ diff --git a/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs b/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs index 502bcca2d44270263a45eeaf305b924d8b37c509..616329a2f06b43f73d059a3471f49c2d7fa82e95 100644 --- a/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs +++ b/polkadot/xcm/xcm-simulator/fuzzer/src/parachain.rs @@ -24,13 +24,11 @@ use frame_support::{ }; use frame_system::EnsureRoot; -use sp_core::ConstU32; use sp_runtime::{ generic, traits::{AccountIdLookup, BlakeTwo256, Hash, IdentifyAccount, Verify}, MultiAddress, MultiSignature, }; -use sp_std::prelude::*; use pallet_xcm::XcmPassthrough; use polkadot_core_primitives::BlockNumber as RelayBlockNumber; @@ -73,24 +71,13 @@ impl frame_system::Config for Runtime { parameter_types! { pub ExistentialDeposit: Balance = 1; - pub const MaxLocks: u32 = 50; - pub const MaxReserves: u32 = 50; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Runtime { - type MaxLocks = MaxLocks; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } parameter_types! { diff --git a/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs b/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs index 4740aee83d870a0e260512ac15a982c515a1e803..459d2640b6d908b14e0964aa2e2a697f95c7dbd3 100644 --- a/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs +++ b/polkadot/xcm/xcm-simulator/fuzzer/src/relay_chain.rs @@ -72,24 +72,13 @@ impl frame_system::Config for Runtime { parameter_types! { pub ExistentialDeposit: Balance = 1; - pub const MaxLocks: u32 = 50; - pub const MaxReserves: u32 = 50; } +#[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)] impl pallet_balances::Config for Runtime { - type MaxLocks = MaxLocks; type Balance = Balance; - type RuntimeEvent = RuntimeEvent; - type DustRemoval = (); type ExistentialDeposit = ExistentialDeposit; type AccountStore = System; - type WeightInfo = (); - type MaxReserves = MaxReserves; - type ReserveIdentifier = [u8; 8]; - type RuntimeHoldReason = RuntimeHoldReason; - type RuntimeFreezeReason = RuntimeFreezeReason; - type FreezeIdentifier = (); - type MaxFreezes = ConstU32<0>; } impl shared::Config for Runtime { diff --git a/polkadot/xcm/xcm-simulator/src/lib.rs b/polkadot/xcm/xcm-simulator/src/lib.rs index 7efbc658bbfb8bc3fadfa037ae966ca935816ba6..59df394406ea00fd3a3d0edb5e78efe1475e77bc 100644 --- a/polkadot/xcm/xcm-simulator/src/lib.rs +++ b/polkadot/xcm/xcm-simulator/src/lib.rs @@ -16,15 +16,22 @@ //! Test kit to simulate cross-chain message passing and XCM execution. +/// Implementation of a simple message queue. +/// Used for sending messages. +pub mod mock_message_queue; + +extern crate alloc; + pub use codec::Encode; pub use paste; +pub use alloc::collections::vec_deque::VecDeque; +pub use core::{cell::RefCell, marker::PhantomData}; pub use frame_support::{ traits::{EnqueueMessage, Get, ProcessMessage, ProcessMessageError, ServiceQueues}, weights::{Weight, WeightMeter}, }; pub use sp_io::{hashing::blake2_256, TestExternalities}; -pub use sp_std::{cell::RefCell, collections::vec_deque::VecDeque, marker::PhantomData}; pub use polkadot_core_primitives::BlockNumber as RelayBlockNumber; pub use polkadot_parachain_primitives::primitives::{ diff --git a/polkadot/xcm/xcm-simulator/src/mock_message_queue.rs b/polkadot/xcm/xcm-simulator/src/mock_message_queue.rs new file mode 100644 index 0000000000000000000000000000000000000000..bf7b0e15967c027738751cff3edaa27c29f41a0c --- /dev/null +++ b/polkadot/xcm/xcm-simulator/src/mock_message_queue.rs @@ -0,0 +1,189 @@ +// Copyright Parity Technologies (UK) Ltd. +// This file is part of Polkadot. + +// Polkadot 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. + +// Polkadot 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 Polkadot. If not, see . + +//! Simple mock message queue. + +use codec::{Decode, Encode}; + +use polkadot_parachain_primitives::primitives::{ + DmpMessageHandler, Id as ParaId, XcmpMessageFormat, XcmpMessageHandler, +}; +use polkadot_primitives::BlockNumber as RelayBlockNumber; +use sp_runtime::traits::{Get, Hash}; + +use xcm::{latest::prelude::*, VersionedXcm}; + +pub use pallet::*; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + use frame_support::pallet_prelude::*; + + #[pallet::config] + pub trait Config: frame_system::Config { + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + type XcmExecutor: ExecuteXcm; + } + + #[pallet::call] + impl Pallet {} + + #[pallet::pallet] + #[pallet::without_storage_info] + pub struct Pallet(_); + + #[pallet::storage] + pub type ParachainId = StorageValue<_, ParaId, ValueQuery>; + + #[pallet::storage] + /// A queue of received DMP messages + pub type ReceivedDmp = StorageValue<_, Vec>, ValueQuery>; + + impl Get for Pallet { + fn get() -> ParaId { + ParachainId::::get() + } + } + + pub type MessageId = [u8; 32]; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + // XCMP + /// Some XCM was executed OK. + Success { message_id: Option }, + /// Some XCM failed. + Fail { message_id: Option, error: XcmError }, + /// Bad XCM version used. + BadVersion { message_id: Option }, + /// Bad XCM format used. + BadFormat { message_id: Option }, + + // DMP + /// Downward message is invalid XCM. + InvalidFormat { message_id: MessageId }, + /// Downward message is unsupported version of XCM. + UnsupportedVersion { message_id: MessageId }, + /// Downward message executed with the given outcome. + ExecutedDownward { message_id: MessageId, outcome: Outcome }, + } + + impl Pallet { + pub fn set_para_id(para_id: ParaId) { + ParachainId::::put(para_id); + } + + fn handle_xcmp_message( + sender: ParaId, + _sent_at: RelayBlockNumber, + xcm: VersionedXcm, + max_weight: xcm::latest::Weight, + ) -> Result { + let hash = Encode::using_encoded(&xcm, T::Hashing::hash); + let mut message_hash = Encode::using_encoded(&xcm, sp_io::hashing::blake2_256); + let (result, event) = match Xcm::::try_from(xcm) { + Ok(xcm) => { + let location = (Parent, Parachain(sender.into())); + match T::XcmExecutor::prepare_and_execute( + location, + xcm, + &mut message_hash, + max_weight, + Weight::zero(), + ) { + Outcome::Error { error } => + (Err(error), Event::Fail { message_id: Some(hash), error }), + Outcome::Complete { used } => + (Ok(used), Event::Success { message_id: Some(hash) }), + // As far as the caller is concerned, this was dispatched without error, so + // we just report the weight used. + Outcome::Incomplete { used, error } => + (Ok(used), Event::Fail { message_id: Some(hash), error }), + } + }, + Err(()) => ( + Err(XcmError::UnhandledXcmVersion), + Event::BadVersion { message_id: Some(hash) }, + ), + }; + Self::deposit_event(event); + result + } + } + + impl XcmpMessageHandler for Pallet { + fn handle_xcmp_messages<'a, I: Iterator>( + iter: I, + max_weight: xcm::latest::Weight, + ) -> xcm::latest::Weight { + for (sender, sent_at, data) in iter { + let mut data_ref = data; + let _ = XcmpMessageFormat::decode(&mut data_ref) + .expect("Simulator encodes with versioned xcm format; qed"); + + let mut remaining_fragments = data_ref; + while !remaining_fragments.is_empty() { + if let Ok(xcm) = + VersionedXcm::::decode(&mut remaining_fragments) + { + let _ = Self::handle_xcmp_message(sender, sent_at, xcm, max_weight); + } else { + debug_assert!(false, "Invalid incoming XCMP message data"); + } + } + } + max_weight + } + } + + impl DmpMessageHandler for Pallet { + fn handle_dmp_messages( + iter: impl Iterator)>, + limit: Weight, + ) -> Weight { + for (_sent_at, data) in iter { + let mut id = sp_io::hashing::blake2_256(&data[..]); + let maybe_versioned = VersionedXcm::::decode(&mut &data[..]); + match maybe_versioned { + Err(_) => { + Self::deposit_event(Event::InvalidFormat { message_id: id }); + }, + Ok(versioned) => match Xcm::try_from(versioned) { + Err(()) => + Self::deposit_event(Event::UnsupportedVersion { message_id: id }), + Ok(x) => { + let outcome = T::XcmExecutor::prepare_and_execute( + Parent, + x.clone(), + &mut id, + limit, + Weight::zero(), + ); + ReceivedDmp::::append(x); + Self::deposit_event(Event::ExecutedDownward { + message_id: id, + outcome, + }); + }, + }, + } + } + limit + } + } +} diff --git a/polkadot/zombienet_tests/assign-core.js b/polkadot/zombienet_tests/assign-core.js new file mode 100644 index 0000000000000000000000000000000000000000..5ddb86930f5a0a04380e1e4cbef5c96f81db4fe0 --- /dev/null +++ b/polkadot/zombienet_tests/assign-core.js @@ -0,0 +1,48 @@ +async function run(nodeName, networkInfo, args) { + const wsUri = networkInfo.nodesByName[nodeName].wsUri; + const api = await zombie.connect(wsUri); + + let core = Number(args[0]); + + let assignments = []; + + for (let i = 1; i < args.length; i += 2) { + let [para, parts] = [args[i], args[i + 1]]; + + console.log(`Assigning para ${para} to core ${core}`); + + assignments.push( + [{ task: para }, parts] + ); + } + await zombie.util.cryptoWaitReady(); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + + await new Promise(async (resolve, reject) => { + const unsub = await api.tx.sudo + .sudo(api.tx.coretime.assignCore(core, 0, assignments, null)) + .signAndSend(alice, ({ status, isError }) => { + if (status.isInBlock) { + console.log( + `Transaction included at blockhash ${status.asInBlock}`, + ); + } else if (status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${status.asFinalized}`, + ); + unsub(); + return resolve(); + } else if (isError) { + console.log(`Transaction error`); + reject(`Transaction error`); + } + }); + }); + + return 0; +} + +module.exports = { run }; diff --git a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.toml b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.toml index 83f5434edddb19afefcba93a9ce7bb305909c07f..611978a33a5f145274dd3c6c158e0de69a1c436a 100644 --- a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.toml +++ b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.toml @@ -7,11 +7,9 @@ timeout = 1000 [relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] max_validators_per_core = 1 - scheduling_lookahead = 2 num_cores = 3 [relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params] - needed_approvals = 3 max_approval_coalesce_count = 5 [relaychain] @@ -48,4 +46,4 @@ addToGenesis = true [types.Header] number = "u64" parent_hash = "Hash" -post_state = "Hash" \ No newline at end of file +post_state = "Hash" diff --git a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl index d624cbaf9df6a62448db2cef637e6d29a0d419b5..d47ef8f415f7ac9ca94b825de23580ab6131f013 100644 --- a/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl +++ b/polkadot/zombienet_tests/elastic_scaling/0001-basic-3cores-6s-blocks.zndsl @@ -11,8 +11,8 @@ elastic-validator-4: reports node_roles is 4 # Register 2 extra cores to this some-parachain. -elastic-validator-0: js-script ./assign-core.js with "2000,0" return is 0 within 600 seconds -elastic-validator-0: js-script ./assign-core.js with "2000,1" return is 0 within 600 seconds +elastic-validator-0: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds +elastic-validator-0: js-script ./assign-core.js with "1,2000,57600" return is 0 within 600 seconds # Wait for 20 relay chain blocks elastic-validator-0: reports substrate_block_height{status="best"} is at least 20 within 600 seconds diff --git a/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl b/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl index 900a3befbc6fc56f5200e9399f5fe5b21eb7af40..7ba896e1c90397642ff0736477f9c793bdb746ec 100644 --- a/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl +++ b/polkadot/zombienet_tests/elastic_scaling/0002-elastic-scaling-doesnt-break-parachains.zndsl @@ -11,8 +11,8 @@ validator: reports substrate_block_height{status="finalized"} is at least 10 wit validator: parachain 2000 block height is at least 10 within 200 seconds # Register the second core assigned to this parachain. -alice: js-script ./assign-core.js with "2000,0" return is 0 within 600 seconds -alice: js-script ./assign-core.js with "2000,1" return is 0 within 600 seconds +alice: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds +alice: js-script ./assign-core.js with "0,2000,57600" return is 0 within 600 seconds validator: reports substrate_block_height{status="finalized"} is at least 35 within 100 seconds diff --git a/polkadot/zombienet_tests/elastic_scaling/assign-core.js b/polkadot/zombienet_tests/elastic_scaling/assign-core.js deleted file mode 100644 index add63b6d30859d2c50a38a73e33ec75ed3669433..0000000000000000000000000000000000000000 --- a/polkadot/zombienet_tests/elastic_scaling/assign-core.js +++ /dev/null @@ -1,39 +0,0 @@ -async function run(nodeName, networkInfo, args) { - const wsUri = networkInfo.nodesByName[nodeName].wsUri; - const api = await zombie.connect(wsUri); - - let para = Number(args[0]); - let core = Number(args[1]); - console.log(`Assigning para ${para} to core ${core}`); - - await zombie.util.cryptoWaitReady(); - - // account to submit tx - const keyring = new zombie.Keyring({ type: "sr25519" }); - const alice = keyring.addFromUri("//Alice"); - - await new Promise(async (resolve, reject) => { - const unsub = await api.tx.sudo - .sudo(api.tx.coretime.assignCore(core, 0, [[{ task: para }, 57600]], null)) - .signAndSend(alice, ({ status, isError }) => { - if (status.isInBlock) { - console.log( - `Transaction included at blockhash ${status.asInBlock}`, - ); - } else if (status.isFinalized) { - console.log( - `Transaction finalized at blockHash ${status.asFinalized}`, - ); - unsub(); - return resolve(); - } else if (isError) { - console.log(`Transaction error`); - reject(`Transaction error`); - } - }); - }); - - return 0; -} - -module.exports = { run }; diff --git a/polkadot/zombienet_tests/elastic_scaling/assign-core.js b/polkadot/zombienet_tests/elastic_scaling/assign-core.js new file mode 120000 index 0000000000000000000000000000000000000000..eeb6402c06f5e52cedf150f924d6791beb1d9867 --- /dev/null +++ b/polkadot/zombienet_tests/elastic_scaling/assign-core.js @@ -0,0 +1 @@ +../assign-core.js \ No newline at end of file diff --git a/polkadot/zombienet_tests/functional/0003-mmr-generate-and-verify-proof.js b/polkadot/zombienet_tests/functional/0003-mmr-generate-and-verify-proof.js index 6583173e40c38a71d4c0091b10814ff72593dd15..20d0c2a988b1d274a092296be8db5f53a632d931 100644 --- a/polkadot/zombienet_tests/functional/0003-mmr-generate-and-verify-proof.js +++ b/polkadot/zombienet_tests/functional/0003-mmr-generate-and-verify-proof.js @@ -3,9 +3,9 @@ const common = require('./0003-common.js'); async function run(nodeName, networkInfo, nodeNames) { const apis = await common.getApis(networkInfo, nodeNames); - const proof = await apis[nodeName].rpc.mmr.generateProof([1, 9, 20]); - - const root = await apis[nodeName].rpc.mmr.root() + let at = await apis[nodeName].rpc.chain.getBlockHash(21); + const root = await apis[nodeName].rpc.mmr.root(at); + const proof = await apis[nodeName].rpc.mmr.generateProof([1, 9, 20], 21, at); const proofVerifications = await Promise.all( Object.values(apis).map(async (api) => { diff --git a/polkadot/zombienet_tests/functional/0013-enable-node-feature.js b/polkadot/zombienet_tests/functional/0013-enable-node-feature.js new file mode 100644 index 0000000000000000000000000000000000000000..5fe2e38dad7d4f0ba340e48617445ae7f907fce5 --- /dev/null +++ b/polkadot/zombienet_tests/functional/0013-enable-node-feature.js @@ -0,0 +1,35 @@ +async function run(nodeName, networkInfo, index) { + const { wsUri, userDefinedTypes } = networkInfo.nodesByName[nodeName]; + const api = await zombie.connect(wsUri, userDefinedTypes); + + await zombie.util.cryptoWaitReady(); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + + await new Promise(async (resolve, reject) => { + const unsub = await api.tx.sudo + .sudo(api.tx.configuration.setNodeFeature(Number(index), true)) + .signAndSend(alice, ({ status, isError }) => { + if (status.isInBlock) { + console.log( + `Transaction included at blockhash ${status.asInBlock}`, + ); + } else if (status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${status.asFinalized}`, + ); + unsub(); + return resolve(); + } else if (isError) { + console.log(`Transaction error`); + reject(`Transaction error`); + } + }); + }); + + return 0; +} + +module.exports = { run }; diff --git a/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml new file mode 100644 index 0000000000000000000000000000000000000000..67925a3d3a7c64201cede004b20fc52dfbae181c --- /dev/null +++ b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.toml @@ -0,0 +1,46 @@ +[settings] +timeout = 1000 +bootnode = true + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] + max_validators_per_core = 2 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config] + needed_approvals = 4 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +default_command = "polkadot" + +[relaychain.default_resources] +limits = { memory = "4G", cpu = "2" } +requests = { memory = "2G", cpu = "1" } + + [[relaychain.nodes]] + name = "alice" + validator = "true" + + [[relaychain.node_groups]] + name = "validator" + count = 3 + args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace"] + +{% for id in range(2000,2002) %} +[[parachains]] +id = {{id}} +addToGenesis = true +cumulus_based = true +chain = "glutton-westend-local-{{id}}" + [parachains.genesis.runtimeGenesis.patch.glutton] + compute = "50000000" + storage = "2500000000" + trashDataCount = 5120 + + [parachains.collator] + name = "collator" + image = "{{CUMULUS_IMAGE}}" + command = "polkadot-parachain" + args = ["-lparachain=debug"] + +{% endfor %} diff --git a/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..e9e5a429e2a2c4913a61e30fc45114f65a939300 --- /dev/null +++ b/polkadot/zombienet_tests/functional/0013-systematic-chunk-recovery.zndsl @@ -0,0 +1,43 @@ +Description: Systematic chunk recovery is used if the chunk mapping feature is enabled. +Network: ./0013-systematic-chunk-recovery.toml +Creds: config + +# Check authority status. +alice: reports node_roles is 4 +validator: reports node_roles is 4 + +# Ensure parachains are registered. +validator: parachain 2000 is registered within 60 seconds +validator: parachain 2001 is registered within 60 seconds + +# Ensure parachains made progress and approval checking works. +validator: parachain 2000 block height is at least 15 within 600 seconds +validator: parachain 2001 block height is at least 15 within 600 seconds + +validator: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds + +validator: reports polkadot_parachain_approval_checking_finality_lag < 3 + +validator: reports polkadot_parachain_approvals_no_shows_total < 3 within 100 seconds + +# Ensure we used regular chunk recovery and that there are no failed recoveries. +validator: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds +validator: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds +validator: count of log lines containing "Data recovery from systematic chunks is not possible" is 0 within 10 seconds +validator: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds +validator: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds + +# Enable the chunk mapping feature +alice: js-script ./0013-enable-node-feature.js with "2" return is 0 within 600 seconds + +validator: reports substrate_block_height{status="finalized"} is at least 60 within 400 seconds + +validator: reports polkadot_parachain_approval_checking_finality_lag < 3 + +validator: reports polkadot_parachain_approvals_no_shows_total < 3 within 100 seconds + +# Ensure we used systematic chunk recovery and that there are no failed recoveries. +validator: count of log lines containing "Data recovery from systematic chunks complete" is at least 10 within 300 seconds +validator: count of log lines containing "Data recovery from systematic chunks is not possible" is 0 within 10 seconds +validator: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds +validator: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds diff --git a/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml new file mode 100644 index 0000000000000000000000000000000000000000..881abab64fd07b8495189982119b3f985332b8a7 --- /dev/null +++ b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.toml @@ -0,0 +1,48 @@ +[settings] +timeout = 1000 +bootnode = true + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] + max_validators_per_core = 2 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config] + needed_approvals = 4 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +default_command = "polkadot" + +[relaychain.default_resources] +limits = { memory = "4G", cpu = "2" } +requests = { memory = "2G", cpu = "1" } + + [[relaychain.node_groups]] + # Use an image that doesn't speak /req_chunk/2 protocol. + image = "{{POLKADOT_IMAGE}}:master-bde0bbe5" + name = "old" + count = 2 + args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace"] + + [[relaychain.node_groups]] + name = "new" + count = 2 + args = ["-lparachain=debug,parachain::availability-recovery=trace,parachain::availability-distribution=trace,sub-libp2p=trace"] + +{% for id in range(2000,2002) %} +[[parachains]] +id = {{id}} +addToGenesis = true +cumulus_based = true +chain = "glutton-westend-local-{{id}}" + [parachains.genesis.runtimeGenesis.patch.glutton] + compute = "50000000" + storage = "2500000000" + trashDataCount = 5120 + + [parachains.collator] + name = "collator" + image = "{{CUMULUS_IMAGE}}" + args = ["-lparachain=debug"] + +{% endfor %} diff --git a/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..2ac5012db668d102b1078b4bf694e98b6c0ff302 --- /dev/null +++ b/polkadot/zombienet_tests/functional/0014-chunk-fetching-network-compatibility.zndsl @@ -0,0 +1,53 @@ +Description: Validators preserve backwards compatibility with peers speaking an older version of the /req_chunk protocol +Network: ./0014-chunk-fetching-network-compatibility.toml +Creds: config + +# Check authority status. +new: reports node_roles is 4 +old: reports node_roles is 4 + +# Ensure parachains are registered. +new: parachain 2000 is registered within 60 seconds +old: parachain 2000 is registered within 60 seconds +old: parachain 2001 is registered within 60 seconds +new: parachain 2001 is registered within 60 seconds + +# Ensure parachains made progress and approval checking works. +new: parachain 2000 block height is at least 15 within 600 seconds +old: parachain 2000 block height is at least 15 within 600 seconds +new: parachain 2001 block height is at least 15 within 600 seconds +old: parachain 2001 block height is at least 15 within 600 seconds + +new: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds +old: reports substrate_block_height{status="finalized"} is at least 30 within 400 seconds + +new: reports polkadot_parachain_approval_checking_finality_lag < 3 +old: reports polkadot_parachain_approval_checking_finality_lag < 3 + +new: reports polkadot_parachain_approvals_no_shows_total < 3 within 10 seconds +old: reports polkadot_parachain_approvals_no_shows_total < 3 within 10 seconds + +# Ensure that there are no failed recoveries. +new: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds +old: count of log lines containing "Data recovery from chunks complete" is at least 10 within 300 seconds +new: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds +old: count of log lines containing "Data recovery from chunks is not possible" is 0 within 10 seconds +new: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds +old: reports polkadot_parachain_availability_recovery_recoveries_finished{result="failure"} is 0 within 10 seconds + +# Ensure we used the fallback network request. +new: log line contains "Trying the fallback protocol" within 100 seconds + +# Ensure systematic recovery was not used. +old: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds +new: count of log lines containing "Data recovery from systematic chunks complete" is 0 within 10 seconds + +# Ensure availability-distribution worked fine +new: reports polkadot_parachain_fetched_chunks_total{success="succeeded"} is at least 10 within 400 seconds +old: reports polkadot_parachain_fetched_chunks_total{success="succeeded"} is at least 10 within 400 seconds + +new: reports polkadot_parachain_fetched_chunks_total{success="failed"} is 0 within 10 seconds +old: reports polkadot_parachain_fetched_chunks_total{success="failed"} is 0 within 10 seconds + +new: reports polkadot_parachain_fetched_chunks_total{success="not-found"} is 0 within 10 seconds +old: reports polkadot_parachain_fetched_chunks_total{success="not-found"} is 0 within 10 seconds diff --git a/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml new file mode 100644 index 0000000000000000000000000000000000000000..fed30e0db05321631fdce66da858e1431ded64dd --- /dev/null +++ b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.toml @@ -0,0 +1,44 @@ +[settings] +timeout = 1000 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.async_backing_params] + max_candidate_depth = 3 + allowed_ancestry_len = 2 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.scheduler_params] + max_validators_per_core = 1 + lookahead = 2 + num_cores = 4 + +[relaychain.genesis.runtimeGenesis.patch.configuration.config.approval_voting_params] + needed_approvals = 3 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +command = "polkadot" + + [[relaychain.node_groups]] + name = "validator" + args = ["-lruntime=debug,parachain=debug,parachain::backing=trace,parachain::collator-protocol=trace,parachain::prospective-parachains=trace,runtime::parachains::scheduler=trace,runtime::inclusion-inherent=trace,runtime::inclusion=trace" ] + count = 4 + +{% for id in range(2000,2004) %} +[[parachains]] +id = {{id}} +register_para = false +onboard_as_parachain = false +add_to_genesis = false +chain = "glutton-westend-local-{{id}}" + [parachains.genesis.runtimeGenesis.patch.glutton] + compute = "50000000" + storage = "2500000000" + trashDataCount = 5120 + + [parachains.collator] + name = "collator-{{id}}" + image = "{{CUMULUS_IMAGE}}" + command = "polkadot-parachain" + args = ["-lparachain=debug"] + +{% endfor %} diff --git a/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..b8b8887df85782268735f906eab771ddfcc22fcf --- /dev/null +++ b/polkadot/zombienet_tests/functional/0015-coretime-shared-core.zndsl @@ -0,0 +1,16 @@ +Description: CT shared core test +Network: ./0015-coretime-shared-core.toml +Creds: config + +validator: reports node_roles is 4 + +# register paras 2 by 2 to speed up the test. registering all at once will exceed the weight limit. +validator-0: js-script ./0015-force-register-paras.js with "2000,2001" return is 0 within 600 seconds +validator-0: js-script ./0015-force-register-paras.js with "2002,2003" return is 0 within 600 seconds +# assign core 0 to be shared by all paras. +validator-0: js-script ./assign-core.js with "0,2000,14400,2001,14400,2002,14400,2003,14400" return is 0 within 600 seconds + +collator-2000: reports block height is at least 6 within 200 seconds +collator-2001: reports block height is at least 6 within 50 seconds +collator-2002: reports block height is at least 6 within 50 seconds +collator-2003: reports block height is at least 6 within 50 seconds diff --git a/polkadot/zombienet_tests/functional/0015-force-register-paras.js b/polkadot/zombienet_tests/functional/0015-force-register-paras.js new file mode 100644 index 0000000000000000000000000000000000000000..f82163b01105a4b7bee09d6827860b685c38890e --- /dev/null +++ b/polkadot/zombienet_tests/functional/0015-force-register-paras.js @@ -0,0 +1,63 @@ +async function run(nodeName, networkInfo, args) { + const init = networkInfo.nodesByName[nodeName]; + let wsUri = init.wsUri; + let userDefinedTypes = init.userDefinedTypes; + const api = await zombie.connect(wsUri, userDefinedTypes); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + + let calls = []; + + for (let i = 0; i < args.length; i++) { + let para = args[i]; + const sec = networkInfo.nodesByName["collator-" + para]; + const api_collator = await zombie.connect(sec.wsUri, sec.userDefinedTypes); + + await zombie.util.cryptoWaitReady(); + + // Get the genesis header and the validation code of the parachain + const genesis_header = await api_collator.rpc.chain.getHeader(); + const validation_code = await api_collator.rpc.state.getStorage("0x3A636F6465"); + + calls.push( + api.tx.paras.addTrustedValidationCode(validation_code.toHex()) + ); + calls.push( + api.tx.registrar.forceRegister( + alice.address, + 0, + Number(para), + genesis_header.toHex(), + validation_code.toHex(), + ) + ); + } + + const sudo_batch = api.tx.sudo.sudo(api.tx.utility.batch(calls)); + + await new Promise(async (resolve, reject) => { + const unsub = await sudo_batch + .signAndSend(alice, ({ status, isError }) => { + if (status.isInBlock) { + console.log( + `Transaction included at blockhash ${status.asInBlock}`, + ); + } else if (status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${status.asFinalized}`, + ); + unsub(); + return resolve(); + } else if (isError) { + console.log(`Transaction error`); + reject(`Transaction error`); + } + }); + }); + + return 0; +} + +module.exports = { run }; diff --git a/polkadot/zombienet_tests/functional/assign-core.js b/polkadot/zombienet_tests/functional/assign-core.js new file mode 120000 index 0000000000000000000000000000000000000000..eeb6402c06f5e52cedf150f924d6791beb1d9867 --- /dev/null +++ b/polkadot/zombienet_tests/functional/assign-core.js @@ -0,0 +1 @@ +../assign-core.js \ No newline at end of file diff --git a/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.js b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.js new file mode 100644 index 0000000000000000000000000000000000000000..9963ce74d64e8c81d38c0ce8a141346e979f7c30 --- /dev/null +++ b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.js @@ -0,0 +1,46 @@ +const assert = require("assert"); + +function nameCase(string) { + return string.charAt(0).toUpperCase() + string.slice(1); +} + +async function run(nodeName, networkInfo, jsArgs) { + const {wsUri, userDefinedTypes} = networkInfo.nodesByName[nodeName]; + const api = await zombie.connect(wsUri, userDefinedTypes); + const action = jsArgs[0] === "register" ? "registerValidators" : "deregisterValidators" + const validatorName = jsArgs[1]; // used as seed + + await zombie.util.cryptoWaitReady(); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + const validatorStash = keyring.createFromUri(`//${nameCase(validatorName)}//stash`); + + await new Promise(async (resolve, reject) => { + const unsub = await api.tx.sudo + .sudo(api.tx.validatorManager[action]([validatorStash.address])) + .signAndSend(alice, (result) => { + console.log(`Current status is ${result.status}`); + if (result.status.isInBlock) { + console.log( + `Transaction included at blockHash ${result.status.asInBlock}` + ); + } else if (result.status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${result.status.asFinalized}` + ); + unsub(); + return resolve(); + } else if (result.isError) { + console.log(`Transaction Error`); + unsub(); + return reject(); + } + }); + }); + + return 0; +} + +module.exports = { run } diff --git a/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.toml b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.toml new file mode 100644 index 0000000000000000000000000000000000000000..2baf21b96cc1aa076173840c34e2d96aa3a5f76a --- /dev/null +++ b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.toml @@ -0,0 +1,32 @@ +[settings] +timeout = 1000 + +[relaychain] +default_image = "{{ZOMBIENET_INTEGRATION_TEST_IMAGE}}" +chain = "rococo-local" +command = "polkadot" + + [[relaychain.nodes]] + name = "alice" + args = ["-lruntime=debug,parachain=trace" ] + + [[relaychain.nodes]] + name = "bob" + args = [ "-lruntime=debug,parachain=trace" ] + + [[relaychain.nodes]] + name = "charlie" + args = [ "-lruntime=debug,parachain=trace" ] + + [[relaychain.nodes]] + name = "dave" + args = [ "-lruntime=debug,parachain=trace" ] + +[[parachains]] +id = 100 +add_to_genesis = true + + [parachains.collator] + name = "collator-100" + image = "{{CUMULUS_IMAGE}}" + command = "polkadot-parachain" diff --git a/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.zndsl b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.zndsl new file mode 100644 index 0000000000000000000000000000000000000000..3ac68caf7e1bf3115e883708da95cbe6cf485175 --- /dev/null +++ b/polkadot/zombienet_tests/smoke/0005-precompile-pvf-smoke.zndsl @@ -0,0 +1,43 @@ +Description: PVF precompilation +Network: ./0005-precompile-pvf-smoke.toml +Creds: config + +# Ensure the calidator is in the validator set +dave: reports polkadot_node_is_parachain_validator is 1 within 240 secs +dave: reports polkadot_node_is_active_validator is 1 within 240 secs + +# Deregister the validator +alice: js-script ./0005-register-deregister-validator.js with "deregister,dave" return is 0 within 30 secs + +# Wait 2 sessions. The authority set change is enacted at curent_session + 2. +sleep 120 seconds +dave: reports polkadot_node_is_parachain_validator is 0 within 180 secs +dave: reports polkadot_node_is_active_validator is 0 within 180 secs + +# register the parachain +alice: js-script ./0005-register-para.js with "100" return is 0 within 600 seconds + +# Ensure the parachain made progress. +alice: parachain 100 block height is at least 10 within 300 seconds + +# Ensure the validator didn't prepare pvf +dave: reports polkadot_pvf_preparation_time_count is 1 within 30 seconds + +# Register the validator again +alice: js-script ./0005-register-deregister-validator.js with "register,dave" return is 0 within 30 secs + +# Wait 1 session and check the pvf preparation +sleep 60 seconds +dave: reports polkadot_pvf_preparation_time_count is 1 within 30 seconds + +# Check the validator is still not in the validator set +dave: reports polkadot_node_is_parachain_validator is 0 within 30 secs +dave: reports polkadot_node_is_active_validator is 0 within 30 secs + +# Check the validator is in the validator set +dave: reports polkadot_node_is_parachain_validator is 1 within 60 secs +dave: reports polkadot_node_is_active_validator is 1 within 60 secs + +# Check the pvf preparation again. The authority set change is enacted at curent_session + 2. +sleep 60 seconds +dave: reports polkadot_pvf_preparation_time_count is 1 within 60 seconds diff --git a/polkadot/zombienet_tests/smoke/0005-register-deregister-validator.js b/polkadot/zombienet_tests/smoke/0005-register-deregister-validator.js new file mode 100644 index 0000000000000000000000000000000000000000..16e7d87d0ffc499981565ad12743ea665edccf42 --- /dev/null +++ b/polkadot/zombienet_tests/smoke/0005-register-deregister-validator.js @@ -0,0 +1,44 @@ +function nameCase(string) { + return string.charAt(0).toUpperCase() + string.slice(1); +} + +async function run(nodeName, networkInfo, args) { + const { wsUri, userDefinedTypes } = networkInfo.nodesByName[nodeName]; + const api = await zombie.connect(wsUri, userDefinedTypes); + const action = args[0] === "register" ? "registerValidators" : "deregisterValidators" + const validatorName = args[1]; // used as seed + + await zombie.util.cryptoWaitReady(); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + const validatorStash = keyring.createFromUri(`//${nameCase(validatorName)}//stash`); + + await new Promise(async (resolve, reject) => { + const unsub = await api.tx.sudo + .sudo(api.tx.validatorManager[action]([validatorStash.address])) + .signAndSend(alice, (result) => { + console.log(`Current status is ${result.status}`); + if (result.status.isInBlock) { + console.log( + `Transaction included at blockHash ${result.status.asInBlock}` + ); + } else if (result.status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${result.status.asFinalized}` + ); + unsub(); + return resolve(); + } else if (result.isError) { + console.log(`Transaction Error`); + unsub(); + return reject(); + } + }); + }); + + return 0; +} + +module.exports = { run } diff --git a/polkadot/zombienet_tests/smoke/0005-register-para.js b/polkadot/zombienet_tests/smoke/0005-register-para.js new file mode 100644 index 0000000000000000000000000000000000000000..aba7bc3601fbe8c779a3f599d6680ed36f09b056 --- /dev/null +++ b/polkadot/zombienet_tests/smoke/0005-register-para.js @@ -0,0 +1,63 @@ +async function run(nodeName, networkInfo, args) { + const init = networkInfo.nodesByName[nodeName]; + let wsUri = init.wsUri; + let userDefinedTypes = init.userDefinedTypes; + const api = await zombie.connect(wsUri, userDefinedTypes); + + // account to submit tx + const keyring = new zombie.Keyring({ type: "sr25519" }); + const alice = keyring.addFromUri("//Alice"); + + let calls = []; + + for (let i = 0; i < args.length; i++) { + let para = args[i]; + const sec = networkInfo.nodesByName["collator-" + para]; + const api_collator = await zombie.connect(sec.wsUri, sec.userDefinedTypes); + + await zombie.util.cryptoWaitReady(); + + // Get the genesis header and the validation code of the parachain + const genesis_header = await api_collator.rpc.chain.getHeader(); + const validation_code = await api_collator.rpc.state.getStorage("0x3A636F6465"); + + calls.push( + api.tx.paras.addTrustedValidationCode(validation_code.toHex()) + ); + calls.push( + api.tx.registrar.forceRegister( + alice.address, + 0, + Number(para), + genesis_header.toHex(), + validation_code.toHex(), + ) + ); + } + + const sudo_batch = api.tx.sudo.sudo(api.tx.utility.batch(calls)); + + await new Promise(async (resolve, reject) => { + const unsub = await sudo_batch + .signAndSend(alice, ({ status, isError }) => { + if (status.isInBlock) { + console.log( + `Transaction included at blockhash ${status.asInBlock}`, + ); + } else if (status.isFinalized) { + console.log( + `Transaction finalized at blockHash ${status.asFinalized}`, + ); + unsub(); + return resolve(); + } else if (isError) { + console.log(`Transaction error`); + reject(`Transaction error`); + } + }); + }); + + return 0; +} + +module.exports = { run }; diff --git a/prdoc/pr_2226.prdoc b/prdoc/1.12.0/pr_2226.prdoc similarity index 100% rename from prdoc/pr_2226.prdoc rename to prdoc/1.12.0/pr_2226.prdoc diff --git a/prdoc/pr_3444.prdoc b/prdoc/1.12.0/pr_3444.prdoc similarity index 100% rename from prdoc/pr_3444.prdoc rename to prdoc/1.12.0/pr_3444.prdoc diff --git a/prdoc/pr_3701.prdoc b/prdoc/1.12.0/pr_3701.prdoc similarity index 100% rename from prdoc/pr_3701.prdoc rename to prdoc/1.12.0/pr_3701.prdoc diff --git a/prdoc/pr_3865.prdoc b/prdoc/1.12.0/pr_3865.prdoc similarity index 100% rename from prdoc/pr_3865.prdoc rename to prdoc/1.12.0/pr_3865.prdoc diff --git a/prdoc/pr_3872.prdoc b/prdoc/1.12.0/pr_3872.prdoc similarity index 100% rename from prdoc/pr_3872.prdoc rename to prdoc/1.12.0/pr_3872.prdoc diff --git a/prdoc/1.12.0/pr_3904.prdoc b/prdoc/1.12.0/pr_3904.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..694f9b443877329e02f47d12de4d375b42fefb36 --- /dev/null +++ b/prdoc/1.12.0/pr_3904.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Introduce pallet-delegated-staking + +doc: + - audience: Runtime Dev + description: | + Adds a new pallet `delegated-staking` that allows delegators to delegate their funds to agents who can stake + these funds on behalf of them. This would be used by Nomination Pools to migrate into a delegation staking based + pool. + +crates: + - name: pallet-delegated-staking + bump: patch + - name: pallet-staking + bump: patch + - name: sp-staking + bump: minor diff --git a/prdoc/1.12.0/pr_3962.prdoc b/prdoc/1.12.0/pr_3962.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..7ef59d38ce5cdea9dbf623e71f14c07752d06828 --- /dev/null +++ b/prdoc/1.12.0/pr_3962.prdoc @@ -0,0 +1,12 @@ +title: Change fork calculation algorithm. + +doc: + - audience: Node Dev + description: | + This PR changes the fork calculation and pruning algorithm to enable future block header pruning. + During the finalization of the block we prune known stale forks, so forks are pruned faster. + +crates: + - name: sc-client-api + - name: sc-client-db + - name: sp-blockchain diff --git a/prdoc/pr_3964.prdoc b/prdoc/1.12.0/pr_3964.prdoc similarity index 100% rename from prdoc/pr_3964.prdoc rename to prdoc/1.12.0/pr_3964.prdoc diff --git a/prdoc/pr_4034.prdoc b/prdoc/1.12.0/pr_4034.prdoc similarity index 100% rename from prdoc/pr_4034.prdoc rename to prdoc/1.12.0/pr_4034.prdoc diff --git a/prdoc/1.12.0/pr_4035.prdoc b/prdoc/1.12.0/pr_4035.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0617a6a261898b743d74dc8fa55224012080391b --- /dev/null +++ b/prdoc/1.12.0/pr_4035.prdoc @@ -0,0 +1,24 @@ +title: "Prospective parachains rework" + +doc: + - audience: Node Dev + description: | + Changes prospective-parachains from dealing with trees of unincluded candidates to maintaining only candidate chains + and a number of unconnected candidates (for which we don't yet know the parent candidate but which otherwise seem potentially viable). + This is needed for elastic scaling, in order to have full throughput even if a candidate is validated by a backing group before the parent candidate + is fetched from the other backing group. + Also simplifies the subsystem by no longer allowing parachain cycles. + +crates: + - name: polkadot-node-core-prospective-parachains + bump: major + - name: polkadot-node-core-backing + bump: minor + - name: polkadot-collator-protocol + bump: minor + - name: polkadot-statement-distribution + bump: minor + - name: polkadot-node-subsystem-types + bump: major + - name: polkadot-node-subsystem-util + bump: major diff --git a/prdoc/1.12.0/pr_4091.prdoc b/prdoc/1.12.0/pr_4091.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5c38a344bd8ad1405dd8d1daaf8f16ee7ffaf06b --- /dev/null +++ b/prdoc/1.12.0/pr_4091.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the authority-discovery pallet + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-authority-discovery`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + When accessed outside the pallet, use the getters current_authorities() and next_authorities() instead. + +crates: + - name: pallet-authority-discovery + bump: major diff --git a/prdoc/pr_4102.prdoc b/prdoc/1.12.0/pr_4102.prdoc similarity index 100% rename from prdoc/pr_4102.prdoc rename to prdoc/1.12.0/pr_4102.prdoc diff --git a/prdoc/pr_4157.prdoc b/prdoc/1.12.0/pr_4157.prdoc similarity index 100% rename from prdoc/pr_4157.prdoc rename to prdoc/1.12.0/pr_4157.prdoc diff --git a/prdoc/pr_4175.prdoc b/prdoc/1.12.0/pr_4175.prdoc similarity index 100% rename from prdoc/pr_4175.prdoc rename to prdoc/1.12.0/pr_4175.prdoc diff --git a/prdoc/pr_4185.prdoc b/prdoc/1.12.0/pr_4185.prdoc similarity index 100% rename from prdoc/pr_4185.prdoc rename to prdoc/1.12.0/pr_4185.prdoc diff --git a/prdoc/pr_4202.prdoc b/prdoc/1.12.0/pr_4202.prdoc similarity index 100% rename from prdoc/pr_4202.prdoc rename to prdoc/1.12.0/pr_4202.prdoc diff --git a/prdoc/pr_4211.prdoc b/prdoc/1.12.0/pr_4211.prdoc similarity index 100% rename from prdoc/pr_4211.prdoc rename to prdoc/1.12.0/pr_4211.prdoc diff --git a/prdoc/pr_4213.prdoc b/prdoc/1.12.0/pr_4213.prdoc similarity index 100% rename from prdoc/pr_4213.prdoc rename to prdoc/1.12.0/pr_4213.prdoc diff --git a/prdoc/pr_4220.prdoc b/prdoc/1.12.0/pr_4220.prdoc similarity index 100% rename from prdoc/pr_4220.prdoc rename to prdoc/1.12.0/pr_4220.prdoc diff --git a/prdoc/pr_4281.prdoc b/prdoc/1.12.0/pr_4281.prdoc similarity index 100% rename from prdoc/pr_4281.prdoc rename to prdoc/1.12.0/pr_4281.prdoc diff --git a/prdoc/pr_4295.prdoc b/prdoc/1.12.0/pr_4295.prdoc similarity index 100% rename from prdoc/pr_4295.prdoc rename to prdoc/1.12.0/pr_4295.prdoc diff --git a/prdoc/pr_4301.prdoc b/prdoc/1.12.0/pr_4301.prdoc similarity index 100% rename from prdoc/pr_4301.prdoc rename to prdoc/1.12.0/pr_4301.prdoc diff --git a/prdoc/1.12.0/pr_4302.prdoc b/prdoc/1.12.0/pr_4302.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..bb4331f280239ffb3a8ee44d912916f8b23b91cb --- /dev/null +++ b/prdoc/1.12.0/pr_4302.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "migrations: take() should consume read and write operation weight" + +doc: + - audience: Runtime Dev + description: | + `take()` consumes only 1 read worth of weight in `single-block-migrations` example, while `take()` is `get() + kill()`, + i.e should be 1 read + 1 write. Since this could mislead developers writing migrations following the example, + this PR fixes the weight calculation. + +crates: + - name: pallet-example-single-block-migrations + bump: minor diff --git a/prdoc/pr_4311.prdoc b/prdoc/1.12.0/pr_4311.prdoc similarity index 100% rename from prdoc/pr_4311.prdoc rename to prdoc/1.12.0/pr_4311.prdoc diff --git a/prdoc/pr_4312.prdoc b/prdoc/1.12.0/pr_4312.prdoc similarity index 100% rename from prdoc/pr_4312.prdoc rename to prdoc/1.12.0/pr_4312.prdoc diff --git a/prdoc/1.12.0/pr_4326.prdoc b/prdoc/1.12.0/pr_4326.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b448bd7e52e76be92924761b8fd925e9b5083247 --- /dev/null +++ b/prdoc/1.12.0/pr_4326.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: CheckWeight checks for combined extrinsic length and proof size + +doc: + - audience: Runtime Dev + description: | + The `CheckWeight` `SignedExtension` will now perform an additional check. The extension was verifying the extrinsic length and + weight limits individually. However, the proof size dimension of the weight and extrinsic length together are bound by the PoV size limit. + The `CheckWeight` extension will now check that the combined size of the proof and the extrinsic lengths will not + exceed the PoV size limit. + +crates: + - name: frame-system + bump: minor diff --git a/prdoc/pr_4329.prdoc b/prdoc/1.12.0/pr_4329.prdoc similarity index 100% rename from prdoc/pr_4329.prdoc rename to prdoc/1.12.0/pr_4329.prdoc diff --git a/prdoc/pr_4346.prdoc b/prdoc/1.12.0/pr_4346.prdoc similarity index 100% rename from prdoc/pr_4346.prdoc rename to prdoc/1.12.0/pr_4346.prdoc diff --git a/prdoc/1.12.0/pr_4349.prdoc b/prdoc/1.12.0/pr_4349.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..fdc9e816e1b9630cb505f7d8270850ad9450c57e --- /dev/null +++ b/prdoc/1.12.0/pr_4349.prdoc @@ -0,0 +1,9 @@ +title: "Store Header in RemoteExt Snapshot" + +doc: + - audience: Runtime Dev + description: Replaces the block hash in the RemoteExt snapshot with the block header. + +crates: + - name: frame-remote-externalities + bump: major diff --git a/prdoc/pr_4364.prdoc b/prdoc/1.12.0/pr_4364.prdoc similarity index 100% rename from prdoc/pr_4364.prdoc rename to prdoc/1.12.0/pr_4364.prdoc diff --git a/prdoc/pr_4394.prdoc b/prdoc/1.12.0/pr_4394.prdoc similarity index 100% rename from prdoc/pr_4394.prdoc rename to prdoc/1.12.0/pr_4394.prdoc diff --git a/prdoc/pr_4406.prdoc b/prdoc/1.12.0/pr_4406.prdoc similarity index 100% rename from prdoc/pr_4406.prdoc rename to prdoc/1.12.0/pr_4406.prdoc diff --git a/prdoc/1.12.0/pr_4414.prdoc b/prdoc/1.12.0/pr_4414.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..864e816be91a9632859c9b11bf992af5ae7832b4 --- /dev/null +++ b/prdoc/1.12.0/pr_4414.prdoc @@ -0,0 +1,10 @@ +title: "Rococo Asset Hub: undeploy state-trie migration" + +doc: + - audience: Runtime Dev + description: | + The state-trie migration on the Rococo Asset Hub is completed and is now removed. + +crates: + - name: asset-hub-rococo-runtime + bump: major diff --git a/prdoc/1.12.0/pr_4417.prdoc b/prdoc/1.12.0/pr_4417.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5aa72edd066a7de2a8e66ca1464446c503802644 --- /dev/null +++ b/prdoc/1.12.0/pr_4417.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-contracts-mock-network + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-contracts-mock-network`s storage items. + +crates: + - name: pallet-contracts-mock-network + bump: minor diff --git a/prdoc/1.12.0/pr_4426.prdoc b/prdoc/1.12.0/pr_4426.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5beccbd2a57a593b4937b9f9fbd7c3552d80cc2c --- /dev/null +++ b/prdoc/1.12.0/pr_4426.prdoc @@ -0,0 +1,15 @@ +title: "Remove warning about `BadCertificate`" + +doc: + - audience: Node Operator + description: | + The node was printing the following warning from time to time: + ``` + Sending fatal alert BadCertificate + ``` + + This is not an user error and thus, the warning will now not be printed + anymore. + +crates: + - name: sc-cli diff --git a/prdoc/1.12.0/pr_4442.prdoc b/prdoc/1.12.0/pr_4442.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ee6ac29e1a1045c67679d4014b893f3eafa8a9f8 --- /dev/null +++ b/prdoc/1.12.0/pr_4442.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Improve mock relay in --dev mode to support async backing + +doc: + - audience: Node Dev + description: | + Support async backing in --dev mode. Improve the relay mock MockValidationDataInherentDataProvider to mach expectations of async backing runtimes. + +crates: + - name: cumulus-client-parachain-inherent + bump: patch diff --git a/prdoc/1.12.0/pr_4457.prdoc b/prdoc/1.12.0/pr_4457.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5c9bd9822769745adcb916b52e98923fc3e555a5 --- /dev/null +++ b/prdoc/1.12.0/pr_4457.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "sc-service: export all public functions" + +doc: + - audience: Node Dev + description: | + A PR #3166 converted private functions used in `spawn_tasks()` to public to make it possible to have custom + implementation of the `spawn_tasks()`. However, not all functions were included in the list of exports from + `sc-service` crate. + +crates: + - name: sc-service + bump: minor diff --git a/prdoc/1.12.0/pr_4461.prdoc b/prdoc/1.12.0/pr_4461.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2dafa3812878b4a2767a91d5ad2121bd23652310 --- /dev/null +++ b/prdoc/1.12.0/pr_4461.prdoc @@ -0,0 +1,10 @@ +title: Fix extrinsics count logging in frame-system + +doc: + - audience: Runtime Dev + description: | + Fixes the issue of the number of extrinsics in the block always being 0 in the log of frame-system. + +crates: + - name: frame-system + bump: patch diff --git a/prdoc/1.13.0/pr_1223.prdoc b/prdoc/1.13.0/pr_1223.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..08b18557b70c6b649c49bb1dd62acc9528a79a86 --- /dev/null +++ b/prdoc/1.13.0/pr_1223.prdoc @@ -0,0 +1,13 @@ +title: Optimize storage append operation + +doc: + - audience: [Node Dev, Runtime Dev] + description: | + This pull request optimizes the storage append operation in the `OverlayedChanges`. + Before the internal buffer was cloned every time a new transaction was created. Cloning + the internal buffer is now only done when there is no other possibility. This should + improve the performance in situations like when depositing events from batched calls. + +crates: + - name: sp-state-machine + bump: major diff --git a/prdoc/1.13.0/pr_1644.prdoc b/prdoc/1.13.0/pr_1644.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cc43847fa09b2fee66924b08ea0aa9ff9842b036 --- /dev/null +++ b/prdoc/1.13.0/pr_1644.prdoc @@ -0,0 +1,59 @@ +title: Add availability-recovery from systematic chunks + +doc: + - audience: Node Operator + description: | + Implements https://github.com/polkadot-fellows/RFCs/pull/47. This optimisation is guarded by a configuration bit in + the runtime and will only be enabled once a supermajority of the validators have upgraded to this version. + It's strongly advised to upgrade to this version. + - audience: Node Dev + description: | + Implements https://github.com/polkadot-fellows/RFCs/pull/47 and adds the logic for availability recovery from systematic chunks. + The /req_chunk/1 req-response protocol is now considered deprecated in favour of /req_chunk/2. Systematic recovery is guarded + by a configuration bit in the runtime (bit with index 2 of the node_features field from the HostConfiguration) + and must not be enabled until all (or almost all) validators have upgraded to the node version that includes + this PR. + +crates: + - name: sc-network + bump: minor + - name: polkadot-primitives + bump: minor + - name: cumulus-client-pov-recovery + bump: none + - name: polkadot-overseer + bump: none + - name: polkadot-node-primitives + bump: major + - name: polkadot-erasure-coding + bump: major + - name: polkadot-node-jaeger + bump: major + - name: polkadot-node-subsystem-types + bump: major + - name: polkadot-node-network-protocol + bump: major + - name: polkadot-service + bump: major + - name: polkadot-node-subsystem-util + bump: major + - name: polkadot-availability-distribution + bump: major + - name: polkadot-availability-recovery + bump: major + - name: polkadot-node-core-approval-voting + bump: minor + - name: polkadot-node-core-av-store + bump: major + - name: polkadot-network-bridge + bump: minor + - name: polkadot-node-core-backing + bump: none + - name: polkadot-node-core-bitfield-signing + bump: none + - name: polkadot-node-core-dispute-coordinator + bump: none + - name: cumulus-relay-chain-minimal-node + bump: minor + - name: polkadot + bump: minor diff --git a/prdoc/1.13.0/pr_3393.prdoc b/prdoc/1.13.0/pr_3393.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..27ebb385930324f0b0821af3d3ac9d3a6d98f531 --- /dev/null +++ b/prdoc/1.13.0/pr_3393.prdoc @@ -0,0 +1,12 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add `MaxRank` Config to `pallet-core-fellowship` + +doc: + - audience: Runtime User + description: | + This PR adds a new Config `MaxRank` to the core fellowship pallet. Initially, the maximum rank was set to IX (Grand Master) on the core-fellowship pallet, corresponding to the establishment of the Technical Fellowship and setting the default member count to nine. However, with the introduction of new collectives, this maximum rank is expected to evolve. + +crates: + - name: pallet-core-fellowship diff --git a/prdoc/1.13.0/pr_3905.prdoc b/prdoc/1.13.0/pr_3905.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d1c03650c9b2365d8f33345fbcef98b4f3885a51 --- /dev/null +++ b/prdoc/1.13.0/pr_3905.prdoc @@ -0,0 +1,25 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Allows Nomination Pool to use different staking strategies including a new DelegateStake strategy. + +doc: + - audience: Runtime Dev + description: | + This PR introduces a new staking strategy called `DelegateStake`. This strategy allows the nomination pool to + delegate its stake to a validator, that is, funds are locked in user account itself instead of being transferred + to the pool account. Includes migration of pools to this strategy for Westend. + +crates: + - name: pallet-nomination-pools + bump: major + - name: pallet-nomination-pools-benchmarking + bump: major + - name: sp-staking + bump: patch + - name: pallet-staking + bump: patch + - name: pallet-delegated-staking + bump: patch + - name: westend-runtime + bump: major diff --git a/prdoc/1.13.0/pr_3935.prdoc b/prdoc/1.13.0/pr_3935.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..93b0fba5d99b47fa918a1100e644ea32f5cc4aa8 --- /dev/null +++ b/prdoc/1.13.0/pr_3935.prdoc @@ -0,0 +1,30 @@ +title: "Introduce Polkadot-SDK umbrella crate" + +doc: + - audience: Runtime Dev + description: | + Introduces a new "umbrella" crate that re-exports all published crates of the Polkadot-SDK. + This helps developers to select a valid set of versions for all underlying dependencies. + + You can now use this create and remove lots of dependencies from your runtime and node crates. + The `staging-node-cli` and `kitchensink-runtime` both adopt this pattern as an example. + + Full docs in `docs/sdk/src/reference_docs/umbrella_crate.rs`. + +crates: + - name: cumulus-pallet-parachain-system + bump: patch + - name: sc-chain-spec-derive + bump: patch + - name: frame-election-provider-solution-type + bump: patch + - name: pallet-staking-reward-curve + bump: patch + - name: frame-support-procedural-tools + bump: patch + - name: sp-api-proc-macro + bump: patch + - name: polkadot-runtime-parachains + bump: patch + - name: polkadot-sdk + bump: major diff --git a/prdoc/1.13.0/pr_3952.prdoc b/prdoc/1.13.0/pr_3952.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2401adbb76c13cbee7c467df1a0284fc9b4fcaa4 --- /dev/null +++ b/prdoc/1.13.0/pr_3952.prdoc @@ -0,0 +1,35 @@ +title: Storage bound the XCMP queue pallet + +doc: + - audience: Runtime Dev + description: | + Enforce upper limits for the number of active XCMP channels, the number of outgoing XCMP + messages per channel and the number of signals per channel. + + ## Integration + + If you see this error in your try-runtime-cli: + ```pre + Max message size for channel is too large. This means that the V5 migration can be front-run and an + attacker could place a large message just right before the migration to make other messages un-decodable. + Please either increase `MaxPageSize` or decrease the `max_message_size` for this channel. Channel max: + 102400, MaxPageSize: 65535 + ``` + + Then increase the `MaxPageSize` of the `cumulus_pallet_xcmp_queue` to something like this: + ```rust + type MaxPageSize = ConstU32<{ 103 * 1024 }>; + ``` + +migrations: + db: [] + + runtime: + - reference: cumulus_pallet_xcmp_queue::migration::v5::MigrateV4ToV5 + description: A No-OP migration is deployed to ensure that all `BoundedVec`s` still decode as expected. + +crates: + - name: cumulus-pallet-xcmp-queue + bump: major + +host_functions: [] diff --git a/prdoc/1.13.0/pr_4131.prdoc b/prdoc/1.13.0/pr_4131.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b0619eabe13b575cc6aa10f7215e68a57698b159 --- /dev/null +++ b/prdoc/1.13.0/pr_4131.prdoc @@ -0,0 +1,26 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Deprecate XCMv2 + +doc: + - audience: Runtime Dev + description: | + XCMv2 has been deprecated. It will be removed when XCMv5 is released. + Use version 3 or 4 instead. + - audience: Runtime User + description: | + XCMv2 has been deprecated. It will be removed when XCMv5 is released. + Use version 3 or 4 instead. + +crates: +- name: staging-xcm + bump: minor +- name: xcm-procedural + bump: minor +- name: staging-xcm-builder + bump: minor +- name: pallet-xcm + bump: minor +- name: cumulus-pallet-xcmp-queue + bump: minor diff --git a/prdoc/1.13.0/pr_4198.prdoc b/prdoc/1.13.0/pr_4198.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cff956812606fc18a500a9cf0de0cc7252955283 --- /dev/null +++ b/prdoc/1.13.0/pr_4198.prdoc @@ -0,0 +1,31 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Replace `Multiaddr` & related types with substrate-specific types + +doc: + - audience: Node Dev + description: | + Introduce custom types / substrate wrappers for `Multiaddr`, `multiaddr::Protocol`, + `Multihash`, `ed25519::*` and supplementary types like errors and iterators. + + Common code in substrate uses these custom types, while `libp2p` & `litep2p` network + backends use their corresponding libraries types. + + This is needed to independently upgrade `libp2p` & `litep2p` dependencies. + +crates: + - name: sc-network-types + bump: minor + - name: sc-network + bump: minor + - name: sc-network-sync + bump: minor + - name: sc-authority-discovery + bump: minor + - name: sc-cli + bump: patch + - name: sc-mixnet + bump: patch + - name: sc-telemetry + bump: patch diff --git a/prdoc/1.13.0/pr_4233.prdoc b/prdoc/1.13.0/pr_4233.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c593fec68a66a133b2ee7db8a08eea38a9a05883 --- /dev/null +++ b/prdoc/1.13.0/pr_4233.prdoc @@ -0,0 +1,14 @@ +title: "[pallet_contracts] Update Host fn benchnmarks" + +doc: + - audience: Runtime Dev + description: | + Update how the host functions are benchmarked. + Instead of benchnarking a contract that calls the host functions, we now benchmark the host functions directly. + +crates: + - name: pallet-contracts + bump: minor + - name: pallet-contracts-proc-macro + bump: minor + diff --git a/prdoc/1.13.0/pr_4249.prdoc b/prdoc/1.13.0/pr_4249.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1a267e263924b7f5d0df62d1e1af6800e3ad255f --- /dev/null +++ b/prdoc/1.13.0/pr_4249.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Moves runtime macro out of experimental flag + +doc: + - audience: Runtime Dev + description: | + Now that the runtime macro (Construct Runtime V2) has been successfully deployed on Westend, + this PR moves it out of the experimental feature flag and makes it generally available for + runtime devs. + +crates: + - name: frame-support + bump: minor + - name: frame-support-procedural + bump: minor diff --git a/prdoc/1.13.0/pr_4274.prdoc b/prdoc/1.13.0/pr_4274.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..77f5d1387cf7bfc19cd548dbed1c7d7031e39c73 --- /dev/null +++ b/prdoc/1.13.0/pr_4274.prdoc @@ -0,0 +1,39 @@ +title: Introduce `CheckMetadataHash` signed extension + +doc: + - audience: Runtime Dev + description: | + Introduces the new `CheckMetadataHash` signed extension. This extension can be added to a + runtime to support verifying the metadata hash as described in + [RFC78](https://polkadot-fellows.github.io/RFCs/approved/0078-merkleized-metadata.html). + This removes the requirement for having a metadata portal and in general a centralized + authentication of the metadata. With this signed extension the runtime is able to verify + that the metadata used by the wallet was correct. This is mainly useful for offline wallets + which users need to trust any way, not that useful for online wallets. + + There is a guide `generate_metadata_hash` for how to integrate this into a runtime that + should make it quite easy to integrate the signed extension. + - audience: Runtime User + description: | + This brings support for the new Ledger app and similar hardware wallets. These hardware + wallets will be able to decode the transaction using the metadata. The runtime will + ensure that the metadata used for this decoding process is correct and that the online + wallet did not tried to trick you. + +crates: + - name: substrate-wasm-builder + bump: minor + - name: sc-executor-wasmtime + bump: patch + - name: frame-metadata-hash-extension + bump: major + - name: polkadot-service + bump: none + - name: rococo-runtime + bump: major + - name: westend-runtime + bump: major + - name: asset-hub-rococo-runtime + bump: major + - name: asset-hub-westend-runtime + bump: major diff --git a/prdoc/1.13.0/pr_4339.prdoc b/prdoc/1.13.0/pr_4339.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..634ccfa1a339df615db5957729c7833c972047ac --- /dev/null +++ b/prdoc/1.13.0/pr_4339.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Improving on_demand_assigner emitted events + +doc: + - audience: Runtime User + description: | + Registering OnDemandOrderPlaced event that is useful for indexers to save data related to on demand orders. Adds SpotPriceSet as a new event to monitor on-demand spot prices. It updates whenever the price changes due to traffic. + +crates: + - name: polkadot-runtime-parachains + bump: minor \ No newline at end of file diff --git a/prdoc/1.13.0/pr_4380.prdoc b/prdoc/1.13.0/pr_4380.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1420409656b320c390ab05eecb15df0eca9e3432 --- /dev/null +++ b/prdoc/1.13.0/pr_4380.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove `parametrized-consensus-hook` feature + +doc: + - audience: Runtime Dev + description: | + `parametrized-consensus-hook` feature is obsolete and is removed by this PR. The + long-deprecated `CheckInherents` trait is set to be removed by September 2024. + +crates: + - name: cumulus-pallet-parachain-system + bump: major + diff --git a/prdoc/1.13.0/pr_4392.prdoc b/prdoc/1.13.0/pr_4392.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..898ce9be069e20a09ccbe1ee4a85bcec36893f02 --- /dev/null +++ b/prdoc/1.13.0/pr_4392.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove `pallet::getter` usage from both bounties and child bounties pallet + +doc: + - audience: Runtime Dev + description: | + This PR removes `pallet::getter`s from `pallet-bounties` and `pallet-child-bounties`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-bounties + bump: major + - name: pallet-child-bounties + bump: major diff --git a/prdoc/1.13.0/pr_4410.prdoc b/prdoc/1.13.0/pr_4410.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1dc1d4c1f87a728ef0edb60d7334ba97a59f539d --- /dev/null +++ b/prdoc/1.13.0/pr_4410.prdoc @@ -0,0 +1,37 @@ +title: "[sc-chain-spec] Remove deprecated code" + +doc: + - audience: Node Dev + description: | + The RuntimeGenesisConfig generic type parameter was removed from GenericChainSpec struct. + ChainSpec::from_genesis method was removed. + Removed related deprecated code from `sc-chain-spec`. + This change simplifies the codebase and ensures the use of up-to-date definitions. + +crates: + - name: sc-service + bump: minor + - name: minimal-template-node + bump: minor + - name: sc-cli + bump: patch + - name: polkadot-test-service + bump: major + - name: sc-service-test + bump: major + - name: staging-node-cli + bump: major + - name: parachain-template-node + bump: minor + - name: solochain-template-node + bump: minor + - name: polkadot-parachain-bin + bump: major + - name: polkadot-service + bump: major + - name: sc-consensus-grandpa + bump: patch + - name: cumulus-test-service + bump: minor + - name: sc-chain-spec + bump: major diff --git a/prdoc/1.13.0/pr_4418.prdoc b/prdoc/1.13.0/pr_4418.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4372692b2b98ee578d8e4768b171ec1e02f15a2c --- /dev/null +++ b/prdoc/1.13.0/pr_4418.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[pallet_contracts] Add `READ_ONLY` flag to contract `call` function" + +doc: + - audience: Runtime User + description: | + This PR implements the `READ_ONLY` flag to be used as a `Callflag` in the contract `call` function. + The flag indicates that the callee is restricted from modifying the state during call execution. + It is equivalent to Ethereum's [STATICCALL](https://eips.ethereum.org/EIPS/eip-214). + +crates: + - name: pallet-contracts + bump: minor + - name: pallet-contracts-uapi + bump: minor + - name: pallet-contracts-proc-macro + bump: minor diff --git a/prdoc/1.13.0/pr_4431.prdoc b/prdoc/1.13.0/pr_4431.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..993a7326b9aad4aa713f47dffeb9622493db1cf2 --- /dev/null +++ b/prdoc/1.13.0/pr_4431.prdoc @@ -0,0 +1,17 @@ +title: "Statement-Distribution validator disabling changes" + +doc: + - audience: Node Dev + description: | + In preparation for launching re-enabling (#2418), we need to adjust the + disabling strategy of statement-distribution to use the relay parent's + state instead of the latest state (union of active leaves). This will also + ensure no raciness of getting the latest state vs accepting statements from + disabling validators at the cost of being more lenient/potentially accepting + more statements from disabled validators. + +crates: + - name: polkadot-statement-distribution + bump: patch + - name: polkadot + bump: none diff --git a/prdoc/1.13.0/pr_4444.prdoc b/prdoc/1.13.0/pr_4444.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0b6a5715e47f858f17d845bb3b4b7e4bc49ae2fb --- /dev/null +++ b/prdoc/1.13.0/pr_4444.prdoc @@ -0,0 +1,10 @@ +title: "Rococo AH: cleanup storage" + +doc: + - audience: Runtime Dev + description: | + Remove old storage that is left over in the Rococo AH storage. + +crates: + - name: asset-hub-rococo-runtime + bump: patch diff --git a/prdoc/1.13.0/pr_4465.prdoc b/prdoc/1.13.0/pr_4465.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cbeff09f871f00d5ce3e646fa4adfb11148971a2 --- /dev/null +++ b/prdoc/1.13.0/pr_4465.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Bridge: added force_set_pallet_state call to pallet-bridge-grandpa" + +doc: + - audience: Runtime Dev + description: | + Added `force_set_pallet_state` to the `pallet-bridge-grandpa`. It is only callable by the + root (governance or sudo) and may be used to update current authorities set and the best + finalized header without any additional checks. + +crates: + - name: pallet-bridge-grandpa + bump: major + - name: bridge-hub-rococo-runtime + bump: minor + - name: bridge-hub-westend-runtime + bump: minor diff --git a/prdoc/1.13.0/pr_4471.prdoc b/prdoc/1.13.0/pr_4471.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..6d589be81fd96904f0c5c76abccb1c9b5acd920d --- /dev/null +++ b/prdoc/1.13.0/pr_4471.prdoc @@ -0,0 +1,16 @@ +title: "Remove prospective-parachains subsystem from collator nodes" + +doc: + - audience: Node Dev + description: | + Removes the prospective-parachains subsystem from collators. The GetMinimumRelayParents of the implicit view + is replaced by direct ChainAPI and runtime calls. The subsystem was causing performance problems when collating + connected to an RPC node, due to the high number of runtime API calls, which were unneccessary for a collator. + +crates: + - name: polkadot-collator-protocol + bump: minor + - name: polkadot-service + bump: minor + - name: polkadot-node-subsystem-util + bump: minor diff --git a/prdoc/1.13.0/pr_4472.prdoc b/prdoc/1.13.0/pr_4472.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cd7527d73d6ba3689d9623c09a591ed61ab5da42 --- /dev/null +++ b/prdoc/1.13.0/pr_4472.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove `pallet::getter` usage from pallet-democracy + +doc: + - audience: Runtime Dev + description: | + This PR removes the `pallet::getter`s from `pallet-democracy`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-democracy + bump: major diff --git a/prdoc/1.13.0/pr_4475.prdoc b/prdoc/1.13.0/pr_4475.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..30093dcd32b89d8f34c00154ee73fc60ced0b00a --- /dev/null +++ b/prdoc/1.13.0/pr_4475.prdoc @@ -0,0 +1,10 @@ +title: "Deprecate dmp-queue pallet" + +doc: + - audience: Runtime Dev + description: | + Schedule the DMP queue pallet for deletion. It is not needed anymore sine https://github.com/paritytech/polkadot-sdk/pull/1246. + +crates: + - name: cumulus-pallet-dmp-queue + bump: minor diff --git a/prdoc/1.13.0/pr_4478.prdoc b/prdoc/1.13.0/pr_4478.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..22e2e43db4caff9d405ca0ca8c4915416e7df1f5 --- /dev/null +++ b/prdoc/1.13.0/pr_4478.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Snowbridge - Ethereum Client - Reject finalized updates without a sync committee in next store period + +doc: + - audience: Runtime Dev + description: | + Bug fix in the Ethereum light client that stalls the light client when an update in the next sync committee period is received without receiving the next sync committee update in the next period. + +crates: + - name: snowbridge-pallet-ethereum-client + bump: patch diff --git a/prdoc/1.13.0/pr_4503.prdoc b/prdoc/1.13.0/pr_4503.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d95a24cc7d6b6281761d81b4ab2ccdc8b14e4550 --- /dev/null +++ b/prdoc/1.13.0/pr_4503.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Patch pool to handle extra consumer ref when destroying. + +doc: + - audience: Runtime User + description: | + An erroneous consumer reference on the pool account is preventing pools from being destroyed. This patch removes the extra reference if it exists when the pool account is destroyed. + +crates: + - name: pallet-nomination-pools + bump: patch diff --git a/prdoc/1.13.0/pr_4510.prdoc b/prdoc/1.13.0/pr_4510.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..fbd9bf961fe902b9e38a1cba1a3393764b6f3ccf --- /dev/null +++ b/prdoc/1.13.0/pr_4510.prdoc @@ -0,0 +1,13 @@ +title: "[Contracts] Remove internal topic index" + +doc: + - audience: Runtime Dev + description: | + This PR removes topics from internal events emitted by pallet_contracts. It does not touch the `deposit_event` host function used by + smart contracts that can still include topics. + Event topics incurs significant Storage costs, and are only used by light clients to index events and avoid downloading the entire block. + They are not used by Dapp or Indexers that download the whole block anyway. + +crates: + - name: pallet-contracts + bump: patch diff --git a/prdoc/1.13.0/pr_4514.prdoc b/prdoc/1.13.0/pr_4514.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..dab6cab303476f32bf0c17836e2b770b5260c0f6 --- /dev/null +++ b/prdoc/1.13.0/pr_4514.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-fast-unstake + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-fast-unstake`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-fast-unstake + bump: major diff --git a/prdoc/1.13.0/pr_4521.prdoc b/prdoc/1.13.0/pr_4521.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a8b42a2c7ee3fd5f4beca6c2aede7a4a82a8a1b1 --- /dev/null +++ b/prdoc/1.13.0/pr_4521.prdoc @@ -0,0 +1,28 @@ +title: AdaptPrice trait is now price controlled + +doc: + - audience: Runtime Dev + description: | + The broker pallet price adaptation interface is changed to be less opinionated and more + information is made available to the `AdaptPrice` trait. A new example impl is included which + adapts the price based not on the number of cores sold, but rather on the price that was + achieved during the sale to mitigate a potential price manipulation vector. More information + here: + + https://github.com/paritytech/polkadot-sdk/issues/4360 + + - audience: Runtime User + description: | + The price controller of the Rococo and Westend Coretime chain will be + adjusted with this release. This will very likely be used in the + fellowship production runtime to have a much larger leadin. This fixes a + price manipulation issue we discovered with the Kusama launch. + +crates: + - name: pallet-broker + bump: minor + - name: coretime-rococo-runtime + bump: minor + - name: coretime-westend-runtime + bump: minor + diff --git a/prdoc/1.13.0/pr_4533.prdoc b/prdoc/1.13.0/pr_4533.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a0835285fc012cb0018e499f87e380f7ac059999 --- /dev/null +++ b/prdoc/1.13.0/pr_4533.prdoc @@ -0,0 +1,10 @@ +title: "Fixed RPC subscriptions leak when subscription stream is finished" + +doc: + - audience: Node Operator + description: | + The node may leak RPC subscriptions in some cases, e.g. during + `author_submitAndWatchExtrinsic` calls. This PR fixes the issue. + +crates: + - name: sc-rpc diff --git a/prdoc/1.13.0/pr_4534.prdoc b/prdoc/1.13.0/pr_4534.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..417e4d3dace01e2e840a074bf9aac8615dbb5f1a --- /dev/null +++ b/prdoc/1.13.0/pr_4534.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add Extra Check in Primary Username Setter + +doc: + - audience: Runtime User + description: | + Setting primary usernames requires an additional verification. + +crates: + - name: pallet-identity + bump: patch diff --git a/prdoc/1.13.0/pr_4537.prdoc b/prdoc/1.13.0/pr_4537.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0148c95fb4e8bcddf530b66f66ffba9c6fdaec1e --- /dev/null +++ b/prdoc/1.13.0/pr_4537.prdoc @@ -0,0 +1,27 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Runtime apis to help with delegate-stake based Nomination Pools. + +doc: + - audience: Runtime User + description: | + Introduces a new set of runtime apis to facilitate dapps and wallets to integrate with delegate-stake + functionalities of Nomination Pools. These apis support pool and member migration, as well as lazy application of + pending slashes of the pool members. + +crates: + - name: pallet-nomination-pools + bump: minor + - name: westend-runtime + bump: minor + - name: kitchensink-runtime + bump: minor + - name: pallet-delegated-staking + bump: minor + - name: sp-staking + bump: minor + - name: pallet-nomination-pools-benchmarking + bump: patch + - name: pallet-nomination-pools-runtime-api + bump: minor diff --git a/prdoc/1.13.0/pr_4541.prdoc b/prdoc/1.13.0/pr_4541.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..815ea2c800625f78e1f92d153a0f3da664508829 --- /dev/null +++ b/prdoc/1.13.0/pr_4541.prdoc @@ -0,0 +1,16 @@ +title: "Remove warning about `BadCertificate` Version 2" + +doc: + - audience: Node Operator + description: | + The node was printing the following warning from time to time: + ``` + Sending fatal alert BadCertificate + ``` + + This is not an user error and thus, the warning will now not be printed + anymore. + +crates: + - name: sc-tracing + bump: patch diff --git a/prdoc/1.13.0/pr_4542.prdoc b/prdoc/1.13.0/pr_4542.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..faaf9dc2c288551ec84b7bcd739158dd817341e6 --- /dev/null +++ b/prdoc/1.13.0/pr_4542.prdoc @@ -0,0 +1,13 @@ +title: "Adds ability to specify chain type in chain-spec-builder" + +doc: + - audience: Node Operator + description: | + Currently, `chain-spec-builder` only creates a spec with Live chain type. This PR adds the + ability to specify it while keeping the same default. + +crates: + - name: staging-chain-spec-builder + bump: patch + - name: sc-chain-spec + bump: patch diff --git a/prdoc/1.13.0/pr_4555.prdoc b/prdoc/1.13.0/pr_4555.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..257115d236e76756007281a0b64d7a73fa2fdff9 --- /dev/null +++ b/prdoc/1.13.0/pr_4555.prdoc @@ -0,0 +1,11 @@ +title: Move `para_id` to `MockValidationDataInherentDataProvider` + +doc: + - audience: Node Dev + description: | + This moves the `para_id` from `MockXcmConfig` to `MockValidationDataInherentDataProvider` to make it more prominent. The `para_id` should + be set to the parachain id of the parachain that gets mocked to ensure that the relay chain storage proof is setup correctly etc. + +crates: + - name: cumulus-client-parachain-inherent + bump: major diff --git a/prdoc/1.13.0/pr_4571.prdoc b/prdoc/1.13.0/pr_4571.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b03fee8a5cc8746f9ae569a6ffd4902f1da4a510 --- /dev/null +++ b/prdoc/1.13.0/pr_4571.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Ignore mandatory extrinsics in total PoV size check + +doc: + - audience: Runtime Dev + description: | + The `CheckWeight` extension is checking that extrinsic length and used storage proof + weight together do not exceed the PoV size limit. This lead to problems when + the PoV size was already reached before mandatory extrinsics were applied.The `CheckWeight` + extension will now allow extrinsics of `DispatchClass::Mandatory` to be applied even if + the limit is reached. + +crates: + - name: frame-system + bump: minor + - name: polkadot-sdk + bump: minor diff --git a/prdoc/1.13.0/pr_4595.prdoc b/prdoc/1.13.0/pr_4595.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..8baa6e8a91f3c54c50a5f20b2e03e812a8857162 --- /dev/null +++ b/prdoc/1.13.0/pr_4595.prdoc @@ -0,0 +1,25 @@ +title: "Remove `elastic-scaling-experimental` feature flag" + +doc: + - audience: Node Dev + description: | + The feature was masking the ability of collators to respond with `CollationWithParentHeadData` + to validator collation fetch requests, a requirement for elastic scaling. + Please note that `CollationWithParentHeadData` is only sent by collators of parachains with + multiple cores assigned, otherwise collators must respond with `CollationFetchingResponse::Collation` + - audience: Node Operator + description: | + This change enables elastic scaling support in collators. Please upgrade to latest version, + otherwise validator nodes will not be able to back elastic parachain blocks leading to + missed rewards. + +crates: + - name: polkadot-collator-protocol + bump: major + validate: false + - name: polkadot-service + bump: major + validate: false + - name: polkadot-parachain-bin + bump: minor + validate: false diff --git a/prdoc/1.13.0/pr_4621.prdoc b/prdoc/1.13.0/pr_4621.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ebc06b92b39c3bf2956f0db71a790acd08f291a9 --- /dev/null +++ b/prdoc/1.13.0/pr_4621.prdoc @@ -0,0 +1,43 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Change XcmDryRunApi::dry_run_extrinsic to take a call instead + +doc: + - audience: Runtime User + description: | + The XcmDryRunApi now dry-run calls instead of extrinsics. + This means it's possible to dry-run an extrinsic before signing it, + allowing for seamless dry-running in dapps. + Additionally, calls can now be dry-run for different accounts. + - audience: Runtime Dev + description: | + The XcmDryRunApi::dry_run_extrinsic function was replaced by + XcmDryRunApi::dry_run_call. + This new function takes an origin (OriginCaller, the encodable inner variant) + and a call instead of an extrinsic. + This was needed to not require the user signing twice, once for the dry-run and + a second time to actually submit the extrinsic. + Additionally, calls can now be dry-run for different accounts. + The implementation for this runtime API is now simpler, being `call.dispatch(origin.into())` + instead of using the `Executive`. + +crates: + - name: xcm-fee-payment-runtime-api + bump: major + - name: penpal-runtime + bump: major + - name: xcm-emulator + bump: minor + - name: polkadot-service + bump: major + - name: rococo-runtime + bump: major + - name: westend-runtime + bump: major + - name: asset-hub-rococo-runtime + bump: major + - name: asset-hub-westend-runtime + bump: major + - name: pallet-xcm + bump: minor diff --git a/prdoc/1.13.0/pr_4633.prdoc b/prdoc/1.13.0/pr_4633.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f239191cc1985a531833e9a1a47a0d22bfce21f2 --- /dev/null +++ b/prdoc/1.13.0/pr_4633.prdoc @@ -0,0 +1,8 @@ +title: "Unify dependency aliases" + +doc: + - audience: [Runtime Dev, Node Dev] + description: | + Changes the re-export names of some crates but does not do any logic changes. + +crates: [ ] diff --git a/prdoc/1.13.0/pr_4634.prdoc b/prdoc/1.13.0/pr_4634.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0c16dedeae16e4cba3b0e69029abaf213771aade --- /dev/null +++ b/prdoc/1.13.0/pr_4634.prdoc @@ -0,0 +1,34 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Implement XcmPaymentApi and DryRunApi on all system parachains + +doc: + - audience: Runtime User + description: | + The new XcmPaymentApi and DryRunApi have been implement on all westend and rococo system parachains. + You can test them out. + - audience: Runtime Dev + description: | + The new XcmPaymentApi and DryRunApi have been implement on all westend and rococo system parachains. + These can be used to build UIs that estimate XCM execution and sending, using libraries like PAPI or PJS. + +crates: + - name: bridge-hub-rococo-runtime + bump: minor + - name: bridge-hub-westend-runtime + bump: minor + - name: collectives-westend-runtime + bump: minor + - name: contracts-rococo-runtime + bump: minor + - name: coretime-rococo-runtime + bump: minor + - name: coretime-westend-runtime + bump: minor + - name: people-rococo-runtime + bump: minor + - name: people-westend-runtime + bump: minor + - name: penpal-runtime + bump: minor diff --git a/prdoc/1.13.0/pr_4645.prdoc b/prdoc/1.13.0/pr_4645.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1bc65f02ea578dace067b21f05cc298d448dffb4 --- /dev/null +++ b/prdoc/1.13.0/pr_4645.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: make all storage items in parachain-system public + +doc: + - audience: Runtime Dev + description: | + All storage items in cumulus-pallet-parachain-systemare now public. This allows + the usage of these storage items from within other runtime-pallets + or the runtime itself. For instance, it should allow to read the latests + relay state proof to read a certain well-known-key. + +crates: + - name: cumulus-pallet-parachain-system + bump: minor \ No newline at end of file diff --git a/prdoc/1.13.0/pr_4646.prdoc b/prdoc/1.13.0/pr_4646.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0252deb57bddaf84414a2f241a1d3749b78eecd5 --- /dev/null +++ b/prdoc/1.13.0/pr_4646.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[Identity] Remove double encoding username signature payload" + +doc: + - audience: Runtime Dev + description: | + The signature payload for setting a username for an account in `pallet-identity` is now just + the raw bytes of said username (still including the suffix), removing the need to first + encode these bytes before signing. + - audience: Runtime User + description: | + The signature payload for setting a username for an account in `pallet-identity` is now just + the raw bytes of said username (still including the suffix), removing the need to first + encode these bytes before signing. + +crates: + - name: pallet-identity + bump: major diff --git a/prdoc/1.13.0/pr_4721.prdoc b/prdoc/1.13.0/pr_4721.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..730ac4d8308692001c20f30a89276af26a1b14ce --- /dev/null +++ b/prdoc/1.13.0/pr_4721.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Skip tree route calculation if no forks present + +doc: + - audience: Node Operator + description: | + Fixes an issue with synchronisation on parachains. Once they reached the tip of the chain, + nodes would show `Preparing 0.0 bps`. This is shown because the node is blocked on calculating + the tree route from genesis to the tip of the chain many times. This PR solves that by skipping + tree route calculation if there is only one leave. In addition, further optimizations have been + done to alleviate long finalization distances. + +crates: + - name: sp-blockchain + bump: minor + - name: sc-client-db + bump: none diff --git a/prdoc/1.14.0/pr_1631.prdoc b/prdoc/1.14.0/pr_1631.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f73d00968552a4b0c589a68079971d0dcac503bc --- /dev/null +++ b/prdoc/1.14.0/pr_1631.prdoc @@ -0,0 +1,39 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Upgrade libp2p to 0.52.4 + +doc: + - audience: [Node Dev, Node Operator] + description: | + Upgrade libp2p from 0.51.4 to 0.52.4 + +crates: + - name: sc-authority-discovery + bump: minor + - name: sc-cli + bump: minor + - name: sc-mixnet + bump: minor + - name: sc-network + bump: minor + - name: sc-network-gossip + bump: minor + - name: sc-network-common + bump: minor + - name: sc-network-light + bump: minor + - name: sc-network-statement + bump: minor + - name: sc-network-sync + bump: minor + - name: sc-network-test + bump: minor + - name: sc-network-transactions + bump: minor + - name: sc-network-types + bump: minor + - name: sc-offchain + bump: major + - name: sc-telemetry + bump: major diff --git a/prdoc/1.14.0/pr_3374.prdoc b/prdoc/1.14.0/pr_3374.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..76744f778db0a5bf5ba259ec2978d4b7e8d4e9b6 --- /dev/null +++ b/prdoc/1.14.0/pr_3374.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: removed `pallet::getter` from `pallet-timestamp` + +doc: + - audience: Runtime Dev + description: | + This PR removes all the `pallet::getter` usages from `pallet-timestamp`, and updates depdendant runtimes accordingly. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-timestamp \ No newline at end of file diff --git a/prdoc/1.14.0/pr_3679.prdoc b/prdoc/1.14.0/pr_3679.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..86c1e9beafe99bfbc36e5308fb0f10b74841dc6c --- /dev/null +++ b/prdoc/1.14.0/pr_3679.prdoc @@ -0,0 +1,14 @@ +title: "[pallet-contracts] bump wasmi to 0.32" + +doc: + - audience: Runtime Dev + description: | + - Bump wasmi to 0.32 + - Turn on lazy and unchecked compilation when calling a contract. + See https://docs.rs/wasmi/0.32.0/wasmi/enum.CompilationMode.html#variant.Lazy + See https://docs.rs/wasmi/0.32.0/wasmi/struct.Module.html#method.new_unchecked + See https://wasmi-labs.github.io/blog/posts/wasmi-v0.32 for more details, on the wasmi update. + +crates: + - name: pallet-contracts + - name: pallet-contracts-proc-macro diff --git a/prdoc/1.14.0/pr_3820.prdoc b/prdoc/1.14.0/pr_3820.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..33e8129df92a3c045f88531f40ee2d1793e591ab --- /dev/null +++ b/prdoc/1.14.0/pr_3820.prdoc @@ -0,0 +1,32 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove deprecated calls from treasury pallet + +doc: + - audience: Runtime User + description: | + This PR remove deprecated calls, relevant tests from `pallet-treasury`. + - Remove deprecated calls `propose_spend`, `reject_proposal`, `approve_proposal`. + - Replace the code flow of `propose_spend` then `approve_proposal` with `spend_local` + - Remove deprecated calls' related weight functions and test cases. + - Remove deprecated parameter types: ProposalBond, ProposalBondMaximum, ProposalBondMinimum + - Remove pallet treasury's relevant deprecated code in pallet-tips, pallet-bounties and pallet-child-bounties + +crates: + - name: pallet-treasury + bump: major + - name: pallet-tips + bump: patch + - name: pallet-child-bounties + bump: patch + - name: pallet-bounties + bump: patch + - name: polkadot-runtime-common + bump: patch + - name: rococo-runtime + bump: patch + - name: westend-runtime + bump: patch + - name: collectives-westend-runtime + bump: patch diff --git a/prdoc/1.14.0/pr_3828.prdoc b/prdoc/1.14.0/pr_3828.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..426625d5f23effb3fe889cacb767650d56921044 --- /dev/null +++ b/prdoc/1.14.0/pr_3828.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[FRAME] Remove storage migration type" + +doc: + - audience: Runtime Dev + description: | + Introduce migration type to remove data associated with a specific storage of a pallet. + +crates: + - name: frame-support + bump: minor diff --git a/prdoc/1.14.0/pr_3843.prdoc b/prdoc/1.14.0/pr_3843.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e01900dcc25b998124a2929f14171d049c2fa698 --- /dev/null +++ b/prdoc/1.14.0/pr_3843.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Introduce a new dispatchable function `set_partial_params` in `pallet-core-fellowship` + +doc: + - audience: Runtime Dev + description: | + This PR adds a new dispatchable function `set_partial_params` + to update config with multiple arguments without duplicating the + fields that does not need to update. + +crates: + - name: pallet-core-fellowship + bump: major + - name: collectives-westend-runtime + bump: patch diff --git a/prdoc/1.14.0/pr_3940.prdoc b/prdoc/1.14.0/pr_3940.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..590afa77bb1ed8ec41958d87279e7be969f55ade --- /dev/null +++ b/prdoc/1.14.0/pr_3940.prdoc @@ -0,0 +1,31 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "RFC-5: Add request revenue info" + +doc: + - audience: Runtime Dev + description: | + Partially implemented RFC-5 in terms of revenue requests and notifications + - audience: Runtime User + description: | + Instantaneous Coretime sold on the relay chain now generates revenue for its provider. + The revenue may be claimed by its provider on the Coretime chain. + +crates: + - name: polkadot-runtime-parachains + bump: minor + - name: rococo-runtime + bump: minor + - name: westend-runtime + bump: minor + - name: pallet-broker + bump: minor + - name: rococo-runtime-constants + bump: minor + - name: westend-runtime-constants + bump: minor + - name: coretime-rococo-runtime + bump: minor + - name: coretime-westend-runtime + bump: minor diff --git a/prdoc/1.14.0/pr_3951.prdoc b/prdoc/1.14.0/pr_3951.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3a8096e6f448748e090cf0732a7b453fafcb6239 --- /dev/null +++ b/prdoc/1.14.0/pr_3951.prdoc @@ -0,0 +1,30 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Pallet Assets Freezer + +doc: + - audience: Runtime Dev + description: | + This pallet is an extension of `pallet-assets`, supporting + freezes similar to `pallet-balances`. + To use this pallet, set `Freezer` of `pallet-assets` Config to the according instance of + `pallet-assets-freezer`. + - audience: Runtime User + description: | + The storage of this pallet contains a Vecs of account freezes. Applications UIs and Developer + Tools might benefit from observing it. + +crates: + - name: frame-support + bump: minor + - name: pallet-assets-freezer + bump: major + - name: pallet-assets + bump: patch + - name: pallet-balances + bump: patch + - name: asset-hub-rococo-runtime + bump: minor + - name: asset-hub-westend-runtime + bump: minor diff --git a/prdoc/1.14.0/pr_4513.prdoc b/prdoc/1.14.0/pr_4513.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e7363d211c1700a9ec3a4b38799ad73da0b13038 --- /dev/null +++ b/prdoc/1.14.0/pr_4513.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-elections-phragmen + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-elections-phragmen`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-elections-phragmen + bump: major diff --git a/prdoc/1.14.0/pr_4596.prdoc b/prdoc/1.14.0/pr_4596.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d47aa3aedfb85abcae3bd76f0d0abe31d544816b --- /dev/null +++ b/prdoc/1.14.0/pr_4596.prdoc @@ -0,0 +1,18 @@ +title: "Frame: `Consideration` trait generic over `Footprint` and handles zero cost" + +doc: + - audience: Runtime Dev + description: | + `Consideration` trait generic over `Footprint` and can handle zero cost for a give footprint. + + `Consideration` trait is generic over `Footprint` (currently defined over the type with the same name). This makes it possible to setup a custom footprint (e.g. current number of proposals in the storage). + + `Consideration::new` and `Consideration::update` return an `Option` instead `Self`, this make it possible to define no cost for a specific footprint (e.g. current number of proposals in the storage < max_proposal_count / 2). + +crates: + - name: frame-support + bump: major + - name: pallet-preimage + bump: major + - name: pallet-balances + bump: patch diff --git a/prdoc/1.14.0/pr_4618.prdoc b/prdoc/1.14.0/pr_4618.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3dd0fce81eeee54a411aef89442c233da204af68 --- /dev/null +++ b/prdoc/1.14.0/pr_4618.prdoc @@ -0,0 +1,20 @@ +title: Unify logic for fetching the `:code` of a block + +doc: + - audience: Node Operator + description: | + Fixes an issue on parachains when running with a custom `substitute` of the on chain wasm code + and having replaced the wasm code on the relay chain. The relay chain was rejecting blocks + build this way, because the collator was reporting the actual on chain wasm code hash + to the relay chain. However, the relay chain was expecting the code hash of the wasm code substitute + that was also registered on the relay chain. + - audience: Node Dev + description: | + `Client::code_at` will now use the same `substitute` to determine the code for a given block as it is + done when executing any runtime call. + +crates: + - name: cumulus-client-consensus-aura + bump: minor + - name: sc-service + bump: minor diff --git a/prdoc/1.14.0/pr_4662.prdoc b/prdoc/1.14.0/pr_4662.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..50f8a5bfd011077cc218e6bcb6978cf7038ce25f --- /dev/null +++ b/prdoc/1.14.0/pr_4662.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Cleanup PVF artifact by cache limit and stale time + +doc: + - audience: Node Operator + description: | + Extend the PVF artifacts cleanup strategy. Previously, we pruned artifacts that were stale more than 24 hours. + After this change we attempt pruning artifacts only when they reach the 10 GB cache limit. If the least used + artifact is stale less than 24 hours we don't remove it. + +crates: + - name: polkadot-node-core-pvf-common + bump: patch + - name: polkadot-node-core-pvf + bump: patch diff --git a/prdoc/1.14.0/pr_4684.prdoc b/prdoc/1.14.0/pr_4684.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b1c429c57822494cd11f75beea93c4dabf2764cb --- /dev/null +++ b/prdoc/1.14.0/pr_4684.prdoc @@ -0,0 +1,13 @@ +title: "Refactor of the parachain template" + +doc: + - audience: Runtime Dev + description: | + Introduce the construct runtime V2 to the parachain template runtime. In addition, url links in the parachain pallet + template now direct to the polkadot sdk docs. + +crates: + - name: pallet-parachain-template + bump: none + - name: parachain-template-runtime + bump: none diff --git a/prdoc/1.14.0/pr_4685.prdoc b/prdoc/1.14.0/pr_4685.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e212919ba2e5bcfede725c1afbdd27115dc5e229 --- /dev/null +++ b/prdoc/1.14.0/pr_4685.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Chain-spec-builder supports `codeSubstitutes`. + +doc: + - audience: Node Operator + description: | + A new subcommand `add-code-substitute` is available for the `chain-spec-builder` binary. It allows users to provide a runtime that should be used from a given + block onwards. The `codeSubstitutes` field in the chain spec is used to force usage of a given runtime at a given block until the next runtime upgrade. It can be + used to progress chains that are stalled due to runtime bugs that prevent block-building. However, parachain usage is only possible in combination with an updated + validation function on the relay chain. + +crates: + - name: staging-chain-spec-builder + bump: minor diff --git a/prdoc/1.14.0/pr_4691.prdoc b/prdoc/1.14.0/pr_4691.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..18cbb2296d43b5c72e04b3de926da5d29b6c716a --- /dev/null +++ b/prdoc/1.14.0/pr_4691.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fix claim queue size + +doc: + - audience: Runtime User + description: | + Ensure claim queue size is always the number configured by ` scheduler_params.lookahead`. Previously the claim queue of a core was shortened by 1 if the core was occupied. + + +crates: + - name: polkadot-runtime-parachains + bump: minor diff --git a/prdoc/1.14.0/pr_4710.prdoc b/prdoc/1.14.0/pr_4710.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d7d31d817208a44402c53d2941750108c250f683 --- /dev/null +++ b/prdoc/1.14.0/pr_4710.prdoc @@ -0,0 +1,11 @@ +title: "Dont partially modify HRMP pages" + +doc: + - audience: Runtime Dev + description: | + The xcmp-queue pallet now does not partially modify a page anymore when the next message does + not fully fit into it but instead cleanly creates a new one. + +crates: + - name: cumulus-pallet-xcmp-queue + bump: patch diff --git a/prdoc/1.14.0/pr_4724.prdoc b/prdoc/1.14.0/pr_4724.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3723c2a70246ad40ad139c4da6e770fd386996f4 --- /dev/null +++ b/prdoc/1.14.0/pr_4724.prdoc @@ -0,0 +1,24 @@ +title: Fix core sharing and make use of scheduling_lookahead during backing + +doc: + - audience: Node Dev + description: | + Core sharing (two or more parachains scheduled on the same core with interlaced assignments) was not working correctly. + Adds the neccessary fixes to the backing subsystems. Moreover, adds support for backing collations which are built + and advertised ahead of time (with up to `scheduling_lookahead` relay chain blocks in advance). + +crates: + - name: polkadot-node-core-backing + bump: patch + - name: polkadot-node-core-prospective-parachains + bump: patch + - name: polkadot-collator-protocol + bump: patch + - name: polkadot-statement-distribution + bump: patch + - name: polkadot-node-subsystem-util + bump: minor + - name: polkadot-runtime-parachains + bump: none + - name: polkadot + bump: none diff --git a/prdoc/1.14.0/pr_4728.prdoc b/prdoc/1.14.0/pr_4728.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1494fbdbb2b9fb2a534e3fa47d13ee46996b180d --- /dev/null +++ b/prdoc/1.14.0/pr_4728.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Glutton - add support for bloating the parachain block length" + +doc: + - audience: [Runtime Dev, Runtime User] + description: | + Introduce a new configuration parameter `block_length` which can be configured via a call to + `set_block_length`. This sets the ration of the block length that is to be filled with trash. + This is implemented by an inherent that takes trash data as a parameter filling the block length. + +crates: + - name: pallet-glutton + bump: major + - name: glutton-westend-runtime + bump: major diff --git a/prdoc/1.14.0/pr_4730.prdoc b/prdoc/1.14.0/pr_4730.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..9af14534bcbd28a600c1bb838ae6ff7f8512f563 --- /dev/null +++ b/prdoc/1.14.0/pr_4730.prdoc @@ -0,0 +1,25 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: rpc upgrade jsonrpsee to v0.23.1 + +doc: + - audience: Node Dev + description: | + Upgrade the rpc library jsonrpsee to v0.23.1 to utilize: + + - Add Extensions which we now is using to get the connection id (used by the rpc spec v2) + - Update hyper to v1.0, http v1.0, soketto and related crates (hyper::service::make_service_fn is removed) + - The subscription API for the client is modified to know why a subscription was closed. + +crates: + - name: sc-rpc-spec-v2 + bump: patch + - name: sc-rpc + bump: patch + - name: sc-rpc-server + bump: patch + - name: cumulus-relay-chain-rpc-interface + bump: patch + - name: frame-remote-externalities + bump: patch diff --git a/prdoc/1.14.0/pr_4733.prdoc b/prdoc/1.14.0/pr_4733.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e633248398526c43fc0da478779c4fea86524e7a --- /dev/null +++ b/prdoc/1.14.0/pr_4733.prdoc @@ -0,0 +1,27 @@ +title: Add pov-recovery unit tests and support for elastic scaling + +doc: + - audience: Node Dev + description: | + Adds unit tests for cumulus pov-recovery and support for elastic scaling (recovering multiple candidates in a single relay chain block). + +crates: + - name: cumulus-client-network + bump: patch + - name: cumulus-client-pov-recovery + bump: patch + - name: cumulus-relay-chain-interface + bump: major + validate: false + - name: cumulus-relay-chain-inprocess-interface + bump: minor + - name: cumulus-relay-chain-rpc-interface + bump: minor + - name: cumulus-client-consensus-common + bump: none + - name: sc-client-api + bump: minor + - name: sp-blockchain + bump: minor + - name: sp-consensus + bump: minor diff --git a/prdoc/1.14.0/pr_4756.prdoc b/prdoc/1.14.0/pr_4756.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..064a79fb06648a39c6983c92a80028fff093355d --- /dev/null +++ b/prdoc/1.14.0/pr_4756.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Do not make pallet-nfts benchmarks signature-dependent + +doc: + - audience: Runtime Dev + description: | + - Adds extra functionality to pallet-nfts's BenchmarkHelper to provide signers and sign message. + - Abstracts away the explicit link with Sr25519 schema in the benchmarks, allowing parachains with a different one to be able to run them and calculate the weights. + - Adds a default implementation for the empty tuple that leaves the code equivalent. + +crates: + - name: pallet-nfts + bump: minor diff --git a/prdoc/1.14.0/pr_4757.prdoc b/prdoc/1.14.0/pr_4757.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d94a20d7bb1a6ab4c79117f5f99f95eaaa1881d8 --- /dev/null +++ b/prdoc/1.14.0/pr_4757.prdoc @@ -0,0 +1,18 @@ +title: "pallet assets: optional auto-increment for the asset ID" + +doc: + - audience: Runtime Dev + description: | + Introduce an optional auto-increment setup for the IDs of new assets. + +crates: + - name: pallet-assets + bump: major + - name: staging-xcm-builder + bump: patch + - name: staging-xcm + bump: patch + - name: pallet-assets-freezer + bump: patch + - name: pallet-contracts + bump: patch diff --git a/prdoc/1.14.0/pr_4765.prdoc b/prdoc/1.14.0/pr_4765.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f64b2fdc51ab12c59aac8a247bf69026dffb9bf1 --- /dev/null +++ b/prdoc/1.14.0/pr_4765.prdoc @@ -0,0 +1,18 @@ +title: CheckWeight - account for extrinsic len as proof size + +doc: + - audience: Runtime Dev + description: | + This changes how CheckWeight extension works. It will now account for the extrinsic length + as proof size. When `on_idle` is called, the remaining weight parameter reflects this. + +crates: + - name: frame-system + bump: patch + - name: frame-executive + bump: none + - name: cumulus-primitives-storage-weight-reclaim + bump: none + + + diff --git a/prdoc/1.14.0/pr_4769.prdoc b/prdoc/1.14.0/pr_4769.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e9691ba6f89744f073f8b0e794706e755aa59f0a --- /dev/null +++ b/prdoc/1.14.0/pr_4769.prdoc @@ -0,0 +1,20 @@ +title: Use real rust type for pallet alias in `runtime` macro + +doc: + - audience: Runtime Dev + description: | + This PR adds the ability to use a real rust type for pallet alias in the new `runtime` macro: + ```rust + #[runtime::pallet_index(0)] + pub type System = frame_system::Pallet; + ``` + + Please note that the current syntax still continues to be supported. + +crates: + - name: frame-support-procedural + bump: patch + - name: frame-support + bump: patch + - name: minimal-template-runtime + bump: patch diff --git a/prdoc/1.14.0/pr_4799.prdoc b/prdoc/1.14.0/pr_4799.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c4e68e316c22f8d805aceb20910f31dd3f7703fe --- /dev/null +++ b/prdoc/1.14.0/pr_4799.prdoc @@ -0,0 +1,24 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "network: Upgrade `litep2p` to v0.6.0" + +doc: + - audience: Node Operator + description: | + This PR brings the latest `litep2p` v0.6.0 to polkadot-sdk with stability improvements, + security fixes, and performance optimizations. + + Specifically: + - Incoming DHT records are now validated also with experimental litep2p network backend. + - Performance of TCP & WebSocket connections improved by setting `TCP_NODELAY` flag. + - Stability of secondary connection establishment improved. + - Multiple possible panics in litep2p library eliminated. + +crates: + - name: sc-authority-discovery + bump: patch + - name: sc-network + bump: patch + - name: sc-network-types + bump: patch diff --git a/prdoc/1.14.0/pr_4802.prdoc b/prdoc/1.14.0/pr_4802.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5757c4cbae184444d4eb78b620bcef50a3b0e133 --- /dev/null +++ b/prdoc/1.14.0/pr_4802.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add `health/readiness endpoint` to the rpc server + +doc: + - audience: Node Operator + description: | + Add `/health/readiness endpoint` to the rpc server which returns HTTP status code 200 if the chain is synced + and can connect to the rest of the network otherwise status code 500 is returned. + The endpoint can be reached by performing a HTTP GET request to the + endpoint such as `$ curl /health/readiness` + +crates: + - name: sc-rpc-server + bump: patch diff --git a/prdoc/1.14.0/pr_4807.prdoc b/prdoc/1.14.0/pr_4807.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b60bfb524510a17f50df19fbbb985dc0d263a9d6 --- /dev/null +++ b/prdoc/1.14.0/pr_4807.prdoc @@ -0,0 +1,11 @@ +title: "pallet ranked collective: max member count per rank" + +doc: + - audience: Runtime Dev + description: | + Configuration for the maximum member count per rank, with the option for no limit. + +crates: + - name: pallet-ranked-collective + bump: major + diff --git a/prdoc/1.14.0/pr_4823.prdoc b/prdoc/1.14.0/pr_4823.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a498b33f7bfa949078ca23ac196116b7f5b2f1f9 --- /dev/null +++ b/prdoc/1.14.0/pr_4823.prdoc @@ -0,0 +1,11 @@ +title: "`pallet-referenda`: Ensure to schedule referendas earliest at the next block" + +doc: + - audience: Runtime User + description: | + Ensure that referendas are scheduled earliest at the next block when they are enacted. + Otherwise the scheduling may fails and thus, the enactment of the referenda. + +crates: + - name: pallet-referenda + bump: patch diff --git a/prdoc/1.14.0/pr_4831.prdoc b/prdoc/1.14.0/pr_4831.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..8629ead6e81d80306bb69cf57ed14cea49313010 --- /dev/null +++ b/prdoc/1.14.0/pr_4831.prdoc @@ -0,0 +1,25 @@ +title: "treasury pallet: - remove unused config parameters" + +doc: + - audience: Runtime Dev + description: | + Remove unused config parameters `ApproveOrigin` and `OnSlash` from the treasury pallet. + Add `OnSlash` config parameter to the bounties and tips pallets. + +crates: + - name: pallet-treasury + bump: major + - name: pallet-bounties + bump: major + - name: pallet-tips + bump: major + - name: collectives-westend-runtime + bump: patch + - name: polkadot-runtime-common + bump: patch + - name: rococo-runtime + bump: patch + - name: westend-runtime + bump: patch + - name: kitchensink-runtime + bump: patch diff --git a/prdoc/1.14.0/pr_4833.prdoc b/prdoc/1.14.0/pr_4833.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a5cf853696eee38fc2659a3357eb7be7fe5f860a --- /dev/null +++ b/prdoc/1.14.0/pr_4833.prdoc @@ -0,0 +1,12 @@ +title: "Reinitialize should allow to override existing config in collationGeneration" + +doc: + - audience: Node Dev + description: | + The Reinitialize collationGeneration subsystem message currently fails if no other config is already set. + As it is difficult to query the collationGeneration subsystem to check when to call Initialize or Reinitialize, this PR + proposes that Reinitialize overrides the configuration regardless if there was one already set. + +crates: + - name: polkadot-node-collation-generation + bump: minor diff --git a/prdoc/1.14.0/pr_4844.prdoc b/prdoc/1.14.0/pr_4844.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..999e63c84ed9a0491c6b4683a5ed3d5b25efa8c2 --- /dev/null +++ b/prdoc/1.14.0/pr_4844.prdoc @@ -0,0 +1,34 @@ +title: Make `Verifier::verify` and `BlockImport::check_block` use `&self` instead of `&mut self` + +doc: + - audience: Node Dev + description: | + `Verifier::verify` and `BlockImport::check_block` were refactored to use `&self` instead of `&mut self` + because there is no fundamental requirement for those operations to be exclusive in nature. + +crates: +- name: sc-consensus + bump: major + validate: false +- name: sc-consensus-aura + bump: major +- name: sc-consensus-babe + bump: major +- name: sc-consensus-beefy + bump: major +- name: sc-consensus-grandpa + bump: major +- name: sc-consensus-manual-seal + bump: major +- name: sc-consensus-pow + bump: major +- name: sc-service + bump: major +- name: cumulus-client-consensus-common + bump: major +- name: cumulus-client-consensus-aura + bump: major +- name: cumulus-client-consensus-relay-chain + bump: major +- name: polkadot-parachain-bin + validate: false diff --git a/prdoc/1.14.0/pr_4857.prdoc b/prdoc/1.14.0/pr_4857.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d515e4257622e046c42b4de2638541397463374a --- /dev/null +++ b/prdoc/1.14.0/pr_4857.prdoc @@ -0,0 +1,50 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[xcm] runtime api for LocationToAccount conversions" + +doc: + - audience: Runtime Dev + description: | + Introduces a new runtime API to help with conversions of XCM `Location` to the runtime's `AccountId`, + showing an Ss58 formatted address for easier verification. + + Besides that, the `xcm-fee-payment-runtime-api` module was merged into the new `xcm-runtime-apis`. + If you are using the `xcm-fee-payment-runtime-api` dependency, you just need to change it to `xcm-runtime-apis` + and update the imports from `use xcm_fee_payment_runtime_api::*` to `use xcm_runtime_apis::*`. + +crates: + - name: xcm-runtime-apis + bump: none + - name: polkadot-sdk + bump: patch + - name: pallet-xcm + bump: patch + - name: polkadot-service + bump: patch + - name: rococo-runtime + bump: patch + - name: westend-runtime + bump: patch + - name: asset-hub-rococo-runtime + bump: patch + - name: asset-hub-westend-runtime + bump: patch + - name: bridge-hub-rococo-runtime + bump: patch + - name: bridge-hub-westend-runtime + bump: patch + - name: collectives-westend-runtime + bump: patch + - name: people-rococo-runtime + bump: patch + - name: people-westend-runtime + bump: patch + - name: penpal-runtime + bump: patch + - name: contracts-rococo-runtime + bump: patch + - name: coretime-rococo-runtime + bump: patch + - name: coretime-westend-runtime + bump: none diff --git a/prdoc/1.14.0/pr_4865.prdoc b/prdoc/1.14.0/pr_4865.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..48ffd04219cf5ab48bb45bae7449a0176d28ec7e --- /dev/null +++ b/prdoc/1.14.0/pr_4865.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Implement trait `ContainsLengthBound` for pallet-membership + +doc: + - audience: Runtime Dev + description: | + Implement trait ContainsLengthBound for pallet membership otherwise we can't use it with pallet-tips without wrapper + +crates: + - name: pallet-membership + bump: minor diff --git a/prdoc/1.14.0/pr_4877.prdoc b/prdoc/1.14.0/pr_4877.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ede536aee450257aaff732870f01d1dfa9106e49 --- /dev/null +++ b/prdoc/1.14.0/pr_4877.prdoc @@ -0,0 +1,13 @@ +title: "Core-Fellowship: new promote_fast call" + +doc: + - audience: Runtime User + description: | + Adds the ability to quickly promote someone within a collective by bypassing the promotion + cooldown. This can help in special situations and comes with a new origin: `FastPromoteOrigin`. + +crates: + - name: pallet-core-fellowship + bump: major + - name: collectives-westend-runtime + bump: major diff --git a/prdoc/1.15.0/pr_3286.prdoc b/prdoc/1.15.0/pr_3286.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3433f63f30295a57d8889eea12aedf731f8471cf --- /dev/null +++ b/prdoc/1.15.0/pr_3286.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Assets: can_decrease/increase for destroying asset is not successful" + +doc: + - audience: Runtime Dev + description: | + Functions `can_decrease` and `can_increase` do not return successful consequence results + for assets undergoing destruction; instead, they return the `UnknownAsset` consequence variant. + This update aligns their behavior with similar functions, such as `reducible_balance`, + `increase_balance`, `decrease_balance`, and `burn`, which return an `AssetNotLive` error + for assets in the process of being destroyed. + +crates: + - name: pallet-assets + bump: patch diff --git a/prdoc/1.15.0/pr_4097.prdoc b/prdoc/1.15.0/pr_4097.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2804a9571c79e5449111affb2e3117f635e0051d --- /dev/null +++ b/prdoc/1.15.0/pr_4097.prdoc @@ -0,0 +1,45 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Introduce experimental slot-based collator + +doc: + - audience: Node Operator + description: | + Introduces an experimental collator that is fit fot elastic-scaling. + It can be activated on `test-parachain` and `polkadot-parachain` binaries via + `--experimental-use-slot-based` flag. The current implementation is MVP status and purely + for testing. Behaviour can change any time and should not be relied upon in environments with + any stability requirements. + +crates: + - name: cumulus-client-consensus-aura + bump: major + - name: cumulus-client-consensus-common + bump: minor + - name: cumulus-client-pov-recovery + bump: none + validate: false + - name: cumulus-pallet-aura-ext + bump: patch + - name: cumulus-relay-chain-interface + bump: major + validate: false + - name: sc-consensus-slots + bump: minor + - name: sc-basic-authorship + bump: patch + - name: cumulus-client-network + bump: none + validate: false + - name: cumulus-relay-chain-inprocess-interface + bump: minor + - name: sc-consensus-aura + bump: patch + - name: cumulus-relay-chain-rpc-interface + bump: minor + - name: polkadot-parachain-bin + bump: patch + - name: polkadot + bump: none + validate: false diff --git a/prdoc/1.15.0/pr_4522.prdoc b/prdoc/1.15.0/pr_4522.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c8fdcfa51a419665ea00ad37051994e73089295b --- /dev/null +++ b/prdoc/1.15.0/pr_4522.prdoc @@ -0,0 +1,39 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Added runtime support for reporting BEEFY fork voting + +doc: + - audience: + - Runtime Dev + - Runtime User + description: | + This PR adds the `report_fork_voting`, `report_future_voting` extrinsics to `pallet-beefy` + and renames the `report_equivocation` extrinsic to `report_double_voting`. + `report_fork_voting` can't be called yet, since it uses `Weight::MAX` weight. We will + add benchmarks for it and set the proper weight in a future PR. + Also a new `AncestryHelper` associated trait was added to `pallet_beefy::Config`. + - audience: Node Dev + description: | + This PR renames the `submit_report_equivocation_unsigned_extrinsic` in `BeefyApi` to + `submit_report_double_voting_unsigned_extrinsic`and bumps the `BeefyApi` version from 3 to 4. + +crates: + - name: pallet-beefy + bump: major + - name: pallet-beefy-mmr + bump: minor + - name: pallet-mmr + bump: major + - name: sc-consensus-beefy + bump: patch + - name: kitchensink-runtime + bump: major + - name: rococo-runtime + bump: major + - name: westend-runtime + bump: major + - name: sp-consensus-beefy + bump: major + - name: polkadot-service + bump: patch diff --git a/prdoc/1.15.0/pr_4563.prdoc b/prdoc/1.15.0/pr_4563.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3780eee5898b555f44f9d7c7d6670e2c06ff4702 --- /dev/null +++ b/prdoc/1.15.0/pr_4563.prdoc @@ -0,0 +1,12 @@ +title: Try State Hook for Bounties. + +doc: + - audience: Runtime User + description: | + Invariants for storage items in the bounties pallet. Enforces the following Invariants: + 1.`BountyCount` should be greater or equals to the length of the number of items in `Bounties`. + 2.`BountyCount` should be greater or equals to the length of the number of items in `BountyDescriptions`. + 3. Number of items in `Bounties` should be the same as `BountyDescriptions` length. +crates: +- name: pallet-bounties + bump: minor diff --git a/prdoc/1.15.0/pr_4566.prdoc b/prdoc/1.15.0/pr_4566.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ea2979bb363aa2c26313f4e0b2d1108e99437492 --- /dev/null +++ b/prdoc/1.15.0/pr_4566.prdoc @@ -0,0 +1,23 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[pallet_contracts] Add support for transient storage in contracts host functions" + +doc: + - audience: Runtime User + description: | + This PR implements transient storage, which behaves identically to regular storage + but is kept only in memory and discarded after every transaction. + This functionality is similar to the `TSTORE` and `TLOAD` operations used in Ethereum. + The following new host functions have been introduced: `get_transient_storage`, + `set_transient_storage`, `take_transient_storage`, `clear_transient_storage` and + `contains_transient_storage`. + These functions are declared as unstable and thus are not activated. + +crates: + - name: pallet-contracts + bump: major + - name: pallet-contracts-uapi + bump: major + - name: contracts-rococo-runtime + bump: minor diff --git a/prdoc/1.15.0/pr_4663.prdoc b/prdoc/1.15.0/pr_4663.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..74b1274828d5c9fb31014c37b39798600f6c25fa --- /dev/null +++ b/prdoc/1.15.0/pr_4663.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add elastic scaling MVP guide + +doc: + - audience: Node Operator + description: | + Adds a guide for parachains that want to use the experimental elastic scaling MVP. + Will be viewable at: https://paritytech.github.io/polkadot-sdk/master/polkadot_sdk_docs/guides/enable_elastic_scaling_mvp/index.html + +crates: + - name: polkadot-parachain-bin + bump: none diff --git a/prdoc/1.15.0/pr_4738.prdoc b/prdoc/1.15.0/pr_4738.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..751f318e64f34355f009e6105f9f9d4d657ab1f2 --- /dev/null +++ b/prdoc/1.15.0/pr_4738.prdoc @@ -0,0 +1,18 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add CheckMetadata SignedExtension to Rococo and Westend Coretime chains + +doc: + - audience: Runtime User + description: | + This brings support for the new Ledger app and similar hardware wallets to the Coretime + Chain on Rococo and Westend. These hardware wallets will be able to decode the transaction + using the metadata. The runtime will ensure that the metadata used for this decoding process + is correct and that the online wallet did not try to trick you. + +crates: + - name: coretime-rococo-runtime + bump: major + - name: coretime-westend-runtime + bump: major diff --git a/prdoc/1.15.0/pr_4755.prdoc b/prdoc/1.15.0/pr_4755.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1018446cb67e7e20a77ce1780c7157fdeed3db56 --- /dev/null +++ b/prdoc/1.15.0/pr_4755.prdoc @@ -0,0 +1,24 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Send PeerViewChange with high priority + +doc: + - audience: Node Dev + description: | + - orchestra updated to 0.4.0, which introduces support for prioritizing system messages. + - PeerViewChange sent with high priority and should be processed first in a queue. + - To count them in tests added tracker to TestSender and TestOverseer. It acts more like a smoke test though. + + +crates: + - name: polkadot-overseer + bump: minor + - name: polkadot-network-bridge + bump: patch + - name: polkadot-availability-distribution + bump: patch + - name: polkadot-test-malus + bump: patch + - name: polkadot-node-subsystem-test-helpers + bump: patch diff --git a/prdoc/1.15.0/pr_4777.prdoc b/prdoc/1.15.0/pr_4777.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..07fa8decebe08bfaad0fe0c621bbda8e016502ab --- /dev/null +++ b/prdoc/1.15.0/pr_4777.prdoc @@ -0,0 +1,27 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: XCM builder pattern allows clear_origin before buy_execution. + +doc: + - audience: Runtime Dev + description: | + Added clear_origin as an allowed command after commands that load the holdings register, in the safe xcm builder. + Previously, although it's logically allowed, an XCM could not be built like this: + ```rust + let xcm = Xcm::builder() + .withdraw_asset((Parent, 100u128)) + .clear_origin() + .buy_execution((Parent, 1u128)) + .deposit_asset(All, [0u8; 32]) + .build(); + ``` + You had to use the unsafe_builder. + Now, it's allowed using the default builder. + +crates: +- name: "xcm-procedural" + bump: minor +- name: "staging-xcm" + bump: minor + diff --git a/prdoc/1.15.0/pr_4839.prdoc b/prdoc/1.15.0/pr_4839.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..84bb393d4c45425f2dd691e16668957d45813313 --- /dev/null +++ b/prdoc/1.15.0/pr_4839.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-insecure-randomness-collective-flip + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-insecure-randomness-collective-flip`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-insecure-randomness-collective-flip + bump: patch diff --git a/prdoc/1.15.0/pr_4840.prdoc b/prdoc/1.15.0/pr_4840.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..265e1f41c3f384c1c0aa3721ec0727d63b7cd96e --- /dev/null +++ b/prdoc/1.15.0/pr_4840.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-membership + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-membership`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-membership + bump: minor \ No newline at end of file diff --git a/prdoc/1.15.0/pr_4848.prdoc b/prdoc/1.15.0/pr_4848.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cbc0c8322d7722678922ef8ba53056aba7836319 --- /dev/null +++ b/prdoc/1.15.0/pr_4848.prdoc @@ -0,0 +1,14 @@ +title: Optimize logic for gossiping assignments + +doc: + - audience: Node Dev + description: | + Optimize the logic for gossiping assignments by obtaining the list of peer ids + from the topology instead of iterating through all connected validators, this + gives us a 15% to 20% reduction in cpu usage. + +crates: +- name: polkadot-approval-distribution + bump: minor +- name: polkadot-node-network-protocol + bump: minor \ No newline at end of file diff --git a/prdoc/1.15.0/pr_4863.prdoc b/prdoc/1.15.0/pr_4863.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..eb43b67a45c5c10cda58e84ff94d6e4815e888b4 --- /dev/null +++ b/prdoc/1.15.0/pr_4863.prdoc @@ -0,0 +1,10 @@ +title: "Make `tracing::log` work in the runtime" + +doc: + - audience: Runtime Dev + description: | + Make `tracing::log` work in the runtime as `log` works in the runtime. + +crates: + - name: sp-runtime + bump: patch diff --git a/prdoc/1.15.0/pr_4871.prdoc b/prdoc/1.15.0/pr_4871.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..6ff36f59d70085f3dfff23678b9d64946d4f75de --- /dev/null +++ b/prdoc/1.15.0/pr_4871.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-tips + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-tips`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + +crates: + - name: pallet-tips + bump: minor diff --git a/prdoc/1.15.0/pr_4885.prdoc b/prdoc/1.15.0/pr_4885.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..50dc31bc1b8fad8886a7ca39a1f4c7fda7e5592e --- /dev/null +++ b/prdoc/1.15.0/pr_4885.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-transaction-storage + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-transaction-storage`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + +crates: + - name: pallet-transaction-storage + bump: minor diff --git a/prdoc/1.15.0/pr_4888.prdoc b/prdoc/1.15.0/pr_4888.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e8cfb25d924d23fe05a44b6a7f076f70dc999e68 --- /dev/null +++ b/prdoc/1.15.0/pr_4888.prdoc @@ -0,0 +1,35 @@ +title: "Allow any asset over the bridge lane between the two Asset Hubs" + +doc: + - audience: Runtime User + description: | + Allow all Rococo-native, Westend-native and Ethereum-native assets to flow over + the bridge between the Rococo and Westend AssetHubs. + + On Rococo Asset Hub, we allow Westend Asset Hub to act as reserve for any asset + native to the Westend ecosystem. + We also allow Ethereum contracts to act as reserves for the foreign assets + identified by the same respective contracts locations (on the other side of Snowbridge). + + On Westend Asset Hub, we allow Rococo Asset Hub to act as reserve for any asset + native to the Rococo or Ethereum ecosystems (practically providing Westend access + to Ethereum assets through double bridging: Ethereum <> Rococo <> Westend). + +crates: + - name: assets-common + bump: major + - name: asset-hub-rococo-runtime + bump: major + - name: asset-hub-westend-runtime + bump: major + - name: asset-hub-rococo-emulated-chain + bump: minor + - name: asset-hub-rococo-integration-tests + bump: minor + - name: bridge-hub-rococo-integration-tests + bump: minor + - name: bridge-hub-westend-integration-tests + bump: minor + - name: emulated-integration-tests-common + bump: minor + diff --git a/prdoc/1.15.0/pr_4902.prdoc b/prdoc/1.15.0/pr_4902.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..19fe168a74abe316ee7e5acae7f1dfd0912c1486 --- /dev/null +++ b/prdoc/1.15.0/pr_4902.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-vesting + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-vesting`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + +crates: + - name: pallet-vesting + bump: minor diff --git a/prdoc/1.15.0/pr_4912.prdoc b/prdoc/1.15.0/pr_4912.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..dd96054b81fa3853d695b4baa4c9474ec4ea8338 --- /dev/null +++ b/prdoc/1.15.0/pr_4912.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-babe + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-babe`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + When accessed outside the pallet, use the public functions of storage. + +crates: + - name: pallet-babe + bump: minor diff --git a/prdoc/1.15.0/pr_4922.prdoc b/prdoc/1.15.0/pr_4922.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2e2dd26947c0d486fa92023c3021cdcb52128938 --- /dev/null +++ b/prdoc/1.15.0/pr_4922.prdoc @@ -0,0 +1,15 @@ +title: Optimize finalization performance + +doc: + - audience: Node Dev + description: | + Finalization algorithm was replaced with a more efficient version, data structures refactored to be faster and do + fewer memory allocations. As the result some APIs have changed in a minor, but incompatible way. + +crates: +- name: sc-client-api + bump: major +- name: sc-client-db + bump: major +- name: sp-blockchain + bump: major diff --git a/prdoc/1.15.0/pr_4932.prdoc b/prdoc/1.15.0/pr_4932.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..94af00d9249eb15c9b9c372cfb96a6a7f48862bc --- /dev/null +++ b/prdoc/1.15.0/pr_4932.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove relay-chain consensus authoring support for asset-hub chains from polkadot-parachain. + +doc: + - audience: Node Operator + description: | + The polkadot-parachain node had special handling for asset-hub parachains. They started out + using relay-chain consensus and later migrated to Aura as soon as it became available. The codepath for authoring + with relay chain consensus has been removed, since all asset hub chains have long migrated. + +crates: + - name: polkadot-parachain-bin + bump: major diff --git a/prdoc/1.15.0/pr_4935.prdoc b/prdoc/1.15.0/pr_4935.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2b06899b63398353209eb38ad5410e24fc3e4f6d --- /dev/null +++ b/prdoc/1.15.0/pr_4935.prdoc @@ -0,0 +1,75 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Bridges V2 refactoring backport and `pallet_bridge_messages` simplifications" + +doc: + - audience: Runtime Dev + description: | + This introduces several simplifications to the pallet_bridge_messages::Config configuration. + Types like `BridgedChainId`, `MaxUnrewardedRelayerEntriesAtInboundLane`, `MaxUnconfirmedMessagesAtInboundLane`, `MaximalOutboundPayloadSize`, + `InboundRelayer`, `TargetHeaderChain`, and `SourceHeaderChain` were removed. + Now, you only need to provide specific bridging chain configurations for `ThisChain`, `BridgedChain`, and `BridgedHeaderChain`. + + If you previously specified implementations for the bp_runtime::Chain* traits, those will fit here exactly, for example: + ``` + type ThisChain = bp_bridge_hub_rococo::BridgeHubRococo; + type BridgedChain = bp_bridge_hub_westend::BridgeHubWestend; + type BridgedHeaderChain = pallet_bridge_parachains::ParachainHeaders< + Runtime, + BridgeParachainWestendInstance, + bp_bridge_hub_westend::BridgeHubWestend, + >; + ``` + +crates: + - name: pallet-bridge-messages + bump: major + - name: bridge-runtime-common + bump: major + - name: bp-header-chain + bump: major + - name: bp-runtime + bump: major + - name: bp-messages + bump: major + - name: bp-polkadot-core + bump: patch + - name: bp-bridge-hub-kusama + bump: minor + - name: bp-bridge-hub-polkadot + bump: minor + - name: bp-bridge-hub-rococo + bump: minor + - name: bp-bridge-hub-westend + bump: minor + - name: bp-kusama + bump: minor + - name: bp-polkadot + bump: minor + - name: bp-polkadot-bulletin + bump: minor + - name: bp-rococo + bump: minor + - name: bp-test-utils + bump: patch + - name: bp-westend + bump: minor + - name: bridge-hub-test-utils + bump: major + - name: pallet-bridge-grandpa + bump: patch + - name: pallet-bridge-parachains + bump: patch + - name: pallet-bridge-relayers + bump: patch + - name: pallet-xcm-bridge-hub + bump: patch + - name: asset-hub-rococo-runtime + bump: patch + - name: asset-hub-westend-runtime + bump: patch + - name: bridge-hub-rococo-runtime + bump: major + - name: bridge-hub-westend-runtime + bump: major diff --git a/prdoc/1.15.0/pr_4943.prdoc b/prdoc/1.15.0/pr_4943.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a8db0f9e1ea10f59654c62122a79dfb69477f375 --- /dev/null +++ b/prdoc/1.15.0/pr_4943.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Update definition of frozen balance (docs PR) + +doc: + - audience: Runtime Dev + description: | + This PR fixes a bug in the docs located in the definition of frozen balances. In addition, it extends that definition for completeness. + +crates: +- name: frame-support + bump: patch diff --git a/prdoc/1.15.0/pr_4972.prdoc b/prdoc/1.15.0/pr_4972.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..dd9f1b531aad1a8a36fbc4b2ba19469ceccdb898 --- /dev/null +++ b/prdoc/1.15.0/pr_4972.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Remove `pallet::getter` usage from pallet-session" + +doc: + - audience: Runtime Dev + description: | + This PR removes the `pallet::getter`s from `pallet-session`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-session + bump: minor diff --git a/prdoc/1.15.0/pr_4978.prdoc b/prdoc/1.15.0/pr_4978.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1f86d512f2c78aa3910ace03a1216eb04faf517b --- /dev/null +++ b/prdoc/1.15.0/pr_4978.prdoc @@ -0,0 +1,18 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add MAX_INSTRUCTIONS_TO_DECODE to XCMv2 + +doc: + - audience: Runtime User + description: | + Added a max number of instructions to XCMv2. If using XCMv2, you'll have to take this limit into account. + It was set to 100. + - audience: Runtime Dev + description: | + Added a max number of instructions to XCMv2. If using XCMv2, you'll have to take this limit into account. + It was set to 100. + +crates: + - name: staging-xcm + bump: minor diff --git a/prdoc/1.15.0/pr_4997.prdoc b/prdoc/1.15.0/pr_4997.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..25620a7e63ea817e9009cf557748deb63d921f2e --- /dev/null +++ b/prdoc/1.15.0/pr_4997.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Do not crash on block gap in displaced_leaves_after_finalizing + +doc: + - audience: + - Node Operator + - Node Dev + description: | + After recent changes, crashes where occuring when calculating displaced branches after a block was finalized. + The reason are block gaps in the finalized chain. When encountering unknown blocks, the node was panicking. + This PR introduces changes to tolerate unknown blocks. Leafs that are separated by a gap from the to-be-finalized + block are not marked as displaced. + +crates: +- name: sc-client-db + bump: none +- name: sp-blockchain + bump: patch diff --git a/prdoc/1.15.0/pr_5011.prdoc b/prdoc/1.15.0/pr_5011.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cb827bae6c591155087ad9a96095c1f3d716844f --- /dev/null +++ b/prdoc/1.15.0/pr_5011.prdoc @@ -0,0 +1,29 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Use `BadOrigin` from `sp_runtime`" + +doc: + - audience: Runtime Dev + description: | + This PR refactor usages of deprecated `frame_support::error::BadOrigin` to `sp_runtime::traits::BadOrigin` + +crates: +- name: pallet-collective-content + bump: patch +- name: polkadot-runtime-common + bump: patch +- name: polkadot-runtime-parachains + bump: patch +- name: pallet-alliance + bump: patch +- name: pallet-contracts + bump: patch +- name: pallet-democracy + bump: patch +- name: pallet-nomination-pools + bump: patch +- name: pallet-ranked-collective + bump: patch +- name: pallet-utility + bump: patch diff --git a/prdoc/1.15.0/pr_5040.prdoc b/prdoc/1.15.0/pr_5040.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..62b175c1d64806fc2a916811af8cf3845eb8051a --- /dev/null +++ b/prdoc/1.15.0/pr_5040.prdoc @@ -0,0 +1,11 @@ +title: Update libp2p-websocket to v0.42.2 + +doc: + - audience: Node Operator + description: | + Fixes a panic coming from the libp2p-websocket which stops the node. + This fix ensures that polling multiple time after error results in an error instead of panics. + +crates: +- name: sc-network + bump: minor diff --git a/prdoc/1.15.0/pr_5103.prdoc b/prdoc/1.15.0/pr_5103.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b0f72bf531f183c7dc1bb4e0d57836778bd8d1b1 --- /dev/null +++ b/prdoc/1.15.0/pr_5103.prdoc @@ -0,0 +1,18 @@ +title: Skip genesis leaf to unblock syncing + +doc: + - audience: + - Node Operator + - Node Dev + description: | + This PR skips over the genesis block reported as leaf when calculating displaced branches. + In those cases, when the genesis block is reported as leaf, the node would compute the path + from the current finalized block to the genesis block. This operation is time consuming and + is enough to block syncing. In the current state, the genesis block is assumed to always be + part of the finalized chain. + +crates: +- name: sc-client-db + bump: none +- name: sp-blockchain + bump: patch diff --git a/prdoc/1.15.0/pr_5153.prdoc b/prdoc/1.15.0/pr_5153.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4f43b52d8edfbf033ffcb23c1a5aa8d529166763 --- /dev/null +++ b/prdoc/1.15.0/pr_5153.prdoc @@ -0,0 +1,12 @@ +title: "Grandpa: Ensure voting doesn't fail after a re-org" + +doc: + - audience: Node Operator + description: | + Ensures that a node is still able to vote with Grandpa, when a re-org happened that + changed the best chain. This ultimately prevents that a network may runs into a + potential finality stall. + +crates: + - name: sc-consensus-grandpa + bump: patch diff --git a/prdoc/1.15.1/pr_4791.prdoc b/prdoc/1.15.1/pr_4791.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..9a7a9ca44e1672fcad796e5c00dfde4ca447ad96 --- /dev/null +++ b/prdoc/1.15.1/pr_4791.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Prepare PVFs if node is a validator in the next session + +doc: + - audience: Node Operator + description: | + - On every active leaf candidate-validation subsystem checks if the node is the next session authority. + - If it is, it fetches backed candidates and prepares unknown PVFs. + - Number of PVF preparations per block is limited to not overload subsystem. + +crates: + - name: polkadot + bump: patch + - name: polkadot-service + bump: patch + - name: polkadot-node-core-candidate-validation + bump: major diff --git a/prdoc/1.15.1/pr_4937.prdoc b/prdoc/1.15.1/pr_4937.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..37b7bc3dda5943550a3e822b5ac3df8b83c4f8d7 --- /dev/null +++ b/prdoc/1.15.1/pr_4937.prdoc @@ -0,0 +1,21 @@ +title: "prospective-parachains rework: take II" + +doc: + - audience: Node Dev + description: | + Add back support for backing parachain forks. Once a candidate reaches the backing quorum, + validators use a shared way of picking the winning fork to back on-chain. This was done in + order to increase the likelihood that all backers will vote on the winning fork. + The functionality of backing unconnected candidates introduced by the previous rework is preserved. + +crates: + - name: polkadot-node-core-prospective-parachains + bump: minor + - name: polkadot-node-subsystem-types + bump: minor + - name: polkadot-node-subsystem-util + bump: minor + - name: polkadot-node-core-provisioner + bump: none + - name: polkadot-statement-distribution + bump: none diff --git a/prdoc/1.15.1/pr_5273.prdoc b/prdoc/1.15.1/pr_5273.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..981172c6c13fa98be6ba3e30535ac37d40eb4a55 --- /dev/null +++ b/prdoc/1.15.1/pr_5273.prdoc @@ -0,0 +1,10 @@ +title: Fix storage weight reclaim bug. + +doc: + - audience: Runtime Dev + description: | + A bug in storage weight reclaim signed extension is fixed. The bug was causing an underestimate of the proof size when the post dispatch info was underestimating the proof size and the pre dispatch info was overestimating the proof size at the same time. + +crates: + - name: cumulus-primitives-storage-weight-reclaim + bump: patch diff --git a/prdoc/1.15.1/pr_5281.prdoc b/prdoc/1.15.1/pr_5281.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..60feab412affd84a930ba06f4dd5fbb1fa471af9 --- /dev/null +++ b/prdoc/1.15.1/pr_5281.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: PoV-Reclaim - Set `BlockWeight` to node-side PoV size if mismatch is detected + +doc: + - audience: Runtime Dev + description: | + After this change, the `StorageWeightReclaim` `SignedExtension` will check the node-side PoV size after every + extrinsic. If we detect a case where the returned proof size is higher than the `BlockWeight` value of the + runtime, we set `BlockWeight` to the size returned from the node. + +crates: + - name: cumulus-primitives-storage-weight-reclaim + bump: patch + - name: frame-system + bump: minor diff --git a/prdoc/1.15.1/pr_5321.prdoc b/prdoc/1.15.1/pr_5321.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..97f75d28dd521ee8a01384af5df5b20047f4465f --- /dev/null +++ b/prdoc/1.15.1/pr_5321.prdoc @@ -0,0 +1,11 @@ +title: fix availability-distribution Jaeger spans memory leak + +doc: + - audience: Node Dev + description: | + Fixes a memory leak which caused the Jaeger span storage in availability-distribution to never be pruned and therefore increasing indefinitely. + This was caused by improper handling of finalized heads. More info in https://github.com/paritytech/polkadot-sdk/issues/5258 + +crates: + - name: polkadot-availability-distribution + bump: patch diff --git a/prdoc/pr_2923.prdoc b/prdoc/pr_2923.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..88bf1d48dd84be6e64f107a4a5a308bd64d92c2f --- /dev/null +++ b/prdoc/pr_2923.prdoc @@ -0,0 +1,16 @@ +title: "Use `console` crate instead of `ansi_term`" + +doc: + - audience: Node Dev + description: | + This PR replace obsoleted `ansi_term` to `console`. + +crates: + - name: relay-utils + bump: patch + - name: sc-informant + bump: patch + - name: sc-tracing + bump: patch + - name: sc-service + bump: major diff --git a/prdoc/pr_3786.prdoc b/prdoc/pr_3786.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0bb9e6c23f75b79db37ab73d7ba997ef810efaa4 --- /dev/null +++ b/prdoc/pr_3786.prdoc @@ -0,0 +1,22 @@ +title: Make changing of peer-id while active a bit more robust + +doc: + - audience: Node Dev + description: | + Implemetation of https://github.com/polkadot-fellows/RFCs/pull/91, to use `creation_time` field to determine + the newest DHT record and to update nodes known to have the old record. + + Gossip-support is modified to try to re-resolve new address authorithies every 5 minutes instead of each session, + so that we pick autorithies that changed their address faster and try to connect to them. + +crates: +- name: sc-authority-discovery + bump: major +- name: polkadot-gossip-support + bump: major +- name: polkadot-network-bridge + bump: major +- name: polkadot-node-subsystem-types + bump: major +- name: sc-network + bump: minor \ No newline at end of file diff --git a/prdoc/pr_4129.prdoc b/prdoc/pr_4129.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..dfcc9b9ef0307362d7be059271d370afd15cd7c1 --- /dev/null +++ b/prdoc/pr_4129.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Update ForeignAssets from xcm::v3::Location to xcm::v4::Location + +doc: + - audience: + - Runtime Dev + - Runtime User + description: | + As a stepping stone for XCMv5, the foreign asset ids have been updated from v3::Location to v4::Location. + +crates: + - name: asset-hub-rococo-runtime + bump: minor + - name: asset-hub-westend-runtime + bump: minor diff --git a/prdoc/pr_4424.prdoc b/prdoc/pr_4424.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..7131ebfca274b40baa70fe582176143aa1bfacc0 --- /dev/null +++ b/prdoc/pr_4424.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Coretime auto renewal + +doc: + - audience: Runtime User + description: | + With the additions in this PR, any task that utilizes a core that can be auto-renewed + can enable auto-renewal. The renewal is paid from the task's sovereign account. + The two new extrinsics for controlling auto-renewal are `enable_auto_renew` and + `disable_auto_renew`. + +crates: + - name: pallet-broker + bump: major + - name: coretime-rococo-runtime + bump: minor + - name: coretime-westend-runtime + bump: minor diff --git a/prdoc/pr_4460.prdoc b/prdoc/pr_4460.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..81636c3313fcff94418aa322e1d38fa2a5c9da29 --- /dev/null +++ b/prdoc/pr_4460.prdoc @@ -0,0 +1,24 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "xcm-executor: allow deposit of multiple assets if at least one of them satisfies ED" + +doc: + - audience: Runtime Dev + description: | + XCM programs that deposit assets to some new (empty) account will now succeed if at least + one of the deposited assets satisfies ED. Before this change, the requirement was that the + _first_ asset had to satisfy ED, but assets order can be changed during reanchoring so it + is not reliable. Now, ordering doesn't matter, any one(s) of them can satisfy ED for the + whole deposit to work. + - audience: Runtime User + description: | + XCM programs that deposit assets to some new (empty) account will now succeed if at least + one of the deposited assets satisfies ED. Before this change, the requirement was that the + _first_ asset had to satisfy ED, but assets order can be changed during reanchoring so it + is not reliable. Now, ordering doesn't matter, any one(s) of them can satisfy ED for the + whole deposit to work. + +crates: + - name: staging-xcm-executor + bump: patch diff --git a/prdoc/pr_4487.prdoc b/prdoc/pr_4487.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..fb2bab2a57a8916e890190ef0cb59d86aa1c9b19 --- /dev/null +++ b/prdoc/pr_4487.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Remove `pallet::getter` usage from pallet-election-provider-multi-phase + +doc: + - audience: Runtime Dev + description: | + This PR removes the `pallet::getter`s from `pallet-election-provider-multi-phase`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-election-provider-multi-phase + bump: minor + - name: pallet-election-provider-e2e-test + bump: minor diff --git a/prdoc/pr_4488.prdoc b/prdoc/pr_4488.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d0b6a877be6b1ecbdfbf94e364cc9c836cb8dd32 --- /dev/null +++ b/prdoc/pr_4488.prdoc @@ -0,0 +1,25 @@ +title: "Tx Payment: drop ED requirements for tx payments with exchangeable asset" + +doc: + - audience: Runtime Dev + description: | + Drop the Existential Deposit requirement for the asset amount exchangeable for the fee asset + (eg. DOT/KSM) during transaction payments. + + This achieved by using `SwapCredit` implementation of asset conversion, which works with + imbalances and does not require a temporary balance account within the transaction payment. + + This is a breaking change for the `pallet-asset-conversion-tx-payment` pallet, use examples + from PR for the migration. + +crates: + - name: pallet-asset-conversion-tx-payment + bump: major + - name: pallet-transaction-payment + bump: patch + - name: pallet-asset-conversion + bump: patch + - name: asset-hub-rococo-runtime + bump: patch + - name: asset-hub-westend-runtime + bump: patch diff --git a/prdoc/pr_4527.prdoc b/prdoc/pr_4527.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..12056f87575b8a6d6a01a7e8727f05d25217a364 --- /dev/null +++ b/prdoc/pr_4527.prdoc @@ -0,0 +1,21 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Call implementation for `transfer_all` + +doc: + - audience: Runtime Dev + description: | + This PR introduces the `transfer_all` call for `pallet-assets`. + The parameters are analog to the same call in `pallet-balances`. + This change is expected to be backwards-compatible. + This change requires running benchmarkings to set accurate weights for + the call. + +crates: + - name: pallet-assets + bump: major + - name: asset-hub-rococo-runtime + bump: minor + - name: asset-hub-westend-runtime + bump: minor diff --git a/prdoc/pr_4564.prdoc b/prdoc/pr_4564.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..896e49ee6b9ff404ccb2d616564d3e0be116476b --- /dev/null +++ b/prdoc/pr_4564.prdoc @@ -0,0 +1,32 @@ +title: "Make `OnUnbalanced::on_unbalanceds` work with `fungibles` `imbalances`" + +doc: + - audience: Runtime Dev + description: | + The `on_unbalanceds` function of `OnUnbalanced` trait accepts the `fungibles` `imbalances` + imbalances. This is done by replacing the `Imbalance` trait bound on imbalance type with + the `TryMerge` trait bound. The `TryMerge` trait is implemented for all imbalance types. + + ### Migration for `OnUnbalanced` trait implementations: + In case if you have a custom implementation of `on_unbalanceds` trait function, remove + it's `` type argument. + + ### Migration for custom imbalance types: + If you have your own imbalance types implementations, implement the `TryMerge` trait for it + introduced with this update. + +crates: + - name: frame-support + bump: major + - name: pallet-balances + bump: minor + - name: pallet-asset-conversion-tx-payment + bump: patch + - name: pallet-transaction-payment + bump: patch + - name: kitchensink-runtime + bump: patch + - name: polkadot-runtime-common + bump: patch + - name: parachains-common + bump: minor diff --git a/prdoc/pr_4586.prdoc b/prdoc/pr_4586.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..46d166d0f9773cddaf0a867943d70c0e9fc53930 --- /dev/null +++ b/prdoc/pr_4586.prdoc @@ -0,0 +1,22 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from pallet-identity + +doc: + - audience: Runtime Dev + description: | + This PR removed the `pallet::getter`s from `pallet-identity`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-identity + bump: minor + - name: pallet-alliance + bump: none + - name: kitchensink-runtime + bump: none + - name: people-rococo-integration-tests + bump: none + - name: people-westend-integration-tests + bump: none diff --git a/prdoc/pr_4613.prdoc b/prdoc/pr_4613.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e6b2e6adc612ac0d867a0e5557cc2790f4a175cb --- /dev/null +++ b/prdoc/pr_4613.prdoc @@ -0,0 +1,10 @@ +title: "pallet-conviction-voting: Include events for vote and remove vote" + +doc: + - audience: Runtime User + description: | + Introduce event called `Voted: { who: T::AccountId, vote: AccountVote> }` and `VoteRemoved: { who: T::AccountId, vote: AccountVote> }` + +crates: + - name: pallet-conviction-voting + bump: major diff --git a/prdoc/pr_4640.prdoc b/prdoc/pr_4640.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..52abc8f4baa5dbefe370ea3ed7b5992afa376924 --- /dev/null +++ b/prdoc/pr_4640.prdoc @@ -0,0 +1,20 @@ +title: Introduce tool for validating PoVs locally + +doc: + - audience: + - Runtime Dev + - Node Dev + description: | + Introduces the `cumulus-pov-validator` for running PoVs locally. This can be helpful for debugging issues that are + only happening when the PoV gets validated on the relay chain or for example to profile the validation code. + Besides that the `polkadot-parachain` was extended with the CLI flag `--export-pov-to-path` to let a collator export + all its build PoV's to the given directory. These PoV's can then be feed into the `cumulus-pov-validator`. + +crates: + - name: polkadot-parachain-bin + bump: minor + - name: cumulus-client-consensus-aura + bump: minor + - name: cumulus-pov-validator + bump: patch + validate: false diff --git a/prdoc/pr_4665.prdoc b/prdoc/pr_4665.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..7a8ec7398e644a161cd9a57231559147a256f91f --- /dev/null +++ b/prdoc/pr_4665.prdoc @@ -0,0 +1,21 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Remove runtime collator signature checks" + +doc: + - audience: [Runtime Dev, Node Dev] + description: | + Removes runtime collator signature checks, but these are still being done on the node. Remove collator + and signature from the `ProspectiveCandidate` definition in the inclusion emulator. Add + `CandidateReceiptV2` node feature bit. + +crates: +- name: polkadot-primitives + bump: minor +- name: polkadot-node-subsystem-util + bump: minor +- name: polkadot-node-core-prospective-parachains + bump: patch +- name: polkadot-runtime-parachains + bump: patch diff --git a/prdoc/pr_4706.prdoc b/prdoc/pr_4706.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ab235768b10db5789a0e116b2fe49c9a217431db --- /dev/null +++ b/prdoc/pr_4706.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Rename `assigner_on_demand` pallet to `on_demand`" + +doc: + - audience: Runtime Dev + description: | + Renames `assigner_on_demand` pallet to `on_demand` + +crates: +- name: polkadot-runtime-parachains + bump: major +- name: rococo-runtime + bump: patch +- name: westend-runtime + bump: patch \ No newline at end of file diff --git a/prdoc/pr_4751.prdoc b/prdoc/pr_4751.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5a2c42209088039a3b570995121d661e620a9a2c --- /dev/null +++ b/prdoc/pr_4751.prdoc @@ -0,0 +1,22 @@ +title: "Use all parachain heads for BEEFY MMR extra data" + +doc: + - audience: Runtime Dev + description: | + Previously, the extra data in an MMR leaf nodes was only computed based on lease-based parachain heads. + This PR extends the extra data to include others, including on-demand parachain heads. + Currently, the number of heads is limited to the first 1024 heads sorted by para id. + +crates: + - name: polkadot-runtime-parachains + bump: minor + - name: rococo-runtime + bump: minor + - name: westend-runtime + bump: minor + - name: pallet-mmr + bump: major + - name: pallet-beefy-mmr + bump: minor + - name: polkadot-sdk + bump: minor diff --git a/prdoc/pr_4792.prdoc b/prdoc/pr_4792.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..5ce4303bcf7525c77f68754bde3b502bb68886e4 --- /dev/null +++ b/prdoc/pr_4792.prdoc @@ -0,0 +1,62 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "rpc: bind to `ipv6` if available and add `CLI --experimental-rpc-endpoint` to specify listen addr" + +doc: + - audience: Node Operator + description: | + This PR changes/adds the following: + + 1. The default setting is that substrate starts a rpc server that listens to localhost both ipv4 and ipv6 on the same port. + ipv6 is allowed to fail because some platforms may not support it + 2. A new RPC CLI option `--experimental-rpc-endpoint` is introduced which allows to configure arbitrary listen addresses including the port, + if this is enabled no other interfaces are enabled. + 3. If the local addr is not found for any of the sockets the server is not started and throws an error. + 4. Remove the deny_unsafe from the RPC implementations instead this is an extension to allow different polices for different interfaces/sockets + such one may enable unsafe on local interface and safe on only the external interface. + 5. This new `--experimental-rpc-endpoint` has several options and in the help menu all possible parameters are documented. + 6. The log emitted by jsonrpc server when it has been started has been modified to indicate all started rpc endpoints. + + So for instance it's now possible to start up three RPC endpoints as follows: + ``` + $ polkadot --experimental-rpc-endpoint "listen-addr=127.0.0.1:9944,methods=unsafe" --experimental-rpc-endpoint "listen-addr=0.0.0.0:9945,methods=safe,rate-limit=100" --experimental-rpc-endpoint "listen-addr=[::1]:9944,optional=true" + ``` + +crates: + - name: sc-rpc-server + bump: major + - name: sc-rpc + bump: major + - name: sc-cli + bump: major + - name: sc-service + bump: major + - name: sc-rpc-api + bump: patch + - name: polkadot-dispute-distribution + bump: patch + - name: polkadot-parachain-lib + bump: patch + - name: substrate-frame-rpc-system + bump: major + - name: substrate-state-trie-migration-rpc + bump: major + - name: cumulus-client-cli + bump: major + validate: false + - name: sc-consensus-beefy-rpc + bump: major + validate: false + - name: sc-consensus-grandpa-rpc + bump: major + validate: false + - name: sc-consensus-babe-rpc + bump: major + validate: false + - name: polkadot-rpc + bump: major + validate: false + - name: polkadot-service + bump: major + validate: false diff --git a/prdoc/pr_4822.prdoc b/prdoc/pr_4822.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..44f3e41d8d5afd3a2859eeb68d51eb2ad49de387 --- /dev/null +++ b/prdoc/pr_4822.prdoc @@ -0,0 +1,25 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Ensure as many as possible pool members can migrate to `DelegateStake` + +doc: + - audience: Runtime Dev + description: | + 1. Allows pool members to use their total balance while joining pool with `DelegateStake`. + 2. Gates call mutating pool or member in unmigrated state. + 3. Runtime apis for reading pool and member balance. + +crates: + - name: westend-runtime + bump: minor + - name: kitchensink-runtime + bump: patch + - name: pallet-delegated-staking + bump: patch + - name: pallet-nomination-pools + bump: minor + - name: sp-staking + bump: patch + - name: pallet-nomination-pools-runtime-api + bump: minor diff --git a/prdoc/pr_4845.prdoc b/prdoc/pr_4845.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..012d34ef090ebc73409f0bdd0155510b49286841 --- /dev/null +++ b/prdoc/pr_4845.prdoc @@ -0,0 +1,13 @@ +title: Make approval-distribution logic runnable on a separate thread + +doc: + - audience: Node Dev + description: | + Pass SubsystemSender trait inside approval-distribution instead of passing SubsystemContext everywhere. + + This allows us in the future to be able to run multiple approval-distribution instances on different workers. + + +crates: +- name: polkadot-approval-distribution + bump: minor diff --git a/prdoc/pr_4930.prdoc b/prdoc/pr_4930.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a7c9a302b11852815b6665370da72097074bedea --- /dev/null +++ b/prdoc/pr_4930.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add test macro to emulated chains + +doc: + - audience: Runtime Dev + description: | + This PR adds a portable test macro that can be used to test trapped assets can be + claimed in an emulated chain. + + +crates: +- name: emulated-integration-tests-common + bump: minor diff --git a/prdoc/pr_4936.prdoc b/prdoc/pr_4936.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f9b7ee506a7ac6eb09014943ec5ce47e427f34e0 --- /dev/null +++ b/prdoc/pr_4936.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Balances Pallet: Emit events when TI is updated in currency impl" + +doc: + - audience: Runtime Dev + description: | + Previously, in the Currency impl, the implementation of pallet_balances was not emitting any instances of Issued and Rescinded events, even though the Fungible equivalent was. This PR adds the Issued and Rescinded events in appropriate places in impl_currency along with tests. + +crates: +- name: pallet-balances + bump: patch diff --git a/prdoc/pr_4938.prdoc b/prdoc/pr_4938.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..acc2a7c98e0ea2f2eb0a2d9efc231d3792cead8a --- /dev/null +++ b/prdoc/pr_4938.prdoc @@ -0,0 +1,21 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: introduce pallet-parameters to Westend to parameterize inflation + +doc: + - audience: Runtime User + description: | + This PR adds `pallet-parameters` to the Westend runtime, and makes the inflation formula be + adjustable based on this. + + Moreover, the old `era_payout` function has been removed from `polkadot_runtime_common` and is + replaced by `relay_era_payout`. This function is only meant to be used in the Polkadot relay + chains, and other users are encouraged to provide their own implementation of `type + EraPayout`. + +crates: + - name: westend-runtime + bump: major + - name: polkadot-runtime-common + bump: major diff --git a/prdoc/pr_4956.prdoc b/prdoc/pr_4956.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a72ca303aaca46c2bd73b46f1987fc5b1a9ecd2c --- /dev/null +++ b/prdoc/pr_4956.prdoc @@ -0,0 +1,39 @@ +title: Add build options to the srtool build step and delete `disanle-logging` feature + +doc: +- audience: Runtime Dev + description: | + This PR adds possibility to set BUILD_OPTIONS to the "Srtool Build\" step in the release pipeline while building runtimes. + And deletes the `disable-logging` feature from test runtimes to be able to build those with an activated logging. + + + +crates: +- name: people-rococo-runtime + bump: patch +- name: people-westend-runtime + bump: patch +- name: rococo-parachain-runtime + bump: patch +- name: asset-hub-rococo-runtime + bump: patch +- name: asset-hub-westend-runtime + bump: patch +- name: bridge-hub-rococo-runtime + bump: patch +- name: bridge-hub-westend-runtime + bump: patch +- name: collectives-westend-runtime + bump: patch +- name: contracts-rococo-runtime + bump: patch +- name: coretime-rococo-runtime + bump: patch +- name: coretime-westend-runtime + bump: patch +- name: glutton-westend-runtime + bump: patch +- name: rococo-runtime + bump: patch +- name: westend-runtime + bump: patch diff --git a/prdoc/pr_4959.prdoc b/prdoc/pr_4959.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4891a97917956b2326871fda30e74e8a1a15b8b3 --- /dev/null +++ b/prdoc/pr_4959.prdoc @@ -0,0 +1,45 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: relax XcmFeeToAccount trait bound on AccountId + +doc: + - audience: Runtime Dev + description: | + This PR relaxes the trait bound on AccountId for the XcmFeeToAccount struct by introducing a new struct called `SendXcmFeeToAccount`. + The old one (`XcmFeeToAccount`) will be deprecated at January 2025. + +crates: + - name: staging-xcm-builder + bump: minor + - name: staging-xcm + bump: minor + - name: pallet-xcm + bump: minor + - name: asset-hub-rococo-runtime + bump: minor + - name: asset-hub-westend-runtime + bump: minor + - name: bridge-hub-rococo-runtime + bump: minor + - name: bridge-hub-westend-runtime + bump: minor + - name: collectives-westend-runtime + bump: minor + - name: contracts-rococo-runtime + bump: minor + - name: coretime-rococo-runtime + bump: minor + - name: coretime-westend-runtime + bump: minor + - name: people-rococo-runtime + bump: minor + - name: people-westend-runtime + bump: minor + - name: penpal-runtime + bump: minor + - name: rococo-runtime + bump: minor + - name: westend-runtime + bump: minor + diff --git a/prdoc/pr_4962.prdoc b/prdoc/pr_4962.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0957f85b66282c4baa620d696a0e44ebc900153d --- /dev/null +++ b/prdoc/pr_4962.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-treasury + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-treasury`s storage items. + Instead use the syntax `StorageItem::::get()`. + +crates: + - name: pallet-treasury + bump: minor \ No newline at end of file diff --git a/prdoc/pr_4963.prdoc b/prdoc/pr_4963.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e274d2cbb689f80a9867afd096bc7797eec94288 --- /dev/null +++ b/prdoc/pr_4963.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Removed `pallet::getter` usage from the pallet-proxy + +doc: + - audience: Runtime Dev + description: | + This PR removed `pallet::getter`s from `pallet-proxy`s storage items. + When accessed inside the pallet, use the syntax `StorageItem::::get()`. + +crates: + - name: pallet-proxy + bump: minor \ No newline at end of file diff --git a/prdoc/pr_4967.prdoc b/prdoc/pr_4967.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0ce4219daa1cf74b540135a52d5ac7877e921b38 --- /dev/null +++ b/prdoc/pr_4967.prdoc @@ -0,0 +1,28 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Remove `pallet::getter` usage from the balances pallet" + +doc: + - audience: Runtime Dev + description: | + This PR removes the `pallet::getter`s from `pallet-balances`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-balances + bump: patch + - name: pallet-staking + bump: patch + - name: pallet-treasury + bump: patch + - name: pallet-bounties + bump: patch + - name: pallet-conviction-voting + bump: patch + - name: pallet-democracy + bump: patch + - name: pallet-elections-phragmen + bump: patch + - name: pallet-referenda + bump: patch diff --git a/prdoc/pr_4970.prdoc b/prdoc/pr_4970.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d86f1af1e86028b8434af06ec2d578ff100d88a7 --- /dev/null +++ b/prdoc/pr_4970.prdoc @@ -0,0 +1,14 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Remove `pallet::getter` usage from the transaction-payment pallet" + +doc: + - audience: Runtime Dev + description: | + This PR removes the `pallet::getter`s from `pallet-transaction-payment`. + The syntax `StorageItem::::get()` should be used instead. + +crates: + - name: pallet-transaction-payment + bump: minor diff --git a/prdoc/pr_4973.prdoc b/prdoc/pr_4973.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..20b8c94dd8a907366f7182984cb87e3bcbbd07e3 --- /dev/null +++ b/prdoc/pr_4973.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[pallet_contracts] Increase the weight of the deposit_event host function to limit the memory used by events." + +doc: + - audience: Runtime User + description: | + This PR updates the weight of the deposit_event host function by adding + a fixed ref_time of 60,000 picoseconds per byte. Given a block time of 2 seconds + and this specified ref_time, the total allocation size is 32MB. + +crates: + - name: pallet-contracts + bump: major diff --git a/prdoc/pr_4976.prdoc b/prdoc/pr_4976.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..72b7b92bc47f711a564046349e0b351b08884287 --- /dev/null +++ b/prdoc/pr_4976.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add pub to xcm::v4::PalletInfo + +doc: + - audience: Runtime Dev + description: | + Forgot to make v4 PalletInfo fields public. Without them we cannot make use of the struct. + +crates: + - name: staging-xcm + bump: patch + validate: false + diff --git a/prdoc/pr_4993.prdoc b/prdoc/pr_4993.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d822d5cd6c76899a47e440bd2f5aa0fa4c97a181 --- /dev/null +++ b/prdoc/pr_4993.prdoc @@ -0,0 +1,27 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Added BEEFY equivocation-related methods to BeefyApi + +doc: + - audience: Node Dev + description: | + This PR adds the `generate_ancestry_proof`, `submit_report_fork_voting_unsigned_extrinsic` and + `submit_report_future_block_voting_unsigned_extrinsic` to `BeefyApi` and bumps the `BeefyApi` version + from 4 to 5. + +crates: + - name: pallet-beefy + bump: minor + - name: pallet-beefy-mmr + bump: minor + - name: kitchensink-runtime + bump: major + - name: rococo-runtime + bump: major + - name: westend-runtime + bump: major + - name: sp-consensus-beefy + bump: minor + - name: polkadot-service + bump: patch diff --git a/prdoc/pr_4998.prdoc b/prdoc/pr_4998.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..41e3886405cc7d7eaa6eb942ff246e5fde19dc83 --- /dev/null +++ b/prdoc/pr_4998.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Ensure members can always exit the pool gracefully + +doc: + - audience: Runtime Dev + description: | + Ensures when a member wants to withdraw all funds but the pool is not able to provide all their funds, the member + can receive as much as possible and exit pool. Also handles cases where some extra funds held in member's account + is released when they are removed. + +crates: + - name: pallet-delegated-staking + bump: patch + - name: pallet-nomination-pools + bump: major + - name: sp-staking + bump: major + diff --git a/prdoc/pr_4999.prdoc b/prdoc/pr_4999.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d396fcdbe8b39e0b5e09587727ca6977d090d865 --- /dev/null +++ b/prdoc/pr_4999.prdoc @@ -0,0 +1,18 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fixes entropy for derivation of proxy delegator account. + +doc: + - audience: Runtime Dev + description: | + This fixes how ProxyDelegator accounts are derived but may cause issues in Westend since it would use the old + derivative accounts. Does not affect Polkadot/Kusama as this pallet is not deployed to them yet. + +crates: + - name: westend-runtime + bump: patch + - name: pallet-delegated-staking + bump: patch + - name: pallet-nomination-pools + bump: patch \ No newline at end of file diff --git a/prdoc/pr_5029.prdoc b/prdoc/pr_5029.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d446ddf274b8bef53aa129c2ade4ce2f1805fa78 --- /dev/null +++ b/prdoc/pr_5029.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Backoff slow peers to avoid duplicate requests + +doc: + - audience: Node Dev + description: | + This PR introduces a backoff strategy mechanism. Whenever a peer disconnects with an inflight + block (or state) request, the peer is backed off for a period of time before receiving requests. + After several attempts, the peer is disconnected and banned. The strategy aims to offload + the pressure from peers that are slow to respond or overloaded. + +crates: +- name: sc-network-sync + bump: minor diff --git a/prdoc/pr_5036.prdoc b/prdoc/pr_5036.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e9f21f823b64bf91264bb63d6a643853998ab900 --- /dev/null +++ b/prdoc/pr_5036.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "[pallet_contracts] Modify the storage host function benchmarks to be run on an unbalanced storage trie" + +doc: + - audience: Runtime User + description: | + This PR modifies the storage host function benchmarks. Previously, they were run + on an empty storage trie. Now, they are run on an unbalanced storage trie + to reflect the worst-case scenario. This approach increases the storage host + function weights and decreases the probability of DoS attacks. + +crates: + - name: pallet-contracts + bump: patch diff --git a/prdoc/pr_5055.prdoc b/prdoc/pr_5055.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2367bd5925f89256b703e68a5c4eb4fc4fdc599e --- /dev/null +++ b/prdoc/pr_5055.prdoc @@ -0,0 +1,11 @@ +title: Only log error in `UnixTime::now` call of the pallet-timestamp implementation if called at genesis + +doc: + - audience: Runtime Dev + description: | + This minor patch re-introduces a check to ensure that the `UnixTime::now` implementation in the timestamp only + logs an error if called at the genesis block. + +crates: +- name: pallet-timestamp + bump: minor diff --git a/prdoc/pr_5065.prdoc b/prdoc/pr_5065.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..11fca2ab71d66b97bd17b480843afba72e462067 --- /dev/null +++ b/prdoc/pr_5065.prdoc @@ -0,0 +1,65 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Replace env_logger with sp_tracing + +doc: + - audience: Node Dev + description: | + This PR replaces env_logger with sp_tracing because of an issue with env_logger and gum #4660 + +crates: + - name: relay-utils + bump: none + - name: snowbridge-outbound-queue-merkle-tree + bump: patch + - name: polkadot-node-core-approval-voting + bump: patch + - name: polkadot-node-core-av-store + bump: patch + - name: polkadot-approval-distribution + bump: patch + - name: polkadot-availability-bitfield-distribution + bump: patch + - name: polkadot-collator-protocol + bump: patch + - name: polkadot-service + bump: patch + - name: polkadot-subsystem-bench + bump: none + - name: polkadot-node-subsystem-util + bump: none + - name: xcm-runtime-apis + bump: patch + - name: sc-executor + bump: patch + - name: sc-rpc + bump: patch + - name: sc-statement-store + bump: patch + - name: pallet-contracts + bump: patch + - name: pallet-mmr + bump: patch + - name: sp-tracing + bump: patch + - name: binary-merkle-tree + bump: patch + - name: frame-omni-bencher + bump: patch + - name: pallet-balances + bump: patch + - name: pallet-staking + bump: patch + - name: pallet-treasury + bump: patch + - name: pallet-bounties + bump: patch + - name: pallet-conviction-voting + bump: patch + - name: pallet-democracy + bump: patch + - name: pallet-elections-phragmen + bump: patch + - name: pallet-referenda + bump: patch \ No newline at end of file diff --git a/prdoc/pr_5067.prdoc b/prdoc/pr_5067.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..9a11f96b5104585aaad4f2c963ac6ebe0611f7b2 --- /dev/null +++ b/prdoc/pr_5067.prdoc @@ -0,0 +1,19 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fix region nonfungible implementation + +doc: + - audience: Runtime User + description: | + PR fixes the issue with the current implementation where minting causes + the region coremask to be set to `Coremask::complete` regardless of the + actual coremask of the region. + +crates: +- name: pallet-broker + bump: major +- name: coretime-rococo-runtime + bump: patch +- name: coretime-westend-runtime + bump: patch \ No newline at end of file diff --git a/prdoc/pr_5074.prdoc b/prdoc/pr_5074.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cddf15ffb47c9e7d56c729006ddd899821a2b309 --- /dev/null +++ b/prdoc/pr_5074.prdoc @@ -0,0 +1,33 @@ +title: "Snowbridge on Westend" + +doc: + - audience: Runtime Dev + description: | + Since Rococo is now deprecated, we need another testnet to detect bleeding-edge changes + to Substrate, Polkadot, BEEFY consensus protocols that could brick the bridge. + - audience: Runtime Dev + description: | + Like Rococo this PR enables the fast-runtime feature by default which is easier + for testing beefy stuff on westend-local. + +crates: + - name: asset-hub-westend-runtime + bump: patch + - name: bridge-hub-westend-runtime + bump: major + - name: bridge-hub-rococo-runtime + bump: patch + - name: testnet-parachains-constants + bump: patch + - name: bridge-hub-westend-emulated-chain + bump: minor + - name: bridge-hub-westend-integration-tests + bump: minor + - name: polkadot-parachain-bin + bump: patch + - name: westend-runtime + bump: patch + - name: polkadot-service + bump: patch + + diff --git a/prdoc/pr_5078.prdoc b/prdoc/pr_5078.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1805a27c3f28a4d16160af055420a7023e2edfd8 --- /dev/null +++ b/prdoc/pr_5078.prdoc @@ -0,0 +1,34 @@ +title: Add possibility to inject non-authorities session-keys in genesis + +doc: + - audience: Runtime Dev + description: | + Allows to inject a set of registered session-keys in pallet-session that are not + part of the first initial set of validators +crates: +- name: pallet-session + bump: major +- name: parachains-runtimes-test-utils + bump: patch +- name: pallet-staking + bump: none +- name: pallet-collator-selection + bump: none +- name: pallet-root-offences + bump: none +- name: pallet-babe + bump: none +- name: pallet-staking + bump: none +- name: pallet-grandpa + bump: none +- name: pallet-collator-selection + bump: none +- name: pallet-beefy + bump: none +- name: pallet-beefy-mmr + bump: none +- name: pallet-root-offences + bump: none +- name: polkadot-parachain-bin + bump: none \ No newline at end of file diff --git a/prdoc/pr_5082.prdoc b/prdoc/pr_5082.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d309f4e7266ed1d57cb225f10b0f27c8881aa746 --- /dev/null +++ b/prdoc/pr_5082.prdoc @@ -0,0 +1,15 @@ +title: "Fix ParaInherent weight overestimation" + +doc: + - audience: Runtime Dev + description: | + This PR fixes the relay chain inherent weight overestimation allowing it + to support more cores and validators. + +crates: +- name: polkadot-runtime-parachains + bump: major +- name: westend-runtime + bump: minor +- name: rococo-runtime + bump: minor diff --git a/prdoc/pr_5113.prdoc b/prdoc/pr_5113.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..64563f7a735d16a4e81c5123f95382dc2be12827 --- /dev/null +++ b/prdoc/pr_5113.prdoc @@ -0,0 +1,14 @@ +title: Make the candidate relay parent progression check more strict for elastic scaling + +doc: + - audience: Runtime Dev + description: | + Previously, the relay chain runtime was checking if the relay parent of a new candidate does + not move backwards from the latest included on-chain candidate. This was fine prior to elastic scaling. + We now need to also check that the relay parent progresses from the latest pending availability candidate, + as well as check the progression within the candidate chain in the inherent data. + Prospective-parachains is already doing this check but it's also needed in the runtime. + +crates: +- name: polkadot-runtime-parachains + bump: patch diff --git a/prdoc/pr_5114.prdoc b/prdoc/pr_5114.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d57141490a3ed65d56f00a93ef8c1410f4361977 --- /dev/null +++ b/prdoc/pr_5114.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Remove not-audited warning" + +doc: + - audience: Runtime Dev + description: | + Pallets `tx-pause` and `safe-mode` have passed audit, this just removes a warning in the docs + to not use them. + +crates: + - name: pallet-safe-mode + bump: patch + - name: pallet-tx-pause + bump: patch diff --git a/prdoc/pr_5124.prdoc b/prdoc/pr_5124.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..966761721fc7599be50ca7a6652d3eba56f0ffb1 --- /dev/null +++ b/prdoc/pr_5124.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add Polkadot Chain genesis chainspec + +doc: + - audience: Node Operator + description: | + The Polkadot People Chain can now be run as all other system parachains without specifying a + chainspec. However this will soon be deprecated and `--chain ./chainspec.json` should continue + to be used instead. + + - audience: Runtime User + description: | + The Polkadot People Chain chainspecs have been added to the polkadot-sdk repo and can now be + pulled from there along with all other system chains. + +crates: + - name: polkadot-parachain-bin + bump: minor diff --git a/prdoc/pr_5129.prdoc b/prdoc/pr_5129.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..beb7eb4d282d59fc9e4fa5a2779dcb52b107bbdb --- /dev/null +++ b/prdoc/pr_5129.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Prevent finalized notification hoarding in beefy gadget + +doc: + - audience: Node Operator + description: | + This PR fixes the error message "Notification block pinning limit + reached." during warp sync. Finality notifications in BEEFY are now + constantly being consumed and don't keep blocks pinned for extended + periods of time. + +crates: + - name: sc-consensus-beefy + bump: minor diff --git a/prdoc/pr_5130.prdoc b/prdoc/pr_5130.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c6a00505babcdf737e5823e71c84f6524a6c7f68 --- /dev/null +++ b/prdoc/pr_5130.prdoc @@ -0,0 +1,40 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add SingleAssetExchangeAdapter + +doc: + - audience: Runtime Dev + description: | + SingleAssetExchangeAdapter is an adapter in xcm-builder that can be used + to configure the AssetExchanger in XCM to use pallet-asset-conversion, + or any other type that implements the `SwapCredit` and `QuotePrice` traits. + It can be configured as follows: + ```rust + pub type AssetExchanger = SingleAssetExchangeAdapter< + // pallet-assets-conversion, as named in `construct_runtime`. + AssetConversion, + // The fungibles implementation that brings together all assets in pools. + // This may be created using `fungible::UnionOf` to mix the native token + // with more tokens. + Fungibles, + // The matcher for making sure which assets should be handled by this exchanger. + Matcher, + >; + ``` + It's called "single asset" since it will only allow exchanging one asset for another. + It will error out if more than one asset tries to be exchanged. + + Also, a new method was added to the `xcm_executor::traits::AssetExchange` trait: + `quote_exchange_price`. This is used to get the exchange price between two asset collections. + If you were using the trait, you now need to also implement this new function. + +crates: + - name: staging-xcm-executor + bump: major + - name: staging-xcm-builder + bump: minor + - name: pallet-asset-conversion + bump: minor + - name: cumulus-primitives-utility + bump: minor diff --git a/prdoc/pr_5132.prdoc b/prdoc/pr_5132.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f23574e04b79f5bb2e6c6006ffb5aee0fb552135 --- /dev/null +++ b/prdoc/pr_5132.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add `from_mel` for `Footprint` + +doc: + - audience: Runtime Dev + description: | + This introduces a new way to generate the `Footprint` type by calculating the max encoded + length of some generic type. This allows you to generate a `Footprint` of a type without + actually constructing that type. + +crates: + - name: frame-support + bump: patch diff --git a/prdoc/pr_5142.prdoc b/prdoc/pr_5142.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4083e5bf53cdb420cdb236e920b5e409b6c82149 --- /dev/null +++ b/prdoc/pr_5142.prdoc @@ -0,0 +1,26 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "Move decompression to worker processes" + +doc: + - audience: Node Dev + description: | + Candidate validation subsystem performed the PVF code decompression as well as the PoV + decompression itself which might affect the subsystem main loop performance and required + it to run on the blocking threadpool. This change moves the decompression to PVF host + workers running synchronously in separate processes. + +crates: + - name: polkadot-node-core-candidate-validation + bump: patch + - name: polkadot-overseer + bump: patch + - name: polkadot-node-core-pvf + bump: major + - name: polkadot-node-core-pvf-common + bump: major + - name: polkadot-node-core-pvf-execute-worker + bump: patch + - name: polkadot-node-core-pvf-prepare-worker + bump: patch diff --git a/prdoc/pr_5155.prdoc b/prdoc/pr_5155.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..373522eea1c393b345b83119961933a2b6753b70 --- /dev/null +++ b/prdoc/pr_5155.prdoc @@ -0,0 +1,27 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Use umbrella crate for minimal template + +doc: + - audience: Runtime Dev + description: | + Minor additions to the `polkadot-sdk-frame` crate and making it ready for usage in more templates. This PR already integrates it in the minimal template. + + +crates: + - name: polkadot-sdk + bump: major + - name: polkadot-sdk-frame + bump: patch + - name: sp-wasm-interface + bump: patch + - name: pallet-revive + bump: patch + - name: pallet-revive-fixtures + bump: patch + - name: frame-support + bump: patch + - name: pallet-balances + bump: patch + diff --git a/prdoc/pr_5173.prdoc b/prdoc/pr_5173.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..81ddcd9578ba164a0615e846c3ae4ca2f66ab1e6 --- /dev/null +++ b/prdoc/pr_5173.prdoc @@ -0,0 +1,39 @@ +title: "Umbrella crate: exclude chain-specific crates" + +doc: + - audience: Runtime Dev + description: | + The `polkadot-sdk` umbrella crate does now not contain chain-specific crates. The reasoning is + that the SDK should be mostly chain-agnostic. Please check out + [psvm](https://github.com/paritytech/psvm) to select matching version numbers for chain- + specific crates. + +crates: + - name: polkadot-sdk + bump: major + - name: rococo-runtime-constants + bump: none + - name: westend-runtime-constants + bump: none + - name: bp-asset-hub-rococo + bump: none + - name: bp-asset-hub-westend + bump: none + - name: bp-bridge-hub-cumulus + bump: none + - name: bp-bridge-hub-kusama + bump: none + - name: bp-bridge-hub-polkadot + bump: none + - name: bp-bridge-hub-rococo + bump: none + - name: bp-bridge-hub-westend + bump: none + - name: bp-kusama + bump: none + - name: bp-polkadot-bulletin + bump: none + - name: bp-rococo + bump: none + - name: bp-westend + bump: none diff --git a/prdoc/pr_5174.prdoc b/prdoc/pr_5174.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2c7a6983377cf9dea5883029b3b5ef8f81feb778 --- /dev/null +++ b/prdoc/pr_5174.prdoc @@ -0,0 +1,10 @@ +title: "Wasm-builder: Set the `resolver` version to `2`" + +doc: + - audience: Runtime Dev + description: | + Set the `resolver` version to `2` in the generated `Cargo.toml`. + +crates: + - name: substrate-wasm-builder + bump: patch diff --git a/prdoc/pr_5188.prdoc b/prdoc/pr_5188.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..b2ab9ff6653b6abcf8b1c125d527a51d11ff88e3 --- /dev/null +++ b/prdoc/pr_5188.prdoc @@ -0,0 +1,32 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Added benchmarks for BEEFY fork voting + +doc: + - audience: + - Runtime Dev + - Runtime User + description: | + This PR adds benchmarks for `report_fork_voting` and `report_future_voting` extrinsics to `pallet-beefy`. + `report_future_voting` can be called now. `report_fork_voting` can't be called yet. Even though we have added + the formula for computing its weight, we still use `Weight::MAX`. We will set the proper weight in a future PR. + In order to do this we need to also check that the ancestry proof is optimal. + The PR adds a `WeightInfo` associated trait to the `pallet_beefy_mmr::Config` and defines benchmarks for + `pallet_beefy_mmr`. + +crates: + - name: pallet-mmr + bump: minor + - name: sp-mmr-primitives + bump: minor + - name: sp-consensus-beefy + bump: minor + - name: rococo-runtime + bump: minor + - name: pallet-beefy + bump: major + - name: pallet-beefy-mmr + bump: major + - name: westend-runtime + bump: minor diff --git a/prdoc/pr_5195.prdoc b/prdoc/pr_5195.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..cfd435fa289d00ed4487c0b0baacbad14f777075 --- /dev/null +++ b/prdoc/pr_5195.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Bump Aura authoring duration to 2s. + +doc: + - audience: Node Dev + description: | + This PR bumps the Aura authoring duration in the asynchronous backing + guide and the polkadot-parachain service file to 2s in order to make + better use of the provided coretime. + +crates: + - name: polkadot-parachain-bin + bump: patch diff --git a/prdoc/pr_5196.prdoc b/prdoc/pr_5196.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3ed4fbdff3f33b1dd4bab3153e67c657408bab15 --- /dev/null +++ b/prdoc/pr_5196.prdoc @@ -0,0 +1,23 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Bring benchmark inline with reference machine used for weights + +doc: + - audience: Node Operator + description: | + - BLAKE2-256 reference values were too low(~30%) when compared with the machine used for generating + the weights, so it was brought in sync with results on the reference hardware recommended here: + https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware + - SR25519-Verify reference values were too low(~10%) when compared with the machine used for generating + the weights, so it was brought in sync with results on the reference hardware recommended here: + https://wiki.polkadot.network/docs/maintain-guides-how-to-validate-polkadot#reference-hardware + - Validators where the `BLAKE2-256` and `SR25519-Verify` were barely passing, might received the + warning that they are not compliant anymore, this should not be treated as critical, but they + should take the necessary steps to become compliant in the near/mid-term future. + - Note!: The reference hardware requirements have not been increased we just fixed the benchmark which + was wrongly reporting lower spec HW as being compliant. + +crates: + - name: frame-benchmarking-cli + bump: minor diff --git a/prdoc/pr_5197.prdoc b/prdoc/pr_5197.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..40e25cf70dd1186e5470d7619b509bc6e0095447 --- /dev/null +++ b/prdoc/pr_5197.prdoc @@ -0,0 +1,16 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Prevent `ConsensusReset` by tolerating runtime API errors in BEEFY + +doc: + - audience: Node Operator + description: | + After warp sync, the BEEFY worker was trying to execute runtime calls on + blocks which had their state already pruned. This led to an error and restarting + of the beefy subsystem in a loop. After this PR, the worker tolerates call errors and therefore prevents this + worker restart loop. + +crates: + - name: sc-consensus-beefy + bump: minor diff --git a/prdoc/pr_5204.prdoc b/prdoc/pr_5204.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..38a73b6b00ef651db166810a54a9e9417ac84cdf --- /dev/null +++ b/prdoc/pr_5204.prdoc @@ -0,0 +1,13 @@ +title: "Pallet assets: fix doc: start_destroy never required asset to be frozen" + +doc: + - audience: Runtime Dev + description: | + In pallet assets calling `start_destroy` doesn't require the asset to be frozen. Doc is fixed. + + +crates: + - name: pallet-assets + bump: patch + - name: frame-support + bump: patch diff --git a/prdoc/pr_5205.prdoc b/prdoc/pr_5205.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..48abfe50ca2411966820bfa1b28339224a90a509 --- /dev/null +++ b/prdoc/pr_5205.prdoc @@ -0,0 +1,18 @@ +title: Enable ChainSpec API for polkadot-parachain + +doc: + - audience: + - Runtime Dev + - Node Dev + description: | + The substrate service-builder now includes the entire rpc v2 API. + The chainspec API was previously defined as rpc extension where for instance chains would need to enable it explicitly. + At the same time, this paves the way for implementing in the future a `chainSpec_v1_getSpec` + method that can extract the chainSpec of any chain (including parachains) for the use with lightclients. + For more info about the `chainSpec`, please see the specification: https://github.com/paritytech/json-rpc-interface-spec/blob/main/src/api/chainSpec.md. + +crates: + - name: sc-service + bump: patch + - name: polkadot-rpc + bump: patch diff --git a/prdoc/pr_5214.prdoc b/prdoc/pr_5214.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4dc8b28c59485d95553362a74a61abb07dcaa778 --- /dev/null +++ b/prdoc/pr_5214.prdoc @@ -0,0 +1,11 @@ +title: make polkadot-parachain startup errors pretty + +doc: + - audience: Node Operator + description: | + Changed the format of how polkadot-parachain prints the startup errors to include + the full displayable context. + +crates: + - name: polkadot-parachain-bin + bump: minor diff --git a/prdoc/pr_5240.prdoc b/prdoc/pr_5240.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..3622a6ada76b47da1b8d72b149918e9661faacbb --- /dev/null +++ b/prdoc/pr_5240.prdoc @@ -0,0 +1,12 @@ +title: Warn on empty public-addr when starting a validator node + +doc: + - audience: Node Operator + description: | + This PR shows a warning when the `--public-addr` CLI parameter is missing for validators. + In the future, we'll transform this warning into a hard failure. + Validators are encouraged to provide this parameter for better availability over the network. + +crates: + - name: sc-cli + bump: patch diff --git a/prdoc/pr_5250.prdoc b/prdoc/pr_5250.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2cac6b2383e34ac80a8bc995943738a3c05b57e6 --- /dev/null +++ b/prdoc/pr_5250.prdoc @@ -0,0 +1,12 @@ +title: Export `MetricsService` and add public constructor to `RpcHandlers` + +doc: + - audience: Node Dev + description: | + `sc-service` was missing just a couple of things in public API in order to make it possible to recreate its + `spawn_tasks`, specifically `MetricsService` struct and `RpcHandlers` didn't have public constructor, which were + both finally addressed. + +crates: + - name: sc-service + bump: patch diff --git a/prdoc/pr_5252.prdoc b/prdoc/pr_5252.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..fd4454ac3b9d6e17589afbb0b3576c365af7dd94 --- /dev/null +++ b/prdoc/pr_5252.prdoc @@ -0,0 +1,11 @@ +title: Additional logging in `dispute-coordinator` subsystem + +doc: + - audience: Node Dev + description: | + Additional logging in `dispute-coordinator` subsystem tracing the list of offchain disabled + validators and the reason why an import statement is considered spam. + +crates: + - name: polkadot-node-core-dispute-coordinator + bump: patch \ No newline at end of file diff --git a/prdoc/pr_5257.prdoc b/prdoc/pr_5257.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..7a4cff671af0d8c4e242ca152aaa75df09c56cb9 --- /dev/null +++ b/prdoc/pr_5257.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Enable proof-recording in benchmarking + +doc: + - audience: Runtime Dev + description: | + We now enable proof recording in the timing benchmarks. This affects the standalone `frame-omni-bencher` as well + as the integrated benchmarking commands of the node. For parachains on recent versions of polkadot-sdk this is the + correct default setting, since PoV-reclaim requires proof recording to be enabled on block import. + This comes with a slight increase in timing weight due to the additional overhead. Relay- or solo-chains + which do not need proof recording can restore the old behaviour by passing `--disable-proof-recording` to the + benchmarking command. + + In addition, the `ProofSizeExt` extension is available during benchmarking. + +crates: + - name: frame-benchmarking-cli + bump: minor \ No newline at end of file diff --git a/prdoc/pr_5262.prdoc b/prdoc/pr_5262.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..828f0ffeb1bc68d7f7f903eee9c438a31d72a39f --- /dev/null +++ b/prdoc/pr_5262.prdoc @@ -0,0 +1,25 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Correct some typos in crates' descriptions + +doc: + - audience: Runtime Dev + description: | + Corrected typos and copy-paste errors in crates' descriptions. + +crates: + - name: cumulus-client-pov-recovery + bump: patch + - name: cumulus-pallet-aura-ext + bump: patch + - name: bridge-hub-rococo-runtime + bump: patch + - name: frame-try-runtime + bump: patch + - name: pallet-whitelist + bump: patch + - name: polkadot-sdk + bump: patch + - name: polkadot-runtime-parachains + bump: none diff --git a/prdoc/pr_5269.prdoc b/prdoc/pr_5269.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e4401f2406cef2da501c46ad71a3149898124430 --- /dev/null +++ b/prdoc/pr_5269.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Added the possibility to build a parachain node with block number u64 + +doc: + - audience: Node Dev + description: | + Added the possibility to build a parachain node with block number u64. + +crates: + - name: polkadot-parachain-lib + bump: minor + - name: polkadot-parachain-bin + bump: patch diff --git a/prdoc/pr_5270.prdoc b/prdoc/pr_5270.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e6d7142cabd07e3609328fb53befb08b74650e7a --- /dev/null +++ b/prdoc/pr_5270.prdoc @@ -0,0 +1,20 @@ +title: "Inclusion: account for enact_candidate weight" + +doc: + - audience: Runtime Dev + description: | + We are now properly accounting for the `enact_candidate`s weight in + processing of a relay chain block inherent. This may result in some + of the user relay chain transactions not being included in the block if + it's really heavy. This should be fine though as we are moving towards + the minimal relay chain. + +crates: +- name: polkadot-runtime-parachains + bump: major +- name: westend-runtime + bump: patch +- name: rococo-runtime + bump: patch +- name: polkadot-node-core-pvf-common + bump: none diff --git a/prdoc/pr_5284.prdoc b/prdoc/pr_5284.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a3244a82c86092b3f9feb82b5c3b838c41bfe470 --- /dev/null +++ b/prdoc/pr_5284.prdoc @@ -0,0 +1,7 @@ +title: Minor clean up +author: conr2d +topic: runtime + +crates: + - name: sp-runtime + bump: none diff --git a/prdoc/pr_5288.prdoc b/prdoc/pr_5288.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..8241e75876f1adf1777a9ae693424ce2543c1606 --- /dev/null +++ b/prdoc/pr_5288.prdoc @@ -0,0 +1,17 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Added `polkadot-parachain-lib` helper library that can be used to build a parachain node + +doc: + - audience: Node Dev + description: | + This PR adds the `polkadot-parachain-lib` helper library that can be used to build a parachain node. + +crates: + - name: polkadot-parachain-bin + bump: patch + - name: polkadot-parachain-lib + bump: patch + - name: polkadot-sdk + bump: patch diff --git a/prdoc/pr_5293.prdoc b/prdoc/pr_5293.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..90528a224e8dfc9172aee980265f42a943eeb430 --- /dev/null +++ b/prdoc/pr_5293.prdoc @@ -0,0 +1,22 @@ +title: Add initial version of pallet_revive + +doc: + - audience: Runtime Dev + description: | + Adds initial **experimental** version of the new pallet_revive. It will run PolkaVM + contracts which were recompiled from YUL using the revive compiler. Do not use the + pallet in production, yet. It is work in progress. + +crates: + - name: polkadot-sdk + bump: minor + - name: pallet-revive + bump: minor + - name: pallet-revive-fixtures + bump: minor + - name: pallet-revive-proc-macro + bump: minor + - name: pallet-revive-uapi + bump: minor + - name: pallet-revive-mock-network + bump: minor diff --git a/prdoc/pr_5316.prdoc b/prdoc/pr_5316.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..75b431c941d546c38efc57d0c5fd146f7c0f5a1e --- /dev/null +++ b/prdoc/pr_5316.prdoc @@ -0,0 +1,11 @@ +title: add timestamp function to sp-consensus-slots + +doc: + - audience: Node Dev + description: | + Added timestamp function to sp-consensus-slots to get the first timestamp + of the given slot. + +crates: + - name: sp-consensus-slots + bump: minor diff --git a/prdoc/pr_5326.prdoc b/prdoc/pr_5326.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0301b8c17a309d0a0493bf49f106b51617efd43a --- /dev/null +++ b/prdoc/pr_5326.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Update Readme of the `polkadot` crate + +doc: + - audience: Node Operator + description: | + Updated Readme of the `polkadot` crate. + +crates: + - name: polkadot + bump: patch diff --git a/prdoc/pr_5339.prdoc b/prdoc/pr_5339.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..850ba903e126547ace404bd1e2e9a64f1fe08b5a --- /dev/null +++ b/prdoc/pr_5339.prdoc @@ -0,0 +1,45 @@ +title: Replace unnecessary `&mut self` with `&self` in `BlockImport::import_block()` + +doc: + - audience: Node Dev + description: | + Simplifies block import API to match intended design where independent blocks can technically be imported + concurrently and in practice was called through `Arc` anyway + +crates: + - name: cumulus-client-consensus-common + bump: major + - name: cumulus-client-network + bump: none + - name: cumulus-relay-chain-inprocess-interface + bump: none + - name: cumulus-pallet-parachain-system + bump: none + - name: sc-basic-authorship + bump: patch + - name: sc-consensus-babe + bump: major + - name: sc-consensus-beefy + bump: major + - name: sc-consensus + bump: major + - name: sc-consensus-grandpa + bump: major + - name: sc-consensus-pow + bump: major + - name: mmr-gadget + bump: none + - name: sc-network + bump: none + - name: sc-network-sync + bump: none + - name: sc-offchain + bump: none + - name: sc-rpc-spec-v2 + bump: none + - name: sc-rpc + bump: none + - name: sc-service + bump: major + - name: sc-transaction-pool + bump: none diff --git a/prdoc/pr_5344.prdoc b/prdoc/pr_5344.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..9f83c113686d79e23d2915233754569a8fca421b --- /dev/null +++ b/prdoc/pr_5344.prdoc @@ -0,0 +1,10 @@ +title: Fix storage weight reclaim bug. + +doc: + - audience: Node Dev + description: | + Improvement in slot worker loop that will not call create inherent data providers if the major sync is in progress. Before it was called every slot and the results were discarded during major sync. + +crates: + - name: sc-consensus-slots + bump: minor diff --git a/prdoc/pr_5348.prdoc b/prdoc/pr_5348.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c2282c4c74c4f6e0e2d427dacea79de3b1bc6176 --- /dev/null +++ b/prdoc/pr_5348.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: allow for u8 to be used as hold/freeze reason + +doc: + - audience: Runtime Dev + description: | + Allows for `u8` type to be configured as `HoldReason` and `FreezeReason` + +crates: + - name: frame-support + bump: patch diff --git a/prdoc/pr_5352.prdoc b/prdoc/pr_5352.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4b055d81cb515ebcbc47c99cc1e466a9bede3c70 --- /dev/null +++ b/prdoc/pr_5352.prdoc @@ -0,0 +1,10 @@ +title: "Aura: Ensure parachains are building on all relay chain forks" + +doc: + - audience: Node Dev + description: | + Ensure that parachains using the `basic` collator are building on all relay chain forks. + +crates: + - name: cumulus-client-consensus-aura + bump: patch diff --git a/prdoc/pr_5354.prdoc b/prdoc/pr_5354.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..e3037b66fbca070d7fe15ceca7556741f86d8ad6 --- /dev/null +++ b/prdoc/pr_5354.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fix benchmark failures when using insecure_zero_ed flag + +doc: + - audience: Runtime Dev + description: | + Currently, when the pallet is compiled with the insecure_zero_ed flag, benchmarks fail because the minimum balance is set to zero. + + The PR aims to resolve this issue by implementing a placeholder value for the minimum balance when the insecure_zero_ed flag is active. it ensures that benchmarks run successfully regardless of whether this flag is used or not + +crates: +- name: pallet-balances + bump: minor diff --git a/prdoc/pr_5356.prdoc b/prdoc/pr_5356.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a306be335440735fdc088d4a506f275e65ff2a73 --- /dev/null +++ b/prdoc/pr_5356.prdoc @@ -0,0 +1,18 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fix OurViewChange small race + +doc: + - audience: Node Dev + description: | + Always queue OurViewChange event before we send view changes to our peers, because otherwise we risk + the peers sending us a message that can be processed by our subsystems before OurViewChange. + Normally, this is not really a problem because the latency of the ViewChange we send to our peers + is way higher than that of our subsystem processing OurViewChange, however on testnets like versi + where CPUs are sometimes overcommitted this race gets triggered occasionally, so let's fix it by + sending the messages in the right order. + +crates: + - name: polkadot-network-bridge + bump: minor diff --git a/prdoc/pr_5359.prdoc b/prdoc/pr_5359.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..bf059129a4362473fb9de83613b1a8ddde88f575 --- /dev/null +++ b/prdoc/pr_5359.prdoc @@ -0,0 +1,21 @@ +title: Make ticket non-optional and add ensure_successful method to Consideration trait + +doc: + - audience: Runtime Dev + description: | + Make ticket non-optional and add ensure_successful method to Consideration trait. + + Reverts the optional return ticket type for the new function introduced in + [polkadot-sdk/4596](https://github.com/paritytech/polkadot-sdk/pull/4596) and adds a helper + `ensure_successful` function for the runtime benchmarks. + Since the existing FRAME pallet represents zero cost with a zero balance type rather than + `None` in an option, maintaining the ticket type as a non-optional balance is beneficial + for backward compatibility and helps avoid unnecessary migrations. + +crates: + - name: frame-support + bump: major + - name: pallet-preimage + bump: major + - name: pallet-balances + bump: patch diff --git a/prdoc/pr_5360.prdoc b/prdoc/pr_5360.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..4b07f30bfd09d4835c998e447e86b0ef4b26acae --- /dev/null +++ b/prdoc/pr_5360.prdoc @@ -0,0 +1,3 @@ +crates: + - name: sc-service + bump: none diff --git a/prdoc/pr_5369.prdoc b/prdoc/pr_5369.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..1baa5e1cbe7dbeff44f5e23ef5dc28722d071262 --- /dev/null +++ b/prdoc/pr_5369.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Fix failing XCM from relay to Coretime Chain when revenue is zero + +doc: + - audience: Runtime Dev + description: | + The coretime assigner now always includes UnpaidExecution when calling `notify_revenue` via a + `Transact`, not just when revenue is nonzero. This fixes an issue where the XCM would fail to + process on the receiving side. + +crates: + - name: polkadot-runtime-parachains + bump: patch diff --git a/prdoc/pr_5376.prdoc b/prdoc/pr_5376.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c9874ef7d865693c5afe82fd74166dd01a171f05 --- /dev/null +++ b/prdoc/pr_5376.prdoc @@ -0,0 +1,3 @@ +crates: + - name: binary-merkle-tree + bump: none diff --git a/prdoc/pr_5380.prdoc b/prdoc/pr_5380.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..75063e3353439508745a0ef3e38b6e798690ae0e --- /dev/null +++ b/prdoc/pr_5380.prdoc @@ -0,0 +1,15 @@ +title: Fix leases with gaps and time slice calculation in MigrateToCoretime + +doc: + - audience: Runtime Dev + description: | + Agile Coretime storage migration wasn't transferring correctly leases with gaps and was + miscalculating time lease period. This patch provides fixes for both issues. + +crates: + - name: rococo-runtime + bump: patch + - name: westend-runtime + bump: major + - name: polkadot-runtime-parachains + bump: patch \ No newline at end of file diff --git a/prdoc/pr_5384.prdoc b/prdoc/pr_5384.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..74d477f8e153d32e3da698acfa02f990141a96d9 --- /dev/null +++ b/prdoc/pr_5384.prdoc @@ -0,0 +1,25 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "`MaybeConsideration` extension trait for `Consideration`" + +doc: + - audience: Runtime Dev + description: | + The trait allows for the management of tickets that may represent no cost. While + the `MaybeConsideration` still requires proper handling, it introduces the ability + to determine if a ticket represents no cost and can be safely forgotten without any + side effects. + + The new trait is particularly useful when a consumer expects the cost to be zero under + certain conditions (e.g., when the proposal count is below a threshold N) and does not want + to store such consideration tickets in storage. The extension approach allows us to avoid + breaking changes to the existing trait and to continue using it as a non-optional version + for migrating pallets that utilize the `Currency` and `fungible` traits for `holds` and + `freezes`, without requiring any storage migration. + +crates: + - name: frame-support + bump: minor + - name: pallet-balances + bump: patch diff --git a/prdoc/pr_5392.prdoc b/prdoc/pr_5392.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..aeeb05de0bc31ec3b18a9b7496953da9d3fca8b3 --- /dev/null +++ b/prdoc/pr_5392.prdoc @@ -0,0 +1,11 @@ +title: "Don't disconnect disabled nodes sending us dispute messages" + +doc: + - audience: Node Operator + description: | + No longer disconnect peers which we consider disabled when raising + disputes as this will affect the approval process and thus finality. + +crates: + - name: polkadot-dispute-distribution + bump: patch diff --git a/prdoc/pr_5393.prdoc b/prdoc/pr_5393.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..7fcf3067fabc580d9c40af0ffb413a50bf5b3d8a --- /dev/null +++ b/prdoc/pr_5393.prdoc @@ -0,0 +1,15 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Allow to enable full PoV size + +doc: + - audience: Node Dev + description: | + A feature is introduced allowing a collator to enable full PoV size at compile time. + WARNING: To use this feature, security considerations must be understood and the latest + SDK version must be used. + +crates: + - name: cumulus-client-consensus-aura + bump: minor diff --git a/prdoc/pr_5396.prdoc b/prdoc/pr_5396.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d78e9ac46932b2a812fbb2ed30569aef40fe8d02 --- /dev/null +++ b/prdoc/pr_5396.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Simplify `SyncingEngine::new()` + +doc: + - audience: Node Dev + description: | + Tiny changes to simplify the internal implemenation of API `SyncingEngine::new()` to prevent panics while fetching the genesis hash and to eliminate unnecessary allocation for reserved peers. + +crates: +- name: sc-network-sync + bump: none diff --git a/prdoc/pr_5407.prdoc b/prdoc/pr_5407.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..f7e6b86f9d1e7cb16022c50391e301d9fb493e69 --- /dev/null +++ b/prdoc/pr_5407.prdoc @@ -0,0 +1,17 @@ +title: Prepare PVFs if node is a validator in the next session + +doc: + - audience: [Node Operator, Node Dev] + description: | + This PR aims to remove the noise caused by the peer store's reputation system. + A warning was emitted each time a reputation was reported for a banned peer, + regardless of the reputation being positive. This has led in the past to + situations where it was hard to identify the actual reason of the ban and + caused noise for node operators. + + The `Banned, disconnecting.` warning is logged only when the peer is banned. + Other misbehaves are logged as `Misbehaved during the ban threshold`. + +crates: + - name: sc-network + bump: patch diff --git a/prdoc/pr_5410.prdoc b/prdoc/pr_5410.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..d0a32bec74239c484073d1e93927ed1434d8b83e --- /dev/null +++ b/prdoc/pr_5410.prdoc @@ -0,0 +1,11 @@ +title: Reactive syncing metrics + +doc: + - audience: Node Dev + description: | + Syncing metrics are now updated immediate as changes happen rather than every 1100ms as it was happening before. + This resulted in minor, but breaking API changes. + +crates: + - name: sc-network-sync + bump: major diff --git a/prdoc/pr_5411.prdoc b/prdoc/pr_5411.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..c24001d77bda27b8c711be74acfeb526276c853a --- /dev/null +++ b/prdoc/pr_5411.prdoc @@ -0,0 +1,3 @@ +crates: + - name: polkadot-approval-distribution + bump: none diff --git a/prdoc/pr_5424.prdoc b/prdoc/pr_5424.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..a94bf7aaeba21812c48c61fe4a56955d9d501115 --- /dev/null +++ b/prdoc/pr_5424.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Suppress the log output for transaction propagation when no transactions are present + +doc: + - audience: Node Dev + description: | + Previously, the log message `Propagating transactions` would always be printed, even when there were no transactions to propagate. This patch optimizes the logging by returning early when no transactions are present, resulting in cleaner and more relevant log output. + +crates: +- name: sc-network-transactions + bump: none diff --git a/prdoc/pr_5430.prdoc b/prdoc/pr_5430.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..83d6d81e252e215d0dfdd49f0107ba866f2328f4 --- /dev/null +++ b/prdoc/pr_5430.prdoc @@ -0,0 +1,13 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: "pallet-collator-selection: correctly register weight in `new_session`" + +doc: + - audience: Runtime Dev + description: | + - Fixes an incorrect usage of the `WeightInfo` trait for `new_session`. + +crates: + - name: pallet-collator-selection + bump: patch diff --git a/prdoc/pr_5431.prdoc b/prdoc/pr_5431.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..9f6db7136a587a9d9f20844b9a2c322c3b698e77 --- /dev/null +++ b/prdoc/pr_5431.prdoc @@ -0,0 +1,20 @@ +title: Remove the need to wait for target block header in warp sync implementation + +doc: + - audience: Node Dev + description: | + Previously warp sync needed to wait for target block header of the relay chain to become available before warp + sync can start, which resulted in cumbersome APIs. Parachain initialization was refactored to initialize warp sync + with target block header from the very beginning, improving and simplifying sync API. + +crates: + - name: sc-service + bump: major + - name: sc-network-sync + bump: major + - name: polkadot-service + bump: major + - name: cumulus-client-service + bump: major + - name: sc-informant + bump: major diff --git a/prdoc/pr_5436.prdoc b/prdoc/pr_5436.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ea624b7bc32de06bc4f4dd50fd0f94d6fdf70384 --- /dev/null +++ b/prdoc/pr_5436.prdoc @@ -0,0 +1,20 @@ +# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0 +# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json + +title: Add Polkadot Coretime Chain genesis chain-spec + +doc: + - audience: Node Operator + description: | + The Polkadot Coretime Chain can now be run as all other system parachains without specifying a + chain-spec. However this will soon be deprecated and `--chain ./chain-spec.json` should continue + to be used instead. + + - audience: Runtime User + description: | + The Polkadot Coretime Chain chain-specs have been added to the polkadot-sdk repo and can now be + pulled from there along with all other system chains. + +crates: + - name: polkadot-parachain-bin + bump: minor \ No newline at end of file diff --git a/prdoc/pr_5439.prdoc b/prdoc/pr_5439.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..00fa48de0e2548b0973dd98bb76c9ae368518314 --- /dev/null +++ b/prdoc/pr_5439.prdoc @@ -0,0 +1,16 @@ +title: "Deprecated calls removed in cumulus parachain system pallet" + +doc: + - audience: [Runtime Dev, Runtime User] + description: | + Call `authorize_upgrade` in parachain system pallet `cumulus-pallet-parachain-system` has + been removed, use `authorize_upgrade` or `authorize_upgrade_without_checks` calls in system + pallet `frame-system` instead. + Call `enact_authorized_upgrade` in parachain system pallet `cumulus-pallet-parachain-system` + has been removed, use `apply_authorized_upgrade` call in system pallet `frame-system` instead. + +crates: + - name: cumulus-pallet-parachain-system + bump: major + - name: cumulus-pallet-xcmp-queue + bump: none diff --git a/prdoc/pr_5442.prdoc b/prdoc/pr_5442.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..6adc34d71ad34ecb11da9f89c8380fea8770d868 --- /dev/null +++ b/prdoc/pr_5442.prdoc @@ -0,0 +1,10 @@ +title: Derive `Clone` on `EncodableOpaqueLeaf` + +doc: + - audience: Runtime Dev + description: | + `Clone` was derived on `EncodableOpaqueLeaf` for convenience of downstream users + +crates: + - name: sp-mmr-primitives + bump: patch diff --git a/prdoc/pr_5443.prdoc b/prdoc/pr_5443.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0fd396be06a2c0ceb8b49aa5b06bb7b40a72517f --- /dev/null +++ b/prdoc/pr_5443.prdoc @@ -0,0 +1,10 @@ +crates: +- name: frame-remote-externalities + bump: patch +doc: +- audience: Runtime Dev + description: as part of https://github.com/paritytech/devops/issues/3502, try-runtime + nodes were migrated to a new provider with a new domain address. The PR fixes + all the references to try-runtime nodes on rococo, westend, kusama and polkadot + networks +title: change try-runtime rpc domains diff --git a/prdoc/pr_5450.prdoc b/prdoc/pr_5450.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ccd319cad246135143980eec274e286aa2349ce2 --- /dev/null +++ b/prdoc/pr_5450.prdoc @@ -0,0 +1,18 @@ +title: Sync status refactoring + +doc: + - audience: Node Dev + description: | + `SyncingService` API in `sc-network-sync` has changed with some of the redundant methods related to sync status + removed that were mostly used internally or for testing purposes and is unlikely to impact external code. + `ExtendedPeerInfo` now has working `Clone` and `Copy` implementation. + +crates: + - name: sc-informant + bump: major + - name: sc-network-sync + bump: major + - name: sc-network-test + bump: major + - name: sc-service + bump: major diff --git a/prdoc/pr_5465.prdoc b/prdoc/pr_5465.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..ae185dc250f6d271aef71d7e4c0c0acfc60205ea --- /dev/null +++ b/prdoc/pr_5465.prdoc @@ -0,0 +1,10 @@ +title: try-state check invariant for nomination-pools (points >= stake) + +doc: + - audience: Runtime Dev + description: | + Adds a new try-state invariant to the nomination pools that checks that for each bonded pool, the pool's points can never be lower than its staked balance. + +crates: + - name: pallet-nomination-pools + bump: minor diff --git a/prdoc/pr_5466.prdoc b/prdoc/pr_5466.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..57f20b3585b4211b00a94986b433631d2462f7c6 --- /dev/null +++ b/prdoc/pr_5466.prdoc @@ -0,0 +1,14 @@ +crates: +- bump: patch + name: frame-omni-bencher +- bump: patch + name: frame-benchmarking-cli +doc: +- audience: Runtime Dev + description: | + Changes: + - Set default level to `Info` again. Seems like a dependency update set it to something higher. + - Fix docs to not use `--locked` since we rely on dependency bumps via cargo. + - Add README with rust docs. + - Fix bug where the node ignored `--heap-pages` argument. +title: frame-omni-bencher maintenance diff --git a/prdoc/pr_5467.prdoc b/prdoc/pr_5467.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..2634c255e168f7c5ce052cd986f3fb674de1d695 --- /dev/null +++ b/prdoc/pr_5467.prdoc @@ -0,0 +1,10 @@ +title: Make PendingConfigs storage item public + +doc: + - audience: Runtime Dev + description: | + Make PendingConfigs storage item in polkadot's configuration crate public. + +crates: + - name: polkadot-runtime-parachains + bump: minor \ No newline at end of file diff --git a/prdoc/pr_5513.prdoc b/prdoc/pr_5513.prdoc new file mode 100644 index 0000000000000000000000000000000000000000..0eda8b02cde04a1b99b61e04a396b701cf824b3f --- /dev/null +++ b/prdoc/pr_5513.prdoc @@ -0,0 +1,10 @@ +title: Add more logs to trace AcceptanceCheckErr + +doc: + - audience: Runtime Dev + description: | + `Debug` was derived on `AcceptanceCheckErr` to print the error. This PR adds more logs to trace the error. + +crates: + - name: polkadot-runtime-parachains + bump: patch diff --git a/prdoc/schema_user.json b/prdoc/schema_user.json index 294005f209d57d719816a40132ea7f5d49b3d029..5f7d460a5cc080b1feb1f744b05e07addbb8cd51 100644 --- a/prdoc/schema_user.json +++ b/prdoc/schema_user.json @@ -148,7 +148,8 @@ } }, "required": [ - "name" + "name", + "bump" ] }, "migration_db": { @@ -218,7 +219,7 @@ }, "doc": { "type": "object", - "description": "You have the the option to provide different description of your PR for different audiences.", + "description": "You have the option to provide different description of your PR for different audiences.", "additionalProperties": false, "properties": { "audience": { diff --git a/scripts/generate-umbrella.py b/scripts/generate-umbrella.py new file mode 100644 index 0000000000000000000000000000000000000000..e1ef6de86f9c46d783a2c19bcf7db815f4063085 --- /dev/null +++ b/scripts/generate-umbrella.py @@ -0,0 +1,210 @@ +""" + +Creates the Polkadot-SDK umbrella crate that re-exports all other crates. + +This re-creates the `umbrella/` folder. Ensure that it does not contain any changes you want to keep. + +Usage: + python3 generate-umbrella.py --sdk --version + +Example: + python3 generate-umbrella.py --sdk .. --version 1.11.0 +""" + +import argparse +import os +import re +import toml +import shutil + +from cargo_workspace import Workspace + +""" +Crate names that should be excluded from the umbrella crate. +""" +def exclude(crate): + name = crate.name + if crate.metadata.get("polkadot-sdk.exclude-from-umbrella", False): + return True + + # No fuzzers or examples: + if "example" in name or name.endswith("fuzzer"): + return True + + # No runtime crates: + if name.endswith("-runtime"): + # Note: this is a bit hacky. We should use custom crate metadata instead. + return name != "sp-runtime" and name != "bp-runtime" and name != "frame-try-runtime" + + return False + +def main(path, version): + delete_umbrella(path) + workspace = Workspace.from_path(path) + print(f'Indexed {workspace}') + + std_crates = [] # name -> path. use list for sorting + nostd_crates = [] + for crate in workspace.crates: + if crate.name == 'polkadot-sdk': + continue + if not crate.publish: + print(f"Skipping {crate.name} as it is not published") + continue + + lib_path = os.path.dirname(crate.abs_path) + manifest_path = os.path.join(lib_path, "Cargo.toml") + lib_path = os.path.join(lib_path, "src", "lib.rs") + path = os.path.dirname(crate.rel_path) + + # Guess which crates support no_std. Proc-macro crates are always no_std: + with open(manifest_path, "r") as f: + manifest = toml.load(f) + if 'lib' in manifest and 'proc-macro' in manifest['lib']: + if manifest['lib']['proc-macro']: + nostd_crates.append((crate, path)) + continue + + # Crates without a lib.rs cannot be no_std + if not os.path.exists(lib_path): + print(f"Skipping {crate.name} as it does not have a 'src/lib.rs'") + continue + if exclude(crate): + print(f"Skipping {crate.name} as it is in the exclude list") + continue + + # No search for a no_std attribute: + with open(lib_path, "r") as f: + content = f.read() + if "#![no_std]" in content or '#![cfg_attr(not(feature = "std"), no_std)]' in content: + nostd_crates.append((crate, path)) + elif 'no_std' in content: + raise Exception(f"Found 'no_std' in {lib_path} without knowing how to handle it") + else: + std_crates.append((crate, path)) + + # Sort by name + std_crates.sort(key=lambda x: x[0].name) + nostd_crates.sort(key=lambda x: x[0].name) + + runtime_crates = [crate for crate in nostd_crates if 'frame' in crate[0].name or crate[0].name.startswith('sp-')] + all_crates = std_crates + nostd_crates + all_crates.sort(key=lambda x: x[0].name) + dependencies = {} + + for (crate, path) in nostd_crates: + dependencies[crate.name] = {"path": f"../{path}", "default-features": False, "optional": True} + + for (crate, path) in std_crates: + dependencies[crate.name] = {"path": f"../{path}", "default-features": False, "optional": True} + + # The empty features are filled by Zepter + features = { + "default": [ "std" ], + "std": [], + "runtime-benchmarks": [], + "try-runtime": [], + "serde": [], + "experimental": [], + "with-tracing": [], + "runtime-full": list([f"{d.name}" for d, _ in nostd_crates]), + "runtime": list([f"{d.name}" for d, _ in runtime_crates]), + "node": ["std"] + list([f"{d.name}" for d, _ in std_crates]), + "tuples-96": [], + "riscv": [], + } + + manifest = { + "package": { + "name": "polkadot-sdk", + "version": version, + "edition": { "workspace": True }, + "authors": { "workspace": True }, + "description": "Polkadot SDK umbrella crate.", + "license": "Apache-2.0", + "metadata": { "docs": { "rs": { + "features": ["runtime-full", "node"], + "targets": ["x86_64-unknown-linux-gnu"] + }}} + }, + "dependencies": dependencies, + "features": features, + } + + umbrella_dir = os.path.join(workspace.path, "umbrella") + manifest_path = os.path.join(umbrella_dir, "Cargo.toml") + lib_path = os.path.join(umbrella_dir, "src", "lib.rs") + # create all dir + os.makedirs(os.path.dirname(lib_path), exist_ok=True) + # Write the manifest + with open(manifest_path, "w") as f: + toml_manifest = toml.dumps(manifest) + f.write(toml_manifest) + print(f"Wrote {manifest_path}") + # and the lib.rs + with open(lib_path, "w") as f: + f.write('''// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +#![cfg_attr(not(feature = "std"), no_std)] + +//! Polkadot SDK umbrella crate re-exporting all other published crates. +//! +//! This helps to set a single version number for all your dependencies. Docs are in the +//! `polkadot-sdk-docs` crate. + +// This file is auto-generated and checked by the CI. You can edit it manually, but it must be +// exactly the way that the CI expects it. +''') + + for crate, _ in all_crates: + use = crate.name.replace("-", "_") + desc = crate.description if crate.description.endswith(".") else crate.description + "." + f.write(f'\n/// {desc}') + f.write(f'\n#[cfg(feature = "{crate.name}")]\n') + f.write(f"pub use {use};\n") + + print(f"Wrote {lib_path}") + + add_to_workspace(workspace.path) + +""" +Delete the umbrella folder and remove the umbrella crate from the workspace. +""" +def delete_umbrella(path): + umbrella_dir = os.path.join(path, "umbrella") + # remove the umbrella crate from the workspace + manifest = os.path.join(path, "Cargo.toml") + manifest = open(manifest, "r").read() + manifest = re.sub(r'\s+"umbrella",\n', "", manifest) + with open(os.path.join(path, "Cargo.toml"), "w") as f: + f.write(manifest) + if os.path.exists(umbrella_dir): + print(f"Deleting {umbrella_dir}") + shutil.rmtree(umbrella_dir) + +""" +Create the umbrella crate and add it to the workspace. +""" +def add_to_workspace(path): + manifest = os.path.join(path, "Cargo.toml") + manifest = open(manifest, "r").read() + manifest = re.sub(r'^members = \[', 'members = [\n "umbrella",', manifest, flags=re.M) + with open(os.path.join(path, "Cargo.toml"), "w") as f: + f.write(manifest) + + os.chdir(path) # hack + os.system("cargo metadata --format-version 1 > /dev/null") # update the lockfile + os.system(f"zepter") # enable the features + os.system(f"taplo format --config .config/taplo.toml Cargo.toml umbrella/Cargo.toml") + +def parse_args(): + parser = argparse.ArgumentParser(description="Create a polkadot-sdk crate") + parser.add_argument("--sdk", type=str, default="polkadot-sdk", help="Path to the polkadot-sdk crate") + parser.add_argument("--version", type=str, help="Version of the polkadot-sdk crate") + return parser.parse_args() + +if __name__ == "__main__": + args = parse_args() + main(args.sdk, args.version) + diff --git a/scripts/getting-started.sh b/scripts/getting-started.sh new file mode 100755 index 0000000000000000000000000000000000000000..57806280914bd8289b253a69c669f941bbc8dabf --- /dev/null +++ b/scripts/getting-started.sh @@ -0,0 +1,147 @@ +#!/usr/bin/env sh + +set -e + +prompt() { + while true; do + echo "$1 [y/N]" + read yn + case $yn in + [Yy]* ) return 0;; # Yes, return 0 (true) + [Nn]* ) return 1;; # No, return 1 (false) + "" ) return 1;; # Default to no if user just presses Enter + * ) echo "Please answer yes or no.";; + esac + done +} + +prompt_default_yes() { + while true; do + echo "$1 [Y/n]" + read yn + case $yn in + [Yy]* ) return 0;; # Yes, return 0 (true) + [Nn]* ) return 1;; # No, return 1 (false) + "" ) return 0;; # Default to yes if user just presses Enter + * ) echo "Please answer yes or no.";; + esac + done +} + +cat </dev/null 2>&1; then + echo "\n✅︎🍺 Homebrew already installed." + else + if prompt_default_yes "\n🍺 Homebrew is not installed. Install it?"; then + echo "🍺 Installing Homebrew." + /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)" + else + echo "❌ Cannot continue without homebrew. Aborting." + exit 1 + fi + fi + + brew update + if command -v git >/dev/null 2>&1; then + echo "\n✅︎🍺 git already installed." + else + if prompt_default_yes "\n🍺 git seems to be missing but we will need it; install git?"; then + brew install git + else + echo "❌ Cannot continue without git. Aborting." + exit 1 + fi + fi + + if prompt "\n🍺 Install cmake, openssl and protobuf?"; then + brew install cmake openssl protobuf + else + echo "🍺 Assuming cmake, openssl and protobuf are present." + fi +elif [ "$os_name" = "Linux" ]; then + # find the distro name in the release files + distro=$( cat /etc/*-release | tr '[:upper:]' '[:lower:]' | grep -Poi '(debian|ubuntu|arch|fedora|opensuse)' | uniq | head -n 1 ) + + if [ "$distro" = "ubuntu" ]; then + echo "\n🐧 Detected Ubuntu. Using apt to install dependencies." + sudo apt install --assume-yes git clang curl libssl-dev protobuf-compiler + elif [ "$distro" = "debian" ]; then + echo "\n🐧 Detected Debian. Using apt to install dependencies." + sudo apt install --assume-yes git clang curl libssl-dev llvm libudev-dev make protobuf-compiler + elif [ "$distro" = "arch" ]; then + echo "\n🐧 Detected Arch Linux. Using pacman to install dependencies." + pacman -Syu --needed --noconfirm curl git clang make protobuf + elif [ "$distro" = "fedora" ]; then + echo "\n🐧 Detected Fedora. Using dnf to install dependencies." + sudo dnf update + sudo dnf install clang curl git openssl-devel make protobuf-compiler + elif [ "$distro" = "opensuse" ]; then + echo "\n🐧 Detected openSUSE. Using zypper to install dependencies." + sudo zypper install clang curl git openssl-devel llvm-devel libudev-devel make protobuf + else + if prompt "\n🐧 Unknown Linux distribution. Unable to install dependencies. Continue anyway?"; then + echo "\n🐧 Proceeding with unknown linux distribution..." + else + exit 1 + fi + fi +else + echo "❌ Unknown operating system. Aborting." + exit 1 +fi + +# Check if rust is installed +if command -v rustc >/dev/null 2>&1; then + echo "\n✅︎🦀 Rust already installed." +else + if prompt_default_yes "\n🦀 Rust is not installed. Install it?"; then + echo "🦀 Installing via rustup." + curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh + else + echo "Aborting." + exit 1 + fi +fi + +# Ensure that we have wasm support +if prompt_default_yes "\n🦀 Setup the Rust environment (e.g. WASM support)?"; then + echo "🦀 Setting up Rust environment." + rustup default stable + rustup update + rustup target add wasm32-unknown-unknown + rustup component add rust-src +fi + +if [ -d "minimal-template" ]; then + echo "\n✅︎ minimal-template directory already exists. -> Entering." +else + echo "\n↓ Let's grab the minimal template from github." + git clone https://github.com/paritytech/polkadot-sdk-minimal-template.git minimal-template +fi +cd minimal-template + +echo "\n⚙️ Let's compile the node." +cargo build --release + +if prompt_default_yes "\n🚀 Everything ready to go, let's run the node?"; then + cargo run --release -- --dev +fi diff --git a/scripts/update-ui-tests.sh b/scripts/update-ui-tests.sh deleted file mode 100755 index dedee8e641f8a88ef7af36fecc3672944c2f477c..0000000000000000000000000000000000000000 --- a/scripts/update-ui-tests.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env bash -# Script for updating the UI tests for a new rust stable version. -# Exit on error -set -e - -# by default current rust stable will be used -RUSTUP_RUN="" -# check if we have a parameter -# ./scripts/update-ui-tests.sh 1.70 -if [ ! -z "$1" ]; then - echo "RUST_VERSION: $1" - # This will run all UI tests with the rust stable 1.70. - # The script requires that rustup is installed. - RUST_VERSION=$1 - RUSTUP_RUN="rustup run $RUST_VERSION" - - - echo "installing rustup $RUST_VERSION" - if ! command -v rustup &> /dev/null - then - echo "rustup needs to be installed" - exit - fi - - rustup install $RUST_VERSION - rustup component add rust-src --toolchain $RUST_VERSION -fi - -# Ensure we run the ui tests -export RUN_UI_TESTS=1 -# We don't need any wasm files for ui tests -export SKIP_WASM_BUILD=1 -# Let trybuild overwrite the .stderr files -export TRYBUILD=overwrite - -# ./substrate -$RUSTUP_RUN cargo test --manifest-path substrate/primitives/runtime-interface/Cargo.toml ui -$RUSTUP_RUN cargo test -p sp-api-test ui -$RUSTUP_RUN cargo test -p frame-election-provider-solution-type ui -$RUSTUP_RUN cargo test -p frame-support-test --features=no-metadata-docs,try-runtime,experimental ui diff --git a/substrate/bin/node/bench/Cargo.toml b/substrate/bin/node/bench/Cargo.toml index b756f3504655bf44f0b5e51699026dcd82afaca3..88ea908abc23a9f270268c6c7911837c2547256b 100644 --- a/substrate/bin/node/bench/Cargo.toml +++ b/substrate/bin/node/bench/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate node integration benchmarks." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -15,33 +15,33 @@ workspace = true # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -array-bytes = "6.2.2" -clap = { version = "4.5.3", features = ["derive"] } +array-bytes = { workspace = true, default-features = true } +clap = { features = ["derive"], workspace = true } log = { workspace = true, default-features = true } -node-primitives = { path = "../primitives" } -node-testing = { path = "../testing" } -kitchensink-runtime = { path = "../runtime" } -sc-client-api = { path = "../../../client/api" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-state-machine = { path = "../../../primitives/state-machine" } +node-primitives = { workspace = true, default-features = true } +node-testing = { workspace = true } +kitchensink-runtime = { workspace = true } +sc-client-api = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } serde = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -derive_more = { version = "0.99.17", default-features = false, features = ["display"] } -kvdb = "0.13.0" -kvdb-rocksdb = "0.19.0" -sp-trie = { path = "../../../primitives/trie" } -sp-core = { path = "../../../primitives/core" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sc-basic-authorship = { path = "../../../client/basic-authorship" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-timestamp = { path = "../../../primitives/timestamp", default-features = false } -sp-tracing = { path = "../../../primitives/tracing" } -hash-db = "0.16.0" -tempfile = "3.1.0" -fs_extra = "1" -rand = { version = "0.8.5", features = ["small_rng"] } -lazy_static = "1.4.0" -parity-db = "0.4.12" -sc-transaction-pool = { path = "../../../client/transaction-pool" } -sc-transaction-pool-api = { path = "../../../client/transaction-pool/api" } -futures = { version = "0.3.30", features = ["thread-pool"] } +derive_more = { features = ["display"], workspace = true } +kvdb = { workspace = true } +kvdb-rocksdb = { workspace = true } +sp-trie = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sc-basic-authorship = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-timestamp = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +hash-db = { workspace = true, default-features = true } +tempfile = { workspace = true } +fs_extra = { workspace = true } +rand = { features = ["small_rng"], workspace = true, default-features = true } +lazy_static = { workspace = true } +parity-db = { workspace = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +futures = { features = ["thread-pool"], workspace = true } diff --git a/substrate/bin/node/bench/src/import.rs b/substrate/bin/node/bench/src/import.rs index 78b280076e0bd625f2c6fa76beb76a9439a7187a..0b972650ef5a0fee317f040513bbb54ceb09bdd5 100644 --- a/substrate/bin/node/bench/src/import.rs +++ b/substrate/bin/node/bench/src/import.rs @@ -121,32 +121,34 @@ impl core::Benchmark for ImportBenchmark { .inspect_state(|| { match self.block_type { BlockType::RandomTransfersKeepAlive => { - // should be 8 per signed extrinsic + 1 per unsigned - // we have 1 unsigned and the rest are signed in the block - // those 8 events per signed are: + // should be 9 per signed extrinsic + 1 per unsigned + // we have 2 unsigned (timestamp and glutton bloat) while the rest are + // signed in the block. + // those 9 events per signed are: // - transaction paid for the transaction payment // - withdraw (Balances::Withdraw) for charging the transaction fee // - new account (System::NewAccount) as we always transfer fund to // non-existent account // - endowed (Balances::Endowed) for this new account + // - issued (Balances::Issued) as total issuance is increased // - successful transfer (Event::Transfer) for this transfer operation // - 2x deposit (Balances::Deposit and Treasury::Deposit) for depositing // the transaction fee into the treasury // - extrinsic success assert_eq!( kitchensink_runtime::System::events().len(), - (self.block.extrinsics.len() - 1) * 8 + 1, + (self.block.extrinsics.len() - 2) * 9 + 2, ); }, BlockType::Noop => { assert_eq!( kitchensink_runtime::System::events().len(), // should be 2 per signed extrinsic + 1 per unsigned - // we have 1 unsigned and the rest are signed in the block + // we have 2 unsigned and the rest are signed in the block // those 2 events per signed are: // - deposit event for charging transaction fee // - extrinsic success - (self.block.extrinsics.len() - 1) * 2 + 1, + (self.block.extrinsics.len() - 2) * 2 + 2, ); }, _ => {}, diff --git a/substrate/bin/node/cli/Cargo.toml b/substrate/bin/node/cli/Cargo.toml index 050004acc78f185ddca3c7637e7ca944319fdc7e..6e734a723cd36f4f86ae6a7f1ad032d8c702ecab 100644 --- a/substrate/bin/node/cli/Cargo.toml +++ b/substrate/bin/node/cli/Cargo.toml @@ -7,7 +7,7 @@ build = "build.rs" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" default-run = "substrate-node" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -23,13 +23,10 @@ wasm-opt = false targets = ["x86_64-unknown-linux-gnu"] [badges] -travis-ci = { repository = "paritytech/substrate" } maintenance = { status = "actively-developed" } -is-it-maintained-issue-resolution = { repository = "paritytech/substrate" } -is-it-maintained-open-issues = { repository = "paritytech/substrate" } +is-it-maintained-issue-resolution = { repository = "paritytech/polkadot-sdk" } +is-it-maintained-open-issues = { repository = "paritytech/polkadot-sdk" } -# The same node binary as the `substrate` (defined in the workspace `Cargo.toml`) binary, -# but just exposed by this crate here. [[bin]] name = "substrate-node" path = "bin/main.rs" @@ -40,196 +37,77 @@ crate-type = ["cdylib", "rlib"] [dependencies] # third-party dependencies -array-bytes = "6.2.2" -clap = { version = "4.5.3", features = ["derive"], optional = true } -codec = { package = "parity-scale-codec", version = "3.6.1" } +array-bytes = { workspace = true, default-features = true } +clap = { features = ["derive"], optional = true, workspace = true } +codec = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } -jsonrpsee = { version = "0.22", features = ["server"] } -futures = "0.3.30" +jsonrpsee = { features = ["server"], workspace = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -rand = "0.8" - -# primitives -sp-authority-discovery = { path = "../../../primitives/authority-discovery" } -sp-consensus-babe = { path = "../../../primitives/consensus/babe" } -beefy-primitives = { package = "sp-consensus-beefy", path = "../../../primitives/consensus/beefy" } -grandpa-primitives = { package = "sp-consensus-grandpa", path = "../../../primitives/consensus/grandpa" } -sp-api = { path = "../../../primitives/api" } -sp-core = { path = "../../../primitives/core" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-timestamp = { path = "../../../primitives/timestamp" } -sp-genesis-builder = { path = "../../../primitives/genesis-builder" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-transaction-storage-proof = { path = "../../../primitives/transaction-storage-proof" } -sp-io = { path = "../../../primitives/io" } -sp-mixnet = { path = "../../../primitives/mixnet" } -sp-mmr-primitives = { path = "../../../primitives/merkle-mountain-range" } -sp-statement-store = { path = "../../../primitives/statement-store" } - -# client dependencies -sc-client-api = { path = "../../../client/api" } -sc-chain-spec = { path = "../../../client/chain-spec" } -sc-consensus = { path = "../../../client/consensus/common" } -sc-transaction-pool = { path = "../../../client/transaction-pool" } -sc-transaction-pool-api = { path = "../../../client/transaction-pool/api" } -sc-statement-store = { path = "../../../client/statement-store" } -sc-network = { path = "../../../client/network" } -sc-network-common = { path = "../../../client/network/common" } -sc-network-sync = { path = "../../../client/network/sync" } -sc-network-statement = { path = "../../../client/network/statement" } -sc-consensus-slots = { path = "../../../client/consensus/slots" } -sc-consensus-babe = { path = "../../../client/consensus/babe" } -beefy = { package = "sc-consensus-beefy", path = "../../../client/consensus/beefy" } -grandpa = { package = "sc-consensus-grandpa", path = "../../../client/consensus/grandpa" } -mmr-gadget = { path = "../../../client/merkle-mountain-range" } -sc-rpc = { path = "../../../client/rpc" } -sc-basic-authorship = { path = "../../../client/basic-authorship" } -sc-service = { path = "../../../client/service", default-features = false } -sc-telemetry = { path = "../../../client/telemetry" } -sc-executor = { path = "../../../client/executor" } -sc-authority-discovery = { path = "../../../client/authority-discovery" } -sc-mixnet = { path = "../../../client/mixnet" } -sc-sync-state-rpc = { path = "../../../client/sync-state-rpc" } -sc-sysinfo = { path = "../../../client/sysinfo" } -sc-storage-monitor = { path = "../../../client/storage-monitor" } -sc-offchain = { path = "../../../client/offchain" } - -# frame dependencies -frame-benchmarking = { path = "../../../frame/benchmarking" } -frame-system = { path = "../../../frame/system" } -frame-system-rpc-runtime-api = { path = "../../../frame/system/rpc/runtime-api" } -pallet-assets = { path = "../../../frame/assets" } -pallet-asset-conversion-tx-payment = { path = "../../../frame/transaction-payment/asset-conversion-tx-payment" } -pallet-asset-tx-payment = { path = "../../../frame/transaction-payment/asset-tx-payment" } -pallet-im-online = { path = "../../../frame/im-online", default-features = false } -pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-feeless-payment", default-features = false } - -# node-specific dependencies -kitchensink-runtime = { path = "../runtime" } -node-rpc = { path = "../rpc" } -node-primitives = { path = "../primitives" } - -# CLI-specific dependencies -sc-cli = { path = "../../../client/cli", optional = true } -frame-benchmarking-cli = { path = "../../../utils/frame/benchmarking-cli", optional = true } -node-inspect = { package = "staging-node-inspect", path = "../inspect", optional = true } +rand = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } +# The Polkadot-SDK: +polkadot-sdk = { features = ["node"], workspace = true, default-features = true } + +# Shared code between the staging node and kitchensink runtime: +kitchensink-runtime = { workspace = true } +node-rpc = { workspace = true } +node-primitives = { workspace = true, default-features = true } +node-inspect = { optional = true, workspace = true, default-features = true } + [dev-dependencies] -sc-keystore = { path = "../../../client/keystore" } -sc-client-db = { path = "../../../client/db" } -sc-consensus = { path = "../../../client/consensus/common" } -sc-consensus-babe = { path = "../../../client/consensus/babe" } -sc-consensus-epochs = { path = "../../../client/consensus/epochs" } -sc-service-test = { path = "../../../client/service/test" } -sc-block-builder = { path = "../../../client/block-builder" } -sp-tracing = { path = "../../../primitives/tracing" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" } -futures = "0.3.30" -tempfile = "3.1.0" -assert_cmd = "2.0.2" -nix = { version = "0.27.1", features = ["signal"] } -regex = "1.6.0" -platforms = "3.0" -soketto = "0.7.1" -criterion = { version = "0.5.1", features = ["async_tokio"] } -tokio = { version = "1.22.0", features = ["macros", "parking_lot", "time"] } -tokio-util = { version = "0.7.4", features = ["compat"] } -wait-timeout = "0.2" -substrate-rpc-client = { path = "../../../utils/frame/rpc/client" } -pallet-timestamp = { path = "../../../frame/timestamp" } -substrate-cli-test-utils = { path = "../../../test-utils/cli" } - -wat = "1.0" -frame-support = { path = "../../../frame/support" } -node-testing = { path = "../testing" } -pallet-balances = { path = "../../../frame/balances" } -pallet-contracts = { path = "../../../frame/contracts" } -pallet-glutton = { path = "../../../frame/glutton" } -pallet-sudo = { path = "../../../frame/sudo" } -pallet-treasury = { path = "../../../frame/treasury" } -pallet-transaction-payment = { path = "../../../frame/transaction-payment" } -sp-application-crypto = { path = "../../../primitives/application-crypto" } -pallet-root-testing = { path = "../../../frame/root-testing" } -sp-consensus-babe = { path = "../../../primitives/consensus/babe" } -sp-externalities = { path = "../../../primitives/externalities" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-runtime = { path = "../../../primitives/runtime" } +futures = { workspace = true } +tempfile = { workspace = true } +assert_cmd = { workspace = true } +nix = { features = ["signal"], workspace = true } +regex = { workspace = true } +platforms = { workspace = true } +soketto = { workspace = true } +criterion = { features = ["async_tokio"], workspace = true, default-features = true } +tokio = { features = ["macros", "parking_lot", "time"], workspace = true, default-features = true } +tokio-util = { features = ["compat"], workspace = true } +wait-timeout = { workspace = true } +wat = { workspace = true } serde_json = { workspace = true, default-features = true } -scale-info = { version = "2.11.1", features = ["derive", "serde"] } -sp-trie = { path = "../../../primitives/trie" } -sp-state-machine = { path = "../../../primitives/state-machine" } +scale-info = { features = ["derive", "serde"], workspace = true, default-features = true } +pretty_assertions.workspace = true + +# These testing-only dependencies are not exported by the Polkadot-SDK crate: +node-testing = { workspace = true } +substrate-cli-test-utils = { workspace = true } +sc-service-test = { workspace = true } [build-dependencies] -clap = { version = "4.5.3", optional = true } -clap_complete = { version = "4.0.2", optional = true } -node-inspect = { package = "staging-node-inspect", path = "../inspect", optional = true } -frame-benchmarking-cli = { path = "../../../utils/frame/benchmarking-cli", optional = true } -substrate-build-script-utils = { path = "../../../utils/build-script-utils", optional = true } -substrate-frame-cli = { path = "../../../utils/frame/frame-utilities-cli", optional = true } -sc-cli = { path = "../../../client/cli", optional = true } -pallet-balances = { path = "../../../frame/balances" } -sc-storage-monitor = { path = "../../../client/storage-monitor" } +clap = { optional = true, workspace = true } +clap_complete = { optional = true, workspace = true } + +node-inspect = { optional = true, workspace = true, default-features = true } + +polkadot-sdk = { features = ["frame-benchmarking-cli", "sc-cli", "sc-storage-monitor", "substrate-build-script-utils"], optional = true, workspace = true, default-features = true } [features] default = ["cli"] cli = [ "clap", "clap_complete", - "frame-benchmarking-cli", "node-inspect", - "sc-cli", - "sc-service/rocksdb", - "substrate-build-script-utils", - "substrate-frame-cli", + "polkadot-sdk", ] runtime-benchmarks = [ - "frame-benchmarking-cli/runtime-benchmarks", - "frame-benchmarking/runtime-benchmarks", - "frame-support/runtime-benchmarks", - "frame-system/runtime-benchmarks", "kitchensink-runtime/runtime-benchmarks", "node-inspect?/runtime-benchmarks", - "pallet-asset-tx-payment/runtime-benchmarks", - "pallet-assets/runtime-benchmarks", - "pallet-balances/runtime-benchmarks", - "pallet-contracts/runtime-benchmarks", - "pallet-glutton/runtime-benchmarks", - "pallet-im-online/runtime-benchmarks", - "pallet-skip-feeless-payment/runtime-benchmarks", - "pallet-sudo/runtime-benchmarks", - "pallet-timestamp/runtime-benchmarks", - "pallet-treasury/runtime-benchmarks", - "sc-client-db/runtime-benchmarks", - "sc-service/runtime-benchmarks", - "sp-runtime/runtime-benchmarks", + "polkadot-sdk/runtime-benchmarks", ] -# Enable features that allow the runtime to be tried and debugged. Name might be subject to change -# in the near future. try-runtime = [ - "frame-support/try-runtime", - "frame-system/try-runtime", "kitchensink-runtime/try-runtime", - "pallet-asset-conversion-tx-payment/try-runtime", - "pallet-asset-tx-payment/try-runtime", - "pallet-assets/try-runtime", - "pallet-balances/try-runtime", - "pallet-contracts/try-runtime", - "pallet-glutton/try-runtime", - "pallet-im-online/try-runtime", - "pallet-root-testing/try-runtime", - "pallet-skip-feeless-payment/try-runtime", - "pallet-sudo/try-runtime", - "pallet-timestamp/try-runtime", - "pallet-transaction-payment/try-runtime", - "pallet-treasury/try-runtime", - "sp-runtime/try-runtime", + "polkadot-sdk/try-runtime", "substrate-cli-test-utils/try-runtime", ] +riscv = [ + "kitchensink-runtime/riscv", + "polkadot-sdk/riscv", +] [[bench]] name = "transaction_pool" diff --git a/substrate/bin/node/cli/benches/block_production.rs b/substrate/bin/node/cli/benches/block_production.rs index ef7ae4fdf26308827e2745d4cb54c8fe21fbc14f..9ac9d8b4f67dbe5f1dd825c34372c1594a3508de 100644 --- a/substrate/bin/node/cli/benches/block_production.rs +++ b/substrate/bin/node/cli/benches/block_production.rs @@ -16,6 +16,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use polkadot_sdk::*; + use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput}; use kitchensink_runtime::{constants::currency::*, BalancesCall}; @@ -102,7 +104,6 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase { announce_block: true, data_path: base_path.path().into(), base_path, - informant_output_format: Default::default(), wasm_runtime_overrides: None, }; @@ -123,7 +124,7 @@ fn extrinsic_set_time(now: u64) -> OpaqueExtrinsic { .into() } -fn import_block(mut client: &FullClient, built: BuiltBlock) { +fn import_block(client: &FullClient, built: BuiltBlock) { let mut params = BlockImportParams::new(BlockOrigin::File, built.block.header); params.state_action = StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(built.storage_changes)); diff --git a/substrate/bin/node/cli/benches/executor.rs b/substrate/bin/node/cli/benches/executor.rs index a326e1a79ea347f169e372581d07dc4f43848e24..fa4da5c13d4344208c6a51067fbf78e380923a82 100644 --- a/substrate/bin/node/cli/benches/executor.rs +++ b/substrate/bin/node/cli/benches/executor.rs @@ -15,6 +15,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +use polkadot_sdk::*; + use codec::{Decode, Encode}; use criterion::{criterion_group, criterion_main, BatchSize, Criterion}; use frame_support::Hashable; @@ -55,7 +57,7 @@ const HEAP_PAGES: u64 = 20; type TestExternalities = CoreTestExternalities; fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic { - node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH) + node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None) } fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities { diff --git a/substrate/bin/node/cli/benches/transaction_pool.rs b/substrate/bin/node/cli/benches/transaction_pool.rs index c4488415b98343a15c8c81eb2ff164db4b36fa29..9a71a4ec585d4621f5cfd141f55ad9fb2a5ab76a 100644 --- a/substrate/bin/node/cli/benches/transaction_pool.rs +++ b/substrate/bin/node/cli/benches/transaction_pool.rs @@ -16,6 +16,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use polkadot_sdk::*; use std::time::Duration; use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput}; @@ -98,7 +99,6 @@ fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase { announce_block: true, data_path: base_path.path().into(), base_path, - informant_output_format: Default::default(), wasm_runtime_overrides: None, }; diff --git a/substrate/bin/node/cli/bin/main.rs b/substrate/bin/node/cli/bin/main.rs index ccc7d7b6b112558832549bf7e5435f68ac0fe944..b18d08880556093319cad2dfd3faa789fae819b1 100644 --- a/substrate/bin/node/cli/bin/main.rs +++ b/substrate/bin/node/cli/bin/main.rs @@ -20,6 +20,7 @@ #![warn(missing_docs)] +use polkadot_sdk::*; use staging_node_cli as node_cli; fn main() -> sc_cli::Result<()> { diff --git a/substrate/bin/node/cli/build.rs b/substrate/bin/node/cli/build.rs index 033f1e3349e6fae1f062f9a075dcb66295aab22d..c25d15de057425458230f48be270ca7ad09d895e 100644 --- a/substrate/bin/node/cli/build.rs +++ b/substrate/bin/node/cli/build.rs @@ -27,8 +27,10 @@ mod cli { use clap::{CommandFactory, ValueEnum}; use clap_complete::{generate_to, Shell}; + use polkadot_sdk::substrate_build_script_utils::{ + generate_cargo_keys, rerun_if_git_head_changed, + }; use std::{env, fs, path::Path}; - use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed}; pub fn main() { build_shell_completion(); diff --git a/substrate/bin/node/cli/src/benchmarking.rs b/substrate/bin/node/cli/src/benchmarking.rs index 333f855f2d7bb876d7768784b60dfa21e1d8d708..a2b28a0f317de4fcc74b963d3ccb1c026ddfa380 100644 --- a/substrate/bin/node/cli/src/benchmarking.rs +++ b/substrate/bin/node/cli/src/benchmarking.rs @@ -22,6 +22,8 @@ use crate::service::{create_extrinsic, FullClient}; +use polkadot_sdk::*; + use kitchensink_runtime::{BalancesCall, SystemCall}; use node_primitives::{AccountId, Balance}; use sc_cli::Result; diff --git a/substrate/bin/node/cli/src/chain_spec.rs b/substrate/bin/node/cli/src/chain_spec.rs index d48d4a50f85f2672d5e65c639a6a0b200c06756c..bc7821bfcf304bc7c41d50d0bf1606e33ac114bc 100644 --- a/substrate/bin/node/cli/src/chain_spec.rs +++ b/substrate/bin/node/cli/src/chain_spec.rs @@ -18,8 +18,8 @@ //! Substrate chain configurations. -use beefy_primitives::ecdsa_crypto::AuthorityId as BeefyId; -use grandpa_primitives::AuthorityId as GrandpaId; +use polkadot_sdk::*; + use kitchensink_runtime::{ constants::currency::*, wasm_binary_unwrap, Block, MaxNominations, SessionKeys, StakerStatus, }; @@ -30,6 +30,8 @@ use sc_telemetry::TelemetryEndpoints; use serde::{Deserialize, Serialize}; use sp_authority_discovery::AuthorityId as AuthorityDiscoveryId; use sp_consensus_babe::AuthorityId as BabeId; +use sp_consensus_beefy::ecdsa_crypto::AuthorityId as BeefyId; +use sp_consensus_grandpa::AuthorityId as GrandpaId; use sp_core::{crypto::UncheckedInto, sr25519, Pair, Public}; use sp_mixnet::types::AuthorityId as MixnetId; use sp_runtime::{ @@ -62,7 +64,7 @@ pub struct Extensions { } /// Specialized `ChainSpec`. -pub type ChainSpec = sc_service::GenericChainSpec; +pub type ChainSpec = sc_service::GenericChainSpec; /// Flaming Fir testnet generator pub fn flaming_fir_config() -> Result { ChainSpec::from_json_bytes(&include_bytes!("../res/flaming-fir.json")[..]) diff --git a/substrate/bin/node/cli/src/cli.rs b/substrate/bin/node/cli/src/cli.rs index 1d1af6e03e9e6eb57055b416038ee97ba95f3e3a..c0dcacb2e4b451990ea08c0c29fd1f92f89b3eaa 100644 --- a/substrate/bin/node/cli/src/cli.rs +++ b/substrate/bin/node/cli/src/cli.rs @@ -16,6 +16,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use polkadot_sdk::*; + /// An overarching CLI command definition. #[derive(Debug, clap::Parser)] pub struct Cli { diff --git a/substrate/bin/node/cli/src/command.rs b/substrate/bin/node/cli/src/command.rs index d869b77e9122859550232136d3907e2f33a4eda3..51fbf0904cf8c303a6af3bed0c24587952723cd0 100644 --- a/substrate/bin/node/cli/src/command.rs +++ b/substrate/bin/node/cli/src/command.rs @@ -16,6 +16,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use polkadot_sdk::*; + use super::benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder}; use crate::{ chain_spec, service, @@ -215,7 +217,7 @@ pub fn run() -> Result<()> { new_partial(&config, None)?; let aux_revert = Box::new(|client: Arc, backend, blocks| { sc_consensus_babe::revert(client.clone(), backend, blocks)?; - grandpa::revert(client, blocks)?; + sc_consensus_grandpa::revert(client, blocks)?; Ok(()) }); Ok((cmd.run(client, backend, Some(aux_revert)), task_manager)) diff --git a/substrate/bin/node/cli/src/service.rs b/substrate/bin/node/cli/src/service.rs index 5dc1193daf8d67f6f9067eb42a161dab9242efed..8fdcc7261b55fc00c4c69a726eac967b7a8f072e 100644 --- a/substrate/bin/node/cli/src/service.rs +++ b/substrate/bin/node/cli/src/service.rs @@ -20,6 +20,11 @@ //! Service implementation. Specialized wrapper over substrate service. +use polkadot_sdk::{ + sc_consensus_beefy as beefy, sc_consensus_grandpa as grandpa, + sp_consensus_beefy as beefy_primitives, *, +}; + use crate::Cli; use codec::Encode; use frame_benchmarking_cli::SUBSTRATE_REFERENCE_HARDWARE; @@ -32,7 +37,7 @@ use sc_consensus_babe::{self, SlotProportion}; use sc_network::{ event::Event, service::traits::NetworkService, NetworkBackend, NetworkEventStream, }; -use sc_network_sync::{strategy::warp::WarpSyncParams, SyncingService}; +use sc_network_sync::{strategy::warp::WarpSyncConfig, SyncingService}; use sc_service::{config::Configuration, error::Error as ServiceError, RpcHandlers, TaskManager}; use sc_statement_store::Store as StatementStore; use sc_telemetry::{Telemetry, TelemetryWorker}; @@ -65,8 +70,13 @@ type FullBackend = sc_service::TFullBackend; type FullSelectChain = sc_consensus::LongestChain; type FullGrandpaBlockImport = grandpa::GrandpaBlockImport; -type FullBeefyBlockImport = - beefy::import::BeefyBlockImport; +type FullBeefyBlockImport = beefy::import::BeefyBlockImport< + Block, + FullBackend, + FullClient, + InnerBlockImport, + beefy_primitives::ecdsa_crypto::AuthorityId, +>; /// The transaction pool type definition. pub type TransactionPool = sc_transaction_pool::FullPool; @@ -126,6 +136,7 @@ pub fn create_extrinsic( kitchensink_runtime::Runtime, >::from(tip, None), ), + frame_metadata_hash_extension::CheckMetadataHash::new(false), ); let raw_payload = kitchensink_runtime::SignedPayload::from_raw( @@ -140,6 +151,7 @@ pub fn create_extrinsic( (), (), (), + None, ), ); let signature = raw_payload.using_encoded(|e| sender.sign(e)); @@ -165,7 +177,6 @@ pub fn new_partial( sc_transaction_pool::FullPool, ( impl Fn( - node_rpc::DenyUnsafe, sc_rpc::SubscriptionTaskExecutor, ) -> Result, sc_service::Error>, ( @@ -176,7 +187,7 @@ pub fn new_partial( >, grandpa::LinkHalf, sc_consensus_babe::BabeLink, - beefy::BeefyVoterLinks, + beefy::BeefyVoterLinks, ), grandpa::SharedVoterState, Option, @@ -306,13 +317,12 @@ pub fn new_partial( let rpc_backend = backend.clone(); let rpc_statement_store = statement_store.clone(); let rpc_extensions_builder = - move |deny_unsafe, subscription_executor: node_rpc::SubscriptionTaskExecutor| { + move |subscription_executor: node_rpc::SubscriptionTaskExecutor| { let deps = node_rpc::FullDeps { client: client.clone(), pool: pool.clone(), select_chain: select_chain.clone(), chain_spec: chain_spec.cloned_box(), - deny_unsafe, babe: node_rpc::BabeDeps { keystore: keystore.clone(), babe_worker_handle: babe_worker_handle.clone(), @@ -324,7 +334,7 @@ pub fn new_partial( subscription_executor: subscription_executor.clone(), finality_provider: finality_proof_provider.clone(), }, - beefy: node_rpc::BeefyDeps { + beefy: node_rpc::BeefyDeps:: { beefy_finality_proof_stream: beefy_rpc_links .from_voter_justif_stream .clone(), @@ -429,8 +439,10 @@ pub fn new_full_base::Hash>>( let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht; let auth_disc_public_addresses = config.network.public_addresses.clone(); - let mut net_config = - sc_network::config::FullNetworkConfiguration::<_, _, N>::new(&config.network); + let mut net_config = sc_network::config::FullNetworkConfiguration::<_, _, N>::new( + &config.network, + config.prometheus_config.as_ref().map(|cfg| cfg.registry.clone()), + ); let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); let peer_store_handle = net_config.peer_store_handle(); @@ -503,7 +515,7 @@ pub fn new_full_base::Hash>>( spawn_handle: task_manager.spawn_handle(), import_queue, block_announce_validator_builder: None, - warp_sync_params: Some(WarpSyncParams::WithProvider(warp_sync)), + warp_sync_config: Some(WarpSyncConfig::WithProvider(warp_sync)), block_relay: None, metrics, })?; @@ -668,7 +680,7 @@ pub fn new_full_base::Hash>>( let beefy_params = beefy::BeefyParams { client: client.clone(), backend: backend.clone(), - payload_provider: beefy_primitives::mmr::MmrRootProvider::new(client.clone()), + payload_provider: sp_consensus_beefy::mmr::MmrRootProvider::new(client.clone()), runtime: client.clone(), key_store: keystore.clone(), network_params, @@ -679,7 +691,7 @@ pub fn new_full_base::Hash>>( is_authority: role.is_authority(), }; - let beefy_gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params); + let beefy_gadget = beefy::start_beefy_gadget::<_, _, _, _, _, _, _, _>(beefy_params); // BEEFY is part of consensus, if it fails we'll bring the node down with it to make sure it // is noticed. task_manager @@ -842,6 +854,7 @@ mod tests { Address, BalancesCall, RuntimeCall, UncheckedExtrinsic, }; use node_primitives::{Block, DigestItem, Signature}; + use polkadot_sdk::*; use sc_client_api::BlockBackend; use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy}; use sc_consensus_babe::{BabeIntermediate, CompatibleDigestItem, INTERMEDIATE_KEY}; @@ -1041,6 +1054,7 @@ mod tests { let tx_payment = pallet_skip_feeless_payment::SkipCheckIfFeeless::from( pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(0, None), ); + let metadata_hash = frame_metadata_hash_extension::CheckMetadataHash::new(false); let extra = ( check_non_zero_sender, check_spec_version, @@ -1050,11 +1064,22 @@ mod tests { check_nonce, check_weight, tx_payment, + metadata_hash, ); let raw_payload = SignedPayload::from_raw( function, extra, - ((), spec_version, transaction_version, genesis_hash, genesis_hash, (), (), ()), + ( + (), + spec_version, + transaction_version, + genesis_hash, + genesis_hash, + (), + (), + (), + None, + ), ); let signature = raw_payload.using_encoded(|payload| signer.sign(payload)); let (function, extra, _) = raw_payload.deconstruct(); diff --git a/substrate/bin/node/cli/tests/basic.rs b/substrate/bin/node/cli/tests/basic.rs index a9eea84d926000fafce766d3aa2889919ef5c376..037ddbb1e47b573df0e019b25a28c09601d95b83 100644 --- a/substrate/bin/node/cli/tests/basic.rs +++ b/substrate/bin/node/cli/tests/basic.rs @@ -22,6 +22,7 @@ use frame_support::{ weights::Weight, }; use frame_system::{self, AccountInfo, EventRecord, Phase}; +use polkadot_sdk::*; use sp_core::{storage::well_known_keys, traits::Externalities}; use sp_runtime::{ traits::Hash as HashT, transaction_validity::InvalidTransaction, ApplyExtrinsicResult, @@ -34,6 +35,7 @@ use kitchensink_runtime::{ }; use node_primitives::{Balance, Hash}; use node_testing::keyring::*; +use pretty_assertions::assert_eq; use wat; pub mod common; @@ -379,6 +381,13 @@ fn full_native_block_import_works() { }), topics: vec![], }, + EventRecord { + phase: Phase::ApplyExtrinsic(1), + event: RuntimeEvent::Balances(pallet_balances::Event::Rescinded { + amount: fees * 2 / 10, + }), + topics: vec![], + }, EventRecord { phase: Phase::ApplyExtrinsic(1), event: RuntimeEvent::TransactionPayment( @@ -464,6 +473,13 @@ fn full_native_block_import_works() { }), topics: vec![], }, + EventRecord { + phase: Phase::ApplyExtrinsic(1), + event: RuntimeEvent::Balances(pallet_balances::Event::Rescinded { + amount: fees - fees * 8 / 10, + }), + topics: vec![], + }, EventRecord { phase: Phase::ApplyExtrinsic(1), event: RuntimeEvent::TransactionPayment( @@ -514,6 +530,13 @@ fn full_native_block_import_works() { }), topics: vec![], }, + EventRecord { + phase: Phase::ApplyExtrinsic(2), + event: RuntimeEvent::Balances(pallet_balances::Event::Rescinded { + amount: fees - fees * 8 / 10, + }), + topics: vec![], + }, EventRecord { phase: Phase::ApplyExtrinsic(2), event: RuntimeEvent::TransactionPayment( @@ -827,7 +850,7 @@ fn should_import_block_with_test_client() { sp_consensus::BlockOrigin, ClientBlockImportExt, TestClientBuilder, TestClientBuilderExt, }; - let mut client = TestClientBuilder::new().build(); + let client = TestClientBuilder::new().build(); let block1 = changes_trie_block(); let block_data = block1.0; let block = node_primitives::Block::decode(&mut &block_data[..]).unwrap(); diff --git a/substrate/bin/node/cli/tests/common.rs b/substrate/bin/node/cli/tests/common.rs index 2d74cdd5a0418aa7f93d7ebadfe3598036fb38ab..95583395f73403959f20162c543617a84d2741fa 100644 --- a/substrate/bin/node/cli/tests/common.rs +++ b/substrate/bin/node/cli/tests/common.rs @@ -18,6 +18,7 @@ use codec::{Decode, Encode}; use frame_support::Hashable; use frame_system::offchain::AppCrypto; +use polkadot_sdk::*; use sc_executor::error::Result; use sp_consensus_babe::{ digests::{PreDigest, SecondaryPlainPreDigest}, @@ -48,7 +49,7 @@ pub const TEST_KEY_TYPE_ID: KeyTypeId = KeyTypeId(*b"test"); pub mod sr25519 { mod app_sr25519 { use super::super::TEST_KEY_TYPE_ID; - use sp_application_crypto::{app_crypto, sr25519}; + use polkadot_sdk::sp_application_crypto::{app_crypto, sr25519}; app_crypto!(sr25519, TEST_KEY_TYPE_ID); } @@ -83,7 +84,7 @@ pub const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_ve pub type TestExternalities = CoreTestExternalities; pub fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic { - node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH) + node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None) } pub fn default_transfer_call() -> pallet_balances::Call { diff --git a/substrate/bin/node/cli/tests/fees.rs b/substrate/bin/node/cli/tests/fees.rs index 69c96bf63a6d8d7b7c24746cdf5c3c48b526c12e..9f82338b4fb03bbe36d09894add142027e419f7e 100644 --- a/substrate/bin/node/cli/tests/fees.rs +++ b/substrate/bin/node/cli/tests/fees.rs @@ -28,6 +28,7 @@ use kitchensink_runtime::{ }; use node_primitives::Balance; use node_testing::keyring::*; +use polkadot_sdk::*; use sp_runtime::{traits::One, Perbill}; pub mod common; diff --git a/substrate/bin/node/cli/tests/res/default_genesis_config.json b/substrate/bin/node/cli/tests/res/default_genesis_config.json index e21fbb47da8c4619e0923c85bf3470828cd80b23..a2e52837d88222b18c42996bd13d400c97d4e920 100644 --- a/substrate/bin/node/cli/tests/res/default_genesis_config.json +++ b/substrate/bin/node/cli/tests/res/default_genesis_config.json @@ -16,6 +16,7 @@ "balances": { "balances": [] }, + "broker": {}, "transactionPayment": { "multiplier": "1000000000000000000" }, @@ -33,7 +34,9 @@ "maxNominatorCount": null }, "session": { - "keys": [] + "keys": [], + "nonAuthorityKeys": [] + }, "democracy": {}, "council": { @@ -74,17 +77,20 @@ "glutton": { "compute": "0", "storage": "0", + "blockLength": "0", "trashDataCount": 0 }, "assets": { "assets": [], "metadata": [], - "accounts": [] + "accounts": [], + "nextAssetId": null }, "poolAssets": { "assets": [], "metadata": [], - "accounts": [] + "accounts": [], + "nextAssetId": null }, "transactionStorage": { "byteFee": 10, diff --git a/substrate/bin/node/cli/tests/submit_transaction.rs b/substrate/bin/node/cli/tests/submit_transaction.rs index 5cbb0103d471b96902bb341bcd796e6cf09eac76..18826e7e90a784e2b644b88024a8d83e3e15f3c1 100644 --- a/substrate/bin/node/cli/tests/submit_transaction.rs +++ b/substrate/bin/node/cli/tests/submit_transaction.rs @@ -18,6 +18,7 @@ use codec::Decode; use frame_system::offchain::{SendSignedTransaction, Signer, SubmitTransaction}; use kitchensink_runtime::{Executive, Indices, Runtime, UncheckedExtrinsic}; +use polkadot_sdk::*; use sp_application_crypto::AppCrypto; use sp_core::offchain::{testing::TestTransactionPoolExt, TransactionPoolExt}; use sp_keyring::sr25519::Keyring::Alice; diff --git a/substrate/bin/node/inspect/Cargo.toml b/substrate/bin/node/inspect/Cargo.toml index 8453aa3cdeb18715afede5d93fb52f3c6b39be7e..6c8a4e59f68d7e2c848463361755b51eeecac668 100644 --- a/substrate/bin/node/inspect/Cargo.toml +++ b/substrate/bin/node/inspect/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate node block inspection tool." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true [lints] @@ -15,17 +15,17 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -clap = { version = "4.5.3", features = ["derive"] } -codec = { package = "parity-scale-codec", version = "3.6.1" } +clap = { features = ["derive"], workspace = true } +codec = { workspace = true, default-features = true } thiserror = { workspace = true } -sc-cli = { path = "../../../client/cli" } -sc-client-api = { path = "../../../client/api" } -sc-service = { path = "../../../client/service", default-features = false } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-core = { path = "../../../primitives/core" } -sp-io = { path = "../../../primitives/io" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-statement-store = { path = "../../../primitives/statement-store" } +sc-cli = { workspace = true } +sc-client-api = { workspace = true, default-features = true } +sc-service = { workspace = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-statement-store = { workspace = true, default-features = true } [features] runtime-benchmarks = [ diff --git a/substrate/bin/node/primitives/Cargo.toml b/substrate/bin/node/primitives/Cargo.toml index 24279ad09c3d9f4576a212d7c67ac24be27b8e22..87271439921a0530675a6d3e8a68801411e9f501 100644 --- a/substrate/bin/node/primitives/Cargo.toml +++ b/substrate/bin/node/primitives/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate node low-level primitives." edition.workspace = true license = "Apache-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -16,8 +16,8 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -sp-core = { path = "../../../primitives/core", default-features = false } -sp-runtime = { path = "../../../primitives/runtime", default-features = false } +sp-core = { workspace = true } +sp-runtime = { workspace = true } [features] default = ["std"] diff --git a/substrate/bin/node/rpc/Cargo.toml b/substrate/bin/node/rpc/Cargo.toml index 894dbf0da85ca56d412087adf01fa12c7983ae7a..02f5d9a4a70258f1259042bbd1b6f3096c70725c 100644 --- a/substrate/bin/node/rpc/Cargo.toml +++ b/substrate/bin/node/rpc/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate node rpc methods." edition.workspace = true license = "Apache-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -16,31 +16,31 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -jsonrpsee = { version = "0.22", features = ["server"] } -node-primitives = { path = "../primitives" } -pallet-transaction-payment-rpc = { path = "../../../frame/transaction-payment/rpc" } -mmr-rpc = { path = "../../../client/merkle-mountain-range/rpc" } -sc-chain-spec = { path = "../../../client/chain-spec" } -sc-client-api = { path = "../../../client/api" } -sc-consensus-babe = { path = "../../../client/consensus/babe" } -sc-consensus-babe-rpc = { path = "../../../client/consensus/babe/rpc" } -sc-consensus-beefy = { path = "../../../client/consensus/beefy" } -sc-consensus-beefy-rpc = { path = "../../../client/consensus/beefy/rpc" } -sc-consensus-grandpa = { path = "../../../client/consensus/grandpa" } -sc-consensus-grandpa-rpc = { path = "../../../client/consensus/grandpa/rpc" } -sc-mixnet = { path = "../../../client/mixnet" } -sc-rpc = { path = "../../../client/rpc" } -sc-rpc-api = { path = "../../../client/rpc-api" } -sc-rpc-spec-v2 = { path = "../../../client/rpc-spec-v2" } -sc-sync-state-rpc = { path = "../../../client/sync-state-rpc" } -sc-transaction-pool-api = { path = "../../../client/transaction-pool/api" } -sp-api = { path = "../../../primitives/api" } -sp-block-builder = { path = "../../../primitives/block-builder" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-babe = { path = "../../../primitives/consensus/babe" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-statement-store = { path = "../../../primitives/statement-store" } -substrate-frame-rpc-system = { path = "../../../utils/frame/rpc/system" } -substrate-state-trie-migration-rpc = { path = "../../../utils/frame/rpc/state-trie-migration-rpc" } +jsonrpsee = { features = ["server"], workspace = true } +node-primitives = { workspace = true, default-features = true } +pallet-transaction-payment-rpc = { workspace = true, default-features = true } +mmr-rpc = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-babe-rpc = { workspace = true, default-features = true } +sc-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-beefy-rpc = { workspace = true, default-features = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sc-consensus-grandpa-rpc = { workspace = true, default-features = true } +sc-mixnet = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sc-sync-state-rpc = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-statement-store = { workspace = true, default-features = true } +substrate-frame-rpc-system = { workspace = true, default-features = true } +substrate-state-trie-migration-rpc = { workspace = true, default-features = true } diff --git a/substrate/bin/node/rpc/src/lib.rs b/substrate/bin/node/rpc/src/lib.rs index 4646524a25babfd7cb1276326d4704abdcc65622..988502bb2bfdc498ce0d9662912a2c93ac074add 100644 --- a/substrate/bin/node/rpc/src/lib.rs +++ b/substrate/bin/node/rpc/src/lib.rs @@ -44,13 +44,14 @@ use sc_consensus_grandpa::{ FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState, }; pub use sc_rpc::SubscriptionTaskExecutor; -pub use sc_rpc_api::DenyUnsafe; use sc_transaction_pool_api::TransactionPool; use sp_api::ProvideRuntimeApi; +use sp_application_crypto::RuntimeAppPublic; use sp_block_builder::BlockBuilder; use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; use sp_consensus::SelectChain; use sp_consensus_babe::BabeApi; +use sp_consensus_beefy::AuthorityIdBound; use sp_keystore::KeystorePtr; /// Extra dependencies for BABE. @@ -76,9 +77,9 @@ pub struct GrandpaDeps { } /// Dependencies for BEEFY -pub struct BeefyDeps { +pub struct BeefyDeps { /// Receives notifications about finality proof events from BEEFY. - pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream, + pub beefy_finality_proof_stream: BeefyVersionedFinalityProofStream, /// Receives notifications about best block events from BEEFY. pub beefy_best_block_stream: BeefyBestBlockStream, /// Executor to drive the subscription manager in the BEEFY RPC handler. @@ -86,7 +87,7 @@ pub struct BeefyDeps { } /// Full client dependencies. -pub struct FullDeps { +pub struct FullDeps { /// The client instance to use. pub client: Arc, /// Transaction pool instance. @@ -95,14 +96,12 @@ pub struct FullDeps { pub select_chain: SC, /// A copy of the chain spec. pub chain_spec: Box, - /// Whether to deny unsafe calls - pub deny_unsafe: DenyUnsafe, /// BABE specific dependencies. pub babe: BabeDeps, /// GRANDPA specific dependencies. pub grandpa: GrandpaDeps, /// BEEFY specific dependencies. - pub beefy: BeefyDeps, + pub beefy: BeefyDeps, /// Shared statement store reference. pub statement_store: Arc, /// The backend used by the node. @@ -112,20 +111,19 @@ pub struct FullDeps { } /// Instantiate all Full RPC extensions. -pub fn create_full( +pub fn create_full( FullDeps { client, pool, select_chain, chain_spec, - deny_unsafe, babe, grandpa, beefy, statement_store, backend, mixnet_api, - }: FullDeps, + }: FullDeps, ) -> Result, Box> where C: ProvideRuntimeApi @@ -145,6 +143,8 @@ where SC: SelectChain + 'static, B: sc_client_api::Backend + Send + Sync + 'static, B::State: sc_client_api::backend::StateBackend>, + AuthorityId: AuthorityIdBound, + ::Signature: Send + Sync, { use mmr_rpc::{Mmr, MmrApiServer}; use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; @@ -156,7 +156,6 @@ where mixnet::MixnetApiServer, statement::StatementApiServer, }; - use sc_rpc_spec_v2::chain_spec::{ChainSpec, ChainSpecApiServer}; use sc_sync_state_rpc::{SyncState, SyncStateApiServer}; use substrate_frame_rpc_system::{System, SystemApiServer}; use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer}; @@ -172,12 +171,7 @@ where finality_provider, } = grandpa; - let chain_name = chain_spec.name().to_string(); - let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); - let properties = chain_spec.properties(); - io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?; - - io.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?; + io.merge(System::new(client.clone(), pool).into_rpc())?; // Making synchronous calls in light client freezes the browser currently, // more context: https://github.com/paritytech/substrate/pull/3480 // These RPCs should use an asynchronous caller instead. @@ -192,8 +186,7 @@ where )?; io.merge(TransactionPayment::new(client.clone()).into_rpc())?; io.merge( - Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain, deny_unsafe) - .into_rpc(), + Babe::new(client.clone(), babe_worker_handle.clone(), keystore, select_chain).into_rpc(), )?; io.merge( Grandpa::new( @@ -211,10 +204,9 @@ where .into_rpc(), )?; - io.merge(StateMigration::new(client.clone(), backend, deny_unsafe).into_rpc())?; - io.merge(Dev::new(client, deny_unsafe).into_rpc())?; - let statement_store = - sc_rpc::statement::StatementStore::new(statement_store, deny_unsafe).into_rpc(); + io.merge(StateMigration::new(client.clone(), backend).into_rpc())?; + io.merge(Dev::new(client).into_rpc())?; + let statement_store = sc_rpc::statement::StatementStore::new(statement_store).into_rpc(); io.merge(statement_store)?; if let Some(mixnet_api) = mixnet_api { @@ -223,7 +215,7 @@ where } io.merge( - Beefy::::new( + Beefy::::new( beefy.beefy_finality_proof_stream, beefy.beefy_best_block_stream, beefy.subscription_executor, diff --git a/substrate/bin/node/runtime/Cargo.toml b/substrate/bin/node/runtime/Cargo.toml index 00eab9b75f60dcc4f5b2c8bee15e61d14f306b3c..6310e16d5a14d4d3e4e3b4053448ba488bb125cb 100644 --- a/substrate/bin/node/runtime/Cargo.toml +++ b/substrate/bin/node/runtime/Cargo.toml @@ -6,7 +6,7 @@ description = "Substrate node kitchensink runtime." edition.workspace = true build = "build.rs" license = "Apache-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -19,420 +19,57 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] # third-party dependencies -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ +codec = { features = [ "derive", "max-encoded-len", -] } -scale-info = { version = "2.11.1", default-features = false, features = ["derive", "serde"] } -static_assertions = "1.1.0" +], workspace = true } +scale-info = { features = ["derive", "serde"], workspace = true } +static_assertions = { workspace = true, default-features = true } log = { workspace = true } serde_json = { features = ["alloc", "arbitrary_precision"], workspace = true } # pallet-asset-conversion: turn on "num-traits" feature -primitive-types = { version = "0.12.0", default-features = false, features = ["codec", "num-traits", "scale-info"] } +primitive-types = { features = ["codec", "num-traits", "scale-info"], workspace = true } -# primitives -sp-authority-discovery = { path = "../../../primitives/authority-discovery", default-features = false, features = ["serde"] } -sp-consensus-babe = { path = "../../../primitives/consensus/babe", default-features = false, features = ["serde"] } -sp-consensus-beefy = { path = "../../../primitives/consensus/beefy", default-features = false } -sp-consensus-grandpa = { path = "../../../primitives/consensus/grandpa", default-features = false, features = ["serde"] } -sp-block-builder = { path = "../../../primitives/block-builder", default-features = false } -sp-genesis-builder = { default-features = false, path = "../../../primitives/genesis-builder" } -sp-inherents = { path = "../../../primitives/inherents", default-features = false } -node-primitives = { path = "../primitives", default-features = false } -sp-mixnet = { path = "../../../primitives/mixnet", default-features = false } -sp-offchain = { path = "../../../primitives/offchain", default-features = false } -sp-core = { path = "../../../primitives/core", default-features = false, features = ["serde"] } -sp-std = { path = "../../../primitives/std", default-features = false } -sp-api = { path = "../../../primitives/api", default-features = false } -sp-runtime = { path = "../../../primitives/runtime", default-features = false, features = ["serde"] } -sp-staking = { path = "../../../primitives/staking", default-features = false, features = ["serde"] } -sp-storage = { path = "../../../primitives/storage", default-features = false } -sp-session = { path = "../../../primitives/session", default-features = false } -sp-transaction-pool = { path = "../../../primitives/transaction-pool", default-features = false } -sp-statement-store = { path = "../../../primitives/statement-store", default-features = false, features = ["serde"] } -sp-version = { path = "../../../primitives/version", default-features = false, features = ["serde"] } -sp-io = { path = "../../../primitives/io", default-features = false } +polkadot-sdk = { features = ["runtime-full", "tuples-96"], workspace = true } -# frame dependencies -frame-executive = { path = "../../../frame/executive", default-features = false } -frame-benchmarking = { path = "../../../frame/benchmarking", default-features = false } -frame-benchmarking-pallet-pov = { path = "../../../frame/benchmarking/pov", default-features = false } -frame-support = { path = "../../../frame/support", default-features = false, features = ["experimental", "tuples-96"] } -frame-system = { path = "../../../frame/system", default-features = false } -frame-system-benchmarking = { path = "../../../frame/system/benchmarking", default-features = false, optional = true } -frame-election-provider-support = { path = "../../../frame/election-provider-support", default-features = false } -frame-system-rpc-runtime-api = { path = "../../../frame/system/rpc/runtime-api", default-features = false } -frame-try-runtime = { path = "../../../frame/try-runtime", default-features = false, optional = true } -pallet-alliance = { path = "../../../frame/alliance", default-features = false } -pallet-asset-conversion = { path = "../../../frame/asset-conversion", default-features = false } -pallet-asset-conversion-ops = { path = "../../../frame/asset-conversion/ops", default-features = false } -pallet-asset-rate = { path = "../../../frame/asset-rate", default-features = false } -pallet-assets = { path = "../../../frame/assets", default-features = false } -pallet-authority-discovery = { path = "../../../frame/authority-discovery", default-features = false } -pallet-authorship = { path = "../../../frame/authorship", default-features = false } -pallet-babe = { path = "../../../frame/babe", default-features = false } -pallet-bags-list = { path = "../../../frame/bags-list", default-features = false } -pallet-balances = { path = "../../../frame/balances", default-features = false } -pallet-beefy = { path = "../../../frame/beefy", default-features = false } -pallet-beefy-mmr = { path = "../../../frame/beefy-mmr", default-features = false } -pallet-bounties = { path = "../../../frame/bounties", default-features = false } -pallet-broker = { path = "../../../frame/broker", default-features = false } -pallet-child-bounties = { path = "../../../frame/child-bounties", default-features = false } -pallet-collective = { path = "../../../frame/collective", default-features = false } -pallet-contracts = { path = "../../../frame/contracts", default-features = false } -pallet-conviction-voting = { path = "../../../frame/conviction-voting", default-features = false } -pallet-core-fellowship = { path = "../../../frame/core-fellowship", default-features = false } -pallet-democracy = { path = "../../../frame/democracy", default-features = false } -pallet-election-provider-multi-phase = { path = "../../../frame/election-provider-multi-phase", default-features = false } -pallet-election-provider-support-benchmarking = { path = "../../../frame/election-provider-support/benchmarking", default-features = false, optional = true } -pallet-elections-phragmen = { path = "../../../frame/elections-phragmen", default-features = false } -pallet-example-tasks = { path = "../../../frame/examples/tasks", default-features = false } -pallet-fast-unstake = { path = "../../../frame/fast-unstake", default-features = false } -pallet-migrations = { path = "../../../frame/migrations", default-features = false } -pallet-example-mbm = { path = "../../../frame/examples/multi-block-migrations", default-features = false } -pallet-nis = { path = "../../../frame/nis", default-features = false } -pallet-grandpa = { path = "../../../frame/grandpa", default-features = false } -pallet-im-online = { path = "../../../frame/im-online", default-features = false } -pallet-indices = { path = "../../../frame/indices", default-features = false } -pallet-identity = { path = "../../../frame/identity", default-features = false } -pallet-lottery = { path = "../../../frame/lottery", default-features = false } -pallet-membership = { path = "../../../frame/membership", default-features = false } -pallet-message-queue = { path = "../../../frame/message-queue", default-features = false } -pallet-mixnet = { path = "../../../frame/mixnet", default-features = false } -pallet-mmr = { path = "../../../frame/merkle-mountain-range", default-features = false } -pallet-multisig = { path = "../../../frame/multisig", default-features = false } -pallet-nfts = { path = "../../../frame/nfts", default-features = false } -pallet-nfts-runtime-api = { path = "../../../frame/nfts/runtime-api", default-features = false } -pallet-nft-fractionalization = { path = "../../../frame/nft-fractionalization", default-features = false } -pallet-nomination-pools = { path = "../../../frame/nomination-pools", default-features = false } -pallet-nomination-pools-benchmarking = { path = "../../../frame/nomination-pools/benchmarking", default-features = false, optional = true } -pallet-nomination-pools-runtime-api = { path = "../../../frame/nomination-pools/runtime-api", default-features = false } -pallet-offences = { path = "../../../frame/offences", default-features = false } -pallet-offences-benchmarking = { path = "../../../frame/offences/benchmarking", default-features = false, optional = true } -pallet-glutton = { path = "../../../frame/glutton", default-features = false } -pallet-preimage = { path = "../../../frame/preimage", default-features = false } -pallet-proxy = { path = "../../../frame/proxy", default-features = false } -pallet-insecure-randomness-collective-flip = { path = "../../../frame/insecure-randomness-collective-flip", default-features = false } -pallet-ranked-collective = { path = "../../../frame/ranked-collective", default-features = false } -pallet-recovery = { path = "../../../frame/recovery", default-features = false } -pallet-referenda = { path = "../../../frame/referenda", default-features = false } -pallet-remark = { path = "../../../frame/remark", default-features = false } -pallet-root-testing = { path = "../../../frame/root-testing", default-features = false } -pallet-salary = { path = "../../../frame/salary", default-features = false } -pallet-session = { path = "../../../frame/session", default-features = false, features = ["historical"] } -pallet-session-benchmarking = { path = "../../../frame/session/benchmarking", default-features = false, optional = true } -pallet-staking = { path = "../../../frame/staking", default-features = false } -pallet-staking-reward-curve = { path = "../../../frame/staking/reward-curve", default-features = false } -pallet-staking-runtime-api = { path = "../../../frame/staking/runtime-api", default-features = false } -pallet-state-trie-migration = { path = "../../../frame/state-trie-migration", default-features = false } -pallet-statement = { path = "../../../frame/statement", default-features = false } -pallet-scheduler = { path = "../../../frame/scheduler", default-features = false } -pallet-society = { path = "../../../frame/society", default-features = false } -pallet-sudo = { path = "../../../frame/sudo", default-features = false } -pallet-timestamp = { path = "../../../frame/timestamp", default-features = false } -pallet-tips = { path = "../../../frame/tips", default-features = false } -pallet-treasury = { path = "../../../frame/treasury", default-features = false } -pallet-utility = { path = "../../../frame/utility", default-features = false } -pallet-transaction-payment = { path = "../../../frame/transaction-payment", default-features = false } -pallet-transaction-payment-rpc-runtime-api = { path = "../../../frame/transaction-payment/rpc/runtime-api", default-features = false } -pallet-asset-conversion-tx-payment = { path = "../../../frame/transaction-payment/asset-conversion-tx-payment", default-features = false } -pallet-asset-tx-payment = { path = "../../../frame/transaction-payment/asset-tx-payment", default-features = false } -pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-feeless-payment", default-features = false } -pallet-transaction-storage = { path = "../../../frame/transaction-storage", default-features = false } -pallet-uniques = { path = "../../../frame/uniques", default-features = false } -pallet-vesting = { path = "../../../frame/vesting", default-features = false } -pallet-whitelist = { path = "../../../frame/whitelist", default-features = false } -pallet-tx-pause = { path = "../../../frame/tx-pause", default-features = false } -pallet-safe-mode = { path = "../../../frame/safe-mode", default-features = false } -pallet-parameters = { path = "../../../frame/parameters", default-features = false } +# shared code between runtime and node +node-primitives = { workspace = true } + +# Example pallets that are not published: +pallet-example-mbm = { workspace = true } +pallet-example-tasks = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] -with-tracing = ["frame-executive/with-tracing"] +with-tracing = ["polkadot-sdk/with-tracing"] std = [ "codec/std", - "frame-benchmarking-pallet-pov/std", - "frame-benchmarking/std", - "frame-election-provider-support/std", - "frame-executive/std", - "frame-support/std", - "frame-system-benchmarking?/std", - "frame-system-rpc-runtime-api/std", - "frame-system/std", - "frame-try-runtime?/std", "log/std", "node-primitives/std", - "pallet-alliance/std", - "pallet-asset-conversion-ops/std", - "pallet-asset-conversion-tx-payment/std", - "pallet-asset-conversion/std", - "pallet-asset-rate/std", - "pallet-asset-tx-payment/std", - "pallet-assets/std", - "pallet-authority-discovery/std", - "pallet-authorship/std", - "pallet-babe/std", - "pallet-bags-list/std", - "pallet-balances/std", - "pallet-beefy-mmr/std", - "pallet-beefy/std", - "pallet-bounties/std", - "pallet-broker/std", - "pallet-child-bounties/std", - "pallet-collective/std", - "pallet-contracts/std", - "pallet-conviction-voting/std", - "pallet-core-fellowship/std", - "pallet-democracy/std", - "pallet-election-provider-multi-phase/std", - "pallet-election-provider-support-benchmarking?/std", - "pallet-elections-phragmen/std", "pallet-example-mbm/std", "pallet-example-tasks/std", - "pallet-fast-unstake/std", - "pallet-glutton/std", - "pallet-grandpa/std", - "pallet-identity/std", - "pallet-im-online/std", - "pallet-indices/std", - "pallet-insecure-randomness-collective-flip/std", - "pallet-lottery/std", - "pallet-membership/std", - "pallet-message-queue/std", - "pallet-migrations/std", - "pallet-mixnet/std", - "pallet-mmr/std", - "pallet-multisig/std", - "pallet-nft-fractionalization/std", - "pallet-nfts-runtime-api/std", - "pallet-nfts/std", - "pallet-nis/std", - "pallet-nomination-pools-benchmarking?/std", - "pallet-nomination-pools-runtime-api/std", - "pallet-nomination-pools/std", - "pallet-offences-benchmarking?/std", - "pallet-offences/std", - "pallet-parameters/std", - "pallet-preimage/std", - "pallet-proxy/std", - "pallet-ranked-collective/std", - "pallet-recovery/std", - "pallet-referenda/std", - "pallet-remark/std", - "pallet-root-testing/std", - "pallet-safe-mode/std", - "pallet-salary/std", - "pallet-scheduler/std", - "pallet-session-benchmarking?/std", - "pallet-session/std", - "pallet-skip-feeless-payment/std", - "pallet-society/std", - "pallet-staking-runtime-api/std", - "pallet-staking/std", - "pallet-state-trie-migration/std", - "pallet-statement/std", - "pallet-sudo/std", - "pallet-timestamp/std", - "pallet-tips/std", - "pallet-transaction-payment-rpc-runtime-api/std", - "pallet-transaction-payment/std", - "pallet-transaction-storage/std", - "pallet-treasury/std", - "pallet-tx-pause/std", - "pallet-uniques/std", - "pallet-utility/std", - "pallet-vesting/std", - "pallet-whitelist/std", + "polkadot-sdk/std", "primitive-types/std", "scale-info/std", "serde_json/std", - "sp-api/std", - "sp-authority-discovery/std", - "sp-block-builder/std", - "sp-consensus-babe/std", - "sp-consensus-beefy/std", - "sp-consensus-grandpa/std", - "sp-core/std", - "sp-genesis-builder/std", - "sp-inherents/std", - "sp-io/std", - "sp-mixnet/std", - "sp-offchain/std", - "sp-runtime/std", - "sp-session/std", - "sp-staking/std", - "sp-statement-store/std", - "sp-std/std", - "sp-storage/std", - "sp-transaction-pool/std", - "sp-version/std", "substrate-wasm-builder", ] runtime-benchmarks = [ - "frame-benchmarking-pallet-pov/runtime-benchmarks", - "frame-benchmarking/runtime-benchmarks", - "frame-election-provider-support/runtime-benchmarks", - "frame-support/runtime-benchmarks", - "frame-system-benchmarking/runtime-benchmarks", - "frame-system/runtime-benchmarks", - "pallet-alliance/runtime-benchmarks", - "pallet-asset-conversion-ops/runtime-benchmarks", - "pallet-asset-conversion/runtime-benchmarks", - "pallet-asset-rate/runtime-benchmarks", - "pallet-asset-tx-payment/runtime-benchmarks", - "pallet-assets/runtime-benchmarks", - "pallet-babe/runtime-benchmarks", - "pallet-bags-list/runtime-benchmarks", - "pallet-balances/runtime-benchmarks", - "pallet-bounties/runtime-benchmarks", - "pallet-broker/runtime-benchmarks", - "pallet-child-bounties/runtime-benchmarks", - "pallet-collective/runtime-benchmarks", - "pallet-contracts/runtime-benchmarks", - "pallet-conviction-voting/runtime-benchmarks", - "pallet-core-fellowship/runtime-benchmarks", - "pallet-democracy/runtime-benchmarks", - "pallet-election-provider-multi-phase/runtime-benchmarks", - "pallet-election-provider-support-benchmarking/runtime-benchmarks", - "pallet-elections-phragmen/runtime-benchmarks", "pallet-example-mbm/runtime-benchmarks", "pallet-example-tasks/runtime-benchmarks", - "pallet-fast-unstake/runtime-benchmarks", - "pallet-glutton/runtime-benchmarks", - "pallet-grandpa/runtime-benchmarks", - "pallet-identity/runtime-benchmarks", - "pallet-im-online/runtime-benchmarks", - "pallet-indices/runtime-benchmarks", - "pallet-lottery/runtime-benchmarks", - "pallet-membership/runtime-benchmarks", - "pallet-message-queue/runtime-benchmarks", - "pallet-migrations/runtime-benchmarks", - "pallet-mixnet/runtime-benchmarks", - "pallet-mmr/runtime-benchmarks", - "pallet-multisig/runtime-benchmarks", - "pallet-nft-fractionalization/runtime-benchmarks", - "pallet-nfts/runtime-benchmarks", - "pallet-nis/runtime-benchmarks", - "pallet-nomination-pools-benchmarking/runtime-benchmarks", - "pallet-nomination-pools/runtime-benchmarks", - "pallet-offences-benchmarking/runtime-benchmarks", - "pallet-offences/runtime-benchmarks", - "pallet-parameters/runtime-benchmarks", - "pallet-preimage/runtime-benchmarks", - "pallet-proxy/runtime-benchmarks", - "pallet-ranked-collective/runtime-benchmarks", - "pallet-recovery/runtime-benchmarks", - "pallet-referenda/runtime-benchmarks", - "pallet-remark/runtime-benchmarks", - "pallet-safe-mode/runtime-benchmarks", - "pallet-salary/runtime-benchmarks", - "pallet-scheduler/runtime-benchmarks", - "pallet-session-benchmarking/runtime-benchmarks", - "pallet-skip-feeless-payment/runtime-benchmarks", - "pallet-society/runtime-benchmarks", - "pallet-staking/runtime-benchmarks", - "pallet-state-trie-migration/runtime-benchmarks", - "pallet-sudo/runtime-benchmarks", - "pallet-timestamp/runtime-benchmarks", - "pallet-tips/runtime-benchmarks", - "pallet-transaction-storage/runtime-benchmarks", - "pallet-treasury/runtime-benchmarks", - "pallet-tx-pause/runtime-benchmarks", - "pallet-uniques/runtime-benchmarks", - "pallet-utility/runtime-benchmarks", - "pallet-vesting/runtime-benchmarks", - "pallet-whitelist/runtime-benchmarks", - "sp-runtime/runtime-benchmarks", - "sp-staking/runtime-benchmarks", + "polkadot-sdk/runtime-benchmarks", ] try-runtime = [ - "frame-benchmarking-pallet-pov/try-runtime", - "frame-election-provider-support/try-runtime", - "frame-executive/try-runtime", - "frame-support/try-runtime", - "frame-system/try-runtime", - "frame-try-runtime/try-runtime", - "pallet-alliance/try-runtime", - "pallet-asset-conversion-ops/try-runtime", - "pallet-asset-conversion-tx-payment/try-runtime", - "pallet-asset-conversion/try-runtime", - "pallet-asset-rate/try-runtime", - "pallet-asset-tx-payment/try-runtime", - "pallet-assets/try-runtime", - "pallet-authority-discovery/try-runtime", - "pallet-authorship/try-runtime", - "pallet-babe/try-runtime", - "pallet-bags-list/try-runtime", - "pallet-balances/try-runtime", - "pallet-beefy-mmr/try-runtime", - "pallet-beefy/try-runtime", - "pallet-bounties/try-runtime", - "pallet-broker/try-runtime", - "pallet-child-bounties/try-runtime", - "pallet-collective/try-runtime", - "pallet-contracts/try-runtime", - "pallet-conviction-voting/try-runtime", - "pallet-core-fellowship/try-runtime", - "pallet-democracy/try-runtime", - "pallet-election-provider-multi-phase/try-runtime", - "pallet-elections-phragmen/try-runtime", "pallet-example-mbm/try-runtime", "pallet-example-tasks/try-runtime", - "pallet-fast-unstake/try-runtime", - "pallet-glutton/try-runtime", - "pallet-grandpa/try-runtime", - "pallet-identity/try-runtime", - "pallet-im-online/try-runtime", - "pallet-indices/try-runtime", - "pallet-insecure-randomness-collective-flip/try-runtime", - "pallet-lottery/try-runtime", - "pallet-membership/try-runtime", - "pallet-message-queue/try-runtime", - "pallet-migrations/try-runtime", - "pallet-mixnet/try-runtime", - "pallet-mmr/try-runtime", - "pallet-multisig/try-runtime", - "pallet-nft-fractionalization/try-runtime", - "pallet-nfts/try-runtime", - "pallet-nis/try-runtime", - "pallet-nomination-pools/try-runtime", - "pallet-offences/try-runtime", - "pallet-parameters/try-runtime", - "pallet-preimage/try-runtime", - "pallet-proxy/try-runtime", - "pallet-ranked-collective/try-runtime", - "pallet-recovery/try-runtime", - "pallet-referenda/try-runtime", - "pallet-remark/try-runtime", - "pallet-root-testing/try-runtime", - "pallet-safe-mode/try-runtime", - "pallet-salary/try-runtime", - "pallet-scheduler/try-runtime", - "pallet-session/try-runtime", - "pallet-skip-feeless-payment/try-runtime", - "pallet-society/try-runtime", - "pallet-staking/try-runtime", - "pallet-state-trie-migration/try-runtime", - "pallet-statement/try-runtime", - "pallet-sudo/try-runtime", - "pallet-timestamp/try-runtime", - "pallet-tips/try-runtime", - "pallet-transaction-payment/try-runtime", - "pallet-transaction-storage/try-runtime", - "pallet-treasury/try-runtime", - "pallet-tx-pause/try-runtime", - "pallet-uniques/try-runtime", - "pallet-utility/try-runtime", - "pallet-vesting/try-runtime", - "pallet-whitelist/try-runtime", - "sp-runtime/try-runtime", + "polkadot-sdk/try-runtime", ] experimental = [ - "frame-support/experimental", - "frame-system/experimental", "pallet-example-tasks/experimental", ] +metadata-hash = ["substrate-wasm-builder/metadata-hash"] +riscv = ["polkadot-sdk/riscv"] diff --git a/substrate/bin/node/runtime/build.rs b/substrate/bin/node/runtime/build.rs index b7676a70dfe843e2cd47fc600ef599bbe7bff591..0e11c579f09ee04918c5d53d4f8779044b57ef30 100644 --- a/substrate/bin/node/runtime/build.rs +++ b/substrate/bin/node/runtime/build.rs @@ -15,13 +15,17 @@ // See the License for the specific language governing permissions and // limitations under the License. +#[cfg(all(feature = "std", not(feature = "metadata-hash")))] fn main() { - #[cfg(feature = "std")] - { - substrate_wasm_builder::WasmBuilder::new() - .with_current_project() - .export_heap_base() - .import_memory() - .build(); - } + substrate_wasm_builder::WasmBuilder::build_using_defaults() } + +#[cfg(all(feature = "std", feature = "metadata-hash"))] +fn main() { + substrate_wasm_builder::WasmBuilder::init_with_defaults() + .enable_metadata_hash("Test", 14) + .build() +} + +#[cfg(not(feature = "std"))] +fn main() {} diff --git a/substrate/bin/node/runtime/src/assets_api.rs b/substrate/bin/node/runtime/src/assets_api.rs index 792ed7c6576bd85485eae9abe84ea17d5749cd13..98187e7391f3e2d316c53da6b52ebdaea97f85fc 100644 --- a/substrate/bin/node/runtime/src/assets_api.rs +++ b/substrate/bin/node/runtime/src/assets_api.rs @@ -18,8 +18,10 @@ //! Runtime API definition for assets. +use polkadot_sdk::*; + +use alloc::vec::Vec; use codec::Codec; -use sp_std::vec::Vec; sp_api::decl_runtime_apis! { pub trait AssetsApi diff --git a/substrate/bin/node/runtime/src/constants.rs b/substrate/bin/node/runtime/src/constants.rs index e4fafbf0fa4790121787788cef8aa2547b226cf3..d13dca48d1f125acdc38217b677279f259a35aa5 100644 --- a/substrate/bin/node/runtime/src/constants.rs +++ b/substrate/bin/node/runtime/src/constants.rs @@ -50,7 +50,7 @@ pub mod time { /// always be assigned, in which case `MILLISECS_PER_BLOCK` and /// `SLOT_DURATION` should have the same value. /// - /// + /// pub const MILLISECS_PER_BLOCK: Moment = 3000; pub const SECS_PER_BLOCK: Moment = MILLISECS_PER_BLOCK / 1000; diff --git a/substrate/bin/node/runtime/src/impls.rs b/substrate/bin/node/runtime/src/impls.rs index 34f043b33a4edfe2d8cdbe154896e937826110ca..43e7a766e0e80c78f46f8f38772b90654e3aae19 100644 --- a/substrate/bin/node/runtime/src/impls.rs +++ b/substrate/bin/node/runtime/src/impls.rs @@ -17,6 +17,7 @@ //! Some configurable implementations as associated type for the substrate runtime. +use alloc::boxed::Box; use frame_support::{ pallet_prelude::*, traits::{ @@ -27,7 +28,7 @@ use frame_support::{ use pallet_alliance::{IdentityVerifier, ProposalIndex, ProposalProvider}; use pallet_asset_tx_payment::HandleCredit; use pallet_identity::legacy::IdentityField; -use sp_std::prelude::*; +use polkadot_sdk::*; use crate::{ AccountId, AllianceCollective, AllianceMotion, Assets, Authorship, Balances, Hash, @@ -62,8 +63,8 @@ impl IdentityVerifier for AllianceIdentityVerifier { } fn has_good_judgement(who: &AccountId) -> bool { - use pallet_identity::Judgement; - crate::Identity::identity(who) + use pallet_identity::{IdentityOf, Judgement}; + IdentityOf::::get(who) .map(|(registration, _)| registration.judgements) .map_or(false, |judgements| { judgements @@ -73,7 +74,8 @@ impl IdentityVerifier for AllianceIdentityVerifier { } fn super_account_id(who: &AccountId) -> Option { - crate::Identity::super_of(who).map(|parent| parent.0) + use pallet_identity::SuperOf; + SuperOf::::get(who).map(|parent| parent.0) } } @@ -118,6 +120,7 @@ mod multiplier_tests { weights::{Weight, WeightToFee}, }; use pallet_transaction_payment::{Multiplier, TargetedFeeAdjustment}; + use polkadot_sdk::*; use sp_runtime::{ assert_eq_error_rate, traits::{Convert, One, Zero}, diff --git a/substrate/bin/node/runtime/src/lib.rs b/substrate/bin/node/runtime/src/lib.rs index 18b0d0c31a4df97010149c12c1e12b3c2d4d5119..ef5c52bf6e6ec88fa7db507e8900e988871ba209 100644 --- a/substrate/bin/node/runtime/src/lib.rs +++ b/substrate/bin/node/runtime/src/lib.rs @@ -22,6 +22,11 @@ // `construct_runtime!` does a lot of recursion and requires us to increase the limits. #![recursion_limit = "1024"] +extern crate alloc; + +use polkadot_sdk::*; + +use alloc::{vec, vec::Vec}; use codec::{Decode, Encode, MaxEncodedLen}; use frame_election_provider_support::{ bounds::{ElectionBounds, ElectionBoundsBuilder}, @@ -47,7 +52,7 @@ use frame_support::{ AsEnsureOriginWithArg, ConstBool, ConstU128, ConstU16, ConstU32, Contains, Currency, EitherOfDiverse, EnsureOriginWithArg, EqualPrivilegeOnly, Imbalance, InsideBoth, InstanceFilter, KeyOwnerProofSystem, LinearStoragePrice, LockIdentifier, Nothing, - OnUnbalanced, WithdrawReasons, + OnUnbalanced, VariantCountOf, WithdrawReasons, }, weights::{ constants::{ @@ -64,6 +69,7 @@ use frame_system::{ pub use node_primitives::{AccountId, Signature}; use node_primitives::{AccountIndex, Balance, BlockNumber, Hash, Moment, Nonce}; use pallet_asset_conversion::{AccountIdConverter, Ascending, Chain, WithFirstAsset}; +use pallet_asset_conversion_tx_payment::SwapAssetAdapter; use pallet_broker::{CoreAssignment, CoreIndex, CoretimeInterface, PartsOf57600}; use pallet_election_provider_multi_phase::{GeometricDepositBase, SolutionAccuracyOf}; use pallet_identity::legacy::IdentityInfo; @@ -73,6 +79,7 @@ use pallet_nis::WithMaximumOf; use pallet_session::historical as pallet_session_historical; // Can't use `FungibleAdapter` here until Treasury pallet migrates to fungibles // +use pallet_broker::TaskId; #[allow(deprecated)] pub use pallet_transaction_payment::{CurrencyAdapter, Multiplier, TargetedFeeAdjustment}; use pallet_transaction_payment::{FeeDetails, RuntimeDispatchInfo}; @@ -91,14 +98,13 @@ use sp_runtime::{ curve::PiecewiseLinear, generic, impl_opaque_keys, traits::{ - self, AccountIdConversion, BlakeTwo256, Block as BlockT, Bounded, ConvertInto, NumberFor, - OpaqueKeys, SaturatedConversion, StaticLookup, + self, AccountIdConversion, BlakeTwo256, Block as BlockT, Bounded, ConvertInto, + MaybeConvert, NumberFor, OpaqueKeys, SaturatedConversion, StaticLookup, }, transaction_validity::{TransactionPriority, TransactionSource, TransactionValidity}, ApplyExtrinsicResult, FixedPointNumber, FixedU128, Perbill, Percent, Permill, Perquintill, RuntimeDebug, }; -use sp_std::prelude::*; #[cfg(any(feature = "std", test))] use sp_version::NativeVersion; use sp_version::RuntimeVersion; @@ -119,7 +125,7 @@ pub use sp_runtime::BuildStorage; pub mod impls; #[cfg(not(feature = "runtime-benchmarks"))] use impls::AllianceIdentityVerifier; -use impls::{AllianceProposalProvider, Author, CreditToBlockAuthor}; +use impls::{AllianceProposalProvider, Author}; /// Constant values used within the runtime. pub mod constants; @@ -185,7 +191,7 @@ type NegativeImbalance = >::NegativeImbalance; pub struct DealWithFees; impl OnUnbalanced for DealWithFees { - fn on_unbalanceds(mut fees_then_tips: impl Iterator) { + fn on_unbalanceds(mut fees_then_tips: impl Iterator) { if let Some(fees) = fees_then_tips.next() { // for fees, 80% to treasury, 20% to author let mut split = fees.ration(80, 20); @@ -540,7 +546,7 @@ impl pallet_balances::Config for Runtime { type AccountStore = frame_system::Pallet; type WeightInfo = pallet_balances::weights::SubstrateWeight; type FreezeIdentifier = RuntimeFreezeReason; - type MaxFreezes = ConstU32<1>; + type MaxFreezes = VariantCountOf; } parameter_types! { @@ -570,22 +576,14 @@ impl pallet_transaction_payment::Config for Runtime { >; } -impl pallet_asset_tx_payment::Config for Runtime { - type RuntimeEvent = RuntimeEvent; - type Fungibles = Assets; - type OnChargeAssetTransaction = pallet_asset_tx_payment::FungiblesAdapter< - pallet_assets::BalanceToAssetBalance, - CreditToBlockAuthor, - >; -} - impl pallet_asset_conversion_tx_payment::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type Fungibles = Assets; - type OnChargeAssetTransaction = pallet_asset_conversion_tx_payment::AssetConversionAdapter< - Balances, - AssetConversion, + type AssetId = NativeOrWithId; + type OnChargeAssetTransaction = SwapAssetAdapter< Native, + NativeAndAssets, + AssetConversion, + ResolveAssetTo, >; } @@ -855,7 +853,7 @@ impl pallet_election_provider_multi_phase::Config for Runtime { type SignedDepositWeight = (); type SignedMaxWeight = MinerMaxWeight; type SlashHandler = (); // burn slashes - type RewardHandler = (); // nothing to do upon rewards + type RewardHandler = (); // rewards are minted from the void type DataProvider = Staking; type Fallback = onchain::OnChainExecution; type GovernanceFallback = onchain::OnChainExecution; @@ -910,7 +908,7 @@ impl pallet_nomination_pools::Config for Runtime { type RewardCounter = FixedU128; type BalanceToU256 = BalanceToU256; type U256ToBalance = U256ToBalance; - type Staking = Staking; + type StakeAdapter = pallet_nomination_pools::adapter::TransferStake; type PostUnbondingPoolsWindow = PostUnbondPoolsWindow; type MaxMetadataLen = ConstU32<256>; type MaxUnbonding = ConstU32<8>; @@ -1036,6 +1034,7 @@ impl pallet_ranked_collective::Config for Runtime { type MinRankOfClass = traits::Identity; type VoteWeight = pallet_ranked_collective::Geometric; type MemberSwappedHandler = (CoreFellowship, Salary); + type MaxMemberCount = (); #[cfg(feature = "runtime-benchmarks")] type BenchmarkSetup = (CoreFellowship, Salary); } @@ -1210,8 +1209,6 @@ impl pallet_membership::Config for Runtime { } parameter_types! { - pub const ProposalBond: Permill = Permill::from_percent(5); - pub const ProposalBondMinimum: Balance = 1 * DOLLARS; pub const SpendPeriod: BlockNumber = 1 * DAYS; pub const Burn: Permill = Permill::from_percent(50); pub const TipCountdown: BlockNumber = 1 * DAYS; @@ -1228,19 +1225,11 @@ parameter_types! { impl pallet_treasury::Config for Runtime { type PalletId = TreasuryPalletId; type Currency = Balances; - type ApproveOrigin = EitherOfDiverse< - EnsureRoot, - pallet_collective::EnsureProportionAtLeast, - >; type RejectOrigin = EitherOfDiverse< EnsureRoot, pallet_collective::EnsureProportionMoreThan, >; type RuntimeEvent = RuntimeEvent; - type OnSlash = (); - type ProposalBond = ProposalBond; - type ProposalBondMinimum = ProposalBondMinimum; - type ProposalBondMaximum = (); type SpendPeriod = SpendPeriod; type Burn = Burn; type BurnDestination = (); @@ -1294,6 +1283,7 @@ impl pallet_bounties::Config for Runtime { type MaximumReasonLength = MaximumReasonLength; type WeightInfo = pallet_bounties::weights::SubstrateWeight; type ChildBountyManager = ChildBounties; + type OnSlash = Treasury; } parameter_types! { @@ -1338,9 +1328,13 @@ impl pallet_tips::Config for Runtime { type TipReportDepositBase = TipReportDepositBase; type MaxTipAmount = ConstU128<{ 500 * DOLLARS }>; type WeightInfo = pallet_tips::weights::SubstrateWeight; + type OnSlash = Treasury; } parameter_types! { + pub const DepositPerItem: Balance = deposit(1, 0); + pub const DepositPerByte: Balance = deposit(0, 1); + pub const DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024); pub Schedule: pallet_contracts::Schedule = Default::default(); pub CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(30); } @@ -1358,9 +1352,9 @@ impl pallet_contracts::Config for Runtime { /// change because that would break already deployed contracts. The `Call` structure itself /// is not allowed to change the indices of existing pallets, too. type CallFilter = Nothing; - type DepositPerItem = dynamic_params::contracts::DepositPerItem; - type DepositPerByte = dynamic_params::contracts::DepositPerByte; - type DefaultDepositLimit = dynamic_params::contracts::DefaultDepositLimit; + type DepositPerItem = DepositPerItem; + type DepositPerByte = DepositPerByte; + type DefaultDepositLimit = DefaultDepositLimit; type CallStack = [pallet_contracts::Frame; 5]; type WeightPrice = pallet_transaction_payment::Pallet; type WeightInfo = pallet_contracts::weights::SubstrateWeight; @@ -1373,6 +1367,7 @@ impl pallet_contracts::Config for Runtime { type UploadOrigin = EnsureSigned; type InstantiateOrigin = EnsureSigned; type MaxDebugBufferLen = ConstU32<{ 2 * 1024 * 1024 }>; + type MaxTransientStorageSize = ConstU32<{ 1 * 1024 * 1024 }>; type RuntimeHoldReason = RuntimeHoldReason; #[cfg(not(feature = "runtime-benchmarks"))] type Migrations = (); @@ -1386,6 +1381,34 @@ impl pallet_contracts::Config for Runtime { type Xcm = (); } +impl pallet_revive::Config for Runtime { + type Time = Timestamp; + type Currency = Balances; + type RuntimeEvent = RuntimeEvent; + type RuntimeCall = RuntimeCall; + type CallFilter = Nothing; + type DepositPerItem = DepositPerItem; + type DepositPerByte = DepositPerByte; + type WeightPrice = pallet_transaction_payment::Pallet; + type WeightInfo = pallet_revive::weights::SubstrateWeight; + type ChainExtension = (); + type AddressGenerator = pallet_revive::DefaultAddressGenerator; + type MaxCodeLen = ConstU32<{ 123 * 1024 }>; + type RuntimeMemory = ConstU32<{ 128 * 1024 * 1024 }>; + type PVFMemory = ConstU32<{ 512 * 1024 * 1024 }>; + type UnsafeUnstableInterface = ConstBool; + type UploadOrigin = EnsureSigned; + type InstantiateOrigin = EnsureSigned; + type RuntimeHoldReason = RuntimeHoldReason; + #[cfg(not(feature = "runtime-benchmarks"))] + type Migrations = (); + #[cfg(feature = "runtime-benchmarks")] + type Migrations = pallet_revive::migration::codegen::BenchMigrations; + type CodeHashLockupDepositPercent = CodeHashLockupDepositPercent; + type Debug = (); + type Xcm = (); +} + impl pallet_sudo::Config for Runtime { type RuntimeEvent = RuntimeEvent; type RuntimeCall = RuntimeCall; @@ -1434,6 +1457,7 @@ where tip, None, ), ), + frame_metadata_hash_extension::CheckMetadataHash::new(false), ); let raw_payload = SignedPayload::new(call, extra) .map_err(|e| { @@ -1603,6 +1627,8 @@ impl pallet_mmr::Config for Runtime { type OnNewRoot = pallet_beefy_mmr::DepositBeefyDigest; type BlockHashProvider = pallet_mmr::DefaultBlockHashProvider; type WeightInfo = (); + #[cfg(feature = "runtime-benchmarks")] + type BenchmarkHelper = (); } parameter_types! { @@ -1614,6 +1640,7 @@ impl pallet_beefy_mmr::Config for Runtime { type BeefyAuthorityToMerkleLeaf = pallet_beefy_mmr::BeefyEcdsaToEthereum; type LeafExtra = Vec; type BeefyDataProvider = (); + type WeightInfo = (); } parameter_types! { @@ -1701,12 +1728,15 @@ parameter_types! { pub const Native: NativeOrWithId = NativeOrWithId::Native; } +pub type NativeAndAssets = + UnionOf, AccountId>; + impl pallet_asset_conversion::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Balance = u128; type HigherPrecisionBalance = sp_core::U256; type AssetKind = NativeOrWithId; - type Assets = UnionOf, AccountId>; + type Assets = NativeAndAssets; type PoolId = (Self::AssetKind, Self::AssetKind); type PoolLocator = Chain< WithFirstAsset< @@ -1868,7 +1898,9 @@ impl pallet_core_fellowship::Config for Runtime { type InductOrigin = pallet_core_fellowship::EnsureInducted; type ApproveOrigin = EnsureRootWithSuccess>; type PromoteOrigin = EnsureRootWithSuccess>; + type FastPromoteOrigin = Self::PromoteOrigin; type EvidenceSize = ConstU32<16_384>; + type MaxRank = ConstU32<9>; } parameter_types! { @@ -2096,10 +2128,6 @@ impl OnUnbalanced> for IntoAuthor { } } -parameter_types! { - pub storage CoretimeRevenue: Option<(BlockNumber, Balance)> = None; -} - pub struct CoretimeProvider; impl CoretimeInterface for CoretimeProvider { type AccountId = AccountId; @@ -2115,17 +2143,17 @@ impl CoretimeInterface for CoretimeProvider { _end_hint: Option, ) { } - fn check_notify_revenue_info() -> Option<(u32, Self::Balance)> { - let revenue = CoretimeRevenue::get(); - CoretimeRevenue::set(&None); - revenue - } - #[cfg(feature = "runtime-benchmarks")] - fn ensure_notify_revenue_info(when: u32, revenue: Self::Balance) { - CoretimeRevenue::set(&Some((when, revenue))); - } } +pub struct SovereignAccountOf; +// Dummy implementation which converts `TaskId` to `AccountId`. +impl MaybeConvert for SovereignAccountOf { + fn maybe_convert(task: TaskId) -> Option { + let mut account: [u8; 32] = [0; 32]; + account[..4].copy_from_slice(&task.to_le_bytes()); + Some(account.into()) + } +} impl pallet_broker::Config for Runtime { type RuntimeEvent = RuntimeEvent; type Currency = Balances; @@ -2138,7 +2166,9 @@ impl pallet_broker::Config for Runtime { type WeightInfo = (); type PalletId = BrokerPalletId; type AdminOrigin = EnsureRoot; - type PriceAdapter = pallet_broker::Linear; + type SovereignAccountOf = SovereignAccountOf; + type MaxAutoRenewals = ConstU32<10>; + type PriceAdapter = pallet_broker::CenterTargetPrice; } parameter_types! { @@ -2181,19 +2211,6 @@ pub mod dynamic_params { #[codec(index = 1)] pub static ByteDeposit: Balance = 1 * CENTS; } - - #[dynamic_pallet_params] - #[codec(index = 1)] - pub mod contracts { - #[codec(index = 0)] - pub static DepositPerItem: Balance = deposit(1, 0); - - #[codec(index = 1)] - pub static DepositPerByte: Balance = deposit(0, 1); - - #[codec(index = 2)] - pub static DefaultDepositLimit: Balance = deposit(1024, 1024 * 1024); - } } #[cfg(feature = "runtime-benchmarks")] @@ -2219,10 +2236,6 @@ impl EnsureOriginWithArg for DynamicParamet frame_system::ensure_root(origin.clone()).map_err(|_| origin)?; return Ok(()) }, - RuntimeParametersKey::Contracts(_) => { - frame_system::ensure_root(origin.clone()).map_err(|_| origin)?; - return Ok(()) - }, } } @@ -2241,6 +2254,8 @@ impl pallet_parameters::Config for Runtime { #[frame_support::runtime] mod runtime { + use super::*; + #[runtime::runtime] #[runtime::derive( RuntimeCall, @@ -2256,248 +2271,248 @@ mod runtime { pub struct Runtime; #[runtime::pallet_index(0)] - pub type System = frame_system; + pub type System = frame_system::Pallet; #[runtime::pallet_index(1)] - pub type Utility = pallet_utility; + pub type Utility = pallet_utility::Pallet; #[runtime::pallet_index(2)] - pub type Babe = pallet_babe; + pub type Babe = pallet_babe::Pallet; #[runtime::pallet_index(3)] - pub type Timestamp = pallet_timestamp; + pub type Timestamp = pallet_timestamp::Pallet; // Authorship must be before session in order to note author in the correct session and era // for im-online and staking. #[runtime::pallet_index(4)] - pub type Authorship = pallet_authorship; + pub type Authorship = pallet_authorship::Pallet; #[runtime::pallet_index(5)] - pub type Indices = pallet_indices; + pub type Indices = pallet_indices::Pallet; #[runtime::pallet_index(6)] - pub type Balances = pallet_balances; + pub type Balances = pallet_balances::Pallet; #[runtime::pallet_index(7)] - pub type TransactionPayment = pallet_transaction_payment; - - #[runtime::pallet_index(8)] - pub type AssetTxPayment = pallet_asset_tx_payment; + pub type TransactionPayment = pallet_transaction_payment::Pallet; #[runtime::pallet_index(9)] - pub type AssetConversionTxPayment = pallet_asset_conversion_tx_payment; + pub type AssetConversionTxPayment = pallet_asset_conversion_tx_payment::Pallet; #[runtime::pallet_index(10)] - pub type ElectionProviderMultiPhase = pallet_election_provider_multi_phase; + pub type ElectionProviderMultiPhase = pallet_election_provider_multi_phase::Pallet; #[runtime::pallet_index(11)] - pub type Staking = pallet_staking; + pub type Staking = pallet_staking::Pallet; #[runtime::pallet_index(12)] - pub type Session = pallet_session; + pub type Session = pallet_session::Pallet; #[runtime::pallet_index(13)] - pub type Democracy = pallet_democracy; + pub type Democracy = pallet_democracy::Pallet; #[runtime::pallet_index(14)] - pub type Council = pallet_collective; + pub type Council = pallet_collective::Pallet; #[runtime::pallet_index(15)] - pub type TechnicalCommittee = pallet_collective; + pub type TechnicalCommittee = pallet_collective::Pallet; #[runtime::pallet_index(16)] - pub type Elections = pallet_elections_phragmen; + pub type Elections = pallet_elections_phragmen::Pallet; #[runtime::pallet_index(17)] - pub type TechnicalMembership = pallet_membership; + pub type TechnicalMembership = pallet_membership::Pallet; #[runtime::pallet_index(18)] - pub type Grandpa = pallet_grandpa; + pub type Grandpa = pallet_grandpa::Pallet; #[runtime::pallet_index(19)] - pub type Treasury = pallet_treasury; + pub type Treasury = pallet_treasury::Pallet; #[runtime::pallet_index(20)] - pub type AssetRate = pallet_asset_rate; + pub type AssetRate = pallet_asset_rate::Pallet; #[runtime::pallet_index(21)] - pub type Contracts = pallet_contracts; + pub type Contracts = pallet_contracts::Pallet; #[runtime::pallet_index(22)] - pub type Sudo = pallet_sudo; + pub type Sudo = pallet_sudo::Pallet; #[runtime::pallet_index(23)] - pub type ImOnline = pallet_im_online; + pub type ImOnline = pallet_im_online::Pallet; #[runtime::pallet_index(24)] - pub type AuthorityDiscovery = pallet_authority_discovery; + pub type AuthorityDiscovery = pallet_authority_discovery::Pallet; #[runtime::pallet_index(25)] - pub type Offences = pallet_offences; + pub type Offences = pallet_offences::Pallet; #[runtime::pallet_index(26)] - pub type Historical = pallet_session_historical; + pub type Historical = pallet_session_historical::Pallet; #[runtime::pallet_index(27)] - pub type RandomnessCollectiveFlip = pallet_insecure_randomness_collective_flip; + pub type RandomnessCollectiveFlip = pallet_insecure_randomness_collective_flip::Pallet; #[runtime::pallet_index(28)] - pub type Identity = pallet_identity; + pub type Identity = pallet_identity::Pallet; #[runtime::pallet_index(29)] - pub type Society = pallet_society; + pub type Society = pallet_society::Pallet; #[runtime::pallet_index(30)] - pub type Recovery = pallet_recovery; + pub type Recovery = pallet_recovery::Pallet; #[runtime::pallet_index(31)] - pub type Vesting = pallet_vesting; + pub type Vesting = pallet_vesting::Pallet; #[runtime::pallet_index(32)] - pub type Scheduler = pallet_scheduler; + pub type Scheduler = pallet_scheduler::Pallet; #[runtime::pallet_index(33)] - pub type Glutton = pallet_glutton; + pub type Glutton = pallet_glutton::Pallet; #[runtime::pallet_index(34)] - pub type Preimage = pallet_preimage; + pub type Preimage = pallet_preimage::Pallet; #[runtime::pallet_index(35)] - pub type Proxy = pallet_proxy; + pub type Proxy = pallet_proxy::Pallet; #[runtime::pallet_index(36)] - pub type Multisig = pallet_multisig; + pub type Multisig = pallet_multisig::Pallet; #[runtime::pallet_index(37)] - pub type Bounties = pallet_bounties; + pub type Bounties = pallet_bounties::Pallet; #[runtime::pallet_index(38)] - pub type Tips = pallet_tips; + pub type Tips = pallet_tips::Pallet; #[runtime::pallet_index(39)] - pub type Assets = pallet_assets; + pub type Assets = pallet_assets::Pallet; #[runtime::pallet_index(40)] - pub type PoolAssets = pallet_assets; + pub type PoolAssets = pallet_assets::Pallet; #[runtime::pallet_index(41)] - pub type Beefy = pallet_beefy; + pub type Beefy = pallet_beefy::Pallet; // MMR leaf construction must be after session in order to have a leaf's next_auth_set // refer to block. See issue polkadot-fellows/runtimes#160 for details. #[runtime::pallet_index(42)] - pub type Mmr = pallet_mmr; + pub type Mmr = pallet_mmr::Pallet; #[runtime::pallet_index(43)] - pub type MmrLeaf = pallet_beefy_mmr; + pub type MmrLeaf = pallet_beefy_mmr::Pallet; #[runtime::pallet_index(44)] - pub type Lottery = pallet_lottery; + pub type Lottery = pallet_lottery::Pallet; #[runtime::pallet_index(45)] - pub type Nis = pallet_nis; + pub type Nis = pallet_nis::Pallet; #[runtime::pallet_index(46)] - pub type Uniques = pallet_uniques; + pub type Uniques = pallet_uniques::Pallet; #[runtime::pallet_index(47)] - pub type Nfts = pallet_nfts; + pub type Nfts = pallet_nfts::Pallet; #[runtime::pallet_index(48)] - pub type NftFractionalization = pallet_nft_fractionalization; + pub type NftFractionalization = pallet_nft_fractionalization::Pallet; #[runtime::pallet_index(49)] - pub type Salary = pallet_salary; + pub type Salary = pallet_salary::Pallet; #[runtime::pallet_index(50)] - pub type CoreFellowship = pallet_core_fellowship; + pub type CoreFellowship = pallet_core_fellowship::Pallet; #[runtime::pallet_index(51)] - pub type TransactionStorage = pallet_transaction_storage; + pub type TransactionStorage = pallet_transaction_storage::Pallet; #[runtime::pallet_index(52)] - pub type VoterList = pallet_bags_list; + pub type VoterList = pallet_bags_list::Pallet; #[runtime::pallet_index(53)] - pub type StateTrieMigration = pallet_state_trie_migration; + pub type StateTrieMigration = pallet_state_trie_migration::Pallet; #[runtime::pallet_index(54)] - pub type ChildBounties = pallet_child_bounties; + pub type ChildBounties = pallet_child_bounties::Pallet; #[runtime::pallet_index(55)] - pub type Referenda = pallet_referenda; + pub type Referenda = pallet_referenda::Pallet; #[runtime::pallet_index(56)] - pub type Remark = pallet_remark; + pub type Remark = pallet_remark::Pallet; #[runtime::pallet_index(57)] - pub type RootTesting = pallet_root_testing; + pub type RootTesting = pallet_root_testing::Pallet; #[runtime::pallet_index(58)] - pub type ConvictionVoting = pallet_conviction_voting; + pub type ConvictionVoting = pallet_conviction_voting::Pallet; #[runtime::pallet_index(59)] - pub type Whitelist = pallet_whitelist; + pub type Whitelist = pallet_whitelist::Pallet; #[runtime::pallet_index(60)] - pub type AllianceMotion = pallet_collective; + pub type AllianceMotion = pallet_collective::Pallet; #[runtime::pallet_index(61)] - pub type Alliance = pallet_alliance; + pub type Alliance = pallet_alliance::Pallet; #[runtime::pallet_index(62)] - pub type NominationPools = pallet_nomination_pools; + pub type NominationPools = pallet_nomination_pools::Pallet; #[runtime::pallet_index(63)] - pub type RankedPolls = pallet_referenda; + pub type RankedPolls = pallet_referenda::Pallet; #[runtime::pallet_index(64)] - pub type RankedCollective = pallet_ranked_collective; + pub type RankedCollective = pallet_ranked_collective::Pallet; #[runtime::pallet_index(65)] - pub type AssetConversion = pallet_asset_conversion; + pub type AssetConversion = pallet_asset_conversion::Pallet; #[runtime::pallet_index(66)] - pub type FastUnstake = pallet_fast_unstake; + pub type FastUnstake = pallet_fast_unstake::Pallet; #[runtime::pallet_index(67)] - pub type MessageQueue = pallet_message_queue; + pub type MessageQueue = pallet_message_queue::Pallet; #[runtime::pallet_index(68)] - pub type Pov = frame_benchmarking_pallet_pov; + pub type Pov = frame_benchmarking_pallet_pov::Pallet; #[runtime::pallet_index(69)] - pub type TxPause = pallet_tx_pause; + pub type TxPause = pallet_tx_pause::Pallet; #[runtime::pallet_index(70)] - pub type SafeMode = pallet_safe_mode; + pub type SafeMode = pallet_safe_mode::Pallet; #[runtime::pallet_index(71)] - pub type Statement = pallet_statement; + pub type Statement = pallet_statement::Pallet; #[runtime::pallet_index(72)] - pub type MultiBlockMigrations = pallet_migrations; + pub type MultiBlockMigrations = pallet_migrations::Pallet; #[runtime::pallet_index(73)] - pub type Broker = pallet_broker; + pub type Broker = pallet_broker::Pallet; #[runtime::pallet_index(74)] - pub type TasksExample = pallet_example_tasks; + pub type TasksExample = pallet_example_tasks::Pallet; #[runtime::pallet_index(75)] - pub type Mixnet = pallet_mixnet; + pub type Mixnet = pallet_mixnet::Pallet; #[runtime::pallet_index(76)] - pub type Parameters = pallet_parameters; + pub type Parameters = pallet_parameters::Pallet; #[runtime::pallet_index(77)] - pub type SkipFeelessPayment = pallet_skip_feeless_payment; + pub type SkipFeelessPayment = pallet_skip_feeless_payment::Pallet; #[runtime::pallet_index(78)] - pub type PalletExampleMbms = pallet_example_mbm; + pub type PalletExampleMbms = pallet_example_mbm::Pallet; #[runtime::pallet_index(79)] - pub type AssetConversionMigration = pallet_asset_conversion_ops; + pub type AssetConversionMigration = pallet_asset_conversion_ops::Pallet; + + #[runtime::pallet_index(80)] + pub type Revive = pallet_revive::Pallet; } /// The address format for describing accounts. @@ -2527,6 +2542,7 @@ pub type SignedExtra = ( Runtime, pallet_asset_conversion_tx_payment::ChargeAssetTxPayment, >, + frame_metadata_hash_extension::CheckMetadataHash, ); /// Unchecked extrinsic type as expected by this runtime. @@ -2556,6 +2572,7 @@ type Migrations = ( pallet_nomination_pools::migration::versioned::V6ToV7, pallet_alliance::migration::Migration, pallet_contracts::Migration, + pallet_revive::Migration, pallet_identity::migration::versioned::V0ToV1, ); @@ -2574,6 +2591,7 @@ impl pallet_beefy::Config for Runtime { type MaxNominators = ConstU32<0>; type MaxSetIdSessionEntries = BeefySetIdSessionEntries; type OnNewValidatorSet = MmrLeaf; + type AncestryHelper = MmrLeaf; type WeightInfo = (); type KeyOwnerProof = >::Proof; type EquivocationReportSystem = @@ -2582,7 +2600,7 @@ impl pallet_beefy::Config for Runtime { /// MMR helper types. mod mmr { - use super::Runtime; + use super::*; pub use pallet_mmr::primitives::*; pub type Leaf = <::LeafData as LeafDataProvider>::LeafData; @@ -2592,7 +2610,7 @@ mod mmr { #[cfg(feature = "runtime-benchmarks")] mod benches { - frame_benchmarking::define_benchmarks!( + polkadot_sdk::frame_benchmarking::define_benchmarks!( [frame_benchmarking, BaselineBench::] [frame_benchmarking_pallet_pov, Pov] [pallet_alliance, Alliance] @@ -2600,12 +2618,14 @@ mod benches { [pallet_babe, Babe] [pallet_bags_list, VoterList] [pallet_balances, Balances] + [pallet_beefy_mmr, MmrLeaf] [pallet_bounties, Bounties] [pallet_broker, Broker] [pallet_child_bounties, ChildBounties] [pallet_collective, Council] [pallet_conviction_voting, ConvictionVoting] [pallet_contracts, Contracts] + [pallet_revive, Revive] [pallet_core_fellowship, CoreFellowship] [tasks_example, TasksExample] [pallet_democracy, Democracy] @@ -2685,7 +2705,7 @@ impl_runtime_apis! { Runtime::metadata_at_version(version) } - fn metadata_versions() -> sp_std::vec::Vec { + fn metadata_versions() -> alloc::vec::Vec { Runtime::metadata_versions() } } @@ -2781,6 +2801,30 @@ impl_runtime_apis! { fn balance_to_points(pool_id: pallet_nomination_pools::PoolId, new_funds: Balance) -> Balance { NominationPools::api_balance_to_points(pool_id, new_funds) } + + fn pool_pending_slash(pool_id: pallet_nomination_pools::PoolId) -> Balance { + NominationPools::api_pool_pending_slash(pool_id) + } + + fn member_pending_slash(member: AccountId) -> Balance { + NominationPools::api_member_pending_slash(member) + } + + fn pool_needs_delegate_migration(pool_id: pallet_nomination_pools::PoolId) -> bool { + NominationPools::api_pool_needs_delegate_migration(pool_id) + } + + fn member_needs_delegate_migration(member: AccountId) -> bool { + NominationPools::api_member_needs_delegate_migration(member) + } + + fn member_total_balance(member: AccountId) -> Balance { + NominationPools::api_member_total_balance(member) + } + + fn pool_balance(pool_id: pallet_nomination_pools::PoolId) -> Balance { + NominationPools::api_pool_balance(pool_id) + } } impl pallet_staking_runtime_api::StakingApi for Runtime { @@ -2944,6 +2988,75 @@ impl_runtime_apis! { } } + impl pallet_revive::ReviveApi for Runtime + { + fn call( + origin: AccountId, + dest: AccountId, + value: Balance, + gas_limit: Option, + storage_deposit_limit: Option, + input_data: Vec, + ) -> pallet_revive::ContractExecResult { + Revive::bare_call( + RuntimeOrigin::signed(origin), + dest, + value, + gas_limit.unwrap_or(RuntimeBlockWeights::get().max_block), + storage_deposit_limit.unwrap_or(u128::MAX), + input_data, + pallet_revive::DebugInfo::UnsafeDebug, + pallet_revive::CollectEvents::UnsafeCollect, + ) + } + + fn instantiate( + origin: AccountId, + value: Balance, + gas_limit: Option, + storage_deposit_limit: Option, + code: pallet_revive::Code, + data: Vec, + salt: Vec, + ) -> pallet_revive::ContractInstantiateResult + { + Revive::bare_instantiate( + RuntimeOrigin::signed(origin), + value, + gas_limit.unwrap_or(RuntimeBlockWeights::get().max_block), + storage_deposit_limit.unwrap_or(u128::MAX), + code, + data, + salt, + pallet_revive::DebugInfo::UnsafeDebug, + pallet_revive::CollectEvents::UnsafeCollect, + ) + } + + fn upload_code( + origin: AccountId, + code: Vec, + storage_deposit_limit: Option, + ) -> pallet_revive::CodeUploadResult + { + Revive::bare_upload_code( + RuntimeOrigin::signed(origin), + code, + storage_deposit_limit.unwrap_or(u128::MAX), + ) + } + + fn get_storage( + address: AccountId, + key: Vec, + ) -> pallet_revive::GetStorageResult { + Revive::get_storage( + address, + key + ) + } + } + impl pallet_transaction_payment_rpc_runtime_api::TransactionPaymentApi< Block, Balance, @@ -3042,7 +3155,7 @@ impl_runtime_apis! { } } - #[api_version(3)] + #[api_version(5)] impl sp_consensus_beefy::BeefyApi for Runtime { fn beefy_genesis() -> Option { pallet_beefy::GenesisBlock::::get() @@ -3052,7 +3165,7 @@ impl_runtime_apis! { Beefy::validator_set() } - fn submit_report_equivocation_unsigned_extrinsic( + fn submit_report_double_voting_unsigned_extrinsic( equivocation_proof: sp_consensus_beefy::DoubleVotingProof< BlockNumber, BeefyId, @@ -3062,12 +3175,37 @@ impl_runtime_apis! { ) -> Option<()> { let key_owner_proof = key_owner_proof.decode()?; - Beefy::submit_unsigned_equivocation_report( + Beefy::submit_unsigned_double_voting_report( equivocation_proof, key_owner_proof, ) } + fn submit_report_fork_voting_unsigned_extrinsic( + equivocation_proof: + sp_consensus_beefy::ForkVotingProof< + ::Header, + BeefyId, + sp_runtime::OpaqueValue + >, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_fork_voting_report( + equivocation_proof.try_into()?, + key_owner_proof.decode()?, + ) + } + + fn submit_report_future_block_voting_unsigned_extrinsic( + equivocation_proof: sp_consensus_beefy::FutureBlockVotingProof, + key_owner_proof: sp_consensus_beefy::OpaqueKeyOwnershipProof, + ) -> Option<()> { + Beefy::submit_unsigned_future_block_voting_report( + equivocation_proof, + key_owner_proof.decode()?, + ) + } + fn generate_key_ownership_proof( _set_id: sp_consensus_beefy::ValidatorSetId, authority_id: BeefyId, @@ -3076,6 +3214,17 @@ impl_runtime_apis! { .map(|p| p.encode()) .map(sp_consensus_beefy::OpaqueKeyOwnershipProof::new) } + + fn generate_ancestry_proof( + prev_block_number: BlockNumber, + best_known_block_number: Option, + ) -> Option { + use sp_consensus_beefy::AncestryHelper; + + MmrLeaf::generate_proof(prev_block_number, best_known_block_number) + .map(|p| p.encode()) + .map(sp_runtime::OpaqueValue::new) + } } impl pallet_mmr::primitives::MmrApi< @@ -3094,7 +3243,7 @@ impl_runtime_apis! { fn generate_proof( block_numbers: Vec, best_known_block_number: Option, - ) -> Result<(Vec, mmr::Proof), mmr::Error> { + ) -> Result<(Vec, mmr::LeafProof), mmr::Error> { Mmr::generate_proof(block_numbers, best_known_block_number).map( |(leaves, proof)| { ( @@ -3108,7 +3257,7 @@ impl_runtime_apis! { ) } - fn verify_proof(leaves: Vec, proof: mmr::Proof) + fn verify_proof(leaves: Vec, proof: mmr::LeafProof) -> Result<(), mmr::Error> { let leaves = leaves.into_iter().map(|leaf| @@ -3121,7 +3270,7 @@ impl_runtime_apis! { fn verify_proof_stateless( root: mmr::Hash, leaves: Vec, - proof: mmr::Proof + proof: mmr::LeafProof ) -> Result<(), mmr::Error> { let nodes = leaves.into_iter().map(|leaf|mmr::DataOrHash::Data(leaf.into_opaque_leaf())).collect(); pallet_mmr::verify_leaves_proof::(root, nodes, proof) diff --git a/substrate/bin/node/testing/Cargo.toml b/substrate/bin/node/testing/Cargo.toml index fa3f90193ba5d11325bfb068fa69780495ec8c90..a5cec856717f676898b883954dafedecf900759f 100644 --- a/substrate/bin/node/testing/Cargo.toml +++ b/substrate/bin/node/testing/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Test utilities for Substrate node." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true publish = false @@ -16,35 +16,36 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -fs_extra = "1" -futures = "0.3.30" +codec = { workspace = true, default-features = true } +fs_extra = { workspace = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -tempfile = "3.1.0" -frame-system = { path = "../../../frame/system" } -node-cli = { package = "staging-node-cli", path = "../cli" } -node-primitives = { path = "../primitives" } -kitchensink-runtime = { path = "../runtime" } -pallet-asset-conversion = { path = "../../../frame/asset-conversion" } -pallet-assets = { path = "../../../frame/assets" } -pallet-asset-conversion-tx-payment = { path = "../../../frame/transaction-payment/asset-conversion-tx-payment" } -pallet-asset-tx-payment = { path = "../../../frame/transaction-payment/asset-tx-payment" } -pallet-skip-feeless-payment = { path = "../../../frame/transaction-payment/skip-feeless-payment" } -sc-block-builder = { path = "../../../client/block-builder" } -sc-client-api = { path = "../../../client/api" } -sc-client-db = { path = "../../../client/db", features = ["rocksdb"] } -sc-consensus = { path = "../../../client/consensus/common" } -sc-executor = { path = "../../../client/executor" } -sc-service = { path = "../../../client/service", features = ["rocksdb", "test-helpers"] } -sp-api = { path = "../../../primitives/api" } -sp-block-builder = { path = "../../../primitives/block-builder" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-core = { path = "../../../primitives/core" } -sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-io = { path = "../../../primitives/io" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-timestamp = { path = "../../../primitives/timestamp", default-features = false } -substrate-test-client = { path = "../../../test-utils/client" } +tempfile = { workspace = true } +frame-metadata-hash-extension = { workspace = true, default-features = true } +frame-system = { workspace = true, default-features = true } +node-cli = { workspace = true } +node-primitives = { workspace = true, default-features = true } +kitchensink-runtime = { workspace = true } +pallet-asset-conversion = { workspace = true, default-features = true } +pallet-assets = { workspace = true, default-features = true } +pallet-asset-conversion-tx-payment = { workspace = true, default-features = true } +pallet-asset-tx-payment = { workspace = true, default-features = true } +pallet-skip-feeless-payment = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-client-db = { features = ["rocksdb"], workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-service = { features = ["rocksdb", "test-helpers"], workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-timestamp = { workspace = true } +substrate-test-client = { workspace = true } diff --git a/substrate/bin/node/testing/src/bench.rs b/substrate/bin/node/testing/src/bench.rs index e5c2563905e9ea59901db1564f2b0f34f6bd4aec..007d314684cf17faeda6adb4842513ea57030fdc 100644 --- a/substrate/bin/node/testing/src/bench.rs +++ b/substrate/bin/node/testing/src/bench.rs @@ -571,6 +571,8 @@ impl BenchKeyring { tx_version, genesis_hash, genesis_hash, + // metadata_hash + None::<()>, ); let key = self.accounts.get(&signed).expect("Account id not found in keyring"); let signature = payload.using_encoded(|b| { diff --git a/substrate/bin/node/testing/src/genesis.rs b/substrate/bin/node/testing/src/genesis.rs index c79612d68444c8bd64ad18c3b0a74ceed176eff8..7f5364744c667f711a5e2c32e20636e904ee02c2 100644 --- a/substrate/bin/node/testing/src/genesis.rs +++ b/substrate/bin/node/testing/src/genesis.rs @@ -54,6 +54,7 @@ pub fn config_endowed(extra_endowed: Vec) -> RuntimeGenesisConfig { (bob(), eve(), session_keys_from_seed(Ed25519Keyring::Bob.into())), (charlie(), ferdie(), session_keys_from_seed(Ed25519Keyring::Charlie.into())), ], + ..Default::default() }, staking: StakingConfig { stakers: vec![ diff --git a/substrate/bin/node/testing/src/keyring.rs b/substrate/bin/node/testing/src/keyring.rs index f712191bed695031275cfb11c5e22c8fa2a26f78..eab088d9100ef266f26b600a501e78881e557efe 100644 --- a/substrate/bin/node/testing/src/keyring.rs +++ b/substrate/bin/node/testing/src/keyring.rs @@ -82,6 +82,7 @@ pub fn signed_extra(nonce: Nonce, extra_fee: Balance) -> SignedExtra { pallet_skip_feeless_payment::SkipCheckIfFeeless::from( pallet_asset_conversion_tx_payment::ChargeAssetTxPayment::from(extra_fee, None), ), + frame_metadata_hash_extension::CheckMetadataHash::new(false), ) } @@ -91,11 +92,19 @@ pub fn sign( spec_version: u32, tx_version: u32, genesis_hash: [u8; 32], + metadata_hash: Option<[u8; 32]>, ) -> UncheckedExtrinsic { match xt.signed { Some((signed, extra)) => { - let payload = - (xt.function, extra.clone(), spec_version, tx_version, genesis_hash, genesis_hash); + let payload = ( + xt.function, + extra.clone(), + spec_version, + tx_version, + genesis_hash, + genesis_hash, + metadata_hash, + ); let key = AccountKeyring::from_account_id(&signed).unwrap(); let signature = payload diff --git a/substrate/bin/utils/chain-spec-builder/Cargo.toml b/substrate/bin/utils/chain-spec-builder/Cargo.toml index 5c8a3ab4e89a55e5e61c371a41878ab8457ec12b..070cf13091756449239894ba6c811a9c21456330 100644 --- a/substrate/bin/utils/chain-spec-builder/Cargo.toml +++ b/substrate/bin/utils/chain-spec-builder/Cargo.toml @@ -1,13 +1,14 @@ [package] name = "staging-chain-spec-builder" -version = "3.0.0" +version = "1.6.1" authors.workspace = true edition.workspace = true build = "build.rs" license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true -publish = false +publish = true +description = "Utility for building chain-specification files for Substrate-based runtimes based on `sp-genesis-builder`" [lints] workspace = true @@ -23,8 +24,8 @@ name = "chain-spec-builder" crate-type = ["rlib"] [dependencies] -clap = { version = "4.5.3", features = ["derive"] } +clap = { features = ["derive"], workspace = true } log = { workspace = true, default-features = true } -sc-chain-spec = { path = "../../../client/chain-spec" } +sc-chain-spec = { features = ["clap"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -sp-tracing = { path = "../../../primitives/tracing" } +sp-tracing = { workspace = true, default-features = true } diff --git a/substrate/bin/utils/chain-spec-builder/bin/main.rs b/substrate/bin/utils/chain-spec-builder/bin/main.rs index 8d6425a46c770765cfe1f4cf60ba755b248f3a78..39fa054b4806d396acd557947a957c6cfdd519f7 100644 --- a/substrate/bin/utils/chain-spec-builder/bin/main.rs +++ b/substrate/bin/utils/chain-spec-builder/bin/main.rs @@ -17,16 +17,19 @@ // along with this program. If not, see . use chain_spec_builder::{ - generate_chain_spec_for_runtime, ChainSpecBuilder, ChainSpecBuilderCmd, ConvertToRawCmd, - DisplayPresetCmd, ListPresetsCmd, UpdateCodeCmd, VerifyCmd, + generate_chain_spec_for_runtime, AddCodeSubstituteCmd, ChainSpecBuilder, ChainSpecBuilderCmd, + ConvertToRawCmd, DisplayPresetCmd, ListPresetsCmd, UpdateCodeCmd, VerifyCmd, }; use clap::Parser; use sc_chain_spec::{ - update_code_in_json_chain_spec, GenericChainSpec, GenesisConfigBuilderRuntimeCaller, + set_code_substitute_in_json_chain_spec, update_code_in_json_chain_spec, GenericChainSpec, + GenesisConfigBuilderRuntimeCaller, }; use staging_chain_spec_builder as chain_spec_builder; use std::fs; +type ChainSpec = GenericChainSpec<(), ()>; + //avoid error message escaping fn main() { match inner_main() { @@ -50,7 +53,7 @@ fn inner_main() -> Result<(), String> { ref input_chain_spec, ref runtime_wasm_path, }) => { - let chain_spec = GenericChainSpec::<()>::from_json_file(input_chain_spec.clone())?; + let chain_spec = ChainSpec::from_json_file(input_chain_spec.clone())?; let mut chain_spec_json = serde_json::from_str::(&chain_spec.as_json(false)?) @@ -65,8 +68,29 @@ fn inner_main() -> Result<(), String> { .map_err(|e| format!("to pretty failed: {e}"))?; fs::write(chain_spec_path, chain_spec_json).map_err(|err| err.to_string())?; }, + ChainSpecBuilderCmd::AddCodeSubstitute(AddCodeSubstituteCmd { + ref input_chain_spec, + ref runtime_wasm_path, + block_height, + }) => { + let chain_spec = ChainSpec::from_json_file(input_chain_spec.clone())?; + + let mut chain_spec_json = + serde_json::from_str::(&chain_spec.as_json(false)?) + .map_err(|e| format!("Conversion to json failed: {e}"))?; + + set_code_substitute_in_json_chain_spec( + &mut chain_spec_json, + &fs::read(runtime_wasm_path.as_path()) + .map_err(|e| format!("Wasm blob file could not be read: {e}"))?[..], + block_height, + ); + let chain_spec_json = serde_json::to_string_pretty(&chain_spec_json) + .map_err(|e| format!("to pretty failed: {e}"))?; + fs::write(chain_spec_path, chain_spec_json).map_err(|err| err.to_string())?; + }, ChainSpecBuilderCmd::ConvertToRaw(ConvertToRawCmd { ref input_chain_spec }) => { - let chain_spec = GenericChainSpec::<()>::from_json_file(input_chain_spec.clone())?; + let chain_spec = ChainSpec::from_json_file(input_chain_spec.clone())?; let chain_spec_json = serde_json::from_str::(&chain_spec.as_json(true)?) @@ -77,7 +101,7 @@ fn inner_main() -> Result<(), String> { fs::write(chain_spec_path, chain_spec_json).map_err(|err| err.to_string())?; }, ChainSpecBuilderCmd::Verify(VerifyCmd { ref input_chain_spec }) => { - let chain_spec = GenericChainSpec::<()>::from_json_file(input_chain_spec.clone())?; + let chain_spec = ChainSpec::from_json_file(input_chain_spec.clone())?; let _ = serde_json::from_str::(&chain_spec.as_json(true)?) .map_err(|e| format!("Conversion to json failed: {e}"))?; }, @@ -99,7 +123,7 @@ fn inner_main() -> Result<(), String> { ) }) .collect(); - println!("{presets:#?}"); + println!("{}", serde_json::json!({"presets":presets}).to_string()); }, ChainSpecBuilderCmd::DisplayPreset(DisplayPresetCmd { runtime_wasm_path, preset_name }) => { let code = fs::read(runtime_wasm_path.as_path()) diff --git a/substrate/bin/utils/chain-spec-builder/src/lib.rs b/substrate/bin/utils/chain-spec-builder/src/lib.rs index 7982da76227aeb70cc4683cc1887440cb2c0ecc0..6c679f109a002401bb6b25718979c2e8fc58d2a9 100644 --- a/substrate/bin/utils/chain-spec-builder/src/lib.rs +++ b/substrate/bin/utils/chain-spec-builder/src/lib.rs @@ -120,12 +120,12 @@ use std::{fs, path::PathBuf}; use clap::{Parser, Subcommand}; -use sc_chain_spec::{GenericChainSpec, GenesisConfigBuilderRuntimeCaller}; +use sc_chain_spec::{ChainType, GenericChainSpec, GenesisConfigBuilderRuntimeCaller}; use serde_json::Value; /// A utility to easily create a chain spec definition. #[derive(Debug, Parser)] -#[command(rename_all = "kebab-case")] +#[command(rename_all = "kebab-case", version, about)] pub struct ChainSpecBuilder { #[command(subcommand)] pub command: ChainSpecBuilderCmd, @@ -143,6 +143,7 @@ pub enum ChainSpecBuilderCmd { ConvertToRaw(ConvertToRawCmd), ListPresets(ListPresetsCmd), DisplayPreset(DisplayPresetCmd), + AddCodeSubstitute(AddCodeSubstituteCmd), } /// Create a new chain spec by interacting with the provided runtime wasm blob. @@ -154,6 +155,9 @@ pub struct CreateCmd { /// The chain id. #[arg(long, short = 'i', default_value = "custom")] chain_id: String, + /// The chain type. + #[arg(value_enum, short = 't', default_value = "live")] + chain_type: ChainType, /// The path to runtime wasm blob. #[arg(long, short)] runtime_wasm_path: PathBuf, @@ -206,14 +210,38 @@ struct NamedPresetCmd { /// /// The code field of the chain spec will be updated with the runtime provided in the /// command line. This operation supports both plain and raw formats. +/// +/// This command does not update chain-spec file in-place. The result of this command will be stored +/// in a file given as `-c/--chain-spec-path` command line argument. #[derive(Parser, Debug, Clone)] pub struct UpdateCodeCmd { /// Chain spec to be updated. + /// + /// Please note that the file will not be updated in-place. pub input_chain_spec: PathBuf, /// The path to new runtime wasm blob to be stored into chain-spec. pub runtime_wasm_path: PathBuf, } +/// Add a code substitute in the chain spec. +/// +/// The `codeSubstitute` object of the chain spec will be updated with the block height as key and +/// runtime code as value. This operation supports both plain and raw formats. The `codeSubstitute` +/// field instructs the node to use the provided runtime code at the given block height. This is +/// useful when the chain can not progress on its own due to a bug that prevents block-building. +/// +/// Note: For parachains, the validation function on the relaychain needs to be adjusted too, +/// otherwise blocks built using the substituted parachain runtime will be rejected. +#[derive(Parser, Debug, Clone)] +pub struct AddCodeSubstituteCmd { + /// Chain spec to be updated. + pub input_chain_spec: PathBuf, + /// New runtime wasm blob that should replace the existing code. + pub runtime_wasm_path: PathBuf, + /// The block height at which the code should be substituted. + pub block_height: u64, +} + /// Converts the given chain spec into the raw format. #[derive(Parser, Debug, Clone)] pub struct ConvertToRawCmd { @@ -256,10 +284,12 @@ pub fn generate_chain_spec_for_runtime(cmd: &CreateCmd) -> Result::builder(&code[..], Default::default()) .with_name(&cmd.chain_name[..]) .with_id(&cmd.chain_id[..]) - .with_chain_type(sc_chain_spec::ChainType::Live); + .with_chain_type(chain_type.clone()); let builder = match cmd.action { GenesisBuildAction::NamedPreset(NamedPresetCmd { ref preset_name }) => diff --git a/substrate/bin/utils/subkey/Cargo.toml b/substrate/bin/utils/subkey/Cargo.toml index 8dc4bf254b2d44e1f6b5c96ca16a2e8586e0333c..72677a2bd43df4116d18c106e20abfbe35e4e5fb 100644 --- a/substrate/bin/utils/subkey/Cargo.toml +++ b/substrate/bin/utils/subkey/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Generate and restore keys for Substrate based chains such as Polkadot, Kusama and a growing number of parachains and Substrate based projects." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -20,5 +20,5 @@ path = "src/main.rs" name = "subkey" [dependencies] -clap = { version = "4.5.3", features = ["derive"] } -sc-cli = { path = "../../../client/cli" } +clap = { features = ["derive"], workspace = true } +sc-cli = { workspace = true, default-features = true } diff --git a/substrate/bin/utils/subkey/README.md b/substrate/bin/utils/subkey/README.md index fc1053e232d70d746cf315d203a51dfd09e8447c..5c6dda37edf681b0425fa5e2c2072fd511200587 100644 --- a/substrate/bin/utils/subkey/README.md +++ b/substrate/bin/utils/subkey/README.md @@ -74,7 +74,7 @@ The output above shows a **secret phrase** (also called **mnemonic phrase**) and **Private Key**). Those 2 secrets are the pieces of information you MUST keep safe and secret. All the other information below can be derived from those secrets. -The output above also show the **public key** and the **Account ID**. Those are the independent from the network where +The output above also shows the **public key** and the **Account ID**. Those are the independent from the network where you will use the key. The **SS58 address** (or **Public Address**) of a new account is a representation of the public keys of an account for @@ -152,7 +152,7 @@ subkey inspect "soup lyrics media market way crouch elevator put moon useful que which recovers the account `5Fe4sqj2K4fRuzEGvToi4KATqZfiDU7TqynjXG6PZE2dxwyh` and not `5He5pZpc7AJ8evPuab37vJF6KkFDqq9uDq2WXh877Qw6iaVC` as we expected. The additional user-defined **password** -(`extra_secret` in our example) is now required to fully recover the account. Let's inspect the the previous mnemonic, +(`extra_secret` in our example) is now required to fully recover the account. Let's inspect the previous mnemonic, this time passing also the required `password` as shown below: ```bash diff --git a/substrate/client/allocator/Cargo.toml b/substrate/client/allocator/Cargo.toml index 2c268b548ea9c32fabdc82226c77e82a7ef59cea..a8b3bdc864c9ae2ce1e10a3e24bd4d5255058522 100644 --- a/substrate/client/allocator/Cargo.toml +++ b/substrate/client/allocator/Cargo.toml @@ -4,7 +4,7 @@ version = "23.0.0" authors.workspace = true edition.workspace = true license = "Apache-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Collection of allocator implementations." documentation = "https://docs.rs/sc-allocator" @@ -19,5 +19,5 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] log = { workspace = true, default-features = true } thiserror = { workspace = true } -sp-core = { path = "../../primitives/core" } -sp-wasm-interface = { path = "../../primitives/wasm-interface" } +sp-core = { workspace = true, default-features = true } +sp-wasm-interface = { workspace = true, default-features = true } diff --git a/substrate/client/api/Cargo.toml b/substrate/client/api/Cargo.toml index fb650c5b532f2cbf841dc65e5f7f1a3c35dae733..670c746844672cc531174c18ad2ede216df0ba44 100644 --- a/substrate/client/api/Cargo.toml +++ b/substrate/client/api/Cargo.toml @@ -4,7 +4,7 @@ version = "28.0.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Substrate client interfaces." documentation = "https://docs.rs/sc-client-api" @@ -17,30 +17,30 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = [ +codec = { features = [ "derive", -] } -fnv = "1.0.6" -futures = "0.3.30" +], workspace = true } +fnv = { workspace = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -parking_lot = "0.12.1" -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus" } -sc-executor = { path = "../executor" } -sc-transaction-pool-api = { path = "../transaction-pool/api" } -sc-utils = { path = "../utils" } -sp-api = { path = "../../primitives/api" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-consensus = { path = "../../primitives/consensus/common" } -sp-core = { path = "../../primitives/core", default-features = false } -sp-database = { path = "../../primitives/database" } -sp-externalities = { path = "../../primitives/externalities" } -sp-runtime = { path = "../../primitives/runtime", default-features = false } -sp-state-machine = { path = "../../primitives/state-machine" } -sp-statement-store = { path = "../../primitives/statement-store" } -sp-storage = { path = "../../primitives/storage" } -sp-trie = { path = "../../primitives/trie" } +parking_lot = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true } +sp-database = { workspace = true, default-features = true } +sp-externalities = { workspace = true, default-features = true } +sp-runtime = { workspace = true } +sp-state-machine = { workspace = true, default-features = true } +sp-statement-store = { workspace = true, default-features = true } +sp-storage = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } [dev-dependencies] thiserror = { workspace = true } -sp-test-primitives = { path = "../../primitives/test-primitives" } -substrate-test-runtime = { path = "../../test-utils/runtime" } +sp-test-primitives = { workspace = true } +substrate-test-runtime = { workspace = true } diff --git a/substrate/client/api/src/backend.rs b/substrate/client/api/src/backend.rs index 31b100433c7086719737275bfaa6b3931bffc88a..0b2a349524018d33b8003b6832363286b77d8503 100644 --- a/substrate/client/api/src/backend.rs +++ b/substrate/client/api/src/backend.rs @@ -217,7 +217,8 @@ pub trait BlockImportOperation { where I: IntoIterator, Option>)>; - /// Mark a block as finalized. + /// Mark a block as finalized, if multiple blocks are finalized in the same operation then they + /// must be marked in ascending order. fn mark_finalized( &mut self, hash: Block::Hash, diff --git a/substrate/client/api/src/client.rs b/substrate/client/api/src/client.rs index 2de09840e4dfdc15e1f1d1acaa5f3e438de0caca..45cfafb258463a50c2ce0ce5b843346bd6cb9dcb 100644 --- a/substrate/client/api/src/client.rs +++ b/substrate/client/api/src/client.rs @@ -168,7 +168,7 @@ pub trait ProvideUncles { } /// Client info -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct ClientInfo { /// Best block hash. pub chain: Info, diff --git a/substrate/client/api/src/in_mem.rs b/substrate/client/api/src/in_mem.rs index b933ed1f17e01a8822b958ac6a064fe2f3503926..ba89aede9147ff0ebe16beb6fedf39389ee9c700 100644 --- a/substrate/client/api/src/in_mem.rs +++ b/substrate/client/api/src/in_mem.rs @@ -419,20 +419,6 @@ impl blockchain::Backend for Blockchain { Ok(self.storage.read().leaves.hashes()) } - fn displaced_leaves_after_finalizing( - &self, - block_number: NumberFor, - ) -> sp_blockchain::Result> { - Ok(self - .storage - .read() - .leaves - .displaced_by_finalize_height(block_number) - .leaves() - .cloned() - .collect::>()) - } - fn children(&self, _parent_hash: Block::Hash) -> sp_blockchain::Result> { unimplemented!() } diff --git a/substrate/client/api/src/leaves.rs b/substrate/client/api/src/leaves.rs index a8a988771e2fdf346dd0c50983d0e8b32c74bafc..70efe8b19c627d03741a3ea11b8889332b5a567c 100644 --- a/substrate/client/api/src/leaves.rs +++ b/substrate/client/api/src/leaves.rs @@ -45,23 +45,20 @@ pub struct RemoveOutcome { } /// Removed leaves after a finalization action. -pub struct FinalizationOutcome { - removed: BTreeMap, Vec>, +pub struct FinalizationOutcome +where + I: Iterator, +{ + removed: I, } -impl FinalizationOutcome { - /// Merge with another. This should only be used for displaced items that - /// are produced within one transaction of each other. - pub fn merge(&mut self, mut other: Self) { - // this will ignore keys that are in duplicate, however - // if these are actually produced correctly via the leaf-set within - // one transaction, then there will be no overlap in the keys. - self.removed.append(&mut other.removed); - } - - /// Iterate over all displaced leaves. - pub fn leaves(&self) -> impl Iterator { - self.removed.values().flatten() +impl FinalizationOutcome +where + I: Iterator, +{ + /// Constructor + pub fn new(new_displaced: I) -> Self { + FinalizationOutcome { removed: new_displaced } } } @@ -76,7 +73,7 @@ pub struct LeafSet { impl LeafSet where H: Clone + PartialEq + Decode + Encode, - N: std::fmt::Debug + Clone + AtLeast32Bit + Decode + Encode, + N: std::fmt::Debug + Copy + AtLeast32Bit + Decode + Encode, { /// Construct a new, blank leaf set. pub fn new() -> Self { @@ -107,13 +104,13 @@ where let number = Reverse(number); let removed = if number.0 != N::zero() { - let parent_number = Reverse(number.0.clone() - N::one()); + let parent_number = Reverse(number.0 - N::one()); self.remove_leaf(&parent_number, &parent_hash).then(|| parent_hash) } else { None }; - self.insert_leaf(number.clone(), hash.clone()); + self.insert_leaf(number, hash.clone()); ImportOutcome { inserted: LeafSetItem { hash, number }, removed } } @@ -140,7 +137,7 @@ where let inserted = parent_hash.and_then(|parent_hash| { if number.0 != N::zero() { - let parent_number = Reverse(number.0.clone() - N::one()); + let parent_number = Reverse(number.0 - N::one()); self.insert_leaf(parent_number, parent_hash.clone()); Some(parent_hash) } else { @@ -151,39 +148,13 @@ where Some(RemoveOutcome { inserted, removed: LeafSetItem { hash, number } }) } - /// Note a block height finalized, displacing all leaves with number less than the finalized - /// block's. - /// - /// Although it would be more technically correct to also prune out leaves at the - /// same number as the finalized block, but with different hashes, the current behavior - /// is simpler and our assumptions about how finalization works means that those leaves - /// will be pruned soon afterwards anyway. - pub fn finalize_height(&mut self, number: N) -> FinalizationOutcome { - let boundary = if number == N::zero() { - return FinalizationOutcome { removed: BTreeMap::new() } - } else { - number - N::one() - }; - - let below_boundary = self.storage.split_off(&Reverse(boundary)); - FinalizationOutcome { removed: below_boundary } - } - - /// The same as [`Self::finalize_height`], but it only simulates the operation. - /// - /// This means that no changes are done. - /// - /// Returns the leaves that would be displaced by finalizing the given block. - pub fn displaced_by_finalize_height(&self, number: N) -> FinalizationOutcome { - let boundary = if number == N::zero() { - return FinalizationOutcome { removed: BTreeMap::new() } - } else { - number - N::one() - }; - - let below_boundary = self.storage.range(&Reverse(boundary)..); - FinalizationOutcome { - removed: below_boundary.map(|(k, v)| (k.clone(), v.clone())).collect(), + /// Remove all leaves displaced by the last block finalization. + pub fn remove_displaced_leaves(&mut self, displaced_leaves: FinalizationOutcome) + where + I: Iterator, + { + for (number, hash) in displaced_leaves.removed { + self.remove_leaf(&Reverse(number), &hash); } } @@ -203,13 +174,13 @@ where let items = self .storage .iter() - .flat_map(|(number, hashes)| hashes.iter().map(move |h| (h.clone(), number.clone()))) + .flat_map(|(number, hashes)| hashes.iter().map(move |h| (h.clone(), *number))) .collect::>(); - for (hash, number) in &items { + for (hash, number) in items { if number.0 > best_number { assert!( - self.remove_leaf(number, hash), + self.remove_leaf(&number, &hash), "item comes from an iterator over storage; qed", ); } @@ -224,7 +195,7 @@ where // we need to make sure that the best block exists in the leaf set as // this is an invariant of regular block import. if !leaves_contains_best { - self.insert_leaf(best_number.clone(), best_hash.clone()); + self.insert_leaf(best_number, best_hash.clone()); } } @@ -246,7 +217,7 @@ where column: u32, prefix: &[u8], ) { - let leaves: Vec<_> = self.storage.iter().map(|(n, h)| (n.0.clone(), h.clone())).collect(); + let leaves: Vec<_> = self.storage.iter().map(|(n, h)| (n.0, h.clone())).collect(); tx.set_from_vec(column, prefix, leaves.encode()); } @@ -291,7 +262,7 @@ where /// Returns the highest leaf and all hashes associated to it. pub fn highest_leaf(&self) -> Option<(N, &[H])> { - self.storage.iter().next().map(|(k, v)| (k.0.clone(), &v[..])) + self.storage.iter().next().map(|(k, v)| (k.0, &v[..])) } } @@ -303,13 +274,13 @@ pub struct Undo<'a, H: 'a, N: 'a> { impl<'a, H: 'a, N: 'a> Undo<'a, H, N> where H: Clone + PartialEq + Decode + Encode, - N: std::fmt::Debug + Clone + AtLeast32Bit + Decode + Encode, + N: std::fmt::Debug + Copy + AtLeast32Bit + Decode + Encode, { /// Undo an imported block by providing the import operation outcome. /// No additional operations should be performed between import and undo. pub fn undo_import(&mut self, outcome: ImportOutcome) { if let Some(removed_hash) = outcome.removed { - let removed_number = Reverse(outcome.inserted.number.0.clone() - N::one()); + let removed_number = Reverse(outcome.inserted.number.0 - N::one()); self.inner.insert_leaf(removed_number, removed_hash); } self.inner.remove_leaf(&outcome.inserted.number, &outcome.inserted.hash); @@ -319,7 +290,7 @@ where /// No additional operations should be performed between remove and undo. pub fn undo_remove(&mut self, outcome: RemoveOutcome) { if let Some(inserted_hash) = outcome.inserted { - let inserted_number = Reverse(outcome.removed.number.0.clone() - N::one()); + let inserted_number = Reverse(outcome.removed.number.0 - N::one()); self.inner.remove_leaf(&inserted_number, &inserted_hash); } self.inner.insert_leaf(outcome.removed.number, outcome.removed.hash); @@ -327,8 +298,13 @@ where /// Undo a finalization operation by providing the displaced leaves. /// No additional operations should be performed between finalization and undo. - pub fn undo_finalization(&mut self, mut outcome: FinalizationOutcome) { - self.inner.storage.append(&mut outcome.removed); + pub fn undo_finalization(&mut self, outcome: FinalizationOutcome) + where + I: Iterator, + { + for (number, hash) in outcome.removed { + self.inner.storage.entry(Reverse(number)).or_default().push(hash); + } } } @@ -420,32 +396,6 @@ mod tests { assert!(set.contains(11, 11_2)); } - #[test] - fn finalization_works() { - let mut set = LeafSet::new(); - set.import(9_1u32, 9u32, 0u32); - set.import(10_1, 10, 9_1); - set.import(10_2, 10, 9_1); - set.import(11_1, 11, 10_1); - set.import(11_2, 11, 10_1); - set.import(12_1, 12, 11_2); - - let outcome = set.finalize_height(11); - assert_eq!(set.count(), 2); - assert!(set.contains(11, 11_1)); - assert!(set.contains(12, 12_1)); - assert_eq!( - outcome.removed, - [(Reverse(10), vec![10_2])].into_iter().collect::>(), - ); - - set.undo().undo_finalization(outcome); - assert_eq!(set.count(), 3); - assert!(set.contains(11, 11_1)); - assert!(set.contains(12, 12_1)); - assert!(set.contains(10, 10_2)); - } - #[test] fn flush_to_disk() { const PREFIX: &[u8] = b"abcdefg"; @@ -479,35 +429,4 @@ mod tests { assert!(set.contains(10, 1_2)); assert!(!set.contains(10, 1_3)); } - - #[test] - fn finalization_consistent_with_disk() { - const PREFIX: &[u8] = b"prefix"; - let db = Arc::new(sp_database::MemDb::default()); - - let mut set = LeafSet::new(); - set.import(10_1u32, 10u32, 0u32); - set.import(11_1, 11, 10_2); - set.import(11_2, 11, 10_2); - set.import(12_1, 12, 11_123); - - assert!(set.contains(10, 10_1)); - - let mut tx = Transaction::new(); - set.prepare_transaction(&mut tx, 0, PREFIX); - db.commit(tx).unwrap(); - - let _ = set.finalize_height(11); - let mut tx = Transaction::new(); - set.prepare_transaction(&mut tx, 0, PREFIX); - db.commit(tx).unwrap(); - - assert!(set.contains(11, 11_1)); - assert!(set.contains(11, 11_2)); - assert!(set.contains(12, 12_1)); - assert!(!set.contains(10, 10_1)); - - let set2 = LeafSet::read_from_db(&*db, 0, PREFIX).unwrap(); - assert_eq!(set, set2); - } } diff --git a/substrate/client/authority-discovery/Cargo.toml b/substrate/client/authority-discovery/Cargo.toml index ac4537d5ba0a4f606a897fb4c98929427683023a..09381ec6b553d3f574d488068e991fdbca7e6348 100644 --- a/substrate/client/authority-discovery/Cargo.toml +++ b/substrate/client/authority-discovery/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true edition.workspace = true build = "build.rs" license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Substrate authority discovery." readme = "README.md" @@ -17,38 +17,33 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [build-dependencies] -prost-build = "0.12.4" +prost-build = { workspace = true } [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false } -futures = "0.3.30" -futures-timer = "3.0.1" -ip_network = "0.4.1" -libp2p = { version = "0.51.4", features = ["ed25519", "kad"] } -multihash = { version = "0.17.0", default-features = false, features = ["sha2", "std"] } -linked_hash_set = "0.1.4" +codec = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } +ip_network = { workspace = true } +libp2p = { features = ["ed25519", "kad"], workspace = true } +multihash = { workspace = true } +linked_hash_set = { workspace = true } log = { workspace = true, default-features = true } -prost = "0.12.4" -rand = "0.8.5" +prost = { workspace = true } +rand = { workspace = true, default-features = true } thiserror = { workspace = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus" } -sc-client-api = { path = "../api" } -sc-network = { path = "../network" } -sc-network-types = { path = "../network/types" } -sp-api = { path = "../../primitives/api" } -sp-authority-discovery = { path = "../../primitives/authority-discovery" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-core = { path = "../../primitives/core" } -sp-keystore = { path = "../../primitives/keystore" } -sp-runtime = { path = "../../primitives/runtime" } -async-trait = "0.1.79" -multihash-codetable = { version = "0.1.1", features = [ - "digest", - "serde", - "sha2", -] } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-authority-discovery = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +async-trait = { workspace = true } [dev-dependencies] -quickcheck = { version = "1.0.3", default-features = false } -sp-tracing = { path = "../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../test-utils/runtime/client" } +quickcheck = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/authority-discovery/build.rs b/substrate/client/authority-discovery/build.rs index 83076ac8c893736cf9c2e0852d515339f8bde7a5..cdabc1a74427def80e03e5717ea429dfeff09055 100644 --- a/substrate/client/authority-discovery/build.rs +++ b/substrate/client/authority-discovery/build.rs @@ -18,7 +18,11 @@ fn main() { prost_build::compile_protos( - &["src/worker/schema/dht-v1.proto", "src/worker/schema/dht-v2.proto"], + &[ + "src/worker/schema/dht-v1.proto", + "src/worker/schema/dht-v2.proto", + "src/worker/schema/dht-v3.proto", + ], &["src/worker/schema"], ) .unwrap(); diff --git a/substrate/client/authority-discovery/src/error.rs b/substrate/client/authority-discovery/src/error.rs index 6f791237c2f229c3f94996e2a91c0c0de8800d0d..3f395e47922e216e64e0853d866114000a53b00a 100644 --- a/substrate/client/authority-discovery/src/error.rs +++ b/substrate/client/authority-discovery/src/error.rs @@ -35,7 +35,7 @@ pub enum Error { VerifyingDhtPayload, #[error("Failed to hash the authority id to be used as a dht key.")] - HashingAuthorityId(#[from] sc_network::multiaddr::multihash::Error), + HashingAuthorityId(#[from] sc_network_types::multihash::Error), #[error("Failed calling into the Substrate runtime: {0}")] CallingRuntime(#[from] sp_blockchain::Error), @@ -53,7 +53,7 @@ pub enum Error { EncodingDecodingScale(#[from] codec::Error), #[error("Failed to parse a libp2p multi address.")] - ParsingMultiaddress(#[from] sc_network::multiaddr::Error), + ParsingMultiaddress(#[from] sc_network::multiaddr::ParseError), #[error("Failed to parse a libp2p key: {0}")] ParsingLibp2pIdentity(String), @@ -75,4 +75,10 @@ pub enum Error { #[error("Unable to fetch best block.")] BestBlockFetchingError, + + #[error("Publisher not present.")] + MissingPublisher, + + #[error("Unknown authority.")] + UnknownAuthority, } diff --git a/substrate/client/authority-discovery/src/service.rs b/substrate/client/authority-discovery/src/service.rs index 60c7a2b990378f0c91a16854bdb815de8661c53a..852d3ab80c9b8926d291f5a83249515b1c8fabc6 100644 --- a/substrate/client/authority-discovery/src/service.rs +++ b/substrate/client/authority-discovery/src/service.rs @@ -55,7 +55,7 @@ impl Service { /// [`crate::Worker`] failed. /// /// Note: [`Multiaddr`]s returned always include a [`PeerId`] via a - /// [`libp2p::core::multiaddr::Protocol::P2p`] component. Equality of + /// [`sc_network_types::multiaddr::Protocol::P2p`] component. Equality of /// [`PeerId`]s across [`Multiaddr`]s returned by a single call is not /// enforced today, given that there are still authorities out there /// publishing the addresses of their sentry nodes on the DHT. In the future diff --git a/substrate/client/authority-discovery/src/worker.rs b/substrate/client/authority-discovery/src/worker.rs index 53418d2d38c4a0ce0ab2c2b938b288360d2fdbbc..6f4fbac77e05982042ad7bad7ed337f8f1170cac 100644 --- a/substrate/client/authority-discovery/src/worker.rs +++ b/substrate/client/authority-discovery/src/worker.rs @@ -26,7 +26,7 @@ use std::{ collections::{HashMap, HashSet}, marker::PhantomData, sync::Arc, - time::Duration, + time::{Duration, Instant, SystemTime, UNIX_EPOCH}, }; use futures::{channel::mpsc, future, stream::Fuse, FutureExt, Stream, StreamExt}; @@ -34,19 +34,20 @@ use futures::{channel::mpsc, future, stream::Fuse, FutureExt, Stream, StreamExt} use addr_cache::AddrCache; use codec::{Decode, Encode}; use ip_network::IpNetwork; +use libp2p::kad::{PeerRecord, Record}; use linked_hash_set::LinkedHashSet; -use multihash::{Code, Multihash, MultihashDigest}; -use log::{debug, error, log_enabled}; +use log::{debug, error, trace}; use prometheus_endpoint::{register, Counter, CounterVec, Gauge, Opts, U64}; use prost::Message; use rand::{seq::SliceRandom, thread_rng}; use sc_network::{ - event::DhtEvent, multiaddr, KademliaKey, Multiaddr, NetworkDHTProvider, NetworkSigner, - NetworkStateInfo, + config::DEFAULT_KADEMLIA_REPLICATION_FACTOR, event::DhtEvent, multiaddr, KademliaKey, + Multiaddr, NetworkDHTProvider, NetworkSigner, NetworkStateInfo, }; -use sc_network_types::PeerId; +use sc_network_types::{multihash::Code, PeerId}; +use schema::PeerSignature; use sp_api::{ApiError, ProvideRuntimeApi}; use sp_authority_discovery::{ AuthorityDiscoveryApi, AuthorityId, AuthorityPair, AuthoritySignature, @@ -62,7 +63,7 @@ mod schema { #[cfg(test)] mod tests; - include!(concat!(env!("OUT_DIR"), "/authority_discovery_v2.rs")); + include!(concat!(env!("OUT_DIR"), "/authority_discovery_v3.rs")); } #[cfg(test)] pub mod tests; @@ -109,7 +110,7 @@ pub enum Role { /// network peerset. /// /// 5. Allow querying of the collected addresses via the [`crate::Service`]. -pub struct Worker { +pub struct Worker { /// Channel receiver for messages send by a [`crate::Service`]. from_service: Fuse>, @@ -150,9 +151,25 @@ pub struct Worker { /// Queue of throttled lookups pending to be passed to the network. pending_lookups: Vec, + /// The list of all known authorities. + known_authorities: HashMap, + + /// The last time we requested the list of authorities. + authorities_queried_at: Option, + /// Set of in-flight lookups. in_flight_lookups: HashMap, + /// Set of lookups we can still receive records. + /// These are the entries in the `in_flight_lookups` for which + /// we got at least one successfull result. + known_lookups: HashMap, + + /// Last known record by key, here we always keep the record with + /// the highest creation time and we don't accept records older than + /// that. + last_known_records: HashMap, + addr_cache: addr_cache::AddrCache, metrics: Option, @@ -162,6 +179,17 @@ pub struct Worker { phantom: PhantomData, } +#[derive(Debug, Clone)] +struct RecordInfo { + /// Time since UNIX_EPOCH in nanoseconds. + creation_time: u128, + /// Peers that we know have this record, bounded to no more than + /// DEFAULT_KADEMLIA_REPLICATION_FACTOR(20). + peers_with_record: HashSet, + /// The record itself. + record: Record, +} + /// Wrapper for [`AuthorityDiscoveryApi`](sp_authority_discovery::AuthorityDiscoveryApi). Can be /// be implemented by any struct without dependency on the runtime. #[async_trait::async_trait] @@ -238,14 +266,14 @@ where }; let public_addresses = { - let local_peer_id: Multihash = network.local_peer_id().into(); + let local_peer_id = network.local_peer_id(); config .public_addresses .into_iter() .map(|mut address| { if let Some(multiaddr::Protocol::P2p(peer_id)) = address.iter().last() { - if peer_id != local_peer_id { + if peer_id != *local_peer_id.as_ref() { error!( target: LOG_TARGET, "Discarding invalid local peer ID in public address {address}.", @@ -266,6 +294,8 @@ where network, dht_event_rx, publish_interval, + known_authorities: Default::default(), + authorities_queried_at: None, publish_if_changed_interval, latest_published_keys: HashSet::new(), latest_published_kad_keys: HashSet::new(), @@ -275,10 +305,12 @@ where query_interval, pending_lookups: Vec::new(), in_flight_lookups: HashMap::new(), + known_lookups: HashMap::new(), addr_cache, role, metrics, phantom: PhantomData, + last_known_records: HashMap::new(), } } @@ -384,16 +416,17 @@ where }) .collect::>(); - debug!( - target: LOG_TARGET, - "Authority DHT record peer_id='{local_peer_id}' addresses='{addresses:?}'", - ); + if !addresses.is_empty() { + debug!( + target: LOG_TARGET, + "Publishing authority DHT record peer_id='{local_peer_id}' with addresses='{addresses:?}'", + ); + } // The address must include the local peer id. - let local_peer_id: Multihash = local_peer_id.into(); addresses .into_iter() - .map(move |a| a.with(multiaddr::Protocol::P2p(local_peer_id))) + .map(move |a| a.with(multiaddr::Protocol::P2p(*local_peer_id.as_ref()))) } /// Publish own public addresses. @@ -406,6 +439,17 @@ where Role::Discover => return Ok(()), }; + let addresses = serialize_addresses(self.addresses_to_publish()); + if addresses.is_empty() { + trace!( + target: LOG_TARGET, + "No addresses to publish. Skipping publication." + ); + + self.publish_interval.set_to_start(); + return Ok(()) + } + let keys = Worker::::get_own_public_keys_within_authority_set( key_store.clone(), @@ -428,8 +472,6 @@ where self.query_interval.set_to_start(); } - let addresses = serialize_addresses(self.addresses_to_publish()); - if let Some(metrics) = &self.metrics { metrics.publish.inc(); metrics @@ -437,7 +479,7 @@ where .set(addresses.len().try_into().unwrap_or(std::u64::MAX)); } - let serialized_record = serialize_authority_record(addresses)?; + let serialized_record = serialize_authority_record(addresses, Some(build_creation_time()))?; let peer_signature = sign_record_with_peer_id(&serialized_record, &self.network)?; let keys_vec = keys.iter().cloned().collect::>(); @@ -480,13 +522,25 @@ where .filter(|id| !local_keys.contains(id.as_ref())) .collect::>(); + self.known_authorities = authorities + .clone() + .into_iter() + .map(|authority| (hash_authority_id(authority.as_ref()), authority)) + .collect::>(); + self.authorities_queried_at = Some(best_hash); + self.addr_cache.retain_ids(&authorities); + let now = Instant::now(); + self.last_known_records.retain(|k, value| { + self.known_authorities.contains_key(k) && !value.record.is_expired(now) + }); authorities.shuffle(&mut thread_rng()); self.pending_lookups = authorities; // Ignore all still in-flight lookups. Those that are still in-flight are likely stalled as // query interval ticks are far enough apart for all lookups to succeed. self.in_flight_lookups.clear(); + self.known_lookups.clear(); if let Some(metrics) = &self.metrics { metrics @@ -524,16 +578,12 @@ where metrics.dht_event_received.with_label_values(&["value_found"]).inc(); } - if log_enabled!(log::Level::Debug) { - let hashes: Vec<_> = v.iter().map(|(hash, _value)| hash.clone()).collect(); - debug!(target: LOG_TARGET, "Value for hash '{:?}' found on Dht.", hashes); - } + debug!(target: LOG_TARGET, "Value for hash '{:?}' found on Dht.", v.record.key); if let Err(e) = self.handle_dht_value_found_event(v) { if let Some(metrics) = &self.metrics { metrics.handle_value_found_event_failure.inc(); } - debug!(target: LOG_TARGET, "Failed to handle Dht value found event: {}", e); } }, @@ -579,92 +629,221 @@ where debug!(target: LOG_TARGET, "Failed to put hash '{:?}' on Dht.", hash) }, + DhtEvent::PutRecordRequest(record_key, record_value, publisher, expires) => { + if let Err(e) = self + .handle_put_record_requested(record_key, record_value, publisher, expires) + .await + { + debug!(target: LOG_TARGET, "Failed to handle put record request: {}", e) + } + + if let Some(metrics) = &self.metrics { + metrics.dht_event_received.with_label_values(&["put_record_req"]).inc(); + } + }, } } - fn handle_dht_value_found_event(&mut self, values: Vec<(KademliaKey, Vec)>) -> Result<()> { - // Ensure `values` is not empty and all its keys equal. - let remote_key = single(values.iter().map(|(key, _)| key.clone())) - .map_err(|_| Error::ReceivingDhtValueFoundEventWithDifferentKeys)? - .ok_or(Error::ReceivingDhtValueFoundEventWithNoRecords)?; + async fn handle_put_record_requested( + &mut self, + record_key: KademliaKey, + record_value: Vec, + publisher: Option, + expires: Option, + ) -> Result<()> { + let publisher = publisher.ok_or(Error::MissingPublisher)?; + + // Make sure we don't ever work with an outdated set of authorities + // and that we do not update known_authorithies too often. + let best_hash = self.client.best_hash().await?; + if !self.known_authorities.contains_key(&record_key) && + self.authorities_queried_at + .map(|authorities_queried_at| authorities_queried_at != best_hash) + .unwrap_or(true) + { + let authorities = self + .client + .authorities(best_hash) + .await + .map_err(|e| Error::CallingRuntime(e.into()))? + .into_iter() + .collect::>(); - let authority_id: AuthorityId = self - .in_flight_lookups - .remove(&remote_key) - .ok_or(Error::ReceivingUnexpectedRecord)?; + self.known_authorities = authorities + .into_iter() + .map(|authority| (hash_authority_id(authority.as_ref()), authority)) + .collect::>(); - let local_peer_id = self.network.local_peer_id(); + self.authorities_queried_at = Some(best_hash); + } - let remote_addresses: Vec = values - .into_iter() - .map(|(_k, v)| { - let schema::SignedAuthorityRecord { record, auth_signature, peer_signature } = - schema::SignedAuthorityRecord::decode(v.as_slice()) - .map_err(Error::DecodingProto)?; + let authority_id = + self.known_authorities.get(&record_key).ok_or(Error::UnknownAuthority)?; + let signed_record = + Self::check_record_signed_with_authority_id(record_value.as_slice(), authority_id)?; + self.check_record_signed_with_network_key( + &signed_record.record, + signed_record.peer_signature, + publisher, + authority_id, + )?; - let auth_signature = AuthoritySignature::decode(&mut &auth_signature[..]) - .map_err(Error::EncodingDecodingScale)?; + let records_creation_time: u128 = + schema::AuthorityRecord::decode(signed_record.record.as_slice()) + .map_err(Error::DecodingProto)? + .creation_time + .map(|creation_time| { + u128::decode(&mut &creation_time.timestamp[..]).unwrap_or_default() + }) + .unwrap_or_default(); // 0 is a sane default for records that do not have creation time present. + + let current_record_info = self.last_known_records.get(&record_key); + // If record creation time is older than the current record creation time, + // we don't store it since we want to give higher priority to newer records. + if let Some(current_record_info) = current_record_info { + if records_creation_time < current_record_info.creation_time { + debug!( + target: LOG_TARGET, + "Skip storing because record creation time {:?} is older than the current known record {:?}", + records_creation_time, + current_record_info.creation_time + ); + return Ok(()); + } + } - if !AuthorityPair::verify(&auth_signature, &record, &authority_id) { - return Err(Error::VerifyingDhtPayload) - } + self.network.store_record(record_key, record_value, Some(publisher), expires); + Ok(()) + } - let addresses: Vec = schema::AuthorityRecord::decode(record.as_slice()) - .map(|a| a.addresses) - .map_err(Error::DecodingProto)? - .into_iter() - .map(|a| a.try_into()) - .collect::>() - .map_err(Error::ParsingMultiaddress)?; - - let get_peer_id = |a: &Multiaddr| match a.iter().last() { - Some(multiaddr::Protocol::P2p(key)) => PeerId::from_multihash(key).ok(), - _ => None, - }; - - // Ignore [`Multiaddr`]s without [`PeerId`] or with own addresses. - let addresses: Vec = addresses - .into_iter() - .filter(|a| get_peer_id(a).filter(|p| *p != local_peer_id).is_some()) - .collect(); - - let remote_peer_id = single(addresses.iter().map(get_peer_id)) - .map_err(|_| Error::ReceivingDhtValueFoundEventWithDifferentPeerIds)? // different peer_id in records - .flatten() - .ok_or(Error::ReceivingDhtValueFoundEventWithNoPeerIds)?; // no records with peer_id in them - - // At this point we know all the valid multiaddresses from the record, know that - // each of them belong to the same PeerId, we just need to check if the record is - // properly signed by the owner of the PeerId - - if let Some(peer_signature) = peer_signature { - match self.network.verify( - remote_peer_id.into(), - &peer_signature.public_key, - &peer_signature.signature, - &record, - ) { - Ok(true) => {}, - Ok(false) => return Err(Error::VerifyingDhtPayload), - Err(error) => return Err(Error::ParsingLibp2pIdentity(error)), - } - } else if self.strict_record_validation { - return Err(Error::MissingPeerIdSignature) - } else { - debug!( - target: LOG_TARGET, - "Received unsigned authority discovery record from {}", authority_id - ); - } - Ok(addresses) + fn check_record_signed_with_authority_id( + record: &[u8], + authority_id: &AuthorityId, + ) -> Result { + let signed_record: schema::SignedAuthorityRecord = + schema::SignedAuthorityRecord::decode(record).map_err(Error::DecodingProto)?; + + let auth_signature = AuthoritySignature::decode(&mut &signed_record.auth_signature[..]) + .map_err(Error::EncodingDecodingScale)?; + + if !AuthorityPair::verify(&auth_signature, &signed_record.record, &authority_id) { + return Err(Error::VerifyingDhtPayload) + } + + Ok(signed_record) + } + + fn check_record_signed_with_network_key( + &self, + record: &Vec, + peer_signature: Option, + remote_peer_id: PeerId, + authority_id: &AuthorityId, + ) -> Result<()> { + if let Some(peer_signature) = peer_signature { + match self.network.verify( + remote_peer_id.into(), + &peer_signature.public_key, + &peer_signature.signature, + record, + ) { + Ok(true) => {}, + Ok(false) => return Err(Error::VerifyingDhtPayload), + Err(error) => return Err(Error::ParsingLibp2pIdentity(error)), + } + } else if self.strict_record_validation { + return Err(Error::MissingPeerIdSignature) + } else { + debug!( + target: LOG_TARGET, + "Received unsigned authority discovery record from {}", authority_id + ); + } + Ok(()) + } + + fn handle_dht_value_found_event(&mut self, peer_record: PeerRecord) -> Result<()> { + // Ensure `values` is not empty and all its keys equal. + let remote_key = peer_record.record.key.clone(); + + let authority_id: AuthorityId = + if let Some(authority_id) = self.in_flight_lookups.remove(&remote_key) { + self.known_lookups.insert(remote_key.clone(), authority_id.clone()); + authority_id + } else if let Some(authority_id) = self.known_lookups.get(&remote_key) { + authority_id.clone() + } else { + return Err(Error::ReceivingUnexpectedRecord); + }; + + let local_peer_id = self.network.local_peer_id(); + + let schema::SignedAuthorityRecord { record, peer_signature, .. } = + Self::check_record_signed_with_authority_id( + peer_record.record.value.as_slice(), + &authority_id, + )?; + + let authority_record = + schema::AuthorityRecord::decode(record.as_slice()).map_err(Error::DecodingProto)?; + + let records_creation_time: u128 = authority_record + .creation_time + .as_ref() + .map(|creation_time| { + u128::decode(&mut &creation_time.timestamp[..]).unwrap_or_default() }) - .collect::>>>()? + .unwrap_or_default(); // 0 is a sane default for records that do not have creation time present. + + let addresses: Vec = authority_record + .addresses .into_iter() - .flatten() - .take(MAX_ADDRESSES_PER_AUTHORITY) + .map(|a| a.try_into()) + .collect::>() + .map_err(Error::ParsingMultiaddress)?; + + let get_peer_id = |a: &Multiaddr| match a.iter().last() { + Some(multiaddr::Protocol::P2p(key)) => PeerId::from_multihash(key).ok(), + _ => None, + }; + + // Ignore [`Multiaddr`]s without [`PeerId`] or with own addresses. + let addresses: Vec = addresses + .into_iter() + .filter(|a| get_peer_id(&a).filter(|p| *p != local_peer_id).is_some()) .collect(); - if !remote_addresses.is_empty() { + let remote_peer_id = single(addresses.iter().map(|a| get_peer_id(&a))) + .map_err(|_| Error::ReceivingDhtValueFoundEventWithDifferentPeerIds)? // different peer_id in records + .flatten() + .ok_or(Error::ReceivingDhtValueFoundEventWithNoPeerIds)?; // no records with peer_id in them + + // At this point we know all the valid multiaddresses from the record, know that + // each of them belong to the same PeerId, we just need to check if the record is + // properly signed by the owner of the PeerId + self.check_record_signed_with_network_key( + &record, + peer_signature, + remote_peer_id, + &authority_id, + )?; + + let remote_addresses: Vec = + addresses.into_iter().take(MAX_ADDRESSES_PER_AUTHORITY).collect(); + + let answering_peer_id = peer_record.peer.map(|peer| peer.into()); + + let addr_cache_needs_update = self.handle_new_record( + &authority_id, + remote_key.clone(), + RecordInfo { + creation_time: records_creation_time, + peers_with_record: answering_peer_id.into_iter().collect(), + record: peer_record.record, + }, + ); + + if !remote_addresses.is_empty() && addr_cache_needs_update { self.addr_cache.insert(authority_id, remote_addresses); if let Some(metrics) = &self.metrics { metrics @@ -675,6 +854,68 @@ where Ok(()) } + // Handles receiving a new DHT record for the authorithy. + // Returns true if the record was new, false if the record was older than the current one. + fn handle_new_record( + &mut self, + authority_id: &AuthorityId, + kademlia_key: KademliaKey, + new_record: RecordInfo, + ) -> bool { + let current_record_info = self + .last_known_records + .entry(kademlia_key.clone()) + .or_insert_with(|| new_record.clone()); + + if new_record.creation_time > current_record_info.creation_time { + let peers_that_need_updating = current_record_info.peers_with_record.clone(); + self.network.put_record_to( + new_record.record.clone(), + peers_that_need_updating.clone(), + // If this is empty it means we received the answer from our node local + // storage, so we need to update that as well. + current_record_info.peers_with_record.is_empty(), + ); + debug!( + target: LOG_TARGET, + "Found a newer record for {:?} new record creation time {:?} old record creation time {:?}", + authority_id, new_record.creation_time, current_record_info.creation_time + ); + self.last_known_records.insert(kademlia_key, new_record); + return true + } + + if new_record.creation_time == current_record_info.creation_time { + // Same record just update in case this is a record from old nodes that don't have + // timestamp. + debug!( + target: LOG_TARGET, + "Found same record for {:?} record creation time {:?}", + authority_id, new_record.creation_time + ); + if current_record_info.peers_with_record.len() + new_record.peers_with_record.len() <= + DEFAULT_KADEMLIA_REPLICATION_FACTOR + { + current_record_info.peers_with_record.extend(new_record.peers_with_record); + } + return true + } + + debug!( + target: LOG_TARGET, + "Found old record for {:?} received record creation time {:?} current record creation time {:?}", + authority_id, new_record.creation_time, current_record_info.creation_time, + ); + self.network.put_record_to( + current_record_info.record.clone(), + new_record.peers_with_record.clone(), + // If this is empty it means we received the answer from our node local + // storage, so we need to update that as well. + new_record.peers_with_record.is_empty(), + ); + return false + } + /// Retrieve our public keys within the current and next authority set. // A node might have multiple authority discovery keys within its keystore, e.g. an old one and // one for the upcoming session. In addition it could be participating in the current and (/ or) @@ -741,9 +982,21 @@ fn serialize_addresses(addresses: impl Iterator) -> Vec>) -> Result> { +fn build_creation_time() -> schema::TimestampInfo { + let creation_time = SystemTime::now() + .duration_since(UNIX_EPOCH) + .map(|time| time.as_nanos()) + .unwrap_or_default(); + schema::TimestampInfo { timestamp: creation_time.encode() } +} + +fn serialize_authority_record( + addresses: Vec>, + creation_time: Option, +) -> Result> { let mut serialized_record = vec![]; - schema::AuthorityRecord { addresses } + + schema::AuthorityRecord { addresses, creation_time } .encode(&mut serialized_record) .map_err(Error::EncodingProto)?; Ok(serialized_record) @@ -779,7 +1032,6 @@ fn sign_record_with_authority_ids( // Scale encode let auth_signature = auth_signature.encode(); - let signed_record = schema::SignedAuthorityRecord { record: serialized_record.clone(), auth_signature, @@ -868,7 +1120,7 @@ impl Metrics { // Helper functions for unit testing. #[cfg(test)] -impl Worker { +impl Worker { pub(crate) fn inject_addresses(&mut self, authority: AuthorityId, addresses: Vec) { self.addr_cache.insert(authority, addresses); } diff --git a/substrate/client/authority-discovery/src/worker/addr_cache.rs b/substrate/client/authority-discovery/src/worker/addr_cache.rs index 6e3b3c8af20190f3711aac72fbd5e7cf3eb493c7..13bb990bf8b9908a5ec9a11e205a4a380c5954b4 100644 --- a/substrate/client/authority-discovery/src/worker/addr_cache.rs +++ b/substrate/client/authority-discovery/src/worker/addr_cache.rs @@ -176,8 +176,8 @@ fn addresses_to_peer_ids(addresses: &HashSet) -> HashSet { mod tests { use super::*; - use multihash::{self, Multihash}; use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult}; + use sc_network_types::multihash::{Code, Multihash}; use sp_authority_discovery::{AuthorityId, AuthorityPair}; use sp_core::crypto::Pair; @@ -198,10 +198,9 @@ mod tests { impl Arbitrary for TestMultiaddr { fn arbitrary(g: &mut Gen) -> Self { let seed = (0..32).map(|_| u8::arbitrary(g)).collect::>(); - let peer_id = PeerId::from_multihash( - Multihash::wrap(multihash::Code::Sha2_256.into(), &seed).unwrap(), - ) - .unwrap(); + let peer_id = + PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &seed).unwrap()) + .unwrap(); let multiaddr = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333" .parse::() .unwrap() @@ -217,10 +216,9 @@ mod tests { impl Arbitrary for TestMultiaddrsSamePeerCombo { fn arbitrary(g: &mut Gen) -> Self { let seed = (0..32).map(|_| u8::arbitrary(g)).collect::>(); - let peer_id = PeerId::from_multihash( - Multihash::wrap(multihash::Code::Sha2_256.into(), &seed).unwrap(), - ) - .unwrap(); + let peer_id = + PeerId::from_multihash(Multihash::wrap(Code::Sha2_256.into(), &seed).unwrap()) + .unwrap(); let multiaddr1 = "/ip6/2001:db8:0:0:0:0:0:2/tcp/30333" .parse::() .unwrap() diff --git a/substrate/client/authority-discovery/src/worker/schema/dht-v3.proto b/substrate/client/authority-discovery/src/worker/schema/dht-v3.proto new file mode 100644 index 0000000000000000000000000000000000000000..547237573af298125573b9156bcc89adb3188ec7 --- /dev/null +++ b/substrate/client/authority-discovery/src/worker/schema/dht-v3.proto @@ -0,0 +1,31 @@ +syntax = "proto3"; + +package authority_discovery_v3; + +// First we need to serialize the addresses in order to be able to sign them. +message AuthorityRecord { + // Possibly multiple `MultiAddress`es through which the node can be reached. + repeated bytes addresses = 1; + // Information about the creation time of the record + TimestampInfo creation_time = 2; +} + +message PeerSignature { + bytes signature = 1; + bytes public_key = 2; +} + +// Information regarding the creation data of the record +message TimestampInfo { + // Time since UNIX_EPOCH in nanoseconds, scale encoded + bytes timestamp = 1; +} + +// Then we need to serialize the authority record and signature to send them over the wire. +message SignedAuthorityRecord { + bytes record = 1; + bytes auth_signature = 2; + // Even if there are multiple `record.addresses`, all of them have the same peer id. + // Old versions are missing this field. It is optional in order to provide compatibility both ways. + PeerSignature peer_signature = 3; +} diff --git a/substrate/client/authority-discovery/src/worker/schema/tests.rs b/substrate/client/authority-discovery/src/worker/schema/tests.rs index ef06ed7d336b0894f54511dfc87561a7b5d68d54..557fa9641f97b0953760e5f407cf819d617be939 100644 --- a/substrate/client/authority-discovery/src/worker/schema/tests.rs +++ b/substrate/client/authority-discovery/src/worker/schema/tests.rs @@ -20,7 +20,12 @@ mod schema_v1 { include!(concat!(env!("OUT_DIR"), "/authority_discovery_v1.rs")); } +mod schema_v2 { + include!(concat!(env!("OUT_DIR"), "/authority_discovery_v2.rs")); +} + use super::*; +use codec::Encode; use libp2p::identity::Keypair; use prost::Message; use sc_network::{Multiaddr, PeerId}; @@ -65,7 +70,7 @@ fn v1_decodes_v2() { let vec_auth_signature = b"Totally valid signature, I promise!".to_vec(); let vec_peer_signature = b"Surprisingly hard to crack crypto".to_vec(); - let record_v2 = AuthorityRecord { addresses: vec_addresses.clone() }; + let record_v2 = schema_v2::AuthorityRecord { addresses: vec_addresses.clone() }; let mut vec_record_v2 = vec![]; record_v2.encode(&mut vec_record_v2).unwrap(); let vec_peer_public = peer_public.encode_protobuf(); @@ -85,6 +90,82 @@ fn v1_decodes_v2() { assert_eq!(&signed_addresses_v1_decoded.addresses, &vec_record_v2); assert_eq!(&signed_addresses_v1_decoded.signature, &vec_auth_signature); - let addresses_v2_decoded = AuthorityRecord::decode(vec_record_v2.as_slice()).unwrap(); + let addresses_v2_decoded = + schema_v2::AuthorityRecord::decode(vec_record_v2.as_slice()).unwrap(); + assert_eq!(&addresses_v2_decoded.addresses, &vec_addresses); +} + +#[test] +fn v1_decodes_v3() { + let peer_secret = Keypair::generate_ed25519(); + let peer_public = peer_secret.public(); + let peer_id = peer_public.to_peer_id(); + let multiaddress: Multiaddr = + format!("/ip4/127.0.0.1/tcp/3003/p2p/{}", peer_id).parse().unwrap(); + let vec_addresses = vec![multiaddress.to_vec()]; + let vec_auth_signature = b"Totally valid signature, I promise!".to_vec(); + let vec_peer_signature = b"Surprisingly hard to crack crypto".to_vec(); + + let record_v3 = AuthorityRecord { + addresses: vec_addresses.clone(), + creation_time: Some(TimestampInfo { timestamp: Encode::encode(&55) }), + }; + let mut vec_record_v3 = vec![]; + record_v3.encode(&mut vec_record_v3).unwrap(); + let vec_peer_public = peer_public.encode_protobuf(); + let peer_signature_v3 = + PeerSignature { public_key: vec_peer_public, signature: vec_peer_signature }; + let signed_record_v3 = SignedAuthorityRecord { + record: vec_record_v3.clone(), + auth_signature: vec_auth_signature.clone(), + peer_signature: Some(peer_signature_v3.clone()), + }; + let mut vec_signed_record_v3 = vec![]; + signed_record_v3.encode(&mut vec_signed_record_v3).unwrap(); + + let signed_addresses_v1_decoded = + schema_v1::SignedAuthorityAddresses::decode(vec_signed_record_v3.as_slice()).unwrap(); + + assert_eq!(&signed_addresses_v1_decoded.addresses, &vec_record_v3); + assert_eq!(&signed_addresses_v1_decoded.signature, &vec_auth_signature); + + let addresses_v2_decoded = + schema_v2::AuthorityRecord::decode(vec_record_v3.as_slice()).unwrap(); assert_eq!(&addresses_v2_decoded.addresses, &vec_addresses); } + +#[test] +fn v3_decodes_v2() { + let peer_secret = Keypair::generate_ed25519(); + let peer_public = peer_secret.public(); + let peer_id = peer_public.to_peer_id(); + let multiaddress: Multiaddr = + format!("/ip4/127.0.0.1/tcp/3003/p2p/{}", peer_id).parse().unwrap(); + let vec_addresses = vec![multiaddress.to_vec()]; + let vec_auth_signature = b"Totally valid signature, I promise!".to_vec(); + let vec_peer_signature = b"Surprisingly hard to crack crypto".to_vec(); + + let record_v2 = schema_v2::AuthorityRecord { addresses: vec_addresses.clone() }; + let mut vec_record_v2 = vec![]; + record_v2.encode(&mut vec_record_v2).unwrap(); + let vec_peer_public = peer_public.encode_protobuf(); + let peer_signature_v2 = + schema_v2::PeerSignature { public_key: vec_peer_public, signature: vec_peer_signature }; + let signed_record_v2 = schema_v2::SignedAuthorityRecord { + record: vec_record_v2.clone(), + auth_signature: vec_auth_signature.clone(), + peer_signature: Some(peer_signature_v2.clone()), + }; + let mut vec_signed_record_v2 = vec![]; + signed_record_v2.encode(&mut vec_signed_record_v2).unwrap(); + + let signed_addresses_v3_decoded = + SignedAuthorityRecord::decode(vec_signed_record_v2.as_slice()).unwrap(); + + assert_eq!(&signed_addresses_v3_decoded.record, &vec_record_v2); + assert_eq!(&signed_addresses_v3_decoded.auth_signature, &vec_auth_signature); + + let addresses_v3_decoded = AuthorityRecord::decode(vec_record_v2.as_slice()).unwrap(); + assert_eq!(&addresses_v3_decoded.addresses, &vec_addresses); + assert_eq!(&addresses_v3_decoded.creation_time, &None); +} diff --git a/substrate/client/authority-discovery/src/worker/tests.rs b/substrate/client/authority-discovery/src/worker/tests.rs index caeac56c54073e53026ec3f8c52c8e7f88958f2b..b49615382b8a2b2734185da50fd5b9515d42b1d7 100644 --- a/substrate/client/authority-discovery/src/worker/tests.rs +++ b/substrate/client/authority-discovery/src/worker/tests.rs @@ -20,6 +20,7 @@ use std::{ collections::HashSet, sync::{Arc, Mutex}, task::Poll, + time::Instant, }; use futures::{ @@ -29,11 +30,15 @@ use futures::{ sink::SinkExt, task::LocalSpawn, }; -use libp2p::{core::multiaddr, identity::SigningError, kad::record::Key as KademliaKey, PeerId}; +use libp2p::{identity::SigningError, kad::record::Key as KademliaKey}; use prometheus_endpoint::prometheus::default_registry; use sc_client_api::HeaderBackend; use sc_network::{service::signature::Keypair, Signature}; +use sc_network_types::{ + multiaddr::{Multiaddr, Protocol}, + PeerId, +}; use sp_api::{ApiRef, ProvideRuntimeApi}; use sp_keystore::{testing::MemoryKeystore, Keystore}; use sp_runtime::traits::{Block as BlockT, NumberFor, Zero}; @@ -114,6 +119,8 @@ sp_api::mock_impl_runtime_apis! { pub enum TestNetworkEvent { GetCalled(KademliaKey), PutCalled(KademliaKey, Vec), + PutToCalled(Record, HashSet, bool), + StoreRecordCalled(KademliaKey, Vec, Option, Option), } pub struct TestNetwork { @@ -123,7 +130,11 @@ pub struct TestNetwork { // Whenever functions on `TestNetwork` are called, the function arguments are added to the // vectors below. pub put_value_call: Arc)>>>, + pub put_value_to_call: Arc, bool)>>>, pub get_value_call: Arc>>, + pub store_value_call: + Arc, Option, Option)>>>, + event_sender: mpsc::UnboundedSender, event_receiver: Option>, } @@ -144,6 +155,8 @@ impl Default for TestNetwork { external_addresses: vec!["/ip6/2001:db8::/tcp/30333".parse().unwrap()], put_value_call: Default::default(), get_value_call: Default::default(), + put_value_to_call: Default::default(), + store_value_call: Default::default(), event_sender: tx, event_receiver: Some(rx), } @@ -168,7 +181,7 @@ impl NetworkSigner for TestNetwork { let public_key = libp2p::identity::PublicKey::try_decode_protobuf(&public_key) .map_err(|error| error.to_string())?; let peer_id: PeerId = peer_id.into(); - let remote: libp2p::PeerId = public_key.to_peer_id(); + let remote: PeerId = public_key.to_peer_id().into(); Ok(peer_id == remote && public_key.verify(message, signature)) } @@ -189,6 +202,42 @@ impl NetworkDHTProvider for TestNetwork { .unbounded_send(TestNetworkEvent::GetCalled(key.clone())) .unwrap(); } + + fn put_record_to( + &self, + record: Record, + peers: HashSet, + update_local_storage: bool, + ) { + self.put_value_to_call.lock().unwrap().push(( + record.clone(), + peers.clone(), + update_local_storage, + )); + self.event_sender + .clone() + .unbounded_send(TestNetworkEvent::PutToCalled(record, peers, update_local_storage)) + .unwrap(); + } + + fn store_record( + &self, + key: KademliaKey, + value: Vec, + publisher: Option, + expires: Option, + ) { + self.store_value_call.lock().unwrap().push(( + key.clone(), + value.clone(), + publisher, + expires, + )); + self.event_sender + .clone() + .unbounded_send(TestNetworkEvent::StoreRecordCalled(key, value, publisher, expires)) + .unwrap(); + } } impl NetworkStateInfo for TestNetwork { @@ -233,9 +282,11 @@ fn build_dht_event( public_key: AuthorityId, key_store: &MemoryKeystore, network: Option<&Signer>, + creation_time: Option, ) -> Vec<(KademliaKey, Vec)> { let serialized_record = - serialize_authority_record(serialize_addresses(addresses.into_iter())).unwrap(); + serialize_authority_record(serialize_addresses(addresses.into_iter()), creation_time) + .unwrap(); let peer_signature = network.map(|n| sign_record_with_peer_id(&serialized_record, n).unwrap()); let kv_pairs = sign_record_with_authority_ids( @@ -343,7 +394,10 @@ fn publish_discover_cycle() { let dht_event = { let (key, value) = network.put_value_call.lock().unwrap().pop().unwrap(); - DhtEvent::ValueFound(vec![(key, value)]) + DhtEvent::ValueFound(PeerRecord { + peer: None, + record: Record { key, value, publisher: None, expires: None }, + }) }; // Node B discovering node A's address. @@ -435,7 +489,7 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() { let peer_id = PeerId::random(); let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap(); - address.with(multiaddr::Protocol::P2p(peer_id.into())) + address.with(Protocol::P2p(peer_id.into())) }; let remote_key_store = MemoryKeystore::new(); let remote_public_key: AuthorityId = remote_key_store @@ -486,21 +540,39 @@ fn dont_stop_polling_dht_event_stream_after_bogus_event() { // Send an event that should generate an error dht_event_tx - .send(DhtEvent::ValueFound(Default::default())) + .send(DhtEvent::ValueFound(PeerRecord { + peer: None, + record: Record { + key: vec![0x9u8].into(), + value: Default::default(), + publisher: None, + expires: None, + }, + })) .await .expect("Channel has capacity of 1."); // Make previously triggered lookup succeed. - let dht_event = { - let kv_pairs = build_dht_event::( - vec![remote_multiaddr.clone()], - remote_public_key.clone(), - &remote_key_store, - None, - ); - DhtEvent::ValueFound(kv_pairs) - }; - dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1."); + let kv_pairs: Vec = build_dht_event::( + vec![remote_multiaddr.clone()], + remote_public_key.clone(), + &remote_key_store, + None, + Some(build_creation_time()), + ) + .into_iter() + .map(|(key, value)| PeerRecord { + peer: None, + record: Record { key, value, publisher: None, expires: None }, + }) + .collect(); + + for kv_pair in kv_pairs { + dht_event_tx + .send(DhtEvent::ValueFound(kv_pair)) + .await + .expect("Channel has capacity of 1."); + } // Expect authority discovery to function normally, now knowing the // address for the remote node. @@ -552,37 +624,51 @@ impl DhtValueFoundTester { &mut self, strict_record_validation: bool, values: Vec<(KademliaKey, Vec)>, - ) -> Option<&HashSet> { + ) -> (Option>, Option>) { let (_dht_event_tx, dht_event_rx) = channel(1); let local_test_api = Arc::new(TestApi { authorities: vec![self.remote_authority_public.into()] }); - let local_network: Arc = Arc::new(Default::default()); let local_key_store = MemoryKeystore::new(); let (_to_worker, from_service) = mpsc::channel(0); - let mut local_worker = Worker::new( - from_service, - local_test_api, - local_network.clone(), - Box::pin(dht_event_rx), - Role::PublishAndDiscover(Arc::new(local_key_store)), - None, - WorkerConfig { strict_record_validation, ..Default::default() }, - ); + let (local_worker, local_network) = if let Some(local_work) = self.local_worker.as_mut() { + (local_work, None) + } else { + let local_network: Arc = Arc::new(Default::default()); + + self.local_worker = Some(Worker::new( + from_service, + local_test_api, + local_network.clone(), + Box::pin(dht_event_rx), + Role::PublishAndDiscover(Arc::new(local_key_store)), + None, + WorkerConfig { strict_record_validation, ..Default::default() }, + )); + (self.local_worker.as_mut().unwrap(), Some(local_network)) + }; block_on(local_worker.refill_pending_lookups_queue()).unwrap(); local_worker.start_new_lookups(); - drop(local_worker.handle_dht_value_found_event(values)); - - self.local_worker = Some(local_worker); + for record in values.into_iter().map(|(key, value)| PeerRecord { + peer: Some(PeerId::random().into()), + record: Record { key, value, publisher: None, expires: None }, + }) { + drop(local_worker.handle_dht_value_found_event(record)) + } - self.local_worker - .as_ref() - .map(|w| { - w.addr_cache.get_addresses_by_authority_id(&self.remote_authority_public.into()) - }) - .unwrap() + ( + self.local_worker + .as_ref() + .map(|w| { + w.addr_cache + .get_addresses_by_authority_id(&self.remote_authority_public.into()) + .cloned() + }) + .unwrap(), + local_network, + ) } } @@ -596,9 +682,10 @@ fn limit_number_of_addresses_added_to_cache_per_authority() { tester.remote_authority_public.into(), &tester.remote_key_store, None, + Some(build_creation_time()), ); - let cached_remote_addresses = tester.process_value_found(false, kv_pairs); + let cached_remote_addresses = tester.process_value_found(false, kv_pairs).0; assert_eq!(MAX_ADDRESSES_PER_AUTHORITY, cached_remote_addresses.unwrap().len()); } @@ -611,17 +698,242 @@ fn strict_accept_address_with_peer_signature() { tester.remote_authority_public.into(), &tester.remote_key_store, Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), ); - let cached_remote_addresses = tester.process_value_found(true, kv_pairs); + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; assert_eq!( - Some(&HashSet::from([addr])), + Some(HashSet::from([addr])), cached_remote_addresses, "Expect worker to only cache `Multiaddr`s with `PeerId`s.", ); } +#[test] +fn strict_accept_address_without_creation_time() { + let mut tester = DhtValueFoundTester::new(); + let addr = tester.multiaddr_with_peer_id(1); + let kv_pairs = build_dht_event( + vec![addr.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + None, + ); + + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; + + assert_eq!( + Some(HashSet::from([addr])), + cached_remote_addresses, + "Expect worker to cache address without creation time", + ); +} + +#[test] +fn keep_last_received_if_no_creation_time() { + let mut tester: DhtValueFoundTester = DhtValueFoundTester::new(); + let addr = tester.multiaddr_with_peer_id(1); + let kv_pairs = build_dht_event( + vec![addr.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + None, + ); + + let (cached_remote_addresses, network) = tester.process_value_found(true, kv_pairs); + + assert_eq!( + Some(HashSet::from([addr])), + cached_remote_addresses, + "Expect worker to cache address without creation time", + ); + + assert!(network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap_or_default()); + + let addr2 = tester.multiaddr_with_peer_id(2); + let kv_pairs = build_dht_event( + vec![addr2.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + None, + ); + + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; + + assert_eq!( + Some(HashSet::from([addr2])), + cached_remote_addresses, + "Expect worker to cache last received when no creation time", + ); + assert!(network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap_or_default()); +} + +#[test] +fn records_with_incorrectly_signed_creation_time_are_ignored() { + let mut tester: DhtValueFoundTester = DhtValueFoundTester::new(); + let addr = tester.multiaddr_with_peer_id(1); + let kv_pairs = build_dht_event( + vec![addr.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + + let (cached_remote_addresses, network) = tester.process_value_found(true, kv_pairs); + + assert_eq!( + Some(HashSet::from([addr.clone()])), + cached_remote_addresses, + "Expect worker to cache record with creation time", + ); + assert!(network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap_or_default()); + + let alternative_key = tester + .remote_key_store + .sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None) + .unwrap(); + + let addr2 = tester.multiaddr_with_peer_id(2); + let mut kv_pairs = build_dht_event( + vec![addr2.clone()], + alternative_key.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + let kademlia_key = hash_authority_id(tester.remote_authority_public.as_slice()); + for key in kv_pairs.iter_mut() { + key.0 = kademlia_key.clone(); + } + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; + + assert_eq!( + Some(HashSet::from([addr])), + cached_remote_addresses, + "Expect `Multiaddr` to remain the same", + ); + assert!(network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap_or_default()); +} + +#[test] +fn newer_records_overwrite_older_ones() { + let mut tester: DhtValueFoundTester = DhtValueFoundTester::new(); + let old_record = tester.multiaddr_with_peer_id(1); + let kv_pairs = build_dht_event( + vec![old_record.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + + let (cached_remote_addresses, network) = tester.process_value_found(true, kv_pairs); + + assert_eq!( + Some(HashSet::from([old_record])), + cached_remote_addresses, + "Expect worker to cache record with creation time", + ); + + let nothing_updated = network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap(); + assert!(nothing_updated); + + let new_record = tester.multiaddr_with_peer_id(2); + let kv_pairs = build_dht_event( + vec![new_record.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; + + assert_eq!( + Some(HashSet::from([new_record])), + cached_remote_addresses, + "Expect worker to store the newest recrod", + ); + + let result = network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().first().unwrap().clone()) + .unwrap(); + assert!(matches!(result, (_, _, false))); + assert_eq!(result.1.len(), 1); +} + +#[test] +fn older_records_dont_affect_newer_ones() { + let mut tester: DhtValueFoundTester = DhtValueFoundTester::new(); + let old_record = tester.multiaddr_with_peer_id(1); + let old_kv_pairs = build_dht_event( + vec![old_record.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + + let new_record = tester.multiaddr_with_peer_id(2); + let kv_pairs = build_dht_event( + vec![new_record.clone()], + tester.remote_authority_public.into(), + &tester.remote_key_store, + Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), + ); + + let (cached_remote_addresses, network) = tester.process_value_found(true, kv_pairs); + + assert_eq!( + Some(HashSet::from([new_record.clone()])), + cached_remote_addresses, + "Expect worker to store new record", + ); + + let nothing_updated = network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().is_empty()) + .unwrap(); + assert!(nothing_updated); + + let cached_remote_addresses = tester.process_value_found(true, old_kv_pairs).0; + + assert_eq!( + Some(HashSet::from([new_record])), + cached_remote_addresses, + "Expect worker to not update stored record", + ); + + let update_peers_info = network + .as_ref() + .map(|network| network.put_value_to_call.lock().unwrap().remove(0)) + .unwrap(); + assert!(matches!(update_peers_info, (_, _, false))); + assert_eq!(update_peers_info.1.len(), 1); +} + #[test] fn reject_address_with_rogue_peer_signature() { let mut tester = DhtValueFoundTester::new(); @@ -631,9 +943,10 @@ fn reject_address_with_rogue_peer_signature() { tester.remote_authority_public.into(), &tester.remote_key_store, Some(&TestSigner { keypair: &rogue_remote_node_key }), + Some(build_creation_time()), ); - let cached_remote_addresses = tester.process_value_found(false, kv_pairs); + let cached_remote_addresses = tester.process_value_found(false, kv_pairs).0; assert!( cached_remote_addresses.is_none(), @@ -649,13 +962,14 @@ fn reject_address_with_invalid_peer_signature() { tester.remote_authority_public.into(), &tester.remote_key_store, Some(&TestSigner { keypair: &tester.remote_node_key }), + Some(build_creation_time()), ); // tamper with the signature let mut record = schema::SignedAuthorityRecord::decode(kv_pairs[0].1.as_slice()).unwrap(); record.peer_signature.as_mut().map(|p| p.signature[1] = !p.signature[1]); record.encode(&mut kv_pairs[0].1).unwrap(); - let cached_remote_addresses = tester.process_value_found(false, kv_pairs); + let cached_remote_addresses = tester.process_value_found(false, kv_pairs).0; assert!( cached_remote_addresses.is_none(), @@ -671,9 +985,10 @@ fn reject_address_without_peer_signature() { tester.remote_authority_public.into(), &tester.remote_key_store, None, + Some(build_creation_time()), ); - let cached_remote_addresses = tester.process_value_found(true, kv_pairs); + let cached_remote_addresses = tester.process_value_found(true, kv_pairs).0; assert!(cached_remote_addresses.is_none(), "Expected worker to ignore unsigned record.",); } @@ -689,12 +1004,13 @@ fn do_not_cache_addresses_without_peer_id() { tester.remote_authority_public.into(), &tester.remote_key_store, None, + Some(build_creation_time()), ); - let cached_remote_addresses = tester.process_value_found(false, kv_pairs); + let cached_remote_addresses = tester.process_value_found(false, kv_pairs).0; assert_eq!( - Some(&HashSet::from([multiaddr_with_peer_id])), + Some(HashSet::from([multiaddr_with_peer_id])), cached_remote_addresses, "Expect worker to only cache `Multiaddr`s with `PeerId`s.", ); @@ -832,16 +1148,24 @@ fn lookup_throttling() { // Make first lookup succeed. let remote_hash = network.get_value_call.lock().unwrap().pop().unwrap(); let remote_key: AuthorityId = remote_hash_to_key.get(&remote_hash).unwrap().clone(); - let dht_event = { - let kv_pairs = build_dht_event::( - vec![remote_multiaddr.clone()], - remote_key, - &remote_key_store, - None, - ); - DhtEvent::ValueFound(kv_pairs) - }; - dht_event_tx.send(dht_event).await.expect("Channel has capacity of 1."); + let kv_pairs = build_dht_event::( + vec![remote_multiaddr.clone()], + remote_key, + &remote_key_store, + None, + Some(build_creation_time()), + ) + .into_iter() + .map(|(key, value)| PeerRecord { + peer: None, + record: Record { key, value, publisher: None, expires: None }, + }); + for kv_pair in kv_pairs { + dht_event_tx + .send(DhtEvent::ValueFound(kv_pair)) + .await + .expect("Channel has capacity of 1."); + } // Assert worker to trigger another lookup. assert!(matches!(receiver.next().await, Some(TestNetworkEvent::GetCalled(_)))); @@ -867,3 +1191,161 @@ fn lookup_throttling() { .boxed_local(), ); } + +#[test] +fn test_handle_put_record_request() { + let local_node_network = TestNetwork::default(); + let remote_node_network = TestNetwork::default(); + let peer_id = remote_node_network.peer_id; + + let remote_multiaddr = { + let address: Multiaddr = "/ip6/2001:db8:0:0:0:0:0:1/tcp/30333".parse().unwrap(); + + address.with(multiaddr::Protocol::P2p(remote_node_network.peer_id.into())) + }; + + println!("{:?}", remote_multiaddr); + let remote_key_store = MemoryKeystore::new(); + let remote_public_keys: Vec = (0..20) + .map(|_| { + remote_key_store + .sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None) + .unwrap() + .into() + }) + .collect(); + + let remote_non_authorithy_keys: Vec = (0..20) + .map(|_| { + remote_key_store + .sr25519_generate_new(key_types::AUTHORITY_DISCOVERY, None) + .unwrap() + .into() + }) + .collect(); + + let (_dht_event_tx, dht_event_rx) = channel(1); + let (_to_worker, from_service) = mpsc::channel(0); + let network = Arc::new(local_node_network); + let mut worker = Worker::new( + from_service, + Arc::new(TestApi { authorities: remote_public_keys.clone() }), + network.clone(), + dht_event_rx.boxed(), + Role::Discover, + Some(default_registry().clone()), + Default::default(), + ); + + let mut pool = LocalPool::new(); + + let valid_authorithy_key = remote_public_keys.first().unwrap().clone(); + + let kv_pairs = build_dht_event( + vec![remote_multiaddr.clone()], + valid_authorithy_key.clone().into(), + &remote_key_store, + Some(&TestSigner { keypair: &remote_node_network.identity }), + Some(build_creation_time()), + ); + + pool.run_until( + async { + // Invalid format should return an error. + for authority in remote_public_keys.iter() { + let key = hash_authority_id(authority.as_ref()); + assert!(matches!( + worker.handle_put_record_requested(key, vec![0x0], Some(peer_id), None).await, + Err(Error::DecodingProto(_)) + )); + } + let prev_requested_authorithies = worker.authorities_queried_at; + + // Unknown authority should return an error. + for authority in remote_non_authorithy_keys.iter() { + let key = hash_authority_id(authority.as_ref()); + assert!(matches!( + worker.handle_put_record_requested(key, vec![0x0], Some(peer_id), None).await, + Err(Error::UnknownAuthority) + )); + assert!(prev_requested_authorithies == worker.authorities_queried_at); + } + assert_eq!(network.store_value_call.lock().unwrap().len(), 0); + + // Valid authority should return Ok. + for (key, value) in kv_pairs.clone() { + assert!(worker + .handle_put_record_requested(key, value, Some(peer_id), None) + .await + .is_ok()); + } + assert_eq!(network.store_value_call.lock().unwrap().len(), 1); + + let another_authorithy_id = remote_public_keys.get(3).unwrap().clone(); + let key = hash_authority_id(another_authorithy_id.as_ref()); + + // Valid record signed with a different key should return error. + for (_, value) in kv_pairs.clone() { + assert!(matches!( + worker + .handle_put_record_requested(key.clone(), value, Some(peer_id), None) + .await, + Err(Error::VerifyingDhtPayload) + )); + } + assert_eq!(network.store_value_call.lock().unwrap().len(), 1); + let newer_kv_pairs = build_dht_event( + vec![remote_multiaddr], + valid_authorithy_key.clone().into(), + &remote_key_store, + Some(&TestSigner { keypair: &remote_node_network.identity }), + Some(build_creation_time()), + ); + + // Valid old authority, should not throw error, but it should not be stored since a + // newer one already exists. + for (new_key, new_value) in newer_kv_pairs.clone() { + worker.in_flight_lookups.insert(new_key.clone(), valid_authorithy_key.clone()); + + let found = PeerRecord { + peer: Some(peer_id.into()), + record: Record { + key: new_key, + value: new_value, + publisher: Some(peer_id.into()), + expires: None, + }, + }; + assert!(worker.handle_dht_value_found_event(found).is_ok()); + } + + for (key, value) in kv_pairs.clone() { + assert!(worker + .handle_put_record_requested(key, value, Some(peer_id), None) + .await + .is_ok()); + } + assert_eq!(network.store_value_call.lock().unwrap().len(), 1); + + // Newer kv pairs should always be stored. + for (key, value) in newer_kv_pairs.clone() { + assert!(worker + .handle_put_record_requested(key, value, Some(peer_id), None) + .await + .is_ok()); + } + + assert_eq!(network.store_value_call.lock().unwrap().len(), 2); + + worker.refill_pending_lookups_queue().await.unwrap(); + assert_eq!(worker.last_known_records.len(), 1); + + // Check known records gets clean up, when an authorithy gets out of the + // active set. + worker.client = Arc::new(TestApi { authorities: Default::default() }); + worker.refill_pending_lookups_queue().await.unwrap(); + assert_eq!(worker.last_known_records.len(), 0); + } + .boxed_local(), + ); +} diff --git a/substrate/client/basic-authorship/Cargo.toml b/substrate/client/basic-authorship/Cargo.toml index 4890b66c9b2f91ef13ea74fa9f66c797d0beb32c..cc2e0d8d04dfef0a0ea122a954c3f62dde658e6d 100644 --- a/substrate/client/basic-authorship/Cargo.toml +++ b/substrate/client/basic-authorship/Cargo.toml @@ -4,7 +4,7 @@ version = "0.34.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Basic implementation of block-authoring logic." readme = "README.md" @@ -16,24 +16,24 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" -futures-timer = "3.0.1" +codec = { workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../utils/prometheus" } -sc-block-builder = { path = "../block-builder" } -sc-proposer-metrics = { path = "../proposer-metrics" } -sc-telemetry = { path = "../telemetry" } -sc-transaction-pool-api = { path = "../transaction-pool/api" } -sp-api = { path = "../../primitives/api" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-consensus = { path = "../../primitives/consensus/common" } -sp-core = { path = "../../primitives/core" } -sp-inherents = { path = "../../primitives/inherents" } -sp-runtime = { path = "../../primitives/runtime" } +prometheus-endpoint = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-proposer-metrics = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -parking_lot = "0.12.1" -sc-client-api = { path = "../api" } -sc-transaction-pool = { path = "../transaction-pool" } -substrate-test-runtime-client = { path = "../../test-utils/runtime/client" } +parking_lot = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/basic-authorship/src/basic_authorship.rs b/substrate/client/basic-authorship/src/basic_authorship.rs index 1519c76c42c0efab1fa59c7e53bed41c5e104f9b..527a3d12d9e766c3b15c158ed1fafed8dc56f08c 100644 --- a/substrate/client/basic-authorship/src/basic_authorship.rs +++ b/substrate/client/basic-authorship/src/basic_authorship.rs @@ -205,7 +205,11 @@ where ) -> Proposer { let parent_hash = parent_header.hash(); - info!("🙌 Starting consensus session on top of parent {:?}", parent_hash); + info!( + "🙌 Starting consensus session on top of parent {:?} (#{})", + parent_hash, + parent_header.number() + ); let proposer = Proposer::<_, _, _, PR> { spawn_handle: self.spawn_handle.clone(), @@ -848,7 +852,7 @@ mod tests { block }; - let import_and_maintain = |mut client: Arc, block: TestBlock| { + let import_and_maintain = |client: Arc, block: TestBlock| { let hash = block.hash(); block_on(client.import(BlockOrigin::Own, block)).unwrap(); block_on(txpool.maintain(chain_event( diff --git a/substrate/client/block-builder/Cargo.toml b/substrate/client/block-builder/Cargo.toml index e74d587d9b40fc57e0575b0fae7ecb0c5a177c15..08392e18227f93a2fec12ee7796433c68d4122c8 100644 --- a/substrate/client/block-builder/Cargo.toml +++ b/substrate/client/block-builder/Cargo.toml @@ -4,7 +4,7 @@ version = "0.33.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Substrate block builder" readme = "README.md" @@ -16,17 +16,17 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", features = [ +codec = { features = [ "derive", -] } -sp-api = { path = "../../primitives/api" } -sp-block-builder = { path = "../../primitives/block-builder" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-core = { path = "../../primitives/core" } -sp-trie = { path = "../../primitives/trie" } -sp-inherents = { path = "../../primitives/inherents" } -sp-runtime = { path = "../../primitives/runtime" } +], workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -sp-state-machine = { path = "../../primitives/state-machine" } -substrate-test-runtime-client = { path = "../../test-utils/runtime/client" } +sp-state-machine = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/chain-spec/Cargo.toml b/substrate/client/chain-spec/Cargo.toml index dd7bb3598c2c5d3fefdc588f21988cb3cc4c1c82..2e885240936fe94fcdd408a56e512eec2cf46f5a 100644 --- a/substrate/client/chain-spec/Cargo.toml +++ b/substrate/client/chain-spec/Cargo.toml @@ -4,7 +4,7 @@ version = "28.0.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Substrate chain configurations." readme = "README.md" @@ -16,29 +16,31 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] } -memmap2 = "0.9.3" +clap = { features = ["derive"], optional = true, workspace = true } +codec = { features = ["derive"], workspace = true } +memmap2 = { workspace = true } serde = { features = ["derive"], workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } -sc-client-api = { path = "../api" } -sc-chain-spec-derive = { path = "derive" } -sc-executor = { path = "../executor" } -sp-io = { default-features = false, path = "../../primitives/io" } -sc-network = { path = "../network" } -sc-telemetry = { path = "../telemetry" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-core = { path = "../../primitives/core" } -sp-crypto-hashing = { path = "../../primitives/crypto/hashing" } -sp-genesis-builder = { path = "../../primitives/genesis-builder" } -sp-runtime = { path = "../../primitives/runtime" } -sp-state-machine = { path = "../../primitives/state-machine" } +sc-client-api = { workspace = true, default-features = true } +sc-chain-spec-derive = { workspace = true, default-features = true } +sc-executor = { workspace = true, default-features = true } +sp-io = { workspace = true } +sc-network = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-genesis-builder = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } log = { workspace = true } -sp-tracing = { path = "../../primitives/tracing" } -array-bytes = "6.2.2" -docify = "0.2.8" +sp-tracing = { workspace = true, default-features = true } +array-bytes = { workspace = true, default-features = true } +docify = { workspace = true } [dev-dependencies] -substrate-test-runtime = { path = "../../test-utils/runtime" } -sp-keyring = { path = "../../primitives/keyring" } -sp-application-crypto = { default-features = false, path = "../../primitives/application-crypto", features = ["serde"] } -sp-consensus-babe = { default-features = false, path = "../../primitives/consensus/babe", features = ["serde"] } +substrate-test-runtime = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-application-crypto = { features = ["serde"], workspace = true } +sp-consensus-babe = { features = ["serde"], workspace = true } +regex = { workspace = true } diff --git a/substrate/client/chain-spec/derive/Cargo.toml b/substrate/client/chain-spec/derive/Cargo.toml index 521eee578ecae3b03cf86a3b4e3630bb7cd22f02..ccd898447beaca06db3f2d561bab7f8cb6244954 100644 --- a/substrate/client/chain-spec/derive/Cargo.toml +++ b/substrate/client/chain-spec/derive/Cargo.toml @@ -4,7 +4,7 @@ version = "11.0.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Macros to derive chain spec extension traits implementation." @@ -18,7 +18,7 @@ targets = ["x86_64-unknown-linux-gnu"] proc-macro = true [dependencies] -proc-macro-crate = "3.0.0" -proc-macro2 = "1.0.56" +proc-macro-crate = { workspace = true } +proc-macro2 = { workspace = true } quote = { workspace = true } syn = { workspace = true } diff --git a/substrate/client/chain-spec/derive/src/impls.rs b/substrate/client/chain-spec/derive/src/impls.rs index c0624897c133e6ebd3ecda6556d628dccee3c53b..d8b20c5c2a8cca93bd2a6bc8da051ea3746c1e4e 100644 --- a/substrate/client/chain-spec/derive/src/impls.rs +++ b/substrate/client/chain-spec/derive/src/impls.rs @@ -19,7 +19,7 @@ use proc_macro2::{Span, TokenStream}; use proc_macro_crate::{crate_name, FoundCrate}; use quote::quote; -use syn::{DeriveInput, Error, Ident}; +use syn::{DeriveInput, Error, Ident, Path}; const CRATE_NAME: &str = "sc-chain-spec"; const ATTRIBUTE_NAME: &str = "forks"; @@ -143,7 +143,7 @@ pub fn group_derive(ast: &DeriveInput) -> proc_macro::TokenStream { pub fn derive( ast: &DeriveInput, derive: impl Fn( - &Ident, + &Path, &Ident, &syn::Generics, Vec<&Ident>, @@ -171,25 +171,28 @@ pub fn derive( }; let name = &ast.ident; - let crate_name = match crate_name(CRATE_NAME) { + let crate_path = match crate_name(CRATE_NAME) { Ok(FoundCrate::Itself) => CRATE_NAME.replace("-", "_"), Ok(FoundCrate::Name(chain_spec_name)) => chain_spec_name, - Err(e) => { - let err = Error::new(Span::call_site(), &e).to_compile_error(); - return quote!( #err ).into() + Err(e) => match crate_name("polkadot-sdk") { + Ok(FoundCrate::Name(sdk)) => format!("{sdk}::{CRATE_NAME}").replace("-", "_"), + _ => { + return Error::new(Span::call_site(), &e).to_compile_error().into(); + }, }, }; - let crate_name = Ident::new(&crate_name, Span::call_site()); + let crate_path = + syn::parse_str::(&crate_path).expect("crate_name returns valid path; qed"); let field_names = fields.named.iter().flat_map(|x| x.ident.as_ref()).collect::>(); let field_types = fields.named.iter().map(|x| &x.ty).collect::>(); - derive(&crate_name, name, &ast.generics, field_names, field_types, fields).into() + derive(&crate_path, name, &ast.generics, field_names, field_types, fields).into() } -fn generate_fork_fields(crate_name: &Ident, names: &[&Ident], types: &[&syn::Type]) -> TokenStream { - let crate_name = std::iter::repeat(crate_name); +fn generate_fork_fields(crate_path: &Path, names: &[&Ident], types: &[&syn::Type]) -> TokenStream { + let crate_path = std::iter::repeat(crate_path); quote! { - #( pub #names: Option<<#types as #crate_name::Group>::Fork>, )* + #( pub #names: Option<<#types as #crate_path::Group>::Fork>, )* } } diff --git a/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err b/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err deleted file mode 100644 index c545b53b2bafea88af090236f825bbafe2baf8f8..0000000000000000000000000000000000000000 --- a/substrate/client/chain-spec/res/chain_spec_as_json_fails_with_invalid_config.err +++ /dev/null @@ -1,114 +0,0 @@ -Invalid JSON blob: unknown field `babex`, expected one of `system`, `babe`, `substrateTest`, `balances` at line 3 column 9 for blob: -{ - "system": {}, - "babex": { - "authorities": [ - [ - "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY", - 1 - ], - [ - "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", - 1 - ], - [ - "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y", - 1 - ] - ], - "epochConfig": { - "c": [ - 3, - 10 - ], - "allowed_slots": "PrimaryAndSecondaryPlainSlots" - } - }, - "substrateTest": { - "authorities": [ - "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY", - "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", - "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y" - ] - }, - "balances": { - "balances": [ - [ - "5D34dL5prEUaGNQtPPZ3yN5Y6BnkfXunKXXz6fo7ZJbLwRRH", - 100000000000000000 - ], - [ - "5GBNeWRhZc2jXu7D55rBimKYDk8PGk8itRYFTPfC8RJLKG5o", - 100000000000000000 - ], - [ - "5Dfis6XL8J2P6JHUnUtArnFWndn62SydeP8ee8sG2ky9nfm9", - 100000000000000000 - ], - [ - "5F4H97f7nQovyrbiq4ZetaaviNwThSVcFobcA5aGab6167dK", - 100000000000000000 - ], - [ - "5DiDShBWa1fQx6gLzpf3SFBhMinCoyvHM1BWjPNsmXS8hkrW", - 100000000000000000 - ], - [ - "5EFb84yH9tpcFuiKUcsmdoF7xeeY3ajG1ZLQimxQoFt9HMKR", - 100000000000000000 - ], - [ - "5DZLHESsfGrJ5YzT3HuRPXsSNb589xQ4Unubh1mYLodzKdVY", - 100000000000000000 - ], - [ - "5GHJzqvG6tXnngCpG7B12qjUvbo5e4e9z8Xjidk3CQZHxTPZ", - 100000000000000000 - ], - [ - "5CUnSsgAyLND3bxxnfNhgWXSe9Wn676JzLpGLgyJv858qhoX", - 100000000000000000 - ], - [ - "5CVKn7HAZW1Ky4r7Vkgsr7VEW88C2sHgUNDiwHY9Ct2hjU8q", - 100000000000000000 - ], - [ - "5H673aukQ4PeDe1U2nuv1bi32xDEziimh3PZz7hDdYUB7TNz", - 100000000000000000 - ], - [ - "5HTe9L15LJryjUAt1jZXZCBPnzbbGnpvFwbjE3NwCWaAqovf", - 100000000000000000 - ], - [ - "5D7LFzGpMwHPyDBavkRbWSKWTtJhCaPPZ379wWLT23bJwXJz", - 100000000000000000 - ], - [ - "5CLepMARnEgtVR1EkUuJVUvKh97gzergpSxUU3yKGx1v6EwC", - 100000000000000000 - ], - [ - "5Chb2UhfvZpmjjEziHbFbotM4quX32ZscRV6QJBt1rUKzz51", - 100000000000000000 - ], - [ - "5HmRp3i3ZZk7xsAvbi8hyXVP6whSMnBJGebVC4FsiZVhx52e", - 100000000000000000 - ], - [ - "5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY", - 100000000000000000 - ], - [ - "5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", - 100000000000000000 - ], - [ - "5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y", - 100000000000000000 - ] - ] - } -} \ No newline at end of file diff --git a/substrate/client/chain-spec/src/chain_spec.rs b/substrate/client/chain-spec/src/chain_spec.rs index a9cdce4bf95580f6c00cbf27b0330779e4f39a28..aa3c1ba3e6f132f2b400b6c1dd8a7af2ad1aa9b9 100644 --- a/substrate/client/chain-spec/src/chain_spec.rs +++ b/substrate/client/chain-spec/src/chain_spec.rs @@ -20,7 +20,7 @@ #![warn(missing_docs)] use crate::{ extension::GetExtension, genesis_config_builder::HostFunctions, ChainType, - GenesisConfigBuilderRuntimeCaller as RuntimeCaller, Properties, RuntimeGenesis, + GenesisConfigBuilderRuntimeCaller as RuntimeCaller, Properties, }; use sc_network::config::MultiaddrWithPeerId; use sc_telemetry::TelemetryEndpoints; @@ -37,7 +37,6 @@ use std::{ fs::File, marker::PhantomData, path::PathBuf, - sync::Arc, }; #[derive(Serialize, Deserialize)] @@ -58,37 +57,33 @@ impl Clone for GenesisBuildAction { } } -#[allow(deprecated)] -enum GenesisSource { +enum GenesisSource { File(PathBuf), Binary(Cow<'static, [u8]>), /// factory function + code - //Factory and G type parameter shall be removed together with `ChainSpec::from_genesis` - Factory(Arc G + Send + Sync>, Vec), Storage(Storage), /// build action + code GenesisBuilderApi(GenesisBuildAction, Vec), } -impl Clone for GenesisSource { +impl Clone for GenesisSource { fn clone(&self) -> Self { match *self { Self::File(ref path) => Self::File(path.clone()), Self::Binary(ref d) => Self::Binary(d.clone()), - Self::Factory(ref f, ref c) => Self::Factory(f.clone(), c.clone()), Self::Storage(ref s) => Self::Storage(s.clone()), Self::GenesisBuilderApi(ref s, ref c) => Self::GenesisBuilderApi(s.clone(), c.clone()), } } } -impl GenesisSource { - fn resolve(&self) -> Result, String> { +impl GenesisSource { + fn resolve(&self) -> Result { /// helper container for deserializing genesis from the JSON file (ChainSpec JSON file is /// also supported here) #[derive(Serialize, Deserialize)] - struct GenesisContainer { - genesis: Genesis, + struct GenesisContainer { + genesis: Genesis, } match self { @@ -105,19 +100,15 @@ impl GenesisSource { })? }; - let genesis: GenesisContainer = json::from_slice(&bytes) + let genesis: GenesisContainer = json::from_slice(&bytes) .map_err(|e| format!("Error parsing spec file: {}", e))?; Ok(genesis.genesis) }, Self::Binary(buf) => { - let genesis: GenesisContainer = json::from_reader(buf.as_ref()) + let genesis: GenesisContainer = json::from_reader(buf.as_ref()) .map_err(|e| format!("Error parsing embedded file: {}", e))?; Ok(genesis.genesis) }, - Self::Factory(f, code) => Ok(Genesis::RuntimeAndCode(RuntimeInnerWrapper { - runtime: f(), - code: code.clone(), - })), Self::Storage(storage) => Ok(Genesis::Raw(RawGenesis::from(storage.clone()))), Self::GenesisBuilderApi(GenesisBuildAction::Full(config), code) => Ok(Genesis::RuntimeGenesis(RuntimeGenesisInner { @@ -140,24 +131,12 @@ impl GenesisSource { } } -impl BuildStorage for ChainSpec +impl BuildStorage for ChainSpec where EHF: HostFunctions, { fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> { match self.genesis.resolve()? { - #[allow(deprecated)] - Genesis::Runtime(runtime_genesis_config) => { - runtime_genesis_config.assimilate_storage(storage)?; - }, - #[allow(deprecated)] - Genesis::RuntimeAndCode(RuntimeInnerWrapper { - runtime: runtime_genesis_config, - code, - }) => { - runtime_genesis_config.assimilate_storage(storage)?; - storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code); - }, Genesis::Raw(RawGenesis { top: map, children_default: children_map }) => { storage.top.extend(map.into_iter().map(|(k, v)| (k.0, v.0))); children_map.into_iter().for_each(|(k, v)| { @@ -236,7 +215,7 @@ impl From for RawGenesis { } } -/// Inner representation of [`Genesis::RuntimeGenesis`] format +/// Inner representation of [`Genesis::RuntimeGenesis`] format #[derive(Serialize, Deserialize, Debug)] struct RuntimeGenesisInner { /// Runtime wasm code, expected to be hex-encoded in JSON. @@ -249,7 +228,7 @@ struct RuntimeGenesisInner { } /// Represents two possible variants of the contained JSON blob for the -/// [`Genesis::RuntimeGenesis`] format. +/// [`Genesis::RuntimeGenesis`] format. #[derive(Serialize, Deserialize, Debug)] #[serde(rename_all = "camelCase")] enum RuntimeGenesisConfigJson { @@ -265,31 +244,11 @@ enum RuntimeGenesisConfigJson { Patch(json::Value), } -/// Inner variant wrapper for deprecated runtime. -#[derive(Serialize, Deserialize, Debug)] -struct RuntimeInnerWrapper { - /// The native `RuntimeGenesisConfig` struct. - runtime: G, - /// Runtime code. - #[serde(with = "sp_core::bytes")] - code: Vec, -} - /// Represents the different formats of the genesis state within chain spec JSON blob. #[derive(Serialize, Deserialize)] #[serde(rename_all = "camelCase")] #[serde(deny_unknown_fields)] -enum Genesis { - /// (Deprecated) Contains the JSON representation of G (the native type representing the - /// runtime's `RuntimeGenesisConfig` struct) (will be removed with `ChainSpec::from_genesis`) - /// without the runtime code. It is required to deserialize the legacy chainspecs generated - /// with `ChainsSpec::from_genesis` method. - Runtime(G), - /// (Deprecated) Contains the JSON representation of G (the native type representing the - /// runtime's `RuntimeGenesisConfig` struct) (will be removed with `ChainSpec::from_genesis`) - /// and the runtime code. It is required to create and deserialize JSON chainspecs created with - /// deprecated `ChainSpec::from_genesis` method. - RuntimeAndCode(RuntimeInnerWrapper), +enum Genesis { /// The genesis storage as raw data. Typically raw key-value entries in state. Raw(RawGenesis), /// State root hash of the genesis storage. @@ -343,7 +302,7 @@ struct ClientSpec { pub type NoExtension = Option<()>; /// Builder for creating [`ChainSpec`] instances. -pub struct ChainSpecBuilder { +pub struct ChainSpecBuilder { code: Vec, extensions: E, name: String, @@ -355,10 +314,9 @@ pub struct ChainSpecBuilder { protocol_id: Option, fork_id: Option, properties: Option, - _genesis: PhantomData, } -impl ChainSpecBuilder { +impl ChainSpecBuilder { /// Creates a new builder instance with no defaults. pub fn new(code: &[u8], extensions: E) -> Self { Self { @@ -367,13 +325,12 @@ impl ChainSpecBuilder { name: "Development".to_string(), id: "dev".to_string(), chain_type: ChainType::Local, - genesis_build_action: GenesisBuildAction::Patch(Default::default()), + genesis_build_action: GenesisBuildAction::Patch(json::json!({})), boot_nodes: None, telemetry_endpoints: None, protocol_id: None, fork_id: None, properties: None, - _genesis: Default::default(), } } @@ -457,7 +414,7 @@ impl ChainSpecBuilder { } /// Builds a [`ChainSpec`] instance using the provided settings. - pub fn build(self) -> ChainSpec { + pub fn build(self) -> ChainSpec { let client_spec = ClientSpec { name: self.name, id: self.id, @@ -486,13 +443,13 @@ impl ChainSpecBuilder { /// The chain spec is generic over the native `RuntimeGenesisConfig` struct (`G`). It is also /// possible to parametrize chain spec over the extended host functions (EHF). It should be use if /// runtime is using the non-standard host function during genesis state creation. -pub struct ChainSpec { +pub struct ChainSpec { client_spec: ClientSpec, - genesis: GenesisSource, + genesis: GenesisSource, _host_functions: PhantomData, } -impl Clone for ChainSpec { +impl Clone for ChainSpec { fn clone(&self) -> Self { ChainSpec { client_spec: self.client_spec.clone(), @@ -502,7 +459,7 @@ impl Clone for ChainSpec { } } -impl ChainSpec { +impl ChainSpec { /// A list of bootnode addresses. pub fn boot_nodes(&self) -> &[MultiaddrWithPeerId] { &self.client_spec.boot_nodes @@ -555,58 +512,18 @@ impl ChainSpec { &mut self.client_spec.extensions } - /// Create hardcoded spec. - #[deprecated( - note = "`from_genesis` is planned to be removed in May 2024. Use `builder()` instead." - )] - // deprecated note: Genesis::Runtime + GenesisSource::Factory shall also be removed - pub fn from_genesis G + 'static + Send + Sync>( - name: &str, - id: &str, - chain_type: ChainType, - constructor: F, - boot_nodes: Vec, - telemetry_endpoints: Option, - protocol_id: Option<&str>, - fork_id: Option<&str>, - properties: Option, - extensions: E, - code: &[u8], - ) -> Self { - let client_spec = ClientSpec { - name: name.to_owned(), - id: id.to_owned(), - chain_type, - boot_nodes, - telemetry_endpoints, - protocol_id: protocol_id.map(str::to_owned), - fork_id: fork_id.map(str::to_owned), - properties, - extensions, - consensus_engine: (), - genesis: Default::default(), - code_substitutes: BTreeMap::new(), - }; - - ChainSpec { - client_spec, - genesis: GenesisSource::Factory(Arc::new(constructor), code.into()), - _host_functions: Default::default(), - } - } - /// Type of the chain. fn chain_type(&self) -> ChainType { self.client_spec.chain_type.clone() } /// Provides a `ChainSpec` builder. - pub fn builder(code: &[u8], extensions: E) -> ChainSpecBuilder { + pub fn builder(code: &[u8], extensions: E) -> ChainSpecBuilder { ChainSpecBuilder::new(code, extensions) } } -impl ChainSpec { +impl ChainSpec { /// Parse json content into a `ChainSpec` pub fn from_json_bytes(json: impl Into>) -> Result { let json = json.into(); @@ -649,17 +566,17 @@ impl ChainS #[derive(Serialize, Deserialize)] // we cannot #[serde(deny_unknown_fields)]. Otherwise chain-spec-builder will fail on any // non-standard spec. -struct ChainSpecJsonContainer { +struct ChainSpecJsonContainer { #[serde(flatten)] client_spec: ClientSpec, - genesis: Genesis, + genesis: Genesis, } -impl ChainSpec +impl ChainSpec where EHF: HostFunctions, { - fn json_container(&self, raw: bool) -> Result, String> { + fn json_container(&self, raw: bool) -> Result, String> { let raw_genesis = match (raw, self.genesis.resolve()?) { ( true, @@ -685,20 +602,7 @@ where storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code); RawGenesis::from(storage) }, - - #[allow(deprecated)] - (true, Genesis::RuntimeAndCode(RuntimeInnerWrapper { runtime: g, code })) => { - let mut storage = g.build_storage()?; - storage.top.insert(sp_core::storage::well_known_keys::CODE.to_vec(), code); - RawGenesis::from(storage) - }, - #[allow(deprecated)] - (true, Genesis::Runtime(g)) => { - let storage = g.build_storage()?; - RawGenesis::from(storage) - }, (true, Genesis::Raw(raw)) => raw, - (_, genesis) => return Ok(ChainSpecJsonContainer { client_spec: self.client_spec.clone(), genesis }), }; @@ -716,9 +620,8 @@ where } } -impl crate::ChainSpec for ChainSpec +impl crate::ChainSpec for ChainSpec where - G: RuntimeGenesis + 'static, E: GetExtension + serde::Serialize + Clone + Send + Sync + 'static, EHF: HostFunctions, { @@ -831,8 +734,8 @@ fn json_contains_path(doc: &json::Value, path: &mut VecDeque<&str>) -> bool { /// This function updates the code in given chain spec. /// -/// Function support updating the runtime code in provided JSON chain spec blob. `Genesis::Raw` -/// and `Genesis::RuntimeGenesis` formats are supported. +/// Function support updating the runtime code in provided JSON chain spec blob. `Genesis::Raw` +/// and `Genesis::RuntimeGenesis` formats are supported. /// /// If update was successful `true` is returned, otherwise `false`. Chain spec JSON is modified in /// place. @@ -863,6 +766,16 @@ pub fn update_code_in_json_chain_spec(chain_spec: &mut json::Value, code: &[u8]) } } +/// This function sets a codeSubstitute in the chain spec. +pub fn set_code_substitute_in_json_chain_spec( + chain_spec: &mut json::Value, + code: &[u8], + block_height: u64, +) { + let substitutes = json::json!({"codeSubstitutes":{ &block_height.to_string(): sp_core::bytes::to_hex(code, false) }}); + crate::json_patch::merge(chain_spec, substitutes); +} + #[cfg(test)] mod tests { use super::*; @@ -871,19 +784,7 @@ mod tests { use sp_core::storage::well_known_keys; use sp_keyring::AccountKeyring; - #[derive(Debug, Serialize, Deserialize)] - struct Genesis(BTreeMap); - - impl BuildStorage for Genesis { - fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> { - storage.top.extend( - self.0.iter().map(|(a, b)| (a.clone().into_bytes(), b.clone().into_bytes())), - ); - Ok(()) - } - } - - type TestSpec = ChainSpec; + type TestSpec = ChainSpec; #[test] fn should_deserialize_example_chain_spec() { @@ -919,7 +820,7 @@ mod tests { } } - type TestSpec2 = ChainSpec; + type TestSpec2 = ChainSpec; #[test] fn should_deserialize_chain_spec_with_extensions() { @@ -1137,10 +1038,10 @@ mod tests { #[test] fn chain_spec_as_json_fails_with_invalid_config() { - let expected_error_message = - include_str!("../res/chain_spec_as_json_fails_with_invalid_config.err"); - let j = - include_str!("../../../test-utils/runtime/res/default_genesis_config_invalid_2.json"); + let invalid_genesis_config = from_str::(include_str!( + "../../../test-utils/runtime/res/default_genesis_config_invalid_2.json" + )) + .unwrap(); let output = ChainSpec::<()>::builder( substrate_test_runtime::wasm_binary_unwrap().into(), Default::default(), @@ -1148,12 +1049,25 @@ mod tests { .with_name("TestName") .with_id("test_id") .with_chain_type(ChainType::Local) - .with_genesis_config(from_str(j).unwrap()) + .with_genesis_config(invalid_genesis_config.clone()) .build(); - let result = output.as_json(true); + let result = output.as_json(true).unwrap_err(); + let mut result = result.lines(); + + let result_header = result.next().unwrap(); + let result_body = result.collect::>().join("\n"); + let result_body: Value = serde_json::from_str(&result_body).unwrap(); + + let re = regex::Regex::new(concat!( + r"^Invalid JSON blob: unknown field `babex`, expected one of `system`, `babe`, ", + r"`substrateTest`, `balances` at line \d+ column \d+ for blob:$" + )) + .unwrap(); - assert_eq!(result.err().unwrap(), expected_error_message); + assert_eq!(json!({"a":1,"b":2}), json!({"b":2,"a":1})); + assert!(re.is_match(result_header)); + assert_eq!(invalid_genesis_config, result_body); } #[test] @@ -1278,35 +1192,4 @@ mod tests { &|v| { *v == "0x000102040506" } )); } - - #[test] - fn generate_from_genesis_is_still_supported() { - #[allow(deprecated)] - let chain_spec: ChainSpec = ChainSpec::from_genesis( - "TestName", - "test", - ChainType::Local, - || Default::default(), - Vec::new(), - None, - None, - None, - None, - Default::default(), - &vec![0, 1, 2, 4, 5, 6], - ); - - let chain_spec_json = from_str::(&chain_spec.as_json(false).unwrap()).unwrap(); - assert!(json_eval_value_at_key( - &chain_spec_json, - &mut json_path!["genesis", "runtimeAndCode", "code"], - &|v| { *v == "0x000102040506" } - )); - let chain_spec_json = from_str::(&chain_spec.as_json(true).unwrap()).unwrap(); - assert!(json_eval_value_at_key( - &chain_spec_json, - &mut json_path!["genesis", "raw", "top", "0x3a636f6465"], - &|v| { *v == "0x000102040506" } - )); - } } diff --git a/substrate/client/chain-spec/src/lib.rs b/substrate/client/chain-spec/src/lib.rs index abe01dafd92483fbede02eb6d95205b29bddacb5..5451428d34811bfa54cb87a767d8434b5f4b7524 100644 --- a/substrate/client/chain-spec/src/lib.rs +++ b/substrate/client/chain-spec/src/lib.rs @@ -123,7 +123,10 @@ //! As the compiled WASM blob of the runtime code is stored in the chain's state, the initial //! runtime must also be provided within the chain specification. //! -//! In essence, the most important formats of genesis initial state are: +//! # `chain-spec` formats +//! +//! In essence, the most important formats of genesis initial state in chain specification files +//! are: //! //! //! @@ -135,14 +138,14 @@ //! //! //! //! //! @@ -168,6 +172,12 @@ //! //!
-//! runtime / full config +//! full config //! A JSON object that provides an explicit and comprehensive representation of the //! RuntimeGenesisConfig struct, which is generated by polkadot_sdk_frame::runtime::prelude::construct_runtime macro (example of generated struct). Must contain all the keys of +//! >example of generated struct). Must contain *all* the keys of //! the genesis config, no defaults will be used. //! //! This format explicitly provides the code of the runtime. @@ -154,7 +157,8 @@ //! A JSON object that offers a partial representation of the //! RuntimeGenesisConfig provided by the runtime. It contains a patch, which is //! essentially a list of key-value pairs to customize in the default runtime's -//! RuntimeGenesisConfig. +//! RuntimeGenesisConfig: `full = default + patch`. Please note that `default` +//! `RuntimeGenesisConfig` may not be functional. //! This format explicitly provides the code of the runtime. //!
//! +//! The main purpose of the `RuntimeGenesisConfig` patch is to: +//! - minimize the maintenance effort when RuntimeGenesisConfig is changed in the future (e.g. new +//! pallets added to the runtime or pallet's genesis config changed), +//! - increase the readability - it only contains the relevant fields, +//! - allow to apply numerous changes in distinct domains (e.g. for zombienet). +//! //! For production or long-lasting blockchains, using the `raw` format in the chain specification is //! recommended. Only the `raw` format guarantees that storage root hash will remain unchanged when //! the `RuntimeGenesisConfig` format changes due to software upgrade. @@ -257,7 +267,7 @@ //! pub known_blocks: HashMap, //! } //! -//! pub type MyChainSpec = GenericChainSpec; +//! pub type MyChainSpec = GenericChainSpec; //! ``` //! Some parameters may require different values depending on the current blockchain height (a.k.a. //! forks). You can use the [`ChainSpecGroup`](macro@ChainSpecGroup) macro and the provided [`Forks`] @@ -286,10 +296,10 @@ //! pub type BlockNumber = u64; //! //! /// A chain spec supporting forkable `ClientParams`. -//! pub type MyChainSpec1 = GenericChainSpec>; +//! pub type MyChainSpec1 = GenericChainSpec>; //! //! /// A chain spec supporting forkable `Extension`. -//! pub type MyChainSpec2 = GenericChainSpec>; +//! pub type MyChainSpec2 = GenericChainSpec>; //! ``` //! It's also possible to have a set of parameters that are allowed to change with block numbers //! (i.e., they are forkable), and another set that is not subject to changes. This can also be @@ -316,7 +326,7 @@ //! pub pool: Forks, //! } //! -//! pub type MyChainSpec = GenericChainSpec; +//! pub type MyChainSpec = GenericChainSpec; //! ``` //! The chain spec can be extended with other fields that are opaque to the default chain spec. //! Specific node implementations will need to be able to deserialize these extensions. @@ -329,8 +339,8 @@ pub mod json_patch; pub use self::{ chain_spec::{ - update_code_in_json_chain_spec, ChainSpec as GenericChainSpec, ChainSpecBuilder, - NoExtension, + set_code_substitute_in_json_chain_spec, update_code_in_json_chain_spec, + ChainSpec as GenericChainSpec, ChainSpecBuilder, NoExtension, }, extension::{get_extension, get_extension_mut, Extension, Fork, Forks, GetExtension, Group}, genesis_block::{ @@ -344,7 +354,6 @@ pub use sc_chain_spec_derive::{ChainSpecExtension, ChainSpecGroup}; use sc_network::config::MultiaddrWithPeerId; use sc_telemetry::TelemetryEndpoints; -use serde::{de::DeserializeOwned, Serialize}; use sp_core::storage::Storage; use sp_runtime::BuildStorage; @@ -353,6 +362,7 @@ use sp_runtime::BuildStorage; /// This can be used by tools to determine the type of a chain for displaying /// additional information or enabling additional features. #[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq, Clone)] +#[cfg_attr(feature = "clap", derive(clap::ValueEnum))] pub enum ChainType { /// A development chain that runs mainly on one node. Development, @@ -361,6 +371,7 @@ pub enum ChainType { /// A live chain. Live, /// Some custom chain type. + #[cfg_attr(feature = "clap", clap(skip))] Custom(String), } @@ -373,10 +384,6 @@ impl Default for ChainType { /// Arbitrary properties defined in chain spec as a JSON object pub type Properties = serde_json::map::Map; -/// A set of traits for the runtime genesis config. -pub trait RuntimeGenesis: Serialize + DeserializeOwned + BuildStorage {} -impl RuntimeGenesis for T {} - /// Common interface of a chain specification. pub trait ChainSpec: BuildStorage + Send + Sync { /// Spec name. diff --git a/substrate/client/cli/Cargo.toml b/substrate/client/cli/Cargo.toml index 317a344cf58e5399b062d40c3b9c9afdddb5d1fa..b7d29aebc3d77d59eedd9e460ecf1b850c86b700 100644 --- a/substrate/client/cli/Cargo.toml +++ b/substrate/client/cli/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate CLI interface." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,46 +16,46 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -array-bytes = "6.2.2" -chrono = "0.4.31" -clap = { version = "4.5.3", features = ["derive", "string", "wrap_help"] } -fdlimit = "0.3.0" -futures = "0.3.30" -itertools = "0.11" -libp2p-identity = { version = "0.1.3", features = ["ed25519", "peerid"] } +array-bytes = { workspace = true, default-features = true } +chrono = { workspace = true } +clap = { features = ["derive", "string", "wrap_help"], workspace = true } +fdlimit = { workspace = true } +futures = { workspace = true } +itertools = { workspace = true } +libp2p-identity = { features = ["ed25519", "peerid"], workspace = true } log = { workspace = true, default-features = true } -names = { version = "0.14.0", default-features = false } -parity-scale-codec = "3.6.1" -rand = "0.8.5" -regex = "1.6.0" -rpassword = "7.0.0" +names = { workspace = true } +codec = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } +regex = { workspace = true } +rpassword = { workspace = true } serde = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } thiserror = { workspace = true } # personal fork here as workaround for: https://github.com/rust-bitcoin/rust-bip39/pull/64 bip39 = { package = "parity-bip39", version = "2.0.1", features = ["rand"] } -tokio = { version = "1.22.0", features = ["parking_lot", "rt-multi-thread", "signal"] } -sc-client-api = { path = "../api" } -sc-client-db = { path = "../db", default-features = false } -sc-keystore = { path = "../keystore" } -sc-mixnet = { path = "../mixnet" } -sc-network = { path = "../network" } -sc-service = { path = "../service", default-features = false } -sc-telemetry = { path = "../telemetry" } -sc-tracing = { path = "../tracing" } -sc-utils = { path = "../utils" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-core = { path = "../../primitives/core" } -sp-keyring = { path = "../../primitives/keyring" } -sp-keystore = { path = "../../primitives/keystore" } -sp-panic-handler = { path = "../../primitives/panic-handler" } -sp-runtime = { path = "../../primitives/runtime" } -sp-version = { path = "../../primitives/version" } +tokio = { features = ["parking_lot", "rt-multi-thread", "signal"], workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-client-db = { workspace = true } +sc-keystore = { workspace = true, default-features = true } +sc-mixnet = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-service = { workspace = true } +sc-telemetry = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-panic-handler = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } [dev-dependencies] -tempfile = "3.1.0" -futures-timer = "3.0.1" -sp-tracing = { path = "../../primitives/tracing" } +tempfile = { workspace = true } +futures-timer = { workspace = true } +sp-tracing = { workspace = true, default-features = true } [features] default = ["rocksdb"] diff --git a/substrate/client/cli/src/arg_enums.rs b/substrate/client/cli/src/arg_enums.rs index b5819d03447a8bfb6eb3e9e40d2f129af80283ea..cd245dc0155453e49347c5fb9fc8e13f75a803db 100644 --- a/substrate/client/cli/src/arg_enums.rs +++ b/substrate/client/cli/src/arg_enums.rs @@ -168,6 +168,19 @@ pub enum RpcMethods { Unsafe, } +impl FromStr for RpcMethods { + type Err = String; + + fn from_str(s: &str) -> Result { + match s { + "safe" => Ok(RpcMethods::Safe), + "unsafe" => Ok(RpcMethods::Unsafe), + "auto" => Ok(RpcMethods::Auto), + invalid => Err(format!("Invalid rpc methods {invalid}")), + } + } +} + impl Into for RpcMethods { fn into(self) -> sc_service::config::RpcMethods { match self { diff --git a/substrate/client/cli/src/commands/chain_info_cmd.rs b/substrate/client/cli/src/commands/chain_info_cmd.rs index 002d7893d9f35b01f36078139f872694ef8ca848..8558c8a2d1cb8e90e2e83a363aea5219b55669dc 100644 --- a/substrate/client/cli/src/commands/chain_info_cmd.rs +++ b/substrate/client/cli/src/commands/chain_info_cmd.rs @@ -17,7 +17,7 @@ // along with this program. If not, see . use crate::{CliConfiguration, DatabaseParams, PruningParams, Result as CliResult, SharedParams}; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use sc_client_api::{backend::Backend as BackendT, blockchain::HeaderBackend}; use sp_blockchain::Info; use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; diff --git a/substrate/client/cli/src/commands/insert_key.rs b/substrate/client/cli/src/commands/insert_key.rs index 3d89610b28b1bd0a031ffad6e94fef7fd604e20d..66dbec794865c00bed9e508a44e760299b2bc3ea 100644 --- a/substrate/client/cli/src/commands/insert_key.rs +++ b/substrate/client/cli/src/commands/insert_key.rs @@ -126,8 +126,10 @@ mod tests { } fn load_spec(&self, _: &str) -> std::result::Result, String> { + let builder = + GenericChainSpec::::builder(Default::default(), NoExtension::None); Ok(Box::new( - GenericChainSpec::<()>::builder(Default::default(), NoExtension::None) + builder .with_name("test") .with_id("test_id") .with_chain_type(ChainType::Development) diff --git a/substrate/client/cli/src/commands/run_cmd.rs b/substrate/client/cli/src/commands/run_cmd.rs index c1288b502c95a4045215b66d57e18d7ade0e38ab..7245b46e2f7d01990a39d4403b27f7db50b793b6 100644 --- a/substrate/client/cli/src/commands/run_cmd.rs +++ b/substrate/client/cli/src/commands/run_cmd.rs @@ -20,8 +20,8 @@ use crate::{ arg_enums::{Cors, RpcMethods}, error::{Error, Result}, params::{ - ImportParams, KeystoreParams, NetworkParams, OffchainWorkerParams, SharedParams, - TransactionPoolParams, + ImportParams, KeystoreParams, NetworkParams, OffchainWorkerParams, RpcEndpoint, + SharedParams, TransactionPoolParams, }, CliConfiguration, PrometheusParams, RuntimeParams, TelemetryParams, RPC_DEFAULT_MAX_CONNECTIONS, RPC_DEFAULT_MAX_REQUEST_SIZE_MB, RPC_DEFAULT_MAX_RESPONSE_SIZE_MB, @@ -37,7 +37,7 @@ use sc_service::{ }; use sc_telemetry::TelemetryEndpoints; use std::{ - net::{IpAddr, Ipv4Addr, SocketAddr}, + net::{Ipv4Addr, Ipv6Addr, SocketAddr}, num::NonZeroU32, }; @@ -128,6 +128,47 @@ pub struct RunCmd { #[arg(long, value_name = "PORT")] pub rpc_port: Option, + /// EXPERIMENTAL: Specify the JSON-RPC server interface and this option which can be enabled + /// several times if you want expose several RPC interfaces with different configurations. + /// + /// The format for this option is: + /// `--experimental-rpc-endpoint" listen-addr=,,..."` where each option is + /// separated by a comma and `listen-addr` is the only required param. + /// + /// The following options are available: + /// • listen-addr: The socket address (ip:port) to listen on. Be careful to not expose the + /// server to the public internet unless you know what you're doing. (required) + /// • disable-batch-requests: Disable batch requests (optional) + /// • max-connections: The maximum number of concurrent connections that the server will + /// accept (optional) + /// • max-request-size: The maximum size of a request body in megabytes (optional) + /// • max-response-size: The maximum size of a response body in megabytes (optional) + /// • max-subscriptions-per-connection: The maximum number of subscriptions per connection + /// (optional) + /// • max-buffer-capacity-per-connection: The maximum buffer capacity per connection + /// (optional) + /// • max-batch-request-len: The maximum number of requests in a batch (optional) + /// • cors: The CORS allowed origins, this can enabled more than once (optional) + /// • methods: Which RPC methods to allow, valid values are "safe", "unsafe" and "auto" + /// (optional) + /// • optional: If the listen address is optional i.e the interface is not required to be + /// available For example this may be useful if some platforms doesn't support ipv6 + /// (optional) + /// • rate-limit: The rate limit in calls per minute for each connection (optional) + /// • rate-limit-trust-proxy-headers: Trust proxy headers for disable rate limiting (optional) + /// • rate-limit-whitelisted-ips: Disable rate limiting for certain ip addresses, this can be + /// enabled more than once (optional) • retry-random-port: If the port is already in use, + /// retry with a random port (optional) + /// + /// Use with care, this flag is unstable and subject to change. + #[arg( + long, + num_args = 1.., + verbatim_doc_comment, + conflicts_with_all = &["rpc_external", "unsafe_rpc_external", "rpc_port", "rpc_cors", "rpc_rate_limit_trust_proxy_headers", "rpc_rate_limit", "rpc_rate_limit_whitelisted_ips", "rpc_message_buffer_capacity_per_connection", "rpc_disable_batch_requests", "rpc_max_subscriptions_per_connection", "rpc_max_request_size", "rpc_max_response_size"] + )] + pub experimental_rpc_endpoint: Vec, + /// Maximum number of RPC server connections. #[arg(long, value_name = "COUNT", default_value_t = RPC_DEFAULT_MAX_CONNECTIONS)] pub rpc_max_connections: u32, @@ -410,15 +451,68 @@ impl CliConfiguration for RunCmd { .into()) } - fn rpc_addr(&self, default_listen_port: u16) -> Result> { - let interface = rpc_interface( + fn rpc_addr(&self, default_listen_port: u16) -> Result>> { + if !self.experimental_rpc_endpoint.is_empty() { + for endpoint in &self.experimental_rpc_endpoint { + // Technically, `0.0.0.0` isn't a public IP address, but it's a way to listen on + // all interfaces. Thus, we consider it as a public endpoint and warn about it. + if endpoint.rpc_methods == RpcMethods::Unsafe && endpoint.is_global() || + endpoint.listen_addr.ip().is_unspecified() + { + log::warn!( + "It isn't safe to expose RPC publicly without a proxy server that filters \ + available set of RPC methods." + ); + } + } + + return Ok(Some(self.experimental_rpc_endpoint.clone())); + } + + let (ipv4, ipv6) = rpc_interface( self.rpc_external, self.unsafe_rpc_external, self.rpc_methods, self.validator, )?; - Ok(Some(SocketAddr::new(interface, self.rpc_port.unwrap_or(default_listen_port)))) + let cors = self.rpc_cors(self.is_dev()?)?; + let port = self.rpc_port.unwrap_or(default_listen_port); + + Ok(Some(vec![ + RpcEndpoint { + batch_config: self.rpc_batch_config()?, + max_connections: self.rpc_max_connections, + listen_addr: SocketAddr::new(std::net::IpAddr::V4(ipv4), port), + rpc_methods: self.rpc_methods, + rate_limit: self.rpc_rate_limit, + rate_limit_trust_proxy_headers: self.rpc_rate_limit_trust_proxy_headers, + rate_limit_whitelisted_ips: self.rpc_rate_limit_whitelisted_ips.clone(), + max_payload_in_mb: self.rpc_max_request_size, + max_payload_out_mb: self.rpc_max_response_size, + max_subscriptions_per_connection: self.rpc_max_subscriptions_per_connection, + max_buffer_capacity_per_connection: self.rpc_message_buffer_capacity_per_connection, + cors: cors.clone(), + retry_random_port: true, + is_optional: false, + }, + RpcEndpoint { + batch_config: self.rpc_batch_config()?, + max_connections: self.rpc_max_connections, + listen_addr: SocketAddr::new(std::net::IpAddr::V6(ipv6), port), + rpc_methods: self.rpc_methods, + rate_limit: self.rpc_rate_limit, + rate_limit_trust_proxy_headers: self.rpc_rate_limit_trust_proxy_headers, + rate_limit_whitelisted_ips: self.rpc_rate_limit_whitelisted_ips.clone(), + max_payload_in_mb: self.rpc_max_request_size, + max_payload_out_mb: self.rpc_max_response_size, + max_subscriptions_per_connection: self.rpc_max_subscriptions_per_connection, + max_buffer_capacity_per_connection: self.rpc_message_buffer_capacity_per_connection, + cors: cors.clone(), + retry_random_port: true, + is_optional: true, + }, + ])) } fn rpc_methods(&self) -> Result { @@ -523,7 +617,7 @@ fn rpc_interface( is_unsafe_external: bool, rpc_methods: RpcMethods, is_validator: bool, -) -> Result { +) -> Result<(Ipv4Addr, Ipv6Addr)> { if is_external && is_validator && rpc_methods != RpcMethods::Unsafe { return Err(Error::Input( "--rpc-external option shouldn't be used if the node is running as \ @@ -541,9 +635,9 @@ fn rpc_interface( ); } - Ok(Ipv4Addr::UNSPECIFIED.into()) + Ok((Ipv4Addr::UNSPECIFIED, Ipv6Addr::UNSPECIFIED)) } else { - Ok(Ipv4Addr::LOCALHOST.into()) + Ok((Ipv4Addr::LOCALHOST, Ipv6Addr::LOCALHOST)) } } diff --git a/substrate/client/cli/src/config.rs b/substrate/client/cli/src/config.rs index 783c9313121fef1a199705e8a6508688e51b67ca..7c235847761132822952d9942fb9b382d2a99b83 100644 --- a/substrate/client/cli/src/config.rs +++ b/substrate/client/cli/src/config.rs @@ -20,21 +20,22 @@ use crate::{ arg_enums::Database, error::Result, DatabaseParams, ImportParams, KeystoreParams, - NetworkParams, NodeKeyParams, OffchainWorkerParams, PruningParams, SharedParams, SubstrateCli, + NetworkParams, NodeKeyParams, OffchainWorkerParams, PruningParams, RpcEndpoint, SharedParams, + SubstrateCli, }; use log::warn; use names::{Generator, Name}; use sc_service::{ config::{ BasePath, Configuration, DatabaseSource, IpNetwork, KeystoreConfig, NetworkConfiguration, - NodeKeyConfig, OffchainWorkerConfig, OutputFormat, PrometheusConfig, PruningMode, Role, + NodeKeyConfig, OffchainWorkerConfig, PrometheusConfig, PruningMode, Role, RpcBatchRequestConfig, RpcMethods, TelemetryEndpoints, TransactionPoolOptions, WasmExecutionMethod, }, BlocksPruning, ChainSpec, TracingReceiver, }; use sc_tracing::logging::LoggerBuilder; -use std::{net::SocketAddr, num::NonZeroU32, path::PathBuf}; +use std::{num::NonZeroU32, path::PathBuf}; /// The maximum number of characters for a node name. pub(crate) const NODE_NAME_MAX_LENGTH: usize = 64; @@ -172,7 +173,7 @@ pub trait CliConfiguration: Sized { node_key: NodeKeyConfig, default_listen_port: u16, ) -> Result { - Ok(if let Some(network_params) = self.network_params() { + let network_config = if let Some(network_params) = self.network_params() { network_params.network_config( chain_spec, is_dev, @@ -185,7 +186,13 @@ pub trait CliConfiguration: Sized { ) } else { NetworkConfiguration::new(node_name, client_id, node_key, Some(net_config_dir)) - }) + }; + + // TODO: Return error here in the next release: + // https://github.com/paritytech/polkadot-sdk/issues/5266 + // if is_validator && network_config.public_addresses.is_empty() {} + + Ok(network_config) } /// Get the keystore configuration. @@ -295,7 +302,7 @@ pub trait CliConfiguration: Sized { } /// Get the RPC address. - fn rpc_addr(&self, _default_listen_port: u16) -> Result> { + fn rpc_addr(&self, _default_listen_port: u16) -> Result>> { Ok(None) } @@ -498,6 +505,10 @@ pub trait CliConfiguration: Sized { let telemetry_endpoints = self.telemetry_endpoints(&chain_spec)?; let runtime_cache_size = self.runtime_cache_size()?; + let rpc_addrs: Option> = self + .rpc_addr(DCV::rpc_listen_port())? + .map(|addrs| addrs.into_iter().map(Into::into).collect()); + Ok(Configuration { impl_name: C::impl_name(), impl_version: C::impl_version(), @@ -521,7 +532,7 @@ pub trait CliConfiguration: Sized { blocks_pruning: self.blocks_pruning()?, wasm_method: self.wasm_method()?, wasm_runtime_overrides: self.wasm_runtime_overrides(), - rpc_addr: self.rpc_addr(DCV::rpc_listen_port())?, + rpc_addr: rpc_addrs, rpc_methods: self.rpc_methods()?, rpc_max_connections: self.rpc_max_connections()?, rpc_cors: self.rpc_cors(is_dev)?, @@ -550,7 +561,6 @@ pub trait CliConfiguration: Sized { announce_block: self.announce_block()?, role, base_path, - informant_output_format: OutputFormat { enable_color: !self.disable_log_color()? }, runtime_cache_size, }) } @@ -639,6 +649,14 @@ pub trait CliConfiguration: Sized { logger.init()?; + if config.role.is_authority() && config.network.public_addresses.is_empty() { + warn!( + "WARNING: No public address specified, validator node may not be reachable. + Consider setting `--public-addr` to the public IP address of this node. + This will become a hard requirement in future versions." + ); + } + match fdlimit::raise_fd_limit() { Ok(fdlimit::Outcome::LimitRaised { to, .. }) => if to < RECOMMENDED_OPEN_FILE_DESCRIPTOR_LIMIT { diff --git a/substrate/client/cli/src/error.rs b/substrate/client/cli/src/error.rs index 90ad048009ade90b5ccd4cfc264cc85e3b311843..90f936561512d716ae25c2e4d8115bd1d7c94e84 100644 --- a/substrate/client/cli/src/error.rs +++ b/substrate/client/cli/src/error.rs @@ -42,7 +42,7 @@ pub enum Error { Client(#[from] sp_blockchain::Error), #[error(transparent)] - Codec(#[from] parity_scale_codec::Error), + Codec(#[from] codec::Error), #[error("Invalid input: {0}")] Input(String), diff --git a/substrate/client/cli/src/lib.rs b/substrate/client/cli/src/lib.rs index 104e8ec8b798ee5b8eb6c9561c6ef0729d7a7b2a..1bb9fec0e27690f9b7ec21918f3dce329100de3a 100644 --- a/substrate/client/cli/src/lib.rs +++ b/substrate/client/cli/src/lib.rs @@ -58,11 +58,11 @@ pub trait SubstrateCli: Sized { /// Implementation version. /// - /// By default this will look like this: + /// By default, it will look like this: /// /// `2.0.0-b950f731c` /// - /// Where the hash is the short commit hash of the commit of in the Git repository. + /// Where the hash is the short hash of the commit in the Git repository. fn impl_version() -> String; /// Executable file name. @@ -199,17 +199,8 @@ pub trait SubstrateCli: Sized { fn create_runner, DVC: DefaultConfigurationValues>( &self, command: &T, - ) -> error::Result> { - let tokio_runtime = build_runtime()?; - - // `capture` needs to be called in a tokio context. - // Also capture them as early as possible. - let signals = tokio_runtime.block_on(async { Signals::capture() })?; - - let config = command.create_configuration(self, tokio_runtime.handle().clone())?; - - command.init(&Self::support_url(), &Self::impl_version(), |_, _| {}, &config)?; - Runner::new(config, tokio_runtime, signals) + ) -> Result> { + self.create_runner_with_logger_hook(command, |_, _| {}) } /// Create a runner for the command provided in argument. The `logger_hook` can be used to setup @@ -231,11 +222,15 @@ pub trait SubstrateCli: Sized { /// } /// } /// ``` - fn create_runner_with_logger_hook( + fn create_runner_with_logger_hook< + T: CliConfiguration, + DVC: DefaultConfigurationValues, + F, + >( &self, command: &T, logger_hook: F, - ) -> error::Result> + ) -> Result> where F: FnOnce(&mut LoggerBuilder, &Configuration), { diff --git a/substrate/client/cli/src/params/mod.rs b/substrate/client/cli/src/params/mod.rs index f07223ec6a73ea93b2b1ae6b76238ed9a45aab50..977b57ba06586cfa2141abbe90a23225cb6cf2db 100644 --- a/substrate/client/cli/src/params/mod.rs +++ b/substrate/client/cli/src/params/mod.rs @@ -25,6 +25,7 @@ mod node_key_params; mod offchain_worker_params; mod prometheus_params; mod pruning_params; +mod rpc_params; mod runtime_params; mod shared_params; mod telemetry_params; @@ -32,6 +33,7 @@ mod transaction_pool_params; use crate::arg_enums::{CryptoScheme, OutputType}; use clap::Args; +use sc_service::config::{IpNetwork, RpcBatchRequestConfig}; use sp_core::crypto::{Ss58AddressFormat, Ss58AddressFormatRegistry}; use sp_runtime::{ generic::BlockId, @@ -42,7 +44,7 @@ use std::{fmt::Debug, str::FromStr}; pub use crate::params::{ database_params::*, import_params::*, keystore_params::*, message_params::*, mixnet_params::*, network_params::*, node_key_params::*, offchain_worker_params::*, prometheus_params::*, - pruning_params::*, runtime_params::*, shared_params::*, telemetry_params::*, + pruning_params::*, rpc_params::*, runtime_params::*, shared_params::*, telemetry_params::*, transaction_pool_params::*, }; diff --git a/substrate/client/cli/src/params/node_key_params.rs b/substrate/client/cli/src/params/node_key_params.rs index 7058af19f1d4a5edc31a8e93d062f7f93c065f1e..0e12c7a2a2d3742ef3d9aa3681f900036e67a467 100644 --- a/substrate/client/cli/src/params/node_key_params.rs +++ b/substrate/client/cli/src/params/node_key_params.rs @@ -17,7 +17,7 @@ // along with this program. If not, see . use clap::Args; -use sc_network::config::{identity::ed25519, NodeKeyConfig}; +use sc_network::config::{ed25519, NodeKeyConfig}; use sc_service::Role; use sp_core::H256; use std::{path::PathBuf, str::FromStr}; @@ -148,7 +148,7 @@ fn parse_ed25519_secret(hex: &str) -> error::Result, @@ -42,11 +49,14 @@ pub struct PruningParams { /// /// This mode specifies when the block's body (including justifications) /// should be pruned (ie, removed) from the database. + /// /// Possible values: - /// - 'archive' Keep all blocks. - /// - 'archive-canonical' Keep only finalized blocks. - /// - number - /// Keep the last `number` of finalized blocks. + /// + /// - archive: Keep the data of all blocks. + /// + /// - archive-canonical: Keep only the data of finalized blocks. + /// + /// - NUMBER: Keep the data of the last NUMBER of finalized blocks. #[arg( alias = "keep-blocks", long, @@ -117,3 +127,39 @@ impl Into for DatabasePruningMode { } } } + +#[cfg(test)] +mod tests { + use super::*; + use clap::Parser; + + #[derive(Parser)] + struct Cli { + #[clap(flatten)] + pruning: PruningParams, + } + + #[test] + fn pruning_params_parse_works() { + let Cli { pruning } = + Cli::parse_from(["", "--state-pruning=1000", "--blocks-pruning=1000"]); + + assert!(matches!(pruning.state_pruning, Some(DatabasePruningMode::Custom(1000)))); + assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::Custom(1000))); + + let Cli { pruning } = + Cli::parse_from(["", "--state-pruning=archive", "--blocks-pruning=archive"]); + + assert!(matches!(dbg!(pruning.state_pruning), Some(DatabasePruningMode::Archive))); + assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::Archive)); + + let Cli { pruning } = Cli::parse_from([ + "", + "--state-pruning=archive-canonical", + "--blocks-pruning=archive-canonical", + ]); + + assert!(matches!(dbg!(pruning.state_pruning), Some(DatabasePruningMode::ArchiveCanonical))); + assert!(matches!(pruning.blocks_pruning, DatabasePruningMode::ArchiveCanonical)); + } +} diff --git a/substrate/client/cli/src/params/rpc_params.rs b/substrate/client/cli/src/params/rpc_params.rs new file mode 100644 index 0000000000000000000000000000000000000000..d0ec1fd004431cb207c87219039dc6bf934ab168 --- /dev/null +++ b/substrate/client/cli/src/params/rpc_params.rs @@ -0,0 +1,395 @@ +// This file is part of Substrate. + +// Copyright (C) Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program 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. + +// This program 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 this program. If not, see . + +use crate::{ + arg_enums::RpcMethods, + params::{IpNetwork, RpcBatchRequestConfig}, + RPC_DEFAULT_MAX_CONNECTIONS, RPC_DEFAULT_MAX_REQUEST_SIZE_MB, RPC_DEFAULT_MAX_RESPONSE_SIZE_MB, + RPC_DEFAULT_MAX_SUBS_PER_CONN, RPC_DEFAULT_MESSAGE_CAPACITY_PER_CONN, +}; +use std::{net::SocketAddr, num::NonZeroU32}; + +const RPC_LISTEN_ADDR: &str = "listen-addr"; +const RPC_CORS: &str = "cors"; +const RPC_MAX_CONNS: &str = "max-connections"; +const RPC_MAX_REQUEST_SIZE: &str = "max-request-size"; +const RPC_MAX_RESPONSE_SIZE: &str = "max-response-size"; +const RPC_MAX_SUBS_PER_CONN: &str = "max-subscriptions-per-connection"; +const RPC_MAX_BUF_CAP_PER_CONN: &str = "max-buffer-capacity-per-connection"; +const RPC_RATE_LIMIT: &str = "rate-limit"; +const RPC_RATE_LIMIT_TRUST_PROXY_HEADERS: &str = "rate-limit-trust-proxy-headers"; +const RPC_RATE_LIMIT_WHITELISTED_IPS: &str = "rate-limit-whitelisted-ips"; +const RPC_RETRY_RANDOM_PORT: &str = "retry-random-port"; +const RPC_METHODS: &str = "methods"; +const RPC_OPTIONAL: &str = "optional"; +const RPC_DISABLE_BATCH: &str = "disable-batch-requests"; +const RPC_BATCH_LIMIT: &str = "max-batch-request-len"; + +/// Represent a single RPC endpoint with its configuration. +#[derive(Debug, Clone)] +pub struct RpcEndpoint { + /// Listen address. + pub listen_addr: SocketAddr, + /// Batch request configuration. + pub batch_config: RpcBatchRequestConfig, + /// Maximum number of connections. + pub max_connections: u32, + /// Maximum inbound payload size in MB. + pub max_payload_in_mb: u32, + /// Maximum outbound payload size in MB. + pub max_payload_out_mb: u32, + /// Maximum number of subscriptions per connection. + pub max_subscriptions_per_connection: u32, + /// Maximum buffer capacity per connection. + pub max_buffer_capacity_per_connection: u32, + /// Rate limit per minute. + pub rate_limit: Option, + /// Whether to trust proxy headers for rate limiting. + pub rate_limit_trust_proxy_headers: bool, + /// Whitelisted IPs for rate limiting. + pub rate_limit_whitelisted_ips: Vec, + /// CORS. + pub cors: Option>, + /// RPC methods to expose. + pub rpc_methods: RpcMethods, + /// Whether it's an optional listening address i.e, it's ignored if it fails to bind. + /// For example substrate tries to bind both ipv4 and ipv6 addresses but some platforms + /// may not support ipv6. + pub is_optional: bool, + /// Whether to retry with a random port if the provided port is already in use. + pub retry_random_port: bool, +} + +impl std::str::FromStr for RpcEndpoint { + type Err = String; + + fn from_str(s: &str) -> Result { + let mut listen_addr = None; + let mut max_connections = None; + let mut max_payload_in_mb = None; + let mut max_payload_out_mb = None; + let mut max_subscriptions_per_connection = None; + let mut max_buffer_capacity_per_connection = None; + let mut cors: Option> = None; + let mut rpc_methods = None; + let mut is_optional = None; + let mut disable_batch_requests = None; + let mut max_batch_request_len = None; + let mut rate_limit = None; + let mut rate_limit_trust_proxy_headers = None; + let mut rate_limit_whitelisted_ips = Vec::new(); + let mut retry_random_port = None; + + for input in s.split(',') { + let (key, val) = input.trim().split_once('=').ok_or_else(|| invalid_input(input))?; + let key = key.trim(); + let val = val.trim(); + + match key { + RPC_LISTEN_ADDR => { + if listen_addr.is_some() { + return Err(only_once_err(RPC_LISTEN_ADDR)); + } + let val: SocketAddr = + val.parse().map_err(|_| invalid_value(RPC_LISTEN_ADDR, &val))?; + listen_addr = Some(val); + }, + RPC_CORS => { + if val.is_empty() { + return Err(invalid_value(RPC_CORS, &val)); + } + + if let Some(cors) = cors.as_mut() { + cors.push(val.to_string()); + } else { + cors = Some(vec![val.to_string()]); + } + }, + RPC_MAX_CONNS => { + if max_connections.is_some() { + return Err(only_once_err(RPC_MAX_CONNS)); + } + + let val = val.parse().map_err(|_| invalid_value(RPC_MAX_CONNS, &val))?; + max_connections = Some(val); + }, + RPC_MAX_REQUEST_SIZE => { + if max_payload_in_mb.is_some() { + return Err(only_once_err(RPC_MAX_REQUEST_SIZE)); + } + + let val = + val.parse().map_err(|_| invalid_value(RPC_MAX_RESPONSE_SIZE, &val))?; + max_payload_in_mb = Some(val); + }, + RPC_MAX_RESPONSE_SIZE => { + if max_payload_out_mb.is_some() { + return Err(only_once_err(RPC_MAX_RESPONSE_SIZE)); + } + + let val = + val.parse().map_err(|_| invalid_value(RPC_MAX_RESPONSE_SIZE, &val))?; + max_payload_out_mb = Some(val); + }, + RPC_MAX_SUBS_PER_CONN => { + if max_subscriptions_per_connection.is_some() { + return Err(only_once_err(RPC_MAX_SUBS_PER_CONN)); + } + + let val = + val.parse().map_err(|_| invalid_value(RPC_MAX_SUBS_PER_CONN, &val))?; + max_subscriptions_per_connection = Some(val); + }, + RPC_MAX_BUF_CAP_PER_CONN => { + if max_buffer_capacity_per_connection.is_some() { + return Err(only_once_err(RPC_MAX_BUF_CAP_PER_CONN)); + } + + let val = + val.parse().map_err(|_| invalid_value(RPC_MAX_BUF_CAP_PER_CONN, &val))?; + max_buffer_capacity_per_connection = Some(val); + }, + RPC_RATE_LIMIT => { + if rate_limit.is_some() { + return Err(only_once_err("rate-limit")); + } + + let val = val.parse().map_err(|_| invalid_value(RPC_RATE_LIMIT, &val))?; + rate_limit = Some(val); + }, + RPC_RATE_LIMIT_TRUST_PROXY_HEADERS => { + if rate_limit_trust_proxy_headers.is_some() { + return Err(only_once_err(RPC_RATE_LIMIT_TRUST_PROXY_HEADERS)); + } + + let val = val + .parse() + .map_err(|_| invalid_value(RPC_RATE_LIMIT_TRUST_PROXY_HEADERS, &val))?; + rate_limit_trust_proxy_headers = Some(val); + }, + RPC_RATE_LIMIT_WHITELISTED_IPS => { + let ip: IpNetwork = val + .parse() + .map_err(|_| invalid_value(RPC_RATE_LIMIT_WHITELISTED_IPS, &val))?; + rate_limit_whitelisted_ips.push(ip); + }, + RPC_RETRY_RANDOM_PORT => { + if retry_random_port.is_some() { + return Err(only_once_err(RPC_RETRY_RANDOM_PORT)); + } + let val = + val.parse().map_err(|_| invalid_value(RPC_RETRY_RANDOM_PORT, &val))?; + retry_random_port = Some(val); + }, + RPC_METHODS => { + if rpc_methods.is_some() { + return Err(only_once_err("methods")); + } + let val = val.parse().map_err(|_| invalid_value(RPC_METHODS, &val))?; + rpc_methods = Some(val); + }, + RPC_OPTIONAL => { + if is_optional.is_some() { + return Err(only_once_err(RPC_OPTIONAL)); + } + + let val = val.parse().map_err(|_| invalid_value(RPC_OPTIONAL, &val))?; + is_optional = Some(val); + }, + RPC_DISABLE_BATCH => { + if disable_batch_requests.is_some() { + return Err(only_once_err(RPC_DISABLE_BATCH)); + } + + let val = val.parse().map_err(|_| invalid_value(RPC_DISABLE_BATCH, &val))?; + disable_batch_requests = Some(val); + }, + RPC_BATCH_LIMIT => { + if max_batch_request_len.is_some() { + return Err(only_once_err(RPC_BATCH_LIMIT)); + } + + let val = val.parse().map_err(|_| invalid_value(RPC_BATCH_LIMIT, &val))?; + max_batch_request_len = Some(val); + }, + _ => return Err(invalid_key(key)), + } + } + + let listen_addr = listen_addr.ok_or("`listen-addr` must be specified exactly once")?; + + let batch_config = match (disable_batch_requests, max_batch_request_len) { + (Some(true), Some(_)) => { + return Err(format!("`{RPC_BATCH_LIMIT}` and `{RPC_DISABLE_BATCH}` are mutually exclusive and can't be used together")); + }, + (Some(false), None) => RpcBatchRequestConfig::Disabled, + (None, Some(len)) => RpcBatchRequestConfig::Limit(len), + _ => RpcBatchRequestConfig::Unlimited, + }; + + Ok(Self { + listen_addr, + batch_config, + max_connections: max_connections.unwrap_or(RPC_DEFAULT_MAX_CONNECTIONS), + max_payload_in_mb: max_payload_in_mb.unwrap_or(RPC_DEFAULT_MAX_REQUEST_SIZE_MB), + max_payload_out_mb: max_payload_out_mb.unwrap_or(RPC_DEFAULT_MAX_RESPONSE_SIZE_MB), + cors, + max_buffer_capacity_per_connection: max_buffer_capacity_per_connection + .unwrap_or(RPC_DEFAULT_MESSAGE_CAPACITY_PER_CONN), + max_subscriptions_per_connection: max_subscriptions_per_connection + .unwrap_or(RPC_DEFAULT_MAX_SUBS_PER_CONN), + rpc_methods: rpc_methods.unwrap_or(RpcMethods::Auto), + rate_limit, + rate_limit_trust_proxy_headers: rate_limit_trust_proxy_headers.unwrap_or(false), + rate_limit_whitelisted_ips, + is_optional: is_optional.unwrap_or(false), + retry_random_port: retry_random_port.unwrap_or(false), + }) + } +} + +impl Into for RpcEndpoint { + fn into(self) -> sc_service::config::RpcEndpoint { + sc_service::config::RpcEndpoint { + batch_config: self.batch_config, + listen_addr: self.listen_addr, + max_buffer_capacity_per_connection: self.max_buffer_capacity_per_connection, + max_connections: self.max_connections, + max_payload_in_mb: self.max_payload_in_mb, + max_payload_out_mb: self.max_payload_out_mb, + max_subscriptions_per_connection: self.max_subscriptions_per_connection, + rpc_methods: self.rpc_methods.into(), + rate_limit: self.rate_limit, + rate_limit_trust_proxy_headers: self.rate_limit_trust_proxy_headers, + rate_limit_whitelisted_ips: self.rate_limit_whitelisted_ips, + cors: self.cors, + retry_random_port: self.retry_random_port, + is_optional: self.is_optional, + } + } +} + +impl RpcEndpoint { + /// Returns whether the endpoint is globally exposed. + pub fn is_global(&self) -> bool { + let ip = IpNetwork::from(self.listen_addr.ip()); + ip.is_global() + } +} + +fn only_once_err(reason: &str) -> String { + format!("`{reason}` is only allowed be specified once") +} + +fn invalid_input(input: &str) -> String { + format!("`{input}`, expects: `key=value`") +} + +fn invalid_value(key: &str, value: &str) -> String { + format!("value=`{value}` key=`{key}`") +} + +fn invalid_key(key: &str) -> String { + format!("unknown key=`{key}`, see `--help` for available options") +} + +#[cfg(test)] +mod tests { + use super::*; + use std::{num::NonZeroU32, str::FromStr}; + + #[test] + fn parse_rpc_endpoint_works() { + assert!(RpcEndpoint::from_str("listen-addr=127.0.0.1:9944").is_ok()); + assert!(RpcEndpoint::from_str("listen-addr=[::1]:9944").is_ok()); + assert!(RpcEndpoint::from_str("listen-addr=127.0.0.1:9944,methods=auto").is_ok()); + assert!(RpcEndpoint::from_str("listen-addr=[::1]:9944,methods=auto").is_ok()); + assert!(RpcEndpoint::from_str( + "listen-addr=127.0.0.1:9944,methods=auto,cors=*,optional=true" + ) + .is_ok()); + + assert!(RpcEndpoint::from_str("listen-addrs=127.0.0.1:9944,foo=*").is_err()); + assert!(RpcEndpoint::from_str("listen-addrs=127.0.0.1:9944,cors=").is_err()); + } + + #[test] + fn parse_rpc_endpoint_all() { + let endpoint = RpcEndpoint::from_str( + "listen-addr=127.0.0.1:9944,methods=unsafe,cors=*,optional=true,retry-random-port=true,rate-limit=99,\ + max-batch-request-len=100,rate-limit-trust-proxy-headers=true,max-connections=33,max-request-size=4,\ + max-response-size=3,max-subscriptions-per-connection=7,max-buffer-capacity-per-connection=8,\ + rate-limit-whitelisted-ips=192.168.1.0/24,rate-limit-whitelisted-ips=ff01::0/32" + ).unwrap(); + assert_eq!(endpoint.listen_addr, ([127, 0, 0, 1], 9944).into()); + assert_eq!(endpoint.rpc_methods, RpcMethods::Unsafe); + assert_eq!(endpoint.cors, Some(vec!["*".to_string()])); + assert_eq!(endpoint.is_optional, true); + assert_eq!(endpoint.retry_random_port, true); + assert_eq!(endpoint.rate_limit, Some(NonZeroU32::new(99).unwrap())); + assert!(matches!(endpoint.batch_config, RpcBatchRequestConfig::Limit(l) if l == 100)); + assert_eq!(endpoint.rate_limit_trust_proxy_headers, true); + assert_eq!( + endpoint.rate_limit_whitelisted_ips, + vec![ + IpNetwork::V4("192.168.1.0/24".parse().unwrap()), + IpNetwork::V6("ff01::0/32".parse().unwrap()) + ] + ); + assert_eq!(endpoint.max_connections, 33); + assert_eq!(endpoint.max_payload_in_mb, 4); + assert_eq!(endpoint.max_payload_out_mb, 3); + assert_eq!(endpoint.max_subscriptions_per_connection, 7); + assert_eq!(endpoint.max_buffer_capacity_per_connection, 8); + } + + #[test] + fn parse_rpc_endpoint_multiple_cors() { + let addr = RpcEndpoint::from_str( + "listen-addr=127.0.0.1:9944,methods=auto,cors=https://polkadot.js.org,cors=*,cors=localhost:*", + ) + .unwrap(); + + assert_eq!( + addr.cors, + Some(vec![ + "https://polkadot.js.org".to_string(), + "*".to_string(), + "localhost:*".to_string() + ]) + ); + } + + #[test] + fn parse_rpc_endpoint_whitespaces() { + let addr = RpcEndpoint::from_str( + " listen-addr = 127.0.0.1:9944, methods = auto, optional = true ", + ) + .unwrap(); + assert_eq!(addr.rpc_methods, RpcMethods::Auto); + assert_eq!(addr.is_optional, true); + } + + #[test] + fn parse_rpc_endpoint_batch_options_mutually_exclusive() { + assert!(RpcEndpoint::from_str( + "listen-addr = 127.0.0.1:9944,disable-batch-requests=true,max-batch-request-len=100", + ) + .is_err()); + } +} diff --git a/substrate/client/cli/src/runner.rs b/substrate/client/cli/src/runner.rs index 3bf2768078401f8cfafaceab1b76c8a83e2548d5..b0dbccfa634c881afe7b90b5e3a98a2fdbab6904 100644 --- a/substrate/client/cli/src/runner.rs +++ b/substrate/client/cli/src/runner.rs @@ -252,12 +252,15 @@ mod tests { state_pruning: None, blocks_pruning: sc_client_db::BlocksPruning::KeepAll, chain_spec: Box::new( - GenericChainSpec::<()>::builder(Default::default(), NoExtension::None) - .with_name("test") - .with_id("test_id") - .with_chain_type(ChainType::Development) - .with_genesis_config_patch(Default::default()) - .build(), + GenericChainSpec::::builder( + Default::default(), + NoExtension::None, + ) + .with_name("test") + .with_id("test_id") + .with_chain_type(ChainType::Development) + .with_genesis_config_patch(Default::default()) + .build(), ), wasm_method: Default::default(), wasm_runtime_overrides: None, @@ -288,7 +291,6 @@ mod tests { announce_block: true, base_path: sc_service::BasePath::new(root.clone()), data_path: root, - informant_output_format: Default::default(), runtime_cache_size: 2, }, runtime, diff --git a/substrate/client/consensus/aura/Cargo.toml b/substrate/client/consensus/aura/Cargo.toml index 64e2d16cd913aaea5d2688087e90088e5ff46ab8..98e8ad676be3c9b64aafdc96b08434c0462de62c 100644 --- a/substrate/client/consensus/aura/Cargo.toml +++ b/substrate/client/consensus/aura/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Aura consensus algorithm for substrate" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,37 +16,37 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" +async-trait = { workspace = true } +codec = { workspace = true, default-features = true } +futures = { workspace = true } log = { workspace = true, default-features = true } thiserror = { workspace = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-block-builder = { path = "../../block-builder" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sc-consensus-slots = { path = "../slots" } -sc-telemetry = { path = "../../telemetry" } -sp-api = { path = "../../../primitives/api" } -sp-application-crypto = { path = "../../../primitives/application-crypto" } -sp-block-builder = { path = "../../../primitives/block-builder" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-aura = { path = "../../../primitives/consensus/aura" } -sp-consensus-slots = { path = "../../../primitives/consensus/slots" } -sp-core = { path = "../../../primitives/core" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } +prometheus-endpoint = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-slots = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -parking_lot = "0.12.1" -tempfile = "3.1.0" -sc-keystore = { path = "../../keystore" } -sc-network = { path = "../../network" } -sc-network-test = { path = "../../network/test" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-timestamp = { path = "../../../primitives/timestamp" } -sp-tracing = { path = "../../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } -tokio = { version = "1.22.0" } +parking_lot = { workspace = true, default-features = true } +tempfile = { workspace = true } +sc-keystore = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-test = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +tokio = { workspace = true, default-features = true } diff --git a/substrate/client/consensus/aura/src/import_queue.rs b/substrate/client/consensus/aura/src/import_queue.rs index a8777ef8788cc3a247d6d09c146f61bf4cb23e62..79f4faa5ebf97657b0f6d02933a1e7f8421d4f56 100644 --- a/substrate/client/consensus/aura/src/import_queue.rs +++ b/substrate/client/consensus/aura/src/import_queue.rs @@ -174,7 +174,7 @@ where CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync, { async fn verify( - &mut self, + &self, mut block: BlockImportParams, ) -> Result, String> { // Skip checks that include execution, if being told so or when importing only state. diff --git a/substrate/client/consensus/aura/src/standalone.rs b/substrate/client/consensus/aura/src/standalone.rs index 0f9b8668d4478bfe4dedfc56e234b79acdf14674..c1536d9ef73f38561e9944928b1c7a6c1e985ab6 100644 --- a/substrate/client/consensus/aura/src/standalone.rs +++ b/substrate/client/consensus/aura/src/standalone.rs @@ -24,7 +24,7 @@ use log::trace; use codec::Codec; -use sc_client_api::{backend::AuxStore, UsageProvider}; +use sc_client_api::UsageProvider; use sp_api::{Core, ProvideRuntimeApi}; use sp_application_crypto::{AppCrypto, AppPublic}; use sp_blockchain::Result as CResult; @@ -48,7 +48,7 @@ pub fn slot_duration(client: &C) -> CResult where A: Codec, B: BlockT, - C: AuxStore + ProvideRuntimeApi + UsageProvider, + C: ProvideRuntimeApi + UsageProvider, C::Api: AuraApi, { slot_duration_at(client, client.usage_info().chain.best_hash) @@ -59,7 +59,7 @@ pub fn slot_duration_at(client: &C, block_hash: B::Hash) -> CResult, + C: ProvideRuntimeApi, C::Api: AuraApi, { client.runtime_api().slot_duration(block_hash).map_err(|err| err.into()) diff --git a/substrate/client/consensus/babe/Cargo.toml b/substrate/client/consensus/babe/Cargo.toml index b001e3d117aa94c86e76484336b434f840ec3e69..af55e72a9b7eed54a956f2c283c06fab0b494294 100644 --- a/substrate/client/consensus/babe/Cargo.toml +++ b/substrate/client/consensus/babe/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "BABE consensus algorithm for substrate" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true documentation = "https://docs.rs/sc-consensus-babe" readme = "README.md" @@ -17,41 +17,41 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] } -futures = "0.3.30" +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -num-bigint = "0.4.3" -num-rational = "0.4.1" -num-traits = "0.2.17" -parking_lot = "0.12.1" +num-bigint = { workspace = true } +num-rational = { workspace = true } +num-traits = { workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } thiserror = { workspace = true } -fork-tree = { path = "../../../utils/fork-tree" } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sc-consensus-epochs = { path = "../epochs" } -sc-consensus-slots = { path = "../slots" } -sc-telemetry = { path = "../../telemetry" } -sc-transaction-pool-api = { path = "../../transaction-pool/api" } -sp-api = { path = "../../../primitives/api" } -sp-application-crypto = { path = "../../../primitives/application-crypto" } -sp-block-builder = { path = "../../../primitives/block-builder" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-babe = { path = "../../../primitives/consensus/babe" } -sp-consensus-slots = { path = "../../../primitives/consensus/slots" } -sp-core = { path = "../../../primitives/core" } -sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } +fork-tree = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-epochs = { workspace = true, default-features = true } +sc-consensus-slots = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -sc-block-builder = { path = "../../block-builder" } -sp-keyring = { path = "../../../primitives/keyring" } -sc-network-test = { path = "../../network/test" } -sp-timestamp = { path = "../../../primitives/timestamp" } -sp-tracing = { path = "../../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } -tokio = "1.37" +sc-block-builder = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sc-network-test = { workspace = true } +sp-timestamp = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +tokio = { workspace = true, default-features = true } diff --git a/substrate/client/consensus/babe/README.md b/substrate/client/consensus/babe/README.md index a3cf944b513b80eb96493342b821147bfc905592..47b5820ff71aab8a4a6c92640ebd8981c396fa09 100644 --- a/substrate/client/consensus/babe/README.md +++ b/substrate/client/consensus/babe/README.md @@ -43,6 +43,6 @@ primary blocks in the chain. We will pick the heaviest chain (more primary blocks) and will go with the longest one in case of a tie. An in-depth description and analysis of the protocol can be found here: - + License: GPL-3.0-or-later WITH Classpath-exception-2.0 diff --git a/substrate/client/consensus/babe/rpc/Cargo.toml b/substrate/client/consensus/babe/rpc/Cargo.toml index 4c755df541d70315dea241092145e17c2bd28800..ce5b1baec0b57700b5831a5d86eabd62a841c237 100644 --- a/substrate/client/consensus/babe/rpc/Cargo.toml +++ b/substrate/client/consensus/babe/rpc/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "RPC extensions for the BABE consensus algorithm" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,27 +16,27 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] } -futures = "0.3.30" +jsonrpsee = { features = ["client-core", "macros", "server-core"], workspace = true } +futures = { workspace = true } serde = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } -sc-consensus-babe = { path = ".." } -sc-consensus-epochs = { path = "../../epochs" } -sc-rpc-api = { path = "../../../rpc-api" } -sp-api = { path = "../../../../primitives/api" } -sp-application-crypto = { path = "../../../../primitives/application-crypto" } -sp-blockchain = { path = "../../../../primitives/blockchain" } -sp-consensus = { path = "../../../../primitives/consensus/common" } -sp-consensus-babe = { path = "../../../../primitives/consensus/babe" } -sp-core = { path = "../../../../primitives/core" } -sp-keystore = { path = "../../../../primitives/keystore" } -sp-runtime = { path = "../../../../primitives/runtime" } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-epochs = { workspace = true, default-features = true } +sc-rpc-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] serde_json = { workspace = true, default-features = true } -tokio = "1.37" -sc-consensus = { path = "../../common" } -sc-keystore = { path = "../../../keystore" } -sc-transaction-pool-api = { path = "../../../transaction-pool/api" } -sp-keyring = { path = "../../../../primitives/keyring" } -substrate-test-runtime-client = { path = "../../../../test-utils/runtime/client" } +tokio = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-keystore = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/consensus/babe/rpc/src/lib.rs b/substrate/client/consensus/babe/rpc/src/lib.rs index a3e811baecffd6de1b9f94952be40d00d8b61de3..338d71a432565a8f9af2cf0ee7562278fc9f6b2d 100644 --- a/substrate/client/consensus/babe/rpc/src/lib.rs +++ b/substrate/client/consensus/babe/rpc/src/lib.rs @@ -25,12 +25,13 @@ use jsonrpsee::{ core::async_trait, proc_macros::rpc, types::{ErrorObject, ErrorObjectOwned}, + Extensions, }; use serde::{Deserialize, Serialize}; use sc_consensus_babe::{authorship, BabeWorkerHandle}; use sc_consensus_epochs::Epoch as EpochT; -use sc_rpc_api::{DenyUnsafe, UnsafeRpcError}; +use sc_rpc_api::{check_if_safe, UnsafeRpcError}; use sp_api::ProvideRuntimeApi; use sp_application_crypto::AppCrypto; use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; @@ -47,7 +48,7 @@ const BABE_ERROR: i32 = 9000; pub trait BabeApi { /// Returns data about which slots (primary or secondary) can be claimed in the current epoch /// with the keys in the keystore. - #[method(name = "babe_epochAuthorship")] + #[method(name = "babe_epochAuthorship", with_extensions)] async fn epoch_authorship(&self) -> Result, Error>; } @@ -61,8 +62,6 @@ pub struct Babe { keystore: KeystorePtr, /// The SelectChain strategy select_chain: SC, - /// Whether to deny unsafe calls - deny_unsafe: DenyUnsafe, } impl Babe { @@ -72,9 +71,8 @@ impl Babe { babe_worker_handle: BabeWorkerHandle, keystore: KeystorePtr, select_chain: SC, - deny_unsafe: DenyUnsafe, ) -> Self { - Self { client, babe_worker_handle, keystore, select_chain, deny_unsafe } + Self { client, babe_worker_handle, keystore, select_chain } } } @@ -89,8 +87,11 @@ where C::Api: BabeRuntimeApi, SC: SelectChain + Clone + 'static, { - async fn epoch_authorship(&self) -> Result, Error> { - self.deny_unsafe.check_if_safe()?; + async fn epoch_authorship( + &self, + ext: &Extensions, + ) -> Result, Error> { + check_if_safe(ext)?; let best_header = self.select_chain.best_chain().map_err(Error::SelectChain).await?; @@ -193,6 +194,7 @@ impl From for ErrorObjectOwned { mod tests { use super::*; use sc_consensus_babe::ImportQueueParams; + use sc_rpc_api::DenyUnsafe; use sc_transaction_pool_api::{OffchainTransactionPoolFactory, RejectAllTxPool}; use sp_consensus_babe::inherents::InherentDataProvider; use sp_core::{crypto::key_types::BABE, testing::TaskExecutor}; @@ -211,9 +213,8 @@ mod tests { keystore.into() } - fn test_babe_rpc_module( - deny_unsafe: DenyUnsafe, - ) -> Babe> { + fn test_babe_rpc_module() -> Babe> + { let builder = TestClientBuilder::new(); let (client, longest_chain) = builder.build_with_longest_chain(); let client = Arc::new(client); @@ -248,29 +249,31 @@ mod tests { }) .unwrap(); - Babe::new(client.clone(), babe_worker_handle, keystore, longest_chain, deny_unsafe) + Babe::new(client.clone(), babe_worker_handle, keystore, longest_chain) } #[tokio::test] async fn epoch_authorship_works() { - let babe_rpc = test_babe_rpc_module(DenyUnsafe::No); - let api = babe_rpc.into_rpc(); + let babe_rpc = test_babe_rpc_module(); + let mut api = babe_rpc.into_rpc(); + api.extensions_mut().insert(DenyUnsafe::No); - let request = r#"{"jsonrpc":"2.0","method":"babe_epochAuthorship","params": [],"id":1}"#; + let request = r#"{"jsonrpc":"2.0","id":1,"method":"babe_epochAuthorship","params":[]}"#; let (response, _) = api.raw_json_request(request, 1).await.unwrap(); - let expected = r#"{"jsonrpc":"2.0","result":{"5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY":{"primary":[0],"secondary":[],"secondary_vrf":[1,2,4]}},"id":1}"#; + let expected = r#"{"jsonrpc":"2.0","id":1,"result":{"5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY":{"primary":[0],"secondary":[],"secondary_vrf":[1,2,4]}}}"#; assert_eq!(response, expected); } #[tokio::test] async fn epoch_authorship_is_unsafe() { - let babe_rpc = test_babe_rpc_module(DenyUnsafe::Yes); - let api = babe_rpc.into_rpc(); + let babe_rpc = test_babe_rpc_module(); + let mut api = babe_rpc.into_rpc(); + api.extensions_mut().insert(DenyUnsafe::Yes); let request = r#"{"jsonrpc":"2.0","method":"babe_epochAuthorship","params":[],"id":1}"#; let (response, _) = api.raw_json_request(request, 1).await.unwrap(); - let expected = r#"{"jsonrpc":"2.0","error":{"code":-32601,"message":"RPC call is unsafe to be called externally"},"id":1}"#; + let expected = r#"{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"RPC call is unsafe to be called externally"}}"#; assert_eq!(response, expected); } diff --git a/substrate/client/consensus/babe/src/lib.rs b/substrate/client/consensus/babe/src/lib.rs index d10bdd8c7e4c4d108b78ef3286f475ba85e16a8a..9770b16871e1193230d057acb571d2c0acca108e 100644 --- a/substrate/client/consensus/babe/src/lib.rs +++ b/substrate/client/consensus/babe/src/lib.rs @@ -61,7 +61,7 @@ //! blocks) and will go with the longest one in case of a tie. //! //! An in-depth description and analysis of the protocol can be found here: -//! +//! #![forbid(unsafe_code)] #![warn(missing_docs)] @@ -562,9 +562,10 @@ fn aux_storage_cleanup + HeaderBackend, Block: B // Cleans data for stale forks. let stale_forks = match client.expand_forks(¬ification.stale_heads) { Ok(stale_forks) => stale_forks, - Err((stale_forks, e)) => { + Err(e) => { warn!(target: LOG_TARGET, "{:?}", e); - stale_forks + + Default::default() }, }; hashes.extend(stale_forks.iter()); @@ -1127,7 +1128,7 @@ where CIDP::InherentDataProviders: InherentDataProviderExt + Send + Sync, { async fn verify( - &mut self, + &self, mut block: BlockImportParams, ) -> Result, String> { trace!( @@ -1341,7 +1342,7 @@ where // This function makes multiple transactions to the DB. If one of them fails we may // end up in an inconsistent state and have to resync. async fn import_state( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let hash = block.post_hash(); @@ -1404,7 +1405,7 @@ where type Error = ConsensusError; async fn import_block( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let hash = block.post_hash(); @@ -1680,7 +1681,7 @@ where } async fn check_block( - &mut self, + &self, block: BlockCheckParams, ) -> Result { self.inner.check_block(block).await.map_err(Into::into) diff --git a/substrate/client/consensus/babe/src/tests.rs b/substrate/client/consensus/babe/src/tests.rs index 38c9e1ff6ac25cc26151c668902838ec65ab6189..5c2e0eae959c1584e01176ae683364a5802abcd3 100644 --- a/substrate/client/consensus/babe/src/tests.rs +++ b/substrate/client/consensus/babe/src/tests.rs @@ -143,21 +143,21 @@ thread_local! { pub struct PanickingBlockImport(B); #[async_trait::async_trait] -impl> BlockImport for PanickingBlockImport +impl BlockImport for PanickingBlockImport where - B: Send, + BI: BlockImport + Send + Sync, { - type Error = B::Error; + type Error = BI::Error; async fn import_block( - &mut self, + &self, block: BlockImportParams, ) -> Result { Ok(self.0.import_block(block).await.expect("importing block failed")) } async fn check_block( - &mut self, + &self, block: BlockCheckParams, ) -> Result { Ok(self.0.check_block(block).await.expect("checking block failed")) @@ -198,7 +198,7 @@ impl Verifier for TestVerifier { /// new set of validators to import. If not, err with an Error-Message /// presented to the User in the logs. async fn verify( - &mut self, + &self, mut block: BlockImportParams, ) -> Result, String> { // apply post-sealing mutations (i.e. stripping seal, if desired). @@ -1094,8 +1094,8 @@ async fn obsolete_blocks_aux_data_cleanup() { assert!(aux_data_check(&fork1_hashes[2..3], false)); // Present: A4 assert!(aux_data_check(&fork1_hashes[3..], true)); - // Present C4, C5 - assert!(aux_data_check(&fork3_hashes, true)); + // Wiped C4, C5 + assert!(aux_data_check(&fork3_hashes, false)); } #[tokio::test] diff --git a/substrate/client/consensus/beefy/Cargo.toml b/substrate/client/consensus/beefy/Cargo.toml index 9336841146e74df3539bb64265314a4a7917dff9..900a44b95e0442159c3efb42965cc256d5998e9c 100644 --- a/substrate/client/consensus/beefy/Cargo.toml +++ b/substrate/client/consensus/beefy/Cargo.toml @@ -6,53 +6,52 @@ edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" repository.workspace = true description = "BEEFY Client gadget for substrate" -homepage = "https://substrate.io" +homepage.workspace = true [lints] workspace = true [dependencies] -array-bytes = "6.2.2" -async-channel = "1.8.0" -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] } -fnv = "1.0.6" -futures = "0.3.30" +array-bytes = { workspace = true, default-features = true } +async-channel = { workspace = true } +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +fnv = { workspace = true } +futures = { workspace = true } log = { workspace = true, default-features = true } -parking_lot = "0.12.1" +parking_lot = { workspace = true, default-features = true } thiserror = { workspace = true } -wasm-timer = "0.2.5" -prometheus = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sc-network = { path = "../../network" } -sc-network-gossip = { path = "../../network-gossip" } -sc-network-sync = { path = "../../network/sync" } -sc-network-types = { path = "../../network/types" } -sc-utils = { path = "../../utils" } -sp-api = { path = "../../../primitives/api" } -sp-application-crypto = { path = "../../../primitives/application-crypto" } -sp-arithmetic = { path = "../../../primitives/arithmetic" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-beefy = { path = "../../../primitives/consensus/beefy" } -sp-core = { path = "../../../primitives/core" } -sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } -tokio = "1.37" - +wasm-timer = { workspace = true } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-gossip = { workspace = true, default-features = true } +sc-network-sync = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +tokio = { workspace = true, default-features = true } [dev-dependencies] serde = { workspace = true, default-features = true } -tempfile = "3.1.0" -sc-block-builder = { path = "../../block-builder" } -sc-network-test = { path = "../../network/test" } -sp-consensus-grandpa = { path = "../../../primitives/consensus/grandpa" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-mmr-primitives = { path = "../../../primitives/merkle-mountain-range" } -sp-tracing = { path = "../../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } +tempfile = { workspace = true } +sc-block-builder = { workspace = true, default-features = true } +sc-network-test = { workspace = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +sp-mmr-primitives = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } [features] # This feature adds BLS crypto primitives. It should not be used in production since diff --git a/substrate/client/consensus/beefy/README.md b/substrate/client/consensus/beefy/README.md index a7956cfcd42efab055ea7cc5d0efc14f54ea20ba..cb9a9267f77ef8bad83f4b8d3d215e1467abc3c1 100644 --- a/substrate/client/consensus/beefy/README.md +++ b/substrate/client/consensus/beefy/README.md @@ -159,7 +159,7 @@ ambiguity despite using block number instead of a hash. A collection of **votes* a Commitment and a collection of signatures is going to be called **Signed Commitment**. A valid (see later for the rules) Signed Commitment is also called a **BEEFY Justification** or **BEEFY Finality Proof**. For more details on the actual data structures please see -[BEEFY primitives definitions](https://github.com/paritytech/polkadot-sdk/tree/master/substrate/primitives/beefy/src). +[BEEFY primitives definitions](https://github.com/paritytech/polkadot-sdk/tree/master/substrate/primitives/consensus/beefy/src). A **round** is an attempt by BEEFY validators to produce a BEEFY Justification. **Round number** is simply defined as a block number the validators are voting for, or to be more precise, the diff --git a/substrate/client/consensus/beefy/rpc/Cargo.toml b/substrate/client/consensus/beefy/rpc/Cargo.toml index 0959424ba862d05c693d417fed45cdaa91d38be5..e1956dacf396125c8b7a08a2e43da5d6b75b43b7 100644 --- a/substrate/client/consensus/beefy/rpc/Cargo.toml +++ b/substrate/client/consensus/beefy/rpc/Cargo.toml @@ -6,27 +6,28 @@ edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" repository.workspace = true description = "RPC for the BEEFY Client gadget for substrate" -homepage = "https://substrate.io" +homepage.workspace = true [lints] workspace = true [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] } -futures = "0.3.30" -jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +jsonrpsee = { features = ["client-core", "macros", "server-core"], workspace = true } log = { workspace = true, default-features = true } -parking_lot = "0.12.1" +parking_lot = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } -sc-consensus-beefy = { path = ".." } -sp-consensus-beefy = { path = "../../../../primitives/consensus/beefy" } -sc-rpc = { path = "../../../rpc" } -sp-core = { path = "../../../../primitives/core" } -sp-runtime = { path = "../../../../primitives/runtime" } +sc-consensus-beefy = { workspace = true, default-features = true } +sp-consensus-beefy = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } [dev-dependencies] serde_json = { workspace = true, default-features = true } -sc-rpc = { path = "../../../rpc", features = ["test-helpers"] } -substrate-test-runtime-client = { path = "../../../../test-utils/runtime/client" } -tokio = { version = "1.22.0", features = ["macros"] } +sc-rpc = { features = ["test-helpers"], workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } diff --git a/substrate/client/consensus/beefy/rpc/src/lib.rs b/substrate/client/consensus/beefy/rpc/src/lib.rs index f01baee2d6ece9a9d1dd36e1524a1d004e9b0401..ab58f6866275853d371ec71f9237a97244e2d529 100644 --- a/substrate/client/consensus/beefy/rpc/src/lib.rs +++ b/substrate/client/consensus/beefy/rpc/src/lib.rs @@ -21,9 +21,14 @@ #![warn(missing_docs)] use parking_lot::RwLock; +use sp_consensus_beefy::AuthorityIdBound; use std::sync::Arc; -use sc_rpc::{utils::pipe_from_stream, SubscriptionTaskExecutor}; +use sc_rpc::{ + utils::{BoundedVecDeque, PendingSubscription}, + SubscriptionTaskExecutor, +}; +use sp_application_crypto::RuntimeAppPublic; use sp_runtime::traits::Block as BlockT; use futures::{task::SpawnError, FutureExt, StreamExt}; @@ -98,19 +103,20 @@ pub trait BeefyApi { } /// Implements the BeefyApi RPC trait for interacting with BEEFY. -pub struct Beefy { - finality_proof_stream: BeefyVersionedFinalityProofStream, +pub struct Beefy { + finality_proof_stream: BeefyVersionedFinalityProofStream, beefy_best_block: Arc>>, executor: SubscriptionTaskExecutor, } -impl Beefy +impl Beefy where Block: BlockT, + AuthorityId: AuthorityIdBound, { /// Creates a new Beefy Rpc handler instance. pub fn new( - finality_proof_stream: BeefyVersionedFinalityProofStream, + finality_proof_stream: BeefyVersionedFinalityProofStream, best_block_stream: BeefyBestBlockStream, executor: SubscriptionTaskExecutor, ) -> Result { @@ -129,18 +135,23 @@ where } #[async_trait] -impl BeefyApiServer - for Beefy +impl BeefyApiServer + for Beefy where Block: BlockT, + AuthorityId: AuthorityIdBound, + ::Signature: Send + Sync, { fn subscribe_justifications(&self, pending: PendingSubscriptionSink) { let stream = self .finality_proof_stream .subscribe(100_000) - .map(|vfp| notification::EncodedVersionedFinalityProof::new::(vfp)); + .map(|vfp| notification::EncodedVersionedFinalityProof::new::(vfp)); - sc_rpc::utils::spawn_subscription_task(&self.executor, pipe_from_stream(pending, stream)); + sc_rpc::utils::spawn_subscription_task( + &self.executor, + PendingSubscription::from(pending).pipe_from_stream(stream, BoundedVecDeque::default()), + ); } async fn latest_finalized(&self) -> Result { @@ -158,20 +169,26 @@ mod tests { communication::notification::BeefyVersionedFinalityProofSender, justification::BeefyVersionedFinalityProof, }; - use sp_consensus_beefy::{known_payloads, Payload, SignedCommitment}; + use sp_consensus_beefy::{ecdsa_crypto, known_payloads, Payload, SignedCommitment}; use sp_runtime::traits::{BlakeTwo256, Hash}; use substrate_test_runtime_client::runtime::Block; - fn setup_io_handler() -> (RpcModule>, BeefyVersionedFinalityProofSender) { + fn setup_io_handler() -> ( + RpcModule>, + BeefyVersionedFinalityProofSender, + ) { let (_, stream) = BeefyBestBlockStream::::channel(); setup_io_handler_with_best_block_stream(stream) } fn setup_io_handler_with_best_block_stream( best_block_stream: BeefyBestBlockStream, - ) -> (RpcModule>, BeefyVersionedFinalityProofSender) { + ) -> ( + RpcModule>, + BeefyVersionedFinalityProofSender, + ) { let (finality_proof_sender, finality_proof_stream) = - BeefyVersionedFinalityProofStream::::channel(); + BeefyVersionedFinalityProofStream::::channel(); let handler = Beefy::new(finality_proof_stream, best_block_stream, sc_rpc::testing::test_executor()) @@ -184,7 +201,7 @@ mod tests { async fn uninitialized_rpc_handler() { let (rpc, _) = setup_io_handler(); let request = r#"{"jsonrpc":"2.0","method":"beefy_getFinalizedHead","params":[],"id":1}"#; - let expected_response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"BEEFY RPC endpoint not ready"},"id":1}"#; + let expected_response = r#"{"jsonrpc":"2.0","id":1,"error":{"code":1,"message":"BEEFY RPC endpoint not ready"}}"#; let (response, _) = rpc.raw_json_request(&request, 1).await.unwrap(); assert_eq!(expected_response, response); @@ -203,13 +220,13 @@ mod tests { let request = r#"{"jsonrpc":"2.0","method":"beefy_getFinalizedHead","params":[],"id":1}"#; let expected = "{\ \"jsonrpc\":\"2.0\",\ - \"result\":\"0x2f0039e93a27221fcf657fb877a1d4f60307106113e885096cb44a461cd0afbf\",\ - \"id\":1\ + \"id\":1,\ + \"result\":\"0x2f0039e93a27221fcf657fb877a1d4f60307106113e885096cb44a461cd0afbf\"\ }"; - let not_ready = "{\ + let not_ready: &str = "{\ \"jsonrpc\":\"2.0\",\ - \"error\":{\"code\":1,\"message\":\"BEEFY RPC endpoint not ready\"},\ - \"id\":1\ + \"id\":1,\ + \"error\":{\"code\":1,\"message\":\"BEEFY RPC endpoint not ready\"}\ }"; let deadline = std::time::Instant::now() + std::time::Duration::from_secs(2); @@ -245,15 +262,15 @@ mod tests { ) .await .unwrap(); - let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#; + let expected = r#"{"jsonrpc":"2.0","id":1,"result":false}"#; assert_eq!(response, expected); } - fn create_finality_proof() -> BeefyVersionedFinalityProof { + fn create_finality_proof() -> BeefyVersionedFinalityProof { let payload = Payload::from_single_entry(known_payloads::MMR_ROOT_ID, "Hello World!".encode()); - BeefyVersionedFinalityProof::::V1(SignedCommitment { + BeefyVersionedFinalityProof::::V1(SignedCommitment { commitment: sp_consensus_beefy::Commitment { payload, block_number: 5, @@ -280,7 +297,7 @@ mod tests { // Inspect what we received let (bytes, recv_sub_id) = sub.next::().await.unwrap().unwrap(); - let recv_finality_proof: BeefyVersionedFinalityProof = + let recv_finality_proof: BeefyVersionedFinalityProof = Decode::decode(&mut &bytes[..]).unwrap(); assert_eq!(&recv_sub_id, sub.subscription_id()); assert_eq!(recv_finality_proof, finality_proof); diff --git a/substrate/client/consensus/beefy/rpc/src/notification.rs b/substrate/client/consensus/beefy/rpc/src/notification.rs index 690c511b999ac1b89627cd1e67dc2ce8e2343862..d4339058a6940df75959fbd7b9ded13a318bd5db 100644 --- a/substrate/client/consensus/beefy/rpc/src/notification.rs +++ b/substrate/client/consensus/beefy/rpc/src/notification.rs @@ -19,6 +19,7 @@ use codec::Encode; use serde::{Deserialize, Serialize}; +use sp_consensus_beefy::AuthorityIdBound; use sp_runtime::traits::Block as BlockT; /// An encoded finality proof proving that the given header has been finalized. @@ -28,11 +29,15 @@ use sp_runtime::traits::Block as BlockT; pub struct EncodedVersionedFinalityProof(sp_core::Bytes); impl EncodedVersionedFinalityProof { - pub fn new( - finality_proof: sc_consensus_beefy::justification::BeefyVersionedFinalityProof, + pub fn new( + finality_proof: sc_consensus_beefy::justification::BeefyVersionedFinalityProof< + Block, + AuthorityId, + >, ) -> Self where Block: BlockT, + AuthorityId: AuthorityIdBound, { EncodedVersionedFinalityProof(finality_proof.encode().into()) } diff --git a/substrate/client/consensus/beefy/src/aux_schema.rs b/substrate/client/consensus/beefy/src/aux_schema.rs index 534f668ae69c2996064bef086e2958b23f48caf0..1922494ad11207ae4f46931a5dcf673b3154001b 100644 --- a/substrate/client/consensus/beefy/src/aux_schema.rs +++ b/substrate/client/consensus/beefy/src/aux_schema.rs @@ -20,8 +20,10 @@ use crate::{error::Error, worker::PersistedState, LOG_TARGET}; use codec::{Decode, Encode}; -use log::{debug, trace}; +use log::{debug, trace, warn}; use sc_client_api::{backend::AuxStore, Backend}; +use sp_blockchain::{Error as ClientError, Result as ClientResult}; +use sp_consensus_beefy::AuthorityIdBound; use sp_runtime::traits::Block as BlockT; const VERSION_KEY: &[u8] = b"beefy_auxschema_version"; @@ -36,26 +38,27 @@ pub(crate) fn write_current_version(backend: &BE) -> Result<(), Er } /// Write voter state. -pub(crate) fn write_voter_state( +pub(crate) fn write_voter_state( backend: &BE, - state: &PersistedState, -) -> Result<(), Error> { + state: &PersistedState, +) -> ClientResult<()> { trace!(target: LOG_TARGET, "🥩 persisting {:?}", state); AuxStore::insert_aux(backend, &[(WORKER_STATE_KEY, state.encode().as_slice())], &[]) - .map_err(|e| Error::Backend(e.to_string())) } -fn load_decode(backend: &BE, key: &[u8]) -> Result, Error> { - match backend.get_aux(key).map_err(|e| Error::Backend(e.to_string()))? { +fn load_decode(backend: &BE, key: &[u8]) -> ClientResult> { + match backend.get_aux(key)? { None => Ok(None), Some(t) => T::decode(&mut &t[..]) - .map_err(|e| Error::Backend(format!("BEEFY DB is corrupted: {}", e))) + .map_err(|e| ClientError::Backend(format!("BEEFY DB is corrupted: {}", e))) .map(Some), } } /// Load or initialize persistent data from backend. -pub(crate) fn load_persistent(backend: &BE) -> Result>, Error> +pub(crate) fn load_persistent( + backend: &BE, +) -> ClientResult>> where B: BlockT, BE: Backend, @@ -64,9 +67,14 @@ where match version { None => (), - Some(1) | Some(2) | Some(3) => (), // versions 1, 2 & 3 are obsolete and should be ignored - Some(4) => return load_decode::<_, PersistedState>(backend, WORKER_STATE_KEY), - other => return Err(Error::Backend(format!("Unsupported BEEFY DB version: {:?}", other))), + + Some(v) if 1 <= v && v <= 3 => + // versions 1, 2 & 3 are obsolete and should be ignored + warn!(target: LOG_TARGET, "🥩 backend contains a BEEFY state of an obsolete version {v}. ignoring..."), + Some(4) => + return load_decode::<_, PersistedState>(backend, WORKER_STATE_KEY), + other => + return Err(ClientError::Backend(format!("Unsupported BEEFY DB version: {:?}", other))), } // No persistent state found in DB. @@ -78,6 +86,7 @@ pub(crate) mod tests { use super::*; use crate::tests::BeefyTestNet; use sc_network_test::TestNetFactory; + use sp_consensus_beefy::ecdsa_crypto; // also used in tests.rs pub fn verify_persisted_version>(backend: &BE) -> bool { @@ -91,7 +100,7 @@ pub(crate) mod tests { let backend = net.peer(0).client().as_backend(); // version not available in db -> None - assert_eq!(load_persistent(&*backend).unwrap(), None); + assert_eq!(load_persistent::<_, _, ecdsa_crypto::AuthorityId>(&*backend).unwrap(), None); // populate version in db write_current_version(&*backend).unwrap(); @@ -99,7 +108,7 @@ pub(crate) mod tests { assert_eq!(load_decode(&*backend, VERSION_KEY).unwrap(), Some(CURRENT_VERSION)); // version is available in db but state isn't -> None - assert_eq!(load_persistent(&*backend).unwrap(), None); + assert_eq!(load_persistent::<_, _, ecdsa_crypto::AuthorityId>(&*backend).unwrap(), None); // full `PersistedState` load is tested in `tests.rs`. } diff --git a/substrate/client/consensus/beefy/src/communication/gossip.rs b/substrate/client/consensus/beefy/src/communication/gossip.rs index 947fe13856f476042858b1a5698aa5333b1d287b..95cac250b7c595e7a1f8875096b1f37d061a367f 100644 --- a/substrate/client/consensus/beefy/src/communication/gossip.rs +++ b/substrate/client/consensus/beefy/src/communication/gossip.rs @@ -36,10 +36,8 @@ use crate::{ keystore::BeefyKeystore, LOG_TARGET, }; -use sp_consensus_beefy::{ - ecdsa_crypto::{AuthorityId, Signature}, - ValidatorSet, ValidatorSetId, VoteMessage, -}; +use sp_application_crypto::RuntimeAppPublic; +use sp_consensus_beefy::{AuthorityIdBound, ValidatorSet, ValidatorSetId, VoteMessage}; // Timeout for rebroadcasting messages. #[cfg(not(test))] @@ -72,16 +70,19 @@ enum Consider { /// BEEFY gossip message type that gets encoded and sent on the network. #[derive(Debug, Encode, Decode)] -pub(crate) enum GossipMessage { +pub(crate) enum GossipMessage { /// BEEFY message with commitment and single signature. - Vote(VoteMessage, AuthorityId, Signature>), + Vote(VoteMessage, AuthorityId, ::Signature>), /// BEEFY justification with commitment and signatures. - FinalityProof(BeefyVersionedFinalityProof), + FinalityProof(BeefyVersionedFinalityProof), } -impl GossipMessage { +impl GossipMessage { /// Return inner vote if this message is a Vote. - pub fn unwrap_vote(self) -> Option, AuthorityId, Signature>> { + pub fn unwrap_vote( + self, + ) -> Option, AuthorityId, ::Signature>> + { match self { GossipMessage::Vote(vote) => Some(vote), GossipMessage::FinalityProof(_) => None, @@ -89,7 +90,7 @@ impl GossipMessage { } /// Return inner finality proof if this message is a FinalityProof. - pub fn unwrap_finality_proof(self) -> Option> { + pub fn unwrap_finality_proof(self) -> Option> { match self { GossipMessage::Vote(_) => None, GossipMessage::FinalityProof(proof) => Some(proof), @@ -114,33 +115,33 @@ where } #[derive(Clone, Debug)] -pub(crate) struct GossipFilterCfg<'a, B: Block> { +pub(crate) struct GossipFilterCfg<'a, B: Block, AuthorityId: AuthorityIdBound> { pub start: NumberFor, pub end: NumberFor, pub validator_set: &'a ValidatorSet, } #[derive(Clone, Debug)] -struct FilterInner { +struct FilterInner { pub start: NumberFor, pub end: NumberFor, pub validator_set: ValidatorSet, } -struct Filter { +struct Filter { // specifies live rounds - inner: Option>, + inner: Option>, // cache of seen valid justifications in active rounds rounds_with_valid_proofs: BTreeSet>, } -impl Filter { +impl Filter { pub fn new() -> Self { Self { inner: None, rounds_with_valid_proofs: BTreeSet::new() } } /// Update filter to new `start` and `set_id`. - fn update(&mut self, cfg: GossipFilterCfg) { + fn update(&mut self, cfg: GossipFilterCfg) { self.rounds_with_valid_proofs .retain(|&round| round >= cfg.start && round <= cfg.end); // only clone+overwrite big validator_set if set_id changed @@ -220,21 +221,22 @@ impl Filter { /// rejected/expired. /// ///All messaging is handled in a single BEEFY global topic. -pub(crate) struct GossipValidator +pub(crate) struct GossipValidator where B: Block, { votes_topic: B::Hash, justifs_topic: B::Hash, - gossip_filter: RwLock>, + gossip_filter: RwLock>, next_rebroadcast: Mutex, known_peers: Arc>>, network: Arc, } -impl GossipValidator +impl GossipValidator where B: Block, + AuthorityId: AuthorityIdBound, { pub(crate) fn new(known_peers: Arc>>, network: Arc) -> Self { Self { @@ -250,7 +252,7 @@ where /// Update gossip validator filter. /// /// Only votes for `set_id` and rounds `start <= round <= end` will be accepted. - pub(crate) fn update_filter(&self, filter: GossipFilterCfg) { + pub(crate) fn update_filter(&self, filter: GossipFilterCfg) { debug!( target: LOG_TARGET, "🥩 New gossip filter: start {:?}, end {:?}, validator set id {:?}", @@ -260,10 +262,11 @@ where } } -impl GossipValidator +impl GossipValidator where B: Block, N: NetworkPeers, + AuthorityId: AuthorityIdBound, { fn report(&self, who: PeerId, cost_benefit: ReputationChange) { self.network.report_peer(who, cost_benefit); @@ -271,7 +274,7 @@ where fn validate_vote( &self, - vote: VoteMessage, AuthorityId, Signature>, + vote: VoteMessage, AuthorityId, ::Signature>, sender: &PeerId, ) -> Action { let round = vote.commitment.block_number; @@ -299,7 +302,7 @@ where .unwrap_or(false) { debug!(target: LOG_TARGET, "Message from voter not in validator set: {}", vote.id); - return Action::Discard(cost::UNKNOWN_VOTER) + return Action::Discard(cost::UNKNOWN_VOTER); } } @@ -316,10 +319,10 @@ where fn validate_finality_proof( &self, - proof: BeefyVersionedFinalityProof, + proof: BeefyVersionedFinalityProof, sender: &PeerId, ) -> Action { - let (round, set_id) = proof_block_num_and_set_id::(&proof); + let (round, set_id) = proof_block_num_and_set_id::(&proof); self.known_peers.lock().note_vote_for(*sender, round); let action = { @@ -336,7 +339,7 @@ where } if guard.is_already_proven(round) { - return Action::Discard(benefit::NOT_INTERESTED) + return Action::Discard(benefit::NOT_INTERESTED); } // Verify justification signatures. @@ -344,7 +347,7 @@ where .validator_set() .map(|validator_set| { if let Err((_, signatures_checked)) = - verify_with_validator_set::(round, validator_set, &proof) + verify_with_validator_set::(round, validator_set, &proof) { debug!( target: LOG_TARGET, @@ -369,9 +372,10 @@ where } } -impl Validator for GossipValidator +impl Validator for GossipValidator where B: Block, + AuthorityId: AuthorityIdBound, N: NetworkPeers + Send + Sync, { fn peer_disconnected(&self, _context: &mut dyn ValidatorContext, who: &PeerId) { @@ -385,7 +389,7 @@ where mut data: &[u8], ) -> ValidationResult { let raw = data; - let action = match GossipMessage::::decode_all(&mut data) { + let action = match GossipMessage::::decode_all(&mut data) { Ok(GossipMessage::Vote(msg)) => self.validate_vote(msg, sender), Ok(GossipMessage::FinalityProof(proof)) => self.validate_finality_proof(proof, sender), Err(e) => { @@ -414,26 +418,28 @@ where fn message_expired<'a>(&'a self) -> Box bool + 'a> { let filter = self.gossip_filter.read(); - Box::new(move |_topic, mut data| match GossipMessage::::decode_all(&mut data) { - Ok(GossipMessage::Vote(msg)) => { - let round = msg.commitment.block_number; - let set_id = msg.commitment.validator_set_id; - let expired = filter.consider_vote(round, set_id) != Consider::Accept; - trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired); - expired - }, - Ok(GossipMessage::FinalityProof(proof)) => { - let (round, set_id) = proof_block_num_and_set_id::(&proof); - let expired = filter.consider_finality_proof(round, set_id) != Consider::Accept; - trace!( - target: LOG_TARGET, - "🥩 Finality proof for round #{} expired: {}", - round, + Box::new(move |_topic, mut data| { + match GossipMessage::::decode_all(&mut data) { + Ok(GossipMessage::Vote(msg)) => { + let round = msg.commitment.block_number; + let set_id = msg.commitment.validator_set_id; + let expired = filter.consider_vote(round, set_id) != Consider::Accept; + trace!(target: LOG_TARGET, "🥩 Vote for round #{} expired: {}", round, expired); expired - ); - expired - }, - Err(_) => true, + }, + Ok(GossipMessage::FinalityProof(proof)) => { + let (round, set_id) = proof_block_num_and_set_id::(&proof); + let expired = filter.consider_finality_proof(round, set_id) != Consider::Accept; + trace!( + target: LOG_TARGET, + "🥩 Finality proof for round #{} expired: {}", + round, + expired + ); + expired + }, + Err(_) => true, + } }) } @@ -455,10 +461,10 @@ where let filter = self.gossip_filter.read(); Box::new(move |_who, intent, _topic, mut data| { if let MessageIntent::PeriodicRebroadcast = intent { - return do_rebroadcast + return do_rebroadcast; } - match GossipMessage::::decode_all(&mut data) { + match GossipMessage::::decode_all(&mut data) { Ok(GossipMessage::Vote(msg)) => { let round = msg.commitment.block_number; let set_id = msg.commitment.validator_set_id; @@ -467,7 +473,7 @@ where allowed }, Ok(GossipMessage::FinalityProof(proof)) => { - let (round, set_id) = proof_block_num_and_set_id::(&proof); + let (round, set_id) = proof_block_num_and_set_id::(&proof); let allowed = filter.consider_finality_proof(round, set_id) == Consider::Accept; trace!( target: LOG_TARGET, @@ -490,8 +496,8 @@ pub(crate) mod tests { use sc_network_test::Block; use sp_application_crypto::key_types::BEEFY as BEEFY_KEY_TYPE; use sp_consensus_beefy::{ - ecdsa_crypto::Signature, known_payloads, test_utils::Keyring, Commitment, MmrRootHash, - Payload, SignedCommitment, VoteMessage, + ecdsa_crypto, known_payloads, test_utils::Keyring, Commitment, MmrRootHash, Payload, + SignedCommitment, VoteMessage, }; use sp_keystore::{testing::MemoryKeystore, Keystore}; @@ -607,16 +613,18 @@ pub(crate) mod tests { } pub fn sign_commitment( - who: &Keyring, + who: &Keyring, commitment: &Commitment, - ) -> Signature { + ) -> ecdsa_crypto::Signature { let store = MemoryKeystore::new(); store.ecdsa_generate_new(BEEFY_KEY_TYPE, Some(&who.to_seed())).unwrap(); - let beefy_keystore: BeefyKeystore = Some(store.into()).into(); + let beefy_keystore: BeefyKeystore = Some(store.into()).into(); beefy_keystore.sign(&who.public(), &commitment.encode()).unwrap() } - fn dummy_vote(block_number: u64) -> VoteMessage { + fn dummy_vote( + block_number: u64, + ) -> VoteMessage { let payload = Payload::from_single_entry( known_payloads::MMR_ROOT_ID, MmrRootHash::default().encode(), @@ -629,8 +637,8 @@ pub(crate) mod tests { pub fn dummy_proof( block_number: u64, - validator_set: &ValidatorSet, - ) -> BeefyVersionedFinalityProof { + validator_set: &ValidatorSet, + ) -> BeefyVersionedFinalityProof { let payload = Payload::from_single_entry( known_payloads::MMR_ROOT_ID, MmrRootHash::default().encode(), @@ -639,25 +647,29 @@ pub(crate) mod tests { let signatures = validator_set .validators() .iter() - .map(|validator: &AuthorityId| { + .map(|validator: &ecdsa_crypto::AuthorityId| { Some(sign_commitment( - &Keyring::::from_public(validator).unwrap(), + &Keyring::::from_public(validator).unwrap(), &commitment, )) }) .collect(); - BeefyVersionedFinalityProof::::V1(SignedCommitment { commitment, signatures }) + BeefyVersionedFinalityProof::::V1(SignedCommitment { + commitment, + signatures, + }) } #[test] fn should_validate_messages() { - let keys = vec![Keyring::::Alice.public()]; - let validator_set = ValidatorSet::::new(keys.clone(), 0).unwrap(); + let keys = vec![Keyring::::Alice.public()]; + let validator_set = + ValidatorSet::::new(keys.clone(), 0).unwrap(); let (network, mut report_stream) = TestNetwork::new(); - let gv = GossipValidator::::new( + let gv = GossipValidator::::new( Arc::new(Mutex::new(KnownPeers::new())), Arc::new(network), ); @@ -678,7 +690,8 @@ pub(crate) mod tests { // verify votes validation let vote = dummy_vote(3); - let encoded = GossipMessage::::Vote(vote.clone()).encode(); + let encoded = + GossipMessage::::Vote(vote.clone()).encode(); // filter not initialized let res = gv.validate(&mut context, &sender, &encoded); @@ -696,7 +709,7 @@ pub(crate) mod tests { // reject vote, voter not in validator set let mut bad_vote = vote.clone(); bad_vote.id = Keyring::Bob.public(); - let bad_vote = GossipMessage::::Vote(bad_vote).encode(); + let bad_vote = GossipMessage::::Vote(bad_vote).encode(); let res = gv.validate(&mut context, &sender, &bad_vote); assert!(matches!(res, ValidationResult::Discard)); expected_report.cost_benefit = cost::UNKNOWN_VOTER; @@ -726,7 +739,8 @@ pub(crate) mod tests { // reject old proof let proof = dummy_proof(5, &validator_set); - let encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); let res = gv.validate(&mut context, &sender, &encoded_proof); assert!(matches!(res, ValidationResult::Discard)); expected_report.cost_benefit = cost::OUTDATED_MESSAGE; @@ -734,7 +748,8 @@ pub(crate) mod tests { // accept next proof with good set_id let proof = dummy_proof(7, &validator_set); - let encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); let res = gv.validate(&mut context, &sender, &encoded_proof); assert!(matches!(res, ValidationResult::ProcessAndKeep(_))); expected_report.cost_benefit = benefit::VALIDATED_PROOF; @@ -742,16 +757,18 @@ pub(crate) mod tests { // accept future proof with good set_id let proof = dummy_proof(20, &validator_set); - let encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); let res = gv.validate(&mut context, &sender, &encoded_proof); assert!(matches!(res, ValidationResult::ProcessAndKeep(_))); expected_report.cost_benefit = benefit::VALIDATED_PROOF; assert_eq!(report_stream.try_next().unwrap().unwrap(), expected_report); // reject proof, future set_id - let bad_validator_set = ValidatorSet::::new(keys, 1).unwrap(); + let bad_validator_set = ValidatorSet::::new(keys, 1).unwrap(); let proof = dummy_proof(20, &bad_validator_set); - let encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); let res = gv.validate(&mut context, &sender, &encoded_proof); assert!(matches!(res, ValidationResult::Discard)); expected_report.cost_benefit = cost::FUTURE_MESSAGE; @@ -759,9 +776,10 @@ pub(crate) mod tests { // reject proof, bad signatures (Bob instead of Alice) let bad_validator_set = - ValidatorSet::::new(vec![Keyring::Bob.public()], 0).unwrap(); + ValidatorSet::::new(vec![Keyring::Bob.public()], 0).unwrap(); let proof = dummy_proof(21, &bad_validator_set); - let encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); let res = gv.validate(&mut context, &sender, &encoded_proof); assert!(matches!(res, ValidationResult::Discard)); expected_report.cost_benefit = cost::INVALID_PROOF; @@ -772,8 +790,9 @@ pub(crate) mod tests { #[test] fn messages_allowed_and_expired() { let keys = vec![Keyring::Alice.public()]; - let validator_set = ValidatorSet::::new(keys.clone(), 0).unwrap(); - let gv = GossipValidator::::new( + let validator_set = + ValidatorSet::::new(keys.clone(), 0).unwrap(); + let gv = GossipValidator::::new( Arc::new(Mutex::new(KnownPeers::new())), Arc::new(TestNetwork::new().0), ); @@ -793,58 +812,70 @@ pub(crate) mod tests { // inactive round 1 -> expired let vote = dummy_vote(1); - let mut encoded_vote = GossipMessage::::Vote(vote).encode(); + let mut encoded_vote = + GossipMessage::::Vote(vote).encode(); assert!(!allowed(&sender, intent, &topic, &mut encoded_vote)); assert!(expired(topic, &mut encoded_vote)); let proof = dummy_proof(1, &validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(!allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(expired(topic, &mut encoded_proof)); // active round 2 -> !expired - concluded but still gossiped let vote = dummy_vote(2); - let mut encoded_vote = GossipMessage::::Vote(vote).encode(); + let mut encoded_vote = + GossipMessage::::Vote(vote).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_vote)); assert!(!expired(topic, &mut encoded_vote)); let proof = dummy_proof(2, &validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(!expired(topic, &mut encoded_proof)); // using wrong set_id -> !allowed, expired - let bad_validator_set = ValidatorSet::::new(keys.clone(), 1).unwrap(); + let bad_validator_set = + ValidatorSet::::new(keys.clone(), 1).unwrap(); let proof = dummy_proof(2, &bad_validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(!allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(expired(topic, &mut encoded_proof)); // in progress round 3 -> !expired let vote = dummy_vote(3); - let mut encoded_vote = GossipMessage::::Vote(vote).encode(); + let mut encoded_vote = + GossipMessage::::Vote(vote).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_vote)); assert!(!expired(topic, &mut encoded_vote)); let proof = dummy_proof(3, &validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(!expired(topic, &mut encoded_proof)); // unseen round 4 -> !expired let vote = dummy_vote(4); - let mut encoded_vote = GossipMessage::::Vote(vote).encode(); + let mut encoded_vote = + GossipMessage::::Vote(vote).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_vote)); assert!(!expired(topic, &mut encoded_vote)); let proof = dummy_proof(4, &validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(!expired(topic, &mut encoded_proof)); // future round 11 -> expired let vote = dummy_vote(11); - let mut encoded_vote = GossipMessage::::Vote(vote).encode(); + let mut encoded_vote = + GossipMessage::::Vote(vote).encode(); assert!(!allowed(&sender, intent, &topic, &mut encoded_vote)); assert!(expired(topic, &mut encoded_vote)); // future proofs allowed while same set_id -> allowed let proof = dummy_proof(11, &validator_set); - let mut encoded_proof = GossipMessage::::FinalityProof(proof).encode(); + let mut encoded_proof = + GossipMessage::::FinalityProof(proof).encode(); assert!(allowed(&sender, intent, &topic, &mut encoded_proof)); assert!(!expired(topic, &mut encoded_proof)); } @@ -852,8 +883,9 @@ pub(crate) mod tests { #[test] fn messages_rebroadcast() { let keys = vec![Keyring::Alice.public()]; - let validator_set = ValidatorSet::::new(keys.clone(), 0).unwrap(); - let gv = GossipValidator::::new( + let validator_set = + ValidatorSet::::new(keys.clone(), 0).unwrap(); + let gv = GossipValidator::::new( Arc::new(Mutex::new(KnownPeers::new())), Arc::new(TestNetwork::new().0), ); diff --git a/substrate/client/consensus/beefy/src/communication/notification.rs b/substrate/client/consensus/beefy/src/communication/notification.rs index a4486e523c301f6b64af3936a5bdba3456303ad2..8bb5d848b4faab9ee5a25032b32db0015324d4bc 100644 --- a/substrate/client/consensus/beefy/src/communication/notification.rs +++ b/substrate/client/consensus/beefy/src/communication/notification.rs @@ -32,13 +32,15 @@ pub type BeefyBestBlockStream = /// The sending half of the notifications channel(s) used to send notifications /// about versioned finality proof generated at the end of a BEEFY round. -pub type BeefyVersionedFinalityProofSender = - NotificationSender>; +pub type BeefyVersionedFinalityProofSender = + NotificationSender>; /// The receiving half of a notifications channel used to receive notifications /// about versioned finality proof generated at the end of a BEEFY round. -pub type BeefyVersionedFinalityProofStream = - NotificationStream, BeefyVersionedFinalityProofTracingKey>; +pub type BeefyVersionedFinalityProofStream = NotificationStream< + BeefyVersionedFinalityProof, + BeefyVersionedFinalityProofTracingKey, +>; /// Provides tracing key for BEEFY best block stream. #[derive(Clone)] diff --git a/substrate/client/consensus/beefy/src/communication/peers.rs b/substrate/client/consensus/beefy/src/communication/peers.rs index 2d801aceaa8a76bf1c31820493bbd20b4f93f8da..929cc0c650b3e26e90016512042d620cc40c6408 100644 --- a/substrate/client/consensus/beefy/src/communication/peers.rs +++ b/substrate/client/consensus/beefy/src/communication/peers.rs @@ -75,6 +75,11 @@ impl KnownPeers { pub fn contains(&self, peer: &PeerId) -> bool { self.live.contains_key(peer) } + + /// Number of peers in the set. + pub fn len(&self) -> usize { + self.live.len() + } } #[cfg(test)] diff --git a/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs b/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs index 7893066a01e06c967893bdedbd25ad3c2da9c3bd..c473c14bccc3d90beb6fc50e58b95d6d198fa8f2 100644 --- a/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs +++ b/substrate/client/consensus/beefy/src/communication/request_response/incoming_requests_handler.rs @@ -87,9 +87,9 @@ impl IncomingRequest { sent_feedback: None, }; if let Err(_) = pending_response.send(response) { - return Err(Error::DecodingErrorNoReputationChange(peer, err)) + return Err(Error::DecodingErrorNoReputationChange(peer, err)); } - return Err(Error::DecodingError(peer, err)) + return Err(Error::DecodingError(peer, err)); }, }; Ok(Self::new(peer, payload, pending_response)) @@ -144,7 +144,7 @@ where genesis_hash: Hash, fork_id: Option<&str>, client: Arc, - prometheus_registry: Option, + prometheus_registry: Option, ) -> (Self, Network::RequestResponseProtocolConfig) { let (request_receiver, config): (_, Network::RequestResponseProtocolConfig) = on_demand_justifications_protocol_config::<_, _, Network>(genesis_hash, fork_id); diff --git a/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs b/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs index 2ab072960900817155b42434f69f29236fcda54b..95ecf35557a5189fae4cc117e71126d8c8076536 100644 --- a/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs +++ b/substrate/client/consensus/beefy/src/communication/request_response/outgoing_requests_engine.rs @@ -27,7 +27,7 @@ use sc_network::{ NetworkRequest, ProtocolName, }; use sc_network_types::PeerId; -use sp_consensus_beefy::{ecdsa_crypto::AuthorityId, ValidatorSet}; +use sp_consensus_beefy::{AuthorityIdBound, ValidatorSet}; use sp_runtime::traits::{Block, NumberFor}; use std::{collections::VecDeque, result::Result, sync::Arc}; @@ -49,43 +49,43 @@ type Response = Result<(Vec, ProtocolName), RequestFailure>; type ResponseReceiver = oneshot::Receiver; #[derive(Clone, Debug)] -struct RequestInfo { +struct RequestInfo { block: NumberFor, active_set: ValidatorSet, } -enum State { +enum State { Idle, - AwaitingResponse(PeerId, RequestInfo, ResponseReceiver), + AwaitingResponse(PeerId, RequestInfo, ResponseReceiver), } /// Possible engine responses. -pub(crate) enum ResponseInfo { +pub(crate) enum ResponseInfo { /// No peer response available yet. Pending, /// Valid justification provided alongside peer reputation changes. - ValidProof(BeefyVersionedFinalityProof, PeerReport), + ValidProof(BeefyVersionedFinalityProof, PeerReport), /// No justification yet, only peer reputation changes. PeerReport(PeerReport), } -pub struct OnDemandJustificationsEngine { +pub struct OnDemandJustificationsEngine { network: Arc, protocol_name: ProtocolName, live_peers: Arc>>, peers_cache: VecDeque, - state: State, + state: State, metrics: Option, } -impl OnDemandJustificationsEngine { +impl OnDemandJustificationsEngine { pub fn new( network: Arc, protocol_name: ProtocolName, live_peers: Arc>>, - prometheus_registry: Option, + prometheus_registry: Option, ) -> Self { let metrics = register_metrics(prometheus_registry); Self { @@ -106,13 +106,13 @@ impl OnDemandJustificationsEngine { let live = self.live_peers.lock(); while let Some(peer) = self.peers_cache.pop_front() { if live.contains(&peer) { - return Some(peer) + return Some(peer); } } None } - fn request_from_peer(&mut self, peer: PeerId, req_info: RequestInfo) { + fn request_from_peer(&mut self, peer: PeerId, req_info: RequestInfo) { debug!( target: BEEFY_SYNC_LOG_TARGET, "🥩 requesting justif #{:?} from peer {:?}", req_info.block, peer, @@ -140,7 +140,7 @@ impl OnDemandJustificationsEngine { pub fn request(&mut self, block: NumberFor, active_set: ValidatorSet) { // ignore new requests while there's already one pending if matches!(self.state, State::AwaitingResponse(_, _, _)) { - return + return; } self.reset_peers_cache_for_block(block); @@ -174,9 +174,9 @@ impl OnDemandJustificationsEngine { fn process_response( &mut self, peer: &PeerId, - req_info: &RequestInfo, + req_info: &RequestInfo, response: Result, - ) -> Result, Error> { + ) -> Result, Error> { response .map_err(|e| { debug!( @@ -207,7 +207,7 @@ impl OnDemandJustificationsEngine { } }) .and_then(|(encoded, _)| { - decode_and_verify_finality_proof::( + decode_and_verify_finality_proof::( &encoded[..], req_info.block, &req_info.active_set, @@ -227,11 +227,11 @@ impl OnDemandJustificationsEngine { }) } - pub(crate) async fn next(&mut self) -> ResponseInfo { + pub(crate) async fn next(&mut self) -> ResponseInfo { let (peer, req_info, resp) = match &mut self.state { State::Idle => { futures::future::pending::<()>().await; - return ResponseInfo::Pending + return ResponseInfo::Pending; }, State::AwaitingResponse(peer, req_info, receiver) => { let resp = receiver.await; @@ -249,9 +249,16 @@ impl OnDemandJustificationsEngine { if let Some(peer) = self.try_next_peer() { self.request_from_peer(peer, req_info); } else { + metric_inc!( + self.metrics, + beefy_on_demand_justification_no_peer_to_request_from + ); + + let num_cache = self.peers_cache.len(); + let num_live = self.live_peers.lock().len(); warn!( target: BEEFY_SYNC_LOG_TARGET, - "🥩 ran out of peers to request justif #{:?} from", block + "🥩 ran out of peers to request justif #{block:?} from num_cache={num_cache} num_live={num_live} err={err:?}", ); } // Report peer based on error type. @@ -265,7 +272,7 @@ impl OnDemandJustificationsEngine { metric_inc!(self.metrics, beefy_on_demand_justification_good_proof); debug!( target: BEEFY_SYNC_LOG_TARGET, - "🥩 received valid on-demand justif #{:?} from {:?}", block, peer + "🥩 received valid on-demand justif #{block:?} from {peer:?}", ); let peer_report = PeerReport { who: peer, cost_benefit: benefit::VALIDATED_PROOF }; ResponseInfo::ValidProof(proof, peer_report) diff --git a/substrate/client/consensus/beefy/src/error.rs b/substrate/client/consensus/beefy/src/error.rs index b4773f940193e07d4f6f6962b69096c91805bbeb..9cd09cb99332a28f3f1ec731be3c5af6504c91e0 100644 --- a/substrate/client/consensus/beefy/src/error.rs +++ b/substrate/client/consensus/beefy/src/error.rs @@ -20,6 +20,7 @@ //! //! Used for BEEFY gadget internal error handling only +use sp_blockchain::Error as ClientError; use std::fmt::Debug; #[derive(Debug, thiserror::Error)] @@ -48,6 +49,12 @@ pub enum Error { VotesGossipStreamTerminated, } +impl From for Error { + fn from(e: ClientError) -> Self { + Self::Backend(e.to_string()) + } +} + #[cfg(test)] impl PartialEq for Error { fn eq(&self, other: &Self) -> bool { diff --git a/substrate/client/consensus/beefy/src/fisherman.rs b/substrate/client/consensus/beefy/src/fisherman.rs index a2b4c8f945d1c224c45e522bc7e7b0461a3c00ce..faa4d34eff5ac74b5024f720b975ff72bb5e9b11 100644 --- a/substrate/client/consensus/beefy/src/fisherman.rs +++ b/substrate/client/consensus/beefy/src/fisherman.rs @@ -20,11 +20,11 @@ use crate::{error::Error, keystore::BeefyKeystore, round::Rounds, LOG_TARGET}; use log::{debug, error, warn}; use sc_client_api::Backend; use sp_api::ProvideRuntimeApi; +use sp_application_crypto::RuntimeAppPublic; use sp_blockchain::HeaderBackend; use sp_consensus_beefy::{ - check_equivocation_proof, - ecdsa_crypto::{AuthorityId, Signature}, - BeefyApi, BeefySignatureHasher, DoubleVotingProof, OpaqueKeyOwnershipProof, ValidatorSetId, + check_double_voting_proof, AuthorityIdBound, BeefyApi, BeefySignatureHasher, DoubleVotingProof, + OpaqueKeyOwnershipProof, ValidatorSetId, }; use sp_runtime::{ generic::BlockId, @@ -33,13 +33,13 @@ use sp_runtime::{ use std::{marker::PhantomData, sync::Arc}; /// Helper struct containing the id and the key ownership proof for a validator. -pub struct ProvedValidator<'a> { +pub struct ProvedValidator<'a, AuthorityId: AuthorityIdBound> { pub id: &'a AuthorityId, pub key_owner_proof: OpaqueKeyOwnershipProof, } /// Helper used to check and report equivocations. -pub struct Fisherman { +pub struct Fisherman { backend: Arc, runtime: Arc, key_store: Arc>, @@ -47,9 +47,11 @@ pub struct Fisherman { _phantom: PhantomData, } -impl, RuntimeApi: ProvideRuntimeApi> Fisherman +impl, RuntimeApi: ProvideRuntimeApi, AuthorityId> + Fisherman where RuntimeApi::Api: BeefyApi, + AuthorityId: AuthorityIdBound, { pub fn new( backend: Arc, @@ -64,7 +66,7 @@ where at: BlockId, offender_ids: impl Iterator, validator_set_id: ValidatorSetId, - ) -> Result>, Error> { + ) -> Result>, Error> { let hash = match at { BlockId::Hash(hash) => hash, BlockId::Number(number) => self @@ -119,22 +121,26 @@ where /// isn't necessarily the best block if there are pending authority set changes. pub fn report_double_voting( &self, - proof: DoubleVotingProof, AuthorityId, Signature>, - active_rounds: &Rounds, + proof: DoubleVotingProof< + NumberFor, + AuthorityId, + ::Signature, + >, + active_rounds: &Rounds, ) -> Result<(), Error> { let (validators, validator_set_id) = (active_rounds.validators(), active_rounds.validator_set_id()); let offender_id = proof.offender_id(); - if !check_equivocation_proof::<_, _, BeefySignatureHasher>(&proof) { + if !check_double_voting_proof::<_, _, BeefySignatureHasher>(&proof) { debug!(target: LOG_TARGET, "🥩 Skipping report for bad equivocation {:?}", proof); - return Ok(()) + return Ok(()); } if let Some(local_id) = self.key_store.authority_id(validators) { if offender_id == &local_id { warn!(target: LOG_TARGET, "🥩 Skipping report for own equivocation"); - return Ok(()) + return Ok(()); } } @@ -149,7 +155,7 @@ where for ProvedValidator { key_owner_proof, .. } in key_owner_proofs { self.runtime .runtime_api() - .submit_report_equivocation_unsigned_extrinsic( + .submit_report_double_voting_unsigned_extrinsic( best_block_hash, proof.clone(), key_owner_proof, diff --git a/substrate/client/consensus/beefy/src/import.rs b/substrate/client/consensus/beefy/src/import.rs index ed8ed68c4e8d0d378728ba87d1ffe726f6c4c11a..17a4a586663614ad7136b02beb8a240df297bf0b 100644 --- a/substrate/client/consensus/beefy/src/import.rs +++ b/substrate/client/consensus/beefy/src/import.rs @@ -22,7 +22,7 @@ use log::debug; use sp_api::ProvideRuntimeApi; use sp_consensus::Error as ConsensusError; -use sp_consensus_beefy::{ecdsa_crypto::AuthorityId, BeefyApi, BEEFY_ENGINE_ID}; +use sp_consensus_beefy::{AuthorityIdBound, BeefyApi, BEEFY_ENGINE_ID}; use sp_runtime::{ traits::{Block as BlockT, Header as HeaderT, NumberFor}, EncodedJustification, @@ -45,15 +45,17 @@ use crate::{ /// Wraps a `inner: BlockImport` and ultimately defers to it. /// /// When using BEEFY, the block import worker should be using this block import object. -pub struct BeefyBlockImport { +pub struct BeefyBlockImport { backend: Arc, runtime: Arc, inner: I, - justification_sender: BeefyVersionedFinalityProofSender, + justification_sender: BeefyVersionedFinalityProofSender, metrics: Option, } -impl Clone for BeefyBlockImport { +impl Clone + for BeefyBlockImport +{ fn clone(&self) -> Self { BeefyBlockImport { backend: self.backend.clone(), @@ -65,32 +67,35 @@ impl Clone for BeefyBlockImport BeefyBlockImport { +impl + BeefyBlockImport +{ /// Create a new BeefyBlockImport. pub fn new( backend: Arc, runtime: Arc, inner: I, - justification_sender: BeefyVersionedFinalityProofSender, + justification_sender: BeefyVersionedFinalityProofSender, metrics: Option, - ) -> BeefyBlockImport { + ) -> BeefyBlockImport { BeefyBlockImport { backend, runtime, inner, justification_sender, metrics } } } -impl BeefyBlockImport +impl BeefyBlockImport where Block: BlockT, BE: Backend, Runtime: ProvideRuntimeApi, Runtime::Api: BeefyApi + Send, + AuthorityId: AuthorityIdBound, { fn decode_and_verify( &self, encoded: &EncodedJustification, number: NumberFor, hash: ::Hash, - ) -> Result, ConsensusError> { + ) -> Result, ConsensusError> { use ConsensusError::ClientImport as ImportError; let beefy_genesis = self .runtime @@ -99,7 +104,7 @@ where .map_err(|e| ImportError(e.to_string()))? .ok_or_else(|| ImportError("Unknown BEEFY genesis".to_string()))?; if number < beefy_genesis { - return Err(ImportError("BEEFY genesis is set for future block".to_string())) + return Err(ImportError("BEEFY genesis is set for future block".to_string())); } let validator_set = self .runtime @@ -108,24 +113,26 @@ where .map_err(|e| ImportError(e.to_string()))? .ok_or_else(|| ImportError("Unknown validator set".to_string()))?; - decode_and_verify_finality_proof::(&encoded[..], number, &validator_set) + decode_and_verify_finality_proof::(&encoded[..], number, &validator_set) .map_err(|(err, _)| err) } } #[async_trait::async_trait] -impl BlockImport for BeefyBlockImport +impl BlockImport + for BeefyBlockImport where Block: BlockT, BE: Backend, I: BlockImport + Send + Sync, Runtime: ProvideRuntimeApi + Send + Sync, Runtime::Api: BeefyApi, + AuthorityId: AuthorityIdBound, { type Error = ConsensusError; async fn import_block( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let hash = block.post_hash(); @@ -148,7 +155,7 @@ where // The block is imported as part of some chain sync. // The voter doesn't need to process it now. // It will be detected and processed as part of the voter state init. - return Ok(inner_import_result) + return Ok(inner_import_result); }, } @@ -185,7 +192,7 @@ where } async fn check_block( - &mut self, + &self, block: BlockCheckParams, ) -> Result { self.inner.check_block(block).await diff --git a/substrate/client/consensus/beefy/src/justification.rs b/substrate/client/consensus/beefy/src/justification.rs index 886368c9d7cb096c0178819e1bad23f06c82f3fb..9ff7c3cf54f687c8f937ff0cecd9aea821c2ddaa 100644 --- a/substrate/client/consensus/beefy/src/justification.rs +++ b/substrate/client/consensus/beefy/src/justification.rs @@ -17,18 +17,20 @@ // along with this program. If not, see . use codec::DecodeAll; +use sp_application_crypto::RuntimeAppPublic; use sp_consensus::Error as ConsensusError; use sp_consensus_beefy::{ - ecdsa_crypto::{AuthorityId, Signature}, - BeefySignatureHasher, KnownSignature, ValidatorSet, ValidatorSetId, VersionedFinalityProof, + AuthorityIdBound, BeefySignatureHasher, KnownSignature, ValidatorSet, ValidatorSetId, + VersionedFinalityProof, }; use sp_runtime::traits::{Block as BlockT, NumberFor}; /// A finality proof with matching BEEFY authorities' signatures. -pub type BeefyVersionedFinalityProof = VersionedFinalityProof, Signature>; +pub type BeefyVersionedFinalityProof = + VersionedFinalityProof, ::Signature>; -pub(crate) fn proof_block_num_and_set_id( - proof: &BeefyVersionedFinalityProof, +pub(crate) fn proof_block_num_and_set_id( + proof: &BeefyVersionedFinalityProof, ) -> (NumberFor, ValidatorSetId) { match proof { VersionedFinalityProof::V1(sc) => @@ -37,23 +39,26 @@ pub(crate) fn proof_block_num_and_set_id( } /// Decode and verify a Beefy FinalityProof. -pub(crate) fn decode_and_verify_finality_proof( +pub(crate) fn decode_and_verify_finality_proof( encoded: &[u8], target_number: NumberFor, validator_set: &ValidatorSet, -) -> Result, (ConsensusError, u32)> { - let proof = >::decode_all(&mut &*encoded) +) -> Result, (ConsensusError, u32)> { + let proof = >::decode_all(&mut &*encoded) .map_err(|_| (ConsensusError::InvalidJustification, 0))?; - verify_with_validator_set::(target_number, validator_set, &proof)?; + verify_with_validator_set::(target_number, validator_set, &proof)?; Ok(proof) } /// Verify the Beefy finality proof against the validator set at the block it was generated. -pub(crate) fn verify_with_validator_set<'a, Block: BlockT>( +pub(crate) fn verify_with_validator_set<'a, Block: BlockT, AuthorityId: AuthorityIdBound>( target_number: NumberFor, validator_set: &'a ValidatorSet, - proof: &'a BeefyVersionedFinalityProof, -) -> Result>, (ConsensusError, u32)> { + proof: &'a BeefyVersionedFinalityProof, +) -> Result< + Vec::Signature>>, + (ConsensusError, u32), +> { match proof { VersionedFinalityProof::V1(signed_commitment) => { let signatories = signed_commitment @@ -78,7 +83,7 @@ pub(crate) fn verify_with_validator_set<'a, Block: BlockT>( pub(crate) mod tests { use codec::Encode; use sp_consensus_beefy::{ - known_payloads, test_utils::Keyring, Commitment, Payload, SignedCommitment, + ecdsa_crypto, known_payloads, test_utils::Keyring, Commitment, Payload, SignedCommitment, VersionedFinalityProof, }; use substrate_test_runtime_client::runtime::Block; @@ -88,9 +93,9 @@ pub(crate) mod tests { pub(crate) fn new_finality_proof( block_num: NumberFor, - validator_set: &ValidatorSet, - keys: &[Keyring], - ) -> BeefyVersionedFinalityProof { + validator_set: &ValidatorSet, + keys: &[Keyring], + ) -> BeefyVersionedFinalityProof { let commitment = Commitment { payload: Payload::from_single_entry(known_payloads::MMR_ROOT_ID, vec![]), block_number: block_num, @@ -112,11 +117,20 @@ pub(crate) mod tests { let good_proof = proof.clone().into(); // should verify successfully - verify_with_validator_set::(block_num, &validator_set, &good_proof).unwrap(); + verify_with_validator_set::( + block_num, + &validator_set, + &good_proof, + ) + .unwrap(); // wrong block number -> should fail verification let good_proof = proof.clone().into(); - match verify_with_validator_set::(block_num + 1, &validator_set, &good_proof) { + match verify_with_validator_set::( + block_num + 1, + &validator_set, + &good_proof, + ) { Err((ConsensusError::InvalidJustification, 0)) => (), e => assert!(false, "Got unexpected {:?}", e), }; @@ -124,7 +138,11 @@ pub(crate) mod tests { // wrong validator set id -> should fail verification let good_proof = proof.clone().into(); let other = ValidatorSet::new(make_beefy_ids(keys), 1).unwrap(); - match verify_with_validator_set::(block_num, &other, &good_proof) { + match verify_with_validator_set::( + block_num, + &other, + &good_proof, + ) { Err((ConsensusError::InvalidJustification, 0)) => (), e => assert!(false, "Got unexpected {:?}", e), }; @@ -136,7 +154,11 @@ pub(crate) mod tests { VersionedFinalityProof::V1(ref mut sc) => sc, }; bad_signed_commitment.signatures.pop().flatten().unwrap(); - match verify_with_validator_set::(block_num + 1, &validator_set, &bad_proof.into()) { + match verify_with_validator_set::( + block_num + 1, + &validator_set, + &bad_proof.into(), + ) { Err((ConsensusError::InvalidJustification, 0)) => (), e => assert!(false, "Got unexpected {:?}", e), }; @@ -148,7 +170,11 @@ pub(crate) mod tests { }; // remove a signature (but same length) *bad_signed_commitment.signatures.first_mut().unwrap() = None; - match verify_with_validator_set::(block_num, &validator_set, &bad_proof.into()) { + match verify_with_validator_set::( + block_num, + &validator_set, + &bad_proof.into(), + ) { Err((ConsensusError::InvalidJustification, 2)) => (), e => assert!(false, "Got unexpected {:?}", e), }; @@ -159,9 +185,15 @@ pub(crate) mod tests { VersionedFinalityProof::V1(ref mut sc) => sc, }; // change a signature to a different key - *bad_signed_commitment.signatures.first_mut().unwrap() = - Some(Keyring::::Dave.sign(&bad_signed_commitment.commitment.encode())); - match verify_with_validator_set::(block_num, &validator_set, &bad_proof.into()) { + *bad_signed_commitment.signatures.first_mut().unwrap() = Some( + Keyring::::Dave + .sign(&bad_signed_commitment.commitment.encode()), + ); + match verify_with_validator_set::( + block_num, + &validator_set, + &bad_proof.into(), + ) { Err((ConsensusError::InvalidJustification, 3)) => (), e => assert!(false, "Got unexpected {:?}", e), }; @@ -175,12 +207,17 @@ pub(crate) mod tests { // build valid justification let proof = new_finality_proof(block_num, &validator_set, keys); - let versioned_proof: BeefyVersionedFinalityProof = proof.into(); + let versioned_proof: BeefyVersionedFinalityProof = + proof.into(); let encoded = versioned_proof.encode(); // should successfully decode and verify - let verified = - decode_and_verify_finality_proof::(&encoded, block_num, &validator_set).unwrap(); + let verified = decode_and_verify_finality_proof::( + &encoded, + block_num, + &validator_set, + ) + .unwrap(); assert_eq!(verified, versioned_proof); } } diff --git a/substrate/client/consensus/beefy/src/keystore.rs b/substrate/client/consensus/beefy/src/keystore.rs index 9582c2661c30b431a5934e2bcc592b4a56faf3b3..888a11db89cbe55165de8f34c5bbaed422f13806 100644 --- a/substrate/client/consensus/beefy/src/keystore.rs +++ b/substrate/client/consensus/beefy/src/keystore.rs @@ -15,19 +15,19 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . +use codec::Decode; +use log::warn; use sp_application_crypto::{key_types::BEEFY as BEEFY_KEY_TYPE, AppCrypto, RuntimeAppPublic}; -use sp_consensus_beefy::{AuthorityIdBound, BeefyAuthorityId, BeefySignatureHasher}; -use sp_core::ecdsa; #[cfg(feature = "bls-experimental")] -use sp_core::ecdsa_bls377; -use sp_crypto_hashing::keccak_256; -use sp_keystore::KeystorePtr; +use sp_core::ecdsa_bls381; +use sp_core::{ecdsa, keccak_256}; -use codec::Decode; -use log::warn; +use sp_keystore::KeystorePtr; use std::marker::PhantomData; +use sp_consensus_beefy::{AuthorityIdBound, BeefyAuthorityId, BeefySignatureHasher}; + use crate::{error, LOG_TARGET}; /// A BEEFY specific keystore implemented as a `Newtype`. This is basically a @@ -100,13 +100,13 @@ impl BeefyKeystore { }, #[cfg(feature = "bls-experimental")] - ecdsa_bls377::CRYPTO_ID => { - let public: ecdsa_bls377::Public = - ecdsa_bls377::Public::try_from(public.as_slice()).unwrap(); + ecdsa_bls381::CRYPTO_ID => { + let public: ecdsa_bls381::Public = + ecdsa_bls381::Public::try_from(public.as_slice()).unwrap(); let sig = store - .ecdsa_bls377_sign_with_keccak256(BEEFY_KEY_TYPE, &public, &message) + .ecdsa_bls381_sign_with_keccak256(BEEFY_KEY_TYPE, &public, &message) .map_err(|e| error::Error::Keystore(e.to_string()))? - .ok_or_else(|| error::Error::Signature("bls377_sign() failed".to_string()))?; + .ok_or_else(|| error::Error::Signature("bls381_sign() failed".to_string()))?; let sig_ref: &[u8] = sig.as_ref(); sig_ref.to_vec() }, @@ -146,8 +146,8 @@ impl BeefyKeystore { }), #[cfg(feature = "bls-experimental")] - ecdsa_bls377::CRYPTO_ID => store - .ecdsa_bls377_public_keys(BEEFY_KEY_TYPE) + ecdsa_bls381::CRYPTO_ID => store + .ecdsa_bls381_public_keys(BEEFY_KEY_TYPE) .drain(..) .map(|pk| AuthorityId::try_from(pk.as_ref())) .collect::, _>>() @@ -175,10 +175,7 @@ impl BeefyKeystore { } } -impl From> for BeefyKeystore -where - ::Signature: Send + Sync, -{ +impl From> for BeefyKeystore { fn from(store: Option) -> BeefyKeystore { BeefyKeystore(store, PhantomData) } @@ -257,9 +254,9 @@ pub mod tests { AuthorityId::decode(&mut pk.as_ref()).unwrap() }, #[cfg(feature = "bls-experimental")] - ecdsa_bls377::CRYPTO_ID => { + ecdsa_bls381::CRYPTO_ID => { let pk = store - .ecdsa_bls377_generate_new(key_type, optional_seed.as_deref()) + .ecdsa_bls381_generate_new(key_type, optional_seed.as_deref()) .ok() .unwrap(); AuthorityId::decode(&mut pk.as_ref()).unwrap() @@ -455,7 +452,7 @@ pub mod tests { #[cfg(feature = "bls-experimental")] #[test] fn sign_error_for_ecdsa_n_bls() { - sign_error::("bls377_sign() failed"); + sign_error::("bls381_sign() failed"); } #[test] diff --git a/substrate/client/consensus/beefy/src/lib.rs b/substrate/client/consensus/beefy/src/lib.rs index 0e49839f0fd2dae76e26738823ea9e5af775acb7..30cdd494905f2881bb4b6acd4aa9c081e7e95847 100644 --- a/substrate/client/consensus/beefy/src/lib.rs +++ b/substrate/client/consensus/beefy/src/lib.rs @@ -32,25 +32,27 @@ use crate::{ metrics::register_metrics, }; use futures::{stream::Fuse, FutureExt, StreamExt}; -use log::{debug, error, info, warn}; +use log::{debug, error, info, trace, warn}; use parking_lot::Mutex; -use prometheus::Registry; -use sc_client_api::{Backend, BlockBackend, BlockchainEvents, FinalityNotifications, Finalizer}; +use prometheus_endpoint::Registry; +use sc_client_api::{Backend, BlockBackend, BlockchainEvents, FinalityNotification, Finalizer}; use sc_consensus::BlockImport; use sc_network::{NetworkRequest, NotificationService, ProtocolName}; use sc_network_gossip::{GossipEngine, Network as GossipNetwork, Syncing as GossipSyncing}; +use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver}; use sp_api::ProvideRuntimeApi; use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend}; use sp_consensus::{Error as ConsensusError, SyncOracle}; use sp_consensus_beefy::{ - ecdsa_crypto::AuthorityId, BeefyApi, ConsensusLog, PayloadProvider, ValidatorSet, - BEEFY_ENGINE_ID, + AuthorityIdBound, BeefyApi, ConsensusLog, PayloadProvider, ValidatorSet, BEEFY_ENGINE_ID, }; use sp_keystore::KeystorePtr; use sp_runtime::traits::{Block, Header as HeaderT, NumberFor, Zero}; use std::{ collections::{BTreeMap, VecDeque}, + future::Future, marker::PhantomData, + pin::Pin, sync::Arc, time::Duration, }; @@ -88,6 +90,8 @@ const LOG_TARGET: &str = "beefy"; const HEADER_SYNC_DELAY: Duration = Duration::from_secs(60); +type FinalityNotifications = + sc_utils::mpsc::TracingUnboundedReceiver>; /// A convenience BEEFY client trait that defines all the type bounds a BEEFY client /// has to satisfy. Ideally that should actually be a trait alias. Unfortunately as /// of today, Rust does not allow a type alias to be used as a trait bound. Tracking @@ -118,50 +122,55 @@ where /// Links between the block importer, the background voter and the RPC layer, /// to be used by the voter. #[derive(Clone)] -pub struct BeefyVoterLinks { +pub struct BeefyVoterLinks { // BlockImport -> Voter links /// Stream of BEEFY signed commitments from block import to voter. - pub from_block_import_justif_stream: BeefyVersionedFinalityProofStream, + pub from_block_import_justif_stream: BeefyVersionedFinalityProofStream, // Voter -> RPC links /// Sends BEEFY signed commitments from voter to RPC. - pub to_rpc_justif_sender: BeefyVersionedFinalityProofSender, + pub to_rpc_justif_sender: BeefyVersionedFinalityProofSender, /// Sends BEEFY best block hashes from voter to RPC. pub to_rpc_best_block_sender: BeefyBestBlockSender, } /// Links used by the BEEFY RPC layer, from the BEEFY background voter. #[derive(Clone)] -pub struct BeefyRPCLinks { +pub struct BeefyRPCLinks { /// Stream of signed commitments coming from the voter. - pub from_voter_justif_stream: BeefyVersionedFinalityProofStream, + pub from_voter_justif_stream: BeefyVersionedFinalityProofStream, /// Stream of BEEFY best block hashes coming from the voter. pub from_voter_best_beefy_stream: BeefyBestBlockStream, } /// Make block importer and link half necessary to tie the background voter to it. -pub fn beefy_block_import_and_links( +pub fn beefy_block_import_and_links( wrapped_block_import: I, backend: Arc, runtime: Arc, prometheus_registry: Option, -) -> (BeefyBlockImport, BeefyVoterLinks, BeefyRPCLinks) +) -> ( + BeefyBlockImport, + BeefyVoterLinks, + BeefyRPCLinks, +) where B: Block, BE: Backend, I: BlockImport + Send + Sync, RuntimeApi: ProvideRuntimeApi + Send + Sync, RuntimeApi::Api: BeefyApi, + AuthorityId: AuthorityIdBound, { // Voter -> RPC links let (to_rpc_justif_sender, from_voter_justif_stream) = - BeefyVersionedFinalityProofStream::::channel(); + BeefyVersionedFinalityProofStream::::channel(); let (to_rpc_best_block_sender, from_voter_best_beefy_stream) = BeefyBestBlockStream::::channel(); // BlockImport -> Voter links let (to_voter_justif_sender, from_block_import_justif_stream) = - BeefyVersionedFinalityProofStream::::channel(); + BeefyVersionedFinalityProofStream::::channel(); let metrics = register_metrics(prometheus_registry); // BlockImport @@ -201,7 +210,7 @@ pub struct BeefyNetworkParams { } /// BEEFY gadget initialization parameters. -pub struct BeefyParams { +pub struct BeefyParams { /// BEEFY client pub client: Arc, /// Client Backend @@ -219,7 +228,7 @@ pub struct BeefyParams { /// Prometheus metric registry pub prometheus_registry: Option, /// Links between the block importer, the background voter and the RPC layer. - pub links: BeefyVoterLinks, + pub links: BeefyVoterLinks, /// Handler for incoming BEEFY justifications requests from a remote peer. pub on_demand_justifications_handler: BeefyJustifsRequestHandler, /// Whether running under "Authority" role. @@ -228,10 +237,10 @@ pub struct BeefyParams { /// Helper object holding BEEFY worker communication/gossip components. /// /// These are created once, but will be reused if worker is restarted/reinitialized. -pub(crate) struct BeefyComms { +pub(crate) struct BeefyComms { pub gossip_engine: GossipEngine, - pub gossip_validator: Arc>, - pub on_demand_justifications: OnDemandJustificationsEngine, + pub gossip_validator: Arc>, + pub on_demand_justifications: OnDemandJustificationsEngine, } /// Helper builder object for building [worker::BeefyWorker]. @@ -240,22 +249,23 @@ pub(crate) struct BeefyComms { /// for certain chain and backend conditions, and while sleeping we still need to pump the /// GossipEngine. Once initialization is done, the GossipEngine (and other pieces) are added to get /// the complete [worker::BeefyWorker] object. -pub(crate) struct BeefyWorkerBuilder { +pub(crate) struct BeefyWorkerBuilder { // utilities backend: Arc, runtime: Arc, key_store: BeefyKeystore, // voter metrics metrics: Option, - persisted_state: PersistedState, + persisted_state: PersistedState, } -impl BeefyWorkerBuilder +impl BeefyWorkerBuilder where B: Block + codec::Codec, BE: Backend, R: ProvideRuntimeApi, R::Api: BeefyApi, + AuthorityId: AuthorityIdBound, { /// This will wait for the chain to enable BEEFY (if not yet enabled) and also wait for the /// backend to sync all headers required by the voter to build a contiguous chain of mandatory @@ -269,7 +279,7 @@ where key_store: BeefyKeystore, metrics: Option, min_block_delta: u32, - gossip_validator: Arc>, + gossip_validator: Arc>, finality_notifications: &mut Fuse>, is_authority: bool, ) -> Result { @@ -301,11 +311,11 @@ where self, payload_provider: P, sync: Arc, - comms: BeefyComms, - links: BeefyVoterLinks, - pending_justifications: BTreeMap, BeefyVersionedFinalityProof>, + comms: BeefyComms, + links: BeefyVoterLinks, + pending_justifications: BTreeMap, BeefyVersionedFinalityProof>, is_authority: bool, - ) -> BeefyWorker { + ) -> BeefyWorker { let key_store = Arc::new(self.key_store); BeefyWorker { backend: self.backend.clone(), @@ -334,7 +344,7 @@ where min_block_delta: u32, backend: Arc, runtime: Arc, - ) -> Result, Error> { + ) -> Result, Error> { let blockchain = backend.blockchain(); let beefy_genesis = runtime @@ -378,7 +388,7 @@ where beefy_genesis, ) .ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))?; - break state + break state; } if *header.number() == beefy_genesis { @@ -401,10 +411,10 @@ where min_block_delta, beefy_genesis, ) - .ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))? + .ok_or_else(|| Error::Backend("Invalid BEEFY chain".into()))?; } - if let Some(active) = find_authorities_change::(&header) { + if let Some(active) = find_authorities_change::(&header) { debug!( target: LOG_TARGET, "🥩 Marking block {:?} as BEEFY Mandatory.", @@ -431,7 +441,7 @@ where key_store: &BeefyKeystore, metrics: &Option, is_authority: bool, - ) -> Result, Error> { + ) -> Result, Error> { // Initialize voter state from AUX DB if compatible. if let Some(mut state) = crate::aux_schema::load_persistent(backend.as_ref())? // Verify state pallet genesis matches runtime. @@ -441,14 +451,15 @@ where state.set_best_grandpa(best_grandpa.clone()); // Overwrite persisted data with newly provided `min_block_delta`. state.set_min_block_delta(min_block_delta); - debug!(target: LOG_TARGET, "🥩 Loading BEEFY voter state from db: {:?}.", state); + debug!(target: LOG_TARGET, "🥩 Loading BEEFY voter state from db."); + trace!(target: LOG_TARGET, "🥩 Loaded state: {:?}.", state); // Make sure that all the headers that we need have been synced. let mut new_sessions = vec![]; let mut header = best_grandpa.clone(); while *header.number() > state.best_beefy() { if state.voting_oracle().can_add_session(*header.number()) { - if let Some(active) = find_authorities_change::(&header) { + if let Some(active) = find_authorities_change::(&header) { new_sessions.push((active, *header.number())); } } @@ -471,7 +482,7 @@ where is_authority, ); } - return Ok(state) + return Ok(state); } // No valid voter-state persisted, re-initialize from pallet genesis. @@ -479,11 +490,35 @@ where } } +/// Finality notification for consumption by BEEFY worker. +/// This is a stripped down version of `sc_client_api::FinalityNotification` which does not keep +/// blocks pinned. +struct UnpinnedFinalityNotification { + /// Finalized block header hash. + pub hash: B::Hash, + /// Finalized block header. + pub header: B::Header, + /// Path from the old finalized to new finalized parent (implicitly finalized blocks). + /// + /// This maps to the range `(old_finalized, new_finalized)`. + pub tree_route: Arc<[B::Hash]>, +} + +impl From> for UnpinnedFinalityNotification { + fn from(value: FinalityNotification) -> Self { + UnpinnedFinalityNotification { + hash: value.hash, + header: value.header, + tree_route: value.tree_route, + } + } +} + /// Start the BEEFY gadget. /// /// This is a thin shim around running and awaiting a BEEFY worker. -pub async fn start_beefy_gadget( - beefy_params: BeefyParams, +pub async fn start_beefy_gadget( + beefy_params: BeefyParams, ) where B: Block, BE: Backend, @@ -493,6 +528,7 @@ pub async fn start_beefy_gadget( R::Api: BeefyApi, N: GossipNetwork + NetworkRequest + Send + Sync + 'static, S: GossipSyncing + SyncOracle + 'static, + AuthorityId: AuthorityIdBound, { let BeefyParams { client, @@ -519,10 +555,13 @@ pub async fn start_beefy_gadget( let metrics = register_metrics(prometheus_registry.clone()); + let mut block_import_justif = links.from_block_import_justif_stream.subscribe(100_000).fuse(); + // Subscribe to finality notifications and justifications before waiting for runtime pallet and // reuse the streams, so we don't miss notifications while waiting for pallet to be available. - let mut finality_notifications = client.finality_notification_stream().fuse(); - let mut block_import_justif = links.from_block_import_justif_stream.subscribe(100_000).fuse(); + let finality_notifications = client.finality_notification_stream(); + let (mut transformer, mut finality_notifications) = + finality_notification_transformer_future(finality_notifications); let known_peers = Arc::new(Mutex::new(KnownPeers::new())); // Default votes filter is to discard everything. @@ -576,7 +615,11 @@ pub async fn start_beefy_gadget( _ = &mut beefy_comms.gossip_engine => { error!(target: LOG_TARGET, "🥩 Gossip engine has unexpectedly terminated."); return - } + }, + _ = &mut transformer => { + error!(target: LOG_TARGET, "🥩 Finality notification transformer task has unexpectedly terminated."); + return + }, }; let worker = worker_builder.build( @@ -588,28 +631,54 @@ pub async fn start_beefy_gadget( is_authority, ); - match futures::future::select( - Box::pin(worker.run(&mut block_import_justif, &mut finality_notifications)), - Box::pin(on_demand_justifications_handler.run()), - ) - .await - { - // On `ConsensusReset` error, just reinit and restart voter. - futures::future::Either::Left(((error::Error::ConsensusReset, reuse_comms), _)) => { - error!(target: LOG_TARGET, "🥩 Error: {:?}. Restarting voter.", error::Error::ConsensusReset); - beefy_comms = reuse_comms; - continue + futures::select! { + result = worker.run(&mut block_import_justif, &mut finality_notifications).fuse() => { + match result { + (error::Error::ConsensusReset, reuse_comms) => { + error!(target: LOG_TARGET, "🥩 Error: {:?}. Restarting voter.", error::Error::ConsensusReset); + beefy_comms = reuse_comms; + continue; + }, + (err, _) => { + error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", err) + } + } }, - // On other errors, bring down / finish the task. - futures::future::Either::Left(((worker_err, _), _)) => - error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", worker_err), - futures::future::Either::Right((odj_handler_err, _)) => - error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", odj_handler_err), - }; - return + odj_handler_error = on_demand_justifications_handler.run().fuse() => { + error!(target: LOG_TARGET, "🥩 Error: {:?}. Terminating.", odj_handler_error) + }, + _ = &mut transformer => { + error!(target: LOG_TARGET, "🥩 Finality notification transformer task has unexpectedly terminated."); + } + } + return; } } +/// Produce a future that transformes finality notifications into a struct that does not keep blocks +/// pinned. +fn finality_notification_transformer_future( + mut finality_notifications: sc_client_api::FinalityNotifications, +) -> ( + Pin + Sized>>>, + Fuse>>, +) +where + B: Block, +{ + let (tx, rx) = tracing_unbounded("beefy-notification-transformer-channel", 10000); + let transformer_fut = async move { + while let Some(notification) = finality_notifications.next().await { + debug!(target: LOG_TARGET, "🥩 Transforming grandpa notification. #{}({:?})", notification.header.number(), notification.hash); + if let Err(err) = tx.unbounded_send(UnpinnedFinalityNotification::from(notification)) { + error!(target: LOG_TARGET, "🥩 Unable to send transformed notification. Shutting down. err = {}", err); + return + }; + } + }; + (Box::pin(transformer_fut.fuse()), rx.fuse()) +} + /// Waits until the parent header of `current` is available and returns it. /// /// When the node uses GRANDPA warp sync it initially downloads only the mandatory GRANDPA headers. @@ -651,7 +720,7 @@ where /// Wait for BEEFY runtime pallet to be available, return active validator set. /// Should be called only once during worker initialization. -async fn wait_for_runtime_pallet( +async fn wait_for_runtime_pallet( runtime: &R, finality: &mut Fuse>, ) -> Result<(NumberFor, ::Header), Error> @@ -676,7 +745,7 @@ where "🥩 BEEFY pallet available: block {:?} beefy genesis {:?}", notif.header.number(), start ); - return Ok((start, notif.header)) + return Ok((start, notif.header)); } } } @@ -687,7 +756,7 @@ where /// /// Note: function will `async::sleep()` when walking back the chain if some needed header hasn't /// been synced yet (as it happens when warp syncing when headers are synced in the background). -async fn expect_validator_set( +async fn expect_validator_set( runtime: &R, backend: &BE, at_header: &B::Header, @@ -711,9 +780,9 @@ where loop { debug!(target: LOG_TARGET, "🥩 Looking for auth set change at block number: {:?}", *header.number()); if let Ok(Some(active)) = runtime.runtime_api().validator_set(header.hash()) { - return Ok(active) + return Ok(active); } else { - match find_authorities_change::(&header) { + match find_authorities_change::(&header) { Some(active) => return Ok(active), // Move up the chain. Ultimately we'll get it from chain genesis state, or error out // there. @@ -728,9 +797,12 @@ where /// Scan the `header` digest log for a BEEFY validator set change. Return either the new /// validator set or `None` in case no validator set change has been signaled. -pub(crate) fn find_authorities_change(header: &B::Header) -> Option> +pub(crate) fn find_authorities_change( + header: &B::Header, +) -> Option> where B: Block, + AuthorityId: AuthorityIdBound, { let id = OpaqueDigestItemId::Consensus(&BEEFY_ENGINE_ID); diff --git a/substrate/client/consensus/beefy/src/metrics.rs b/substrate/client/consensus/beefy/src/metrics.rs index ef3928d79faaaee7f0aacf0af583347e825a30bb..30180fe43ec43b4dcc0ef6fbd4500b4445900c0b 100644 --- a/substrate/client/consensus/beefy/src/metrics.rs +++ b/substrate/client/consensus/beefy/src/metrics.rs @@ -20,7 +20,7 @@ use crate::LOG_TARGET; use log::{debug, error}; -use prometheus::{register, Counter, Gauge, PrometheusError, Registry, U64}; +use prometheus_endpoint::{register, Counter, Gauge, PrometheusError, Registry, U64}; /// Helper trait for registering BEEFY metrics to Prometheus registry. pub(crate) trait PrometheusRegister: Sized { @@ -282,7 +282,7 @@ impl PrometheusRegister for OnDemandOutgoingRequestsMetrics { } pub(crate) fn register_metrics( - prometheus_registry: Option, + prometheus_registry: Option, ) -> Option { prometheus_registry.as_ref().map(T::register).and_then(|result| match result { Ok(metrics) => { diff --git a/substrate/client/consensus/beefy/src/round.rs b/substrate/client/consensus/beefy/src/round.rs index 5dae80cb1830ddc2d6402625865af6e965046897..31cfe4c10c2e7d3e7112c353aff1c0572a7bd52b 100644 --- a/substrate/client/consensus/beefy/src/round.rs +++ b/substrate/client/consensus/beefy/src/round.rs @@ -20,9 +20,10 @@ use crate::LOG_TARGET; use codec::{Decode, Encode}; use log::{debug, info}; +use sp_application_crypto::RuntimeAppPublic; use sp_consensus_beefy::{ - ecdsa_crypto::{AuthorityId, Signature}, - Commitment, DoubleVotingProof, SignedCommitment, ValidatorSet, ValidatorSetId, VoteMessage, + AuthorityIdBound, Commitment, DoubleVotingProof, SignedCommitment, ValidatorSet, + ValidatorSetId, VoteMessage, }; use sp_runtime::traits::{Block, NumberFor}; use std::collections::BTreeMap; @@ -31,15 +32,24 @@ use std::collections::BTreeMap; /// whether the local `self` validator has voted/signed. /// /// Does not do any validation on votes or signatures, layers above need to handle that (gossip). -#[derive(Debug, Decode, Default, Encode, PartialEq)] -pub(crate) struct RoundTracker { - votes: BTreeMap, +#[derive(Debug, Decode, Encode, PartialEq)] +pub(crate) struct RoundTracker { + votes: BTreeMap::Signature>, +} + +impl Default for RoundTracker { + fn default() -> Self { + Self { votes: Default::default() } + } } -impl RoundTracker { - fn add_vote(&mut self, vote: (AuthorityId, Signature)) -> bool { +impl RoundTracker { + fn add_vote( + &mut self, + vote: (AuthorityId, ::Signature), + ) -> bool { if self.votes.contains_key(&vote.0) { - return false + return false; } self.votes.insert(vote.0, vote.1); @@ -58,10 +68,12 @@ pub fn threshold(authorities: usize) -> usize { } #[derive(Debug, PartialEq)] -pub enum VoteImportResult { +pub enum VoteImportResult { Ok, - RoundConcluded(SignedCommitment, Signature>), - DoubleVoting(DoubleVotingProof, AuthorityId, Signature>), + RoundConcluded(SignedCommitment, ::Signature>), + DoubleVoting( + DoubleVotingProof, AuthorityId, ::Signature>, + ), Invalid, Stale, } @@ -71,19 +83,22 @@ pub enum VoteImportResult { /// /// Does not do any validation on votes or signatures, layers above need to handle that (gossip). #[derive(Debug, Decode, Encode, PartialEq)] -pub(crate) struct Rounds { - rounds: BTreeMap>, RoundTracker>, - previous_votes: - BTreeMap<(AuthorityId, NumberFor), VoteMessage, AuthorityId, Signature>>, +pub(crate) struct Rounds { + rounds: BTreeMap>, RoundTracker>, + previous_votes: BTreeMap< + (AuthorityId, NumberFor), + VoteMessage, AuthorityId, ::Signature>, + >, session_start: NumberFor, validator_set: ValidatorSet, mandatory_done: bool, best_done: Option>, } -impl Rounds +impl Rounds where B: Block, + AuthorityId: AuthorityIdBound, { pub(crate) fn new( session_start: NumberFor, @@ -121,14 +136,14 @@ where pub(crate) fn add_vote( &mut self, - vote: VoteMessage, AuthorityId, Signature>, - ) -> VoteImportResult { + vote: VoteMessage, AuthorityId, ::Signature>, + ) -> VoteImportResult { let num = vote.commitment.block_number; let vote_key = (vote.id.clone(), num); if num < self.session_start || Some(num) <= self.best_done { debug!(target: LOG_TARGET, "🥩 received vote for old stale round {:?}, ignoring", num); - return VoteImportResult::Stale + return VoteImportResult::Stale; } else if vote.commitment.validator_set_id != self.validator_set_id() { debug!( target: LOG_TARGET, @@ -136,14 +151,14 @@ where self.validator_set_id(), vote, ); - return VoteImportResult::Invalid + return VoteImportResult::Invalid; } else if !self.validators().iter().any(|id| &vote.id == id) { debug!( target: LOG_TARGET, "🥩 received vote {:?} from validator that is not in the validator set, ignoring", vote ); - return VoteImportResult::Invalid + return VoteImportResult::Invalid; } if let Some(previous_vote) = self.previous_votes.get(&vote_key) { @@ -156,7 +171,7 @@ where return VoteImportResult::DoubleVoting(DoubleVotingProof { first: previous_vote.clone(), second: vote, - }) + }); } } else { // this is the first vote sent by `id` for `num`, all good @@ -169,7 +184,7 @@ where round.is_done(threshold(self.validator_set.len())) { if let Some(round) = self.rounds.remove_entry(&vote.commitment) { - return VoteImportResult::RoundConcluded(self.signed_commitment(round)) + return VoteImportResult::RoundConcluded(self.signed_commitment(round)); } } VoteImportResult::Ok @@ -177,8 +192,8 @@ where fn signed_commitment( &mut self, - round: (Commitment>, RoundTracker), - ) -> SignedCommitment, Signature> { + round: (Commitment>, RoundTracker), + ) -> SignedCommitment, ::Signature> { let votes = round.1.votes; let signatures = self .validators() @@ -207,14 +222,14 @@ mod tests { use sc_network_test::Block; use sp_consensus_beefy::{ - known_payloads::MMR_ROOT_ID, test_utils::Keyring, Commitment, DoubleVotingProof, Payload, - SignedCommitment, ValidatorSet, VoteMessage, + ecdsa_crypto, known_payloads::MMR_ROOT_ID, test_utils::Keyring, Commitment, + DoubleVotingProof, Payload, SignedCommitment, ValidatorSet, VoteMessage, }; - use super::{threshold, AuthorityId, Block as BlockT, RoundTracker, Rounds}; + use super::{threshold, Block as BlockT, RoundTracker, Rounds}; use crate::round::VoteImportResult; - impl Rounds + impl Rounds where B: BlockT, { @@ -225,8 +240,11 @@ mod tests { #[test] fn round_tracker() { - let mut rt = RoundTracker::default(); - let bob_vote = (Keyring::Bob.public(), Keyring::::Bob.sign(b"I am committed")); + let mut rt = RoundTracker::::default(); + let bob_vote = ( + Keyring::::Bob.public(), + Keyring::::Bob.sign(b"I am committed"), + ); let threshold = 2; // adding new vote allowed @@ -237,8 +255,10 @@ mod tests { // vote is not done assert!(!rt.is_done(threshold)); - let alice_vote = - (Keyring::Alice.public(), Keyring::::Alice.sign(b"I am committed")); + let alice_vote = ( + Keyring::::Alice.public(), + Keyring::::Alice.sign(b"I am committed"), + ); // adding new vote (self vote this time) allowed assert!(rt.add_vote(alice_vote)); @@ -260,22 +280,22 @@ mod tests { fn new_rounds() { sp_tracing::try_init_simple(); - let validators = ValidatorSet::::new( + let validators = ValidatorSet::::new( vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()], 42, ) .unwrap(); let session_start = 1u64.into(); - let rounds = Rounds::::new(session_start, validators); + let rounds = Rounds::::new(session_start, validators); assert_eq!(42, rounds.validator_set_id()); assert_eq!(1, rounds.session_start()); assert_eq!( &vec![ - Keyring::::Alice.public(), - Keyring::::Bob.public(), - Keyring::::Charlie.public() + Keyring::::Alice.public(), + Keyring::::Bob.public(), + Keyring::::Charlie.public() ], rounds.validators() ); @@ -285,7 +305,7 @@ mod tests { fn add_and_conclude_votes() { sp_tracing::try_init_simple(); - let validators = ValidatorSet::::new( + let validators = ValidatorSet::::new( vec![ Keyring::Alice.public(), Keyring::Bob.public(), @@ -298,7 +318,7 @@ mod tests { let validator_set_id = validators.id(); let session_start = 1u64.into(); - let mut rounds = Rounds::::new(session_start, validators); + let mut rounds = Rounds::::new(session_start, validators); let payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]); let block_number = 1; @@ -306,7 +326,7 @@ mod tests { let mut vote = VoteMessage { id: Keyring::Alice.public(), commitment: commitment.clone(), - signature: Keyring::::Alice.sign(b"I am committed"), + signature: Keyring::::Alice.sign(b"I am committed"), }; // add 1st good vote assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok); @@ -315,26 +335,26 @@ mod tests { assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok); vote.id = Keyring::Dave.public(); - vote.signature = Keyring::::Dave.sign(b"I am committed"); + vote.signature = Keyring::::Dave.sign(b"I am committed"); // invalid vote (Dave is not a validator) assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Invalid); vote.id = Keyring::Bob.public(); - vote.signature = Keyring::::Bob.sign(b"I am committed"); + vote.signature = Keyring::::Bob.sign(b"I am committed"); // add 2nd good vote assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Ok); vote.id = Keyring::Charlie.public(); - vote.signature = Keyring::::Charlie.sign(b"I am committed"); + vote.signature = Keyring::::Charlie.sign(b"I am committed"); // add 3rd good vote -> round concluded -> signatures present assert_eq!( rounds.add_vote(vote.clone()), VoteImportResult::RoundConcluded(SignedCommitment { commitment, signatures: vec![ - Some(Keyring::::Alice.sign(b"I am committed")), - Some(Keyring::::Bob.sign(b"I am committed")), - Some(Keyring::::Charlie.sign(b"I am committed")), + Some(Keyring::::Alice.sign(b"I am committed")), + Some(Keyring::::Bob.sign(b"I am committed")), + Some(Keyring::::Charlie.sign(b"I am committed")), None, ] }) @@ -342,7 +362,7 @@ mod tests { rounds.conclude(block_number); vote.id = Keyring::Eve.public(); - vote.signature = Keyring::::Eve.sign(b"I am committed"); + vote.signature = Keyring::::Eve.sign(b"I am committed"); // Eve is a validator, but round was concluded, adding vote disallowed assert_eq!(rounds.add_vote(vote), VoteImportResult::Stale); } @@ -351,7 +371,7 @@ mod tests { fn old_rounds_not_accepted() { sp_tracing::try_init_simple(); - let validators = ValidatorSet::::new( + let validators = ValidatorSet::::new( vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()], 42, ) @@ -360,7 +380,7 @@ mod tests { // active rounds starts at block 10 let session_start = 10u64.into(); - let mut rounds = Rounds::::new(session_start, validators); + let mut rounds = Rounds::::new(session_start, validators); // vote on round 9 let block_number = 9; @@ -369,7 +389,7 @@ mod tests { let mut vote = VoteMessage { id: Keyring::Alice.public(), commitment, - signature: Keyring::::Alice.sign(b"I am committed"), + signature: Keyring::::Alice.sign(b"I am committed"), }; // add vote for previous session, should fail assert_eq!(rounds.add_vote(vote.clone()), VoteImportResult::Stale); @@ -397,7 +417,7 @@ mod tests { fn multiple_rounds() { sp_tracing::try_init_simple(); - let validators = ValidatorSet::::new( + let validators = ValidatorSet::::new( vec![Keyring::Alice.public(), Keyring::Bob.public(), Keyring::Charlie.public()], Default::default(), ) @@ -405,29 +425,29 @@ mod tests { let validator_set_id = validators.id(); let session_start = 1u64.into(); - let mut rounds = Rounds::::new(session_start, validators); + let mut rounds = Rounds::::new(session_start, validators); let payload = Payload::from_single_entry(MMR_ROOT_ID, vec![]); let commitment = Commitment { block_number: 1, payload, validator_set_id }; let mut alice_vote = VoteMessage { id: Keyring::Alice.public(), commitment: commitment.clone(), - signature: Keyring::::Alice.sign(b"I am committed"), + signature: Keyring::::Alice.sign(b"I am committed"), }; let mut bob_vote = VoteMessage { id: Keyring::Bob.public(), commitment: commitment.clone(), - signature: Keyring::::Bob.sign(b"I am committed"), + signature: Keyring::::Bob.sign(b"I am committed"), }; let mut charlie_vote = VoteMessage { id: Keyring::Charlie.public(), commitment, - signature: Keyring::::Charlie.sign(b"I am committed"), + signature: Keyring::::Charlie.sign(b"I am committed"), }; let expected_signatures = vec![ - Some(Keyring::::Alice.sign(b"I am committed")), - Some(Keyring::::Bob.sign(b"I am committed")), - Some(Keyring::::Charlie.sign(b"I am committed")), + Some(Keyring::::Alice.sign(b"I am committed")), + Some(Keyring::::Bob.sign(b"I am committed")), + Some(Keyring::::Charlie.sign(b"I am committed")), ]; // round 1 - only 2 out of 3 vote @@ -472,14 +492,14 @@ mod tests { fn should_provide_equivocation_proof() { sp_tracing::try_init_simple(); - let validators = ValidatorSet::::new( + let validators = ValidatorSet::::new( vec![Keyring::Alice.public(), Keyring::Bob.public()], Default::default(), ) .unwrap(); let validator_set_id = validators.id(); let session_start = 1u64.into(); - let mut rounds = Rounds::::new(session_start, validators); + let mut rounds = Rounds::::new(session_start, validators); let payload1 = Payload::from_single_entry(MMR_ROOT_ID, vec![1, 1, 1, 1]); let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![2, 2, 2, 2]); @@ -489,7 +509,7 @@ mod tests { let alice_vote1 = VoteMessage { id: Keyring::Alice.public(), commitment: commitment1, - signature: Keyring::::Alice.sign(b"I am committed"), + signature: Keyring::::Alice.sign(b"I am committed"), }; let mut alice_vote2 = alice_vote1.clone(); alice_vote2.commitment = commitment2; diff --git a/substrate/client/consensus/beefy/src/tests.rs b/substrate/client/consensus/beefy/src/tests.rs index 2bb145d660df061561efd2196b2193b5ef70b1df..afa6191d8bfec42f6d3b0afdf1bde2678fd5ca97 100644 --- a/substrate/client/consensus/beefy/src/tests.rs +++ b/substrate/client/consensus/beefy/src/tests.rs @@ -30,13 +30,17 @@ use crate::{ request_response::{on_demand_justifications_protocol_config, BeefyJustifsRequestHandler}, }, error::Error, - gossip_protocol_name, + finality_notification_transformer_future, gossip_protocol_name, justification::*, wait_for_runtime_pallet, worker::PersistedState, - BeefyRPCLinks, BeefyVoterLinks, BeefyWorkerBuilder, KnownPeers, + BeefyRPCLinks, BeefyVoterLinks, BeefyWorkerBuilder, KnownPeers, UnpinnedFinalityNotification, +}; +use futures::{ + future, + stream::{Fuse, FuturesUnordered}, + Future, FutureExt, StreamExt, }; -use futures::{future, stream::FuturesUnordered, Future, FutureExt, StreamExt}; use parking_lot::Mutex; use sc_block_builder::BlockBuilderBuilder; use sc_client_api::{Backend as BackendT, BlockchainEvents, FinalityNotifications, HeaderBackend}; @@ -49,12 +53,13 @@ use sc_network_test::{ Block, BlockImportAdapter, FullPeerConfig, PassThroughVerifier, Peer, PeersClient, PeersFullClient, TestNetFactory, }; -use sc_utils::notification::NotificationReceiver; +use sc_utils::{mpsc::TracingUnboundedReceiver, notification::NotificationReceiver}; use serde::{Deserialize, Serialize}; use sp_api::{ApiRef, ProvideRuntimeApi}; use sp_application_crypto::key_types::BEEFY as BEEFY_KEY_TYPE; use sp_consensus::BlockOrigin; use sp_consensus_beefy::{ + ecdsa_crypto, ecdsa_crypto::{AuthorityId, Signature}, known_payloads, mmr::{find_mmr_root_digest, MmrRootProvider}, @@ -89,6 +94,7 @@ type BeefyBlockImport = crate::BeefyBlockImport< substrate_test_runtime_client::Backend, TestApi, BlockImportAdapter, + AuthorityId, >; pub(crate) type BeefyValidatorSet = ValidatorSet; @@ -107,8 +113,8 @@ impl BuildStorage for Genesis { #[derive(Default)] pub(crate) struct PeerData { - pub(crate) beefy_rpc_links: Mutex>>, - pub(crate) beefy_voter_links: Mutex>>, + pub(crate) beefy_rpc_links: Mutex>>, + pub(crate) beefy_voter_links: Mutex>>, pub(crate) beefy_justif_req_handler: Mutex>>, } @@ -312,7 +318,7 @@ sp_api::mock_impl_runtime_apis! { self.inner.validator_set.clone() } - fn submit_report_equivocation_unsigned_extrinsic( + fn submit_report_double_voting_unsigned_extrinsic( proof: DoubleVotingProof, AuthorityId, Signature>, _dummy: OpaqueKeyOwnershipProof, ) -> Option<()> { @@ -369,9 +375,9 @@ pub(crate) fn create_beefy_keystore(authority: &BeefyKeyring) -> Ke async fn voter_init_setup( net: &mut BeefyTestNet, - finality: &mut futures::stream::Fuse>, + finality: &mut futures::stream::Fuse>, api: &TestApi, -) -> Result, Error> { +) -> Result, Error> { let backend = net.peer(0).client().as_backend(); let (beefy_genesis, best_grandpa) = wait_for_runtime_pallet(api, finality).await.unwrap(); let key_store = None.into(); @@ -389,6 +395,15 @@ async fn voter_init_setup( .await } +fn start_finality_worker( + finality: FinalityNotifications, +) -> Fuse>> { + let (transformer, finality_notifications) = finality_notification_transformer_future(finality); + let tokio_handle = tokio::runtime::Handle::current(); + tokio_handle.spawn(transformer); + finality_notifications +} + // Spawns beefy voters. Returns a future to spawn on the runtime. fn initialize_beefy( net: &mut BeefyTestNet, @@ -446,7 +461,7 @@ where on_demand_justifications_handler: on_demand_justif_handler, is_authority: true, }; - let task = crate::start_beefy_gadget::<_, _, _, _, _, _, _>(beefy_params); + let task = crate::start_beefy_gadget::<_, _, _, _, _, _, _, _>(beefy_params); fn assert_send(_: &T) {} assert_send(&task); @@ -472,8 +487,10 @@ pub(crate) fn get_beefy_streams( net: &mut BeefyTestNet, // peer index and key peers: impl Iterator)>, -) -> (Vec>, Vec>>) -{ +) -> ( + Vec>, + Vec>>, +) { let mut best_block_streams = Vec::new(); let mut versioned_finality_proof_streams = Vec::new(); peers.for_each(|(index, _)| { @@ -511,7 +528,7 @@ async fn wait_for_best_beefy_blocks( } async fn wait_for_beefy_signed_commitments( - streams: Vec>>, + streams: Vec>>, net: &Arc>, expected_commitment_block_nums: &[u64], ) { @@ -773,7 +790,7 @@ async fn beefy_importing_justifications() { let client = net.peer(0).client().clone(); let full_client = client.as_client(); - let (mut block_import, _, peer_data) = net.make_block_import(client.clone()); + let (block_import, _, peer_data) = net.make_block_import(client.clone()); let PeerData { beefy_voter_links, .. } = peer_data; let justif_stream = beefy_voter_links.lock().take().unwrap().from_block_import_justif_stream; let mut justif_recv = justif_stream.subscribe(100_000); @@ -1016,13 +1033,17 @@ async fn should_initialize_voter_at_genesis() { // push 15 blocks with `AuthorityChange` digests every 10 blocks let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); + // finalize 13 without justifications net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap(); let api = TestApi::with_validator_set(&validator_set); // load persistent state - nothing in DB, should init at genesis - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // Test initialization at session boundary. // verify voter initialized with two sessions starting at blocks 1 and 10 @@ -1057,14 +1078,18 @@ async fn should_initialize_voter_at_custom_genesis() { // push 15 blocks with `AuthorityChange` digests every 15 blocks let hashes = net.generate_blocks_and_sync(15, 15, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); + // finalize 3, 5, 8 without justifications net.peer(0).client().as_client().finalize_block(hashes[3], None).unwrap(); net.peer(0).client().as_client().finalize_block(hashes[5], None).unwrap(); net.peer(0).client().as_client().finalize_block(hashes[8], None).unwrap(); // load persistent state - nothing in DB, should init at genesis - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // Test initialization at session boundary. // verify voter initialized with single session starting at block `custom_pallet_genesis` (7) @@ -1094,7 +1119,8 @@ async fn should_initialize_voter_at_custom_genesis() { net.peer(0).client().as_client().finalize_block(hashes[10], None).unwrap(); // load persistent state - state preset in DB, but with different pallet genesis - let new_persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let new_persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // verify voter initialized with single session starting at block `new_pallet_genesis` (10) let sessions = new_persisted_state.voting_oracle().sessions(); @@ -1125,7 +1151,9 @@ async fn should_initialize_voter_when_last_final_is_session_boundary() { // push 15 blocks with `AuthorityChange` digests every 10 blocks let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); // finalize 13 without justifications net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap(); @@ -1149,7 +1177,8 @@ async fn should_initialize_voter_when_last_final_is_session_boundary() { let api = TestApi::with_validator_set(&validator_set); // load persistent state - nothing in DB, should init at session boundary - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // verify voter initialized with single session starting at block 10 assert_eq!(persisted_state.voting_oracle().sessions().len(), 1); @@ -1179,7 +1208,9 @@ async fn should_initialize_voter_at_latest_finalized() { // push 15 blocks with `AuthorityChange` digests every 10 blocks let hashes = net.generate_blocks_and_sync(15, 10, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); // finalize 13 without justifications net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap(); @@ -1202,7 +1233,8 @@ async fn should_initialize_voter_at_latest_finalized() { let api = TestApi::with_validator_set(&validator_set); // load persistent state - nothing in DB, should init at last BEEFY finalized - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // verify voter initialized with single session starting at block 12 assert_eq!(persisted_state.voting_oracle().sessions().len(), 1); @@ -1235,12 +1267,15 @@ async fn should_initialize_voter_at_custom_genesis_when_state_unavailable() { // push 30 blocks with `AuthorityChange` digests every 5 blocks let hashes = net.generate_blocks_and_sync(30, 5, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); // finalize 30 without justifications net.peer(0).client().as_client().finalize_block(hashes[30], None).unwrap(); // load persistent state - nothing in DB, should init at genesis - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // Test initialization at session boundary. // verify voter initialized with all sessions pending, first one starting at block 5 (start of @@ -1278,14 +1313,18 @@ async fn should_catch_up_when_loading_saved_voter_state() { // push 30 blocks with `AuthorityChange` digests every 10 blocks let hashes = net.generate_blocks_and_sync(30, 10, &validator_set, false).await; - let mut finality = net.peer(0).client().as_client().finality_notification_stream().fuse(); + let finality = net.peer(0).client().as_client().finality_notification_stream(); + + let mut finality_notifications = start_finality_worker(finality); + // finalize 13 without justifications net.peer(0).client().as_client().finalize_block(hashes[13], None).unwrap(); let api = TestApi::with_validator_set(&validator_set); // load persistent state - nothing in DB, should init at genesis - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // Test initialization at session boundary. // verify voter initialized with two sessions starting at blocks 1 and 10 @@ -1312,7 +1351,8 @@ async fn should_catch_up_when_loading_saved_voter_state() { // finalize 25 without justifications net.peer(0).client().as_client().finalize_block(hashes[25], None).unwrap(); // load persistent state - state preset in DB - let persisted_state = voter_init_setup(&mut net, &mut finality, &api).await.unwrap(); + let persisted_state = + voter_init_setup(&mut net, &mut finality_notifications, &api).await.unwrap(); // Verify voter initialized with old sessions plus a new one starting at block 20. // There shouldn't be any duplicates. @@ -1417,7 +1457,7 @@ async fn beefy_reports_equivocations() { for wait_ms in [250, 500, 1250, 3000] { run_for(Duration::from_millis(wait_ms), &net).await; if !api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty() { - break + break; } } @@ -1457,7 +1497,7 @@ async fn gossipped_finality_proofs() { // Charlie will run just the gossip engine and not the full voter. let gossip_validator = GossipValidator::new(known_peers, Arc::new(TestNetwork::new().0)); let charlie_gossip_validator = Arc::new(gossip_validator); - charlie_gossip_validator.update_filter(GossipFilterCfg:: { + charlie_gossip_validator.update_filter(GossipFilterCfg:: { start: 1, end: 10, validator_set: &validator_set, @@ -1501,7 +1541,7 @@ async fn gossipped_finality_proofs() { let (best_blocks, versioned_finality_proof) = get_beefy_streams(&mut net.lock(), peers.clone()); // Charlie gossips finality proof for #1 -> Alice and Bob also finalize. let proof = crate::communication::gossip::tests::dummy_proof(1, &validator_set); - let gossip_proof = GossipMessage::::FinalityProof(proof); + let gossip_proof = GossipMessage::::FinalityProof(proof); let encoded_proof = gossip_proof.encode(); charlie_gossip_engine.gossip_message(proofs_topic::(), encoded_proof, true); // Expect #1 is finalized. @@ -1526,7 +1566,8 @@ async fn gossipped_finality_proofs() { let commitment = Commitment { payload, block_number, validator_set_id: validator_set.id() }; let signature = sign_commitment(&BeefyKeyring::Charlie, &commitment); let vote_message = VoteMessage { commitment, id: BeefyKeyring::Charlie.public(), signature }; - let encoded_vote = GossipMessage::::Vote(vote_message).encode(); + let encoded_vote = + GossipMessage::::Vote(vote_message).encode(); charlie_gossip_engine.gossip_message(votes_topic::(), encoded_vote, true); // Expect #2 is finalized. @@ -1538,12 +1579,15 @@ async fn gossipped_finality_proofs() { charlie_gossip_engine .messages_for(proofs_topic::()) .filter_map(|notification| async move { - GossipMessage::::decode(&mut ¬ification.message[..]).ok().and_then( - |message| match message { - GossipMessage::::Vote(_) => unreachable!(), - GossipMessage::::FinalityProof(proof) => Some(proof), - }, + GossipMessage::::decode( + &mut ¬ification.message[..], ) + .ok() + .and_then(|message| match message { + GossipMessage::::Vote(_) => unreachable!(), + GossipMessage::::FinalityProof(proof) => + Some(proof), + }) }) .fuse(), ); @@ -1561,7 +1605,7 @@ async fn gossipped_finality_proofs() { // verify finality proof has been gossipped proof = charlie_gossip_proofs.next() => { let proof = proof.unwrap(); - let (round, _) = proof_block_num_and_set_id::(&proof); + let (round, _) = proof_block_num_and_set_id::(&proof); match round { 1 => continue, // finality proof generated by Charlie in the previous round 2 => break, // finality proof generated by Alice or Bob and gossiped to Charlie diff --git a/substrate/client/consensus/beefy/src/worker.rs b/substrate/client/consensus/beefy/src/worker.rs index cfbb3d63aea446d5b6a9a20a0eb9b2cf8c391e79..3c7f3b1b6efab377ed13ea91f33b80f8d541c109 100644 --- a/substrate/client/consensus/beefy/src/worker.rs +++ b/substrate/client/consensus/beefy/src/worker.rs @@ -29,20 +29,21 @@ use crate::{ metric_inc, metric_set, metrics::VoterMetrics, round::{Rounds, VoteImportResult}, - BeefyComms, BeefyVoterLinks, LOG_TARGET, + BeefyComms, BeefyVoterLinks, UnpinnedFinalityNotification, LOG_TARGET, }; +use sp_application_crypto::RuntimeAppPublic; + use codec::{Codec, Decode, DecodeAll, Encode}; use futures::{stream::Fuse, FutureExt, StreamExt}; use log::{debug, error, info, trace, warn}; -use sc_client_api::{Backend, FinalityNotification, FinalityNotifications, HeaderBackend}; +use sc_client_api::{Backend, HeaderBackend}; use sc_utils::notification::NotificationReceiver; use sp_api::ProvideRuntimeApi; use sp_arithmetic::traits::{AtLeast32Bit, Saturating}; use sp_consensus::SyncOracle; use sp_consensus_beefy::{ - ecdsa_crypto::{AuthorityId, Signature}, - BeefyApi, Commitment, DoubleVotingProof, PayloadProvider, ValidatorSet, VersionedFinalityProof, - VoteMessage, BEEFY_ENGINE_ID, + AuthorityIdBound, BeefyApi, Commitment, DoubleVotingProof, PayloadProvider, ValidatorSet, + VersionedFinalityProof, VoteMessage, BEEFY_ENGINE_ID, }; use sp_runtime::{ generic::BlockId, @@ -52,6 +53,7 @@ use sp_runtime::{ use std::{ collections::{BTreeMap, VecDeque}, fmt::Debug, + marker::PhantomData, sync::Arc, }; @@ -72,7 +74,7 @@ pub(crate) enum RoundAction { /// Note: this is part of `PersistedState` so any changes here should also bump /// aux-db schema version. #[derive(Debug, Decode, Encode, PartialEq)] -pub(crate) struct VoterOracle { +pub(crate) struct VoterOracle { /// Queue of known sessions. Keeps track of voting rounds (block numbers) within each session. /// /// There are three voter states corresponding to three queue states: @@ -82,19 +84,23 @@ pub(crate) struct VoterOracle { /// 3. lagging behind GRANDPA: queue has [1, N] elements, where all `mandatory_done == false`. /// In this state, every time a session gets its mandatory block BEEFY finalized, it's /// popped off the queue, eventually getting to state `2. up-to-date`. - sessions: VecDeque>, + sessions: VecDeque>, /// Min delta in block numbers between two blocks, BEEFY should vote on. min_block_delta: u32, /// Best block we received a GRANDPA finality for. best_grandpa_block_header: ::Header, /// Best block a BEEFY voting round has been concluded for. best_beefy_block: NumberFor, + _phantom: PhantomData AuthorityId>, } -impl VoterOracle { +impl VoterOracle +where + AuthorityId: AuthorityIdBound, +{ /// Verify provided `sessions` satisfies requirements, then build `VoterOracle`. pub fn checked_new( - sessions: VecDeque>, + sessions: VecDeque>, min_block_delta: u32, grandpa_header: ::Header, best_beefy: NumberFor, @@ -105,24 +111,24 @@ impl VoterOracle { let mut validate = || -> bool { let best_grandpa = *grandpa_header.number(); if sessions.is_empty() || best_beefy > best_grandpa { - return false + return false; } for (idx, session) in sessions.iter().enumerate() { let start = session.session_start(); if session.validators().is_empty() { - return false + return false; } if start > best_grandpa || start <= prev_start { - return false + return false; } #[cfg(not(test))] if let Some(prev_id) = prev_validator_id { if session.validator_set_id() <= prev_id { - return false + return false; } } if idx != 0 && session.mandatory_done() { - return false + return false; } prev_start = session.session_start(); prev_validator_id = Some(session.validator_set_id()); @@ -136,6 +142,7 @@ impl VoterOracle { min_block_delta: min_block_delta.max(1), best_grandpa_block_header: grandpa_header, best_beefy_block: best_beefy, + _phantom: PhantomData, }) } else { error!( @@ -151,13 +158,13 @@ impl VoterOracle { // Return reference to rounds pertaining to first session in the queue. // Voting will always happen at the head of the queue. - fn active_rounds(&self) -> Result<&Rounds, Error> { + fn active_rounds(&self) -> Result<&Rounds, Error> { self.sessions.front().ok_or(Error::UninitSession) } // Return mutable reference to rounds pertaining to first session in the queue. // Voting will always happen at the head of the queue. - fn active_rounds_mut(&mut self) -> Result<&mut Rounds, Error> { + fn active_rounds_mut(&mut self) -> Result<&mut Rounds, Error> { self.sessions.front_mut().ok_or(Error::UninitSession) } @@ -183,7 +190,7 @@ impl VoterOracle { } /// Add new observed session to the Oracle. - pub fn add_session(&mut self, rounds: Rounds) { + pub fn add_session(&mut self, rounds: Rounds) { self.sessions.push_back(rounds); // Once we add a new session we can drop/prune previous session if it's been finalized. self.try_prune(); @@ -267,21 +274,21 @@ impl VoterOracle { /// /// Note: Any changes here should also bump aux-db schema version. #[derive(Debug, Decode, Encode, PartialEq)] -pub(crate) struct PersistedState { +pub(crate) struct PersistedState { /// Best block we voted on. best_voted: NumberFor, /// Chooses which incoming votes to accept and which votes to generate. /// Keeps track of voting seen for current and future rounds. - voting_oracle: VoterOracle, + voting_oracle: VoterOracle, /// Pallet-beefy genesis block - block number when BEEFY consensus started for this chain. pallet_genesis: NumberFor, } -impl PersistedState { +impl PersistedState { pub fn checked_new( grandpa_header: ::Header, best_beefy: NumberFor, - sessions: VecDeque>, + sessions: VecDeque>, min_block_delta: u32, pallet_genesis: NumberFor, ) -> Option { @@ -314,11 +321,11 @@ impl PersistedState { self.voting_oracle.best_grandpa_block_header = best_grandpa; } - pub fn voting_oracle(&self) -> &VoterOracle { + pub fn voting_oracle(&self) -> &VoterOracle { &self.voting_oracle } - pub(crate) fn gossip_filter_config(&self) -> Result, Error> { + pub(crate) fn gossip_filter_config(&self) -> Result, Error> { let (start, end) = self.voting_oracle.accepted_interval()?; let validator_set = self.voting_oracle.current_validator_set()?; Ok(GossipFilterCfg { start, end, validator_set }) @@ -373,34 +380,34 @@ impl PersistedState { } /// A BEEFY worker/voter that follows the BEEFY protocol -pub(crate) struct BeefyWorker { +pub(crate) struct BeefyWorker { // utilities pub backend: Arc, pub runtime: Arc, pub key_store: Arc>, pub payload_provider: P, pub sync: Arc, - pub fisherman: Arc>, + pub fisherman: Arc>, // communication (created once, but returned and reused if worker is restarted/reinitialized) - pub comms: BeefyComms, + pub comms: BeefyComms, // channels /// Links between the block importer, the background voter and the RPC layer. - pub links: BeefyVoterLinks, + pub links: BeefyVoterLinks, // voter state /// Buffer holding justifications for future processing. - pub pending_justifications: BTreeMap, BeefyVersionedFinalityProof>, + pub pending_justifications: BTreeMap, BeefyVersionedFinalityProof>, /// Persisted voter state. - pub persisted_state: PersistedState, + pub persisted_state: PersistedState, /// BEEFY voter metrics pub metrics: Option, /// Node runs under "Authority" role. pub is_authority: bool, } -impl BeefyWorker +impl BeefyWorker where B: Block + Codec, BE: Backend, @@ -408,17 +415,18 @@ where S: SyncOracle, R: ProvideRuntimeApi, R::Api: BeefyApi, + AuthorityId: AuthorityIdBound, { fn best_grandpa_block(&self) -> NumberFor { *self.persisted_state.voting_oracle.best_grandpa_block_header.number() } - fn voting_oracle(&self) -> &VoterOracle { + fn voting_oracle(&self) -> &VoterOracle { &self.persisted_state.voting_oracle } #[cfg(test)] - fn active_rounds(&mut self) -> Result<&Rounds, Error> { + fn active_rounds(&mut self) -> Result<&Rounds, Error> { self.persisted_state.voting_oracle.active_rounds() } @@ -439,24 +447,29 @@ where fn handle_finality_notification( &mut self, - notification: &FinalityNotification, + notification: &UnpinnedFinalityNotification, ) -> Result<(), Error> { let header = ¬ification.header; debug!( target: LOG_TARGET, "🥩 Finality notification: header(number {:?}, hash {:?}) tree_route {:?}", header.number(), - header.hash(), + notification.hash, notification.tree_route, ); - self.runtime - .runtime_api() - .beefy_genesis(header.hash()) - .ok() - .flatten() - .filter(|genesis| *genesis == self.persisted_state.pallet_genesis) - .ok_or(Error::ConsensusReset)?; + match self.runtime.runtime_api().beefy_genesis(notification.hash) { + Ok(Some(genesis)) if genesis != self.persisted_state.pallet_genesis => { + debug!(target: LOG_TARGET, "🥩 ConsensusReset detected. Expected genesis: {}, found genesis: {}", self.persisted_state.pallet_genesis, genesis); + return Err(Error::ConsensusReset) + }, + Ok(_) => {}, + Err(api_error) => { + // This can happen in case the block was already pruned. + // Mostly after warp sync when finality notifications are piled up. + debug!(target: LOG_TARGET, "🥩 Unable to check beefy genesis: {}", api_error); + }, + } let mut new_session_added = false; if *header.number() > self.best_grandpa_block() { @@ -476,7 +489,8 @@ where }) .chain(std::iter::once(header.clone())) { - if let Some(new_validator_set) = find_authorities_change::(&header) { + if let Some(new_validator_set) = find_authorities_change::(&header) + { self.init_session_at(new_validator_set, *header.number()); new_session_added = true; } @@ -503,13 +517,17 @@ where /// Based on [VoterOracle] this vote is either processed here or discarded. fn triage_incoming_vote( &mut self, - vote: VoteMessage, AuthorityId, Signature>, - ) -> Result<(), Error> { + vote: VoteMessage, AuthorityId, ::Signature>, + ) -> Result<(), Error> + where + ::Signature: Encode + Decode, + { let block_num = vote.commitment.block_number; match self.voting_oracle().triage_round(block_num)? { RoundAction::Process => if let Some(finality_proof) = self.handle_vote(vote)? { - let gossip_proof = GossipMessage::::FinalityProof(finality_proof); + let gossip_proof = + GossipMessage::::FinalityProof(finality_proof); let encoded_proof = gossip_proof.encode(); self.comms.gossip_engine.gossip_message( proofs_topic::(), @@ -528,7 +546,7 @@ where /// Expects `justification` to be valid. fn triage_incoming_justif( &mut self, - justification: BeefyVersionedFinalityProof, + justification: BeefyVersionedFinalityProof, ) -> Result<(), Error> { let signed_commitment = match justification { VersionedFinalityProof::V1(ref sc) => sc, @@ -560,8 +578,8 @@ where fn handle_vote( &mut self, - vote: VoteMessage, AuthorityId, Signature>, - ) -> Result>, Error> { + vote: VoteMessage, AuthorityId, ::Signature>, + ) -> Result>, Error> { let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?; let block_number = vote.commitment.block_number; @@ -576,7 +594,7 @@ where // New state is persisted after finalization. self.finalize(finality_proof.clone())?; metric_inc!(self.metrics, beefy_good_votes_processed); - return Ok(Some(finality_proof)) + return Ok(Some(finality_proof)); }, VoteImportResult::Ok => { // Persist state after handling mandatory block vote. @@ -608,14 +626,17 @@ where /// 4. Send best block hash and `finality_proof` to RPC worker. /// /// Expects `finality proof` to be valid and for a block > current-best-beefy. - fn finalize(&mut self, finality_proof: BeefyVersionedFinalityProof) -> Result<(), Error> { + fn finalize( + &mut self, + finality_proof: BeefyVersionedFinalityProof, + ) -> Result<(), Error> { let block_num = match finality_proof { VersionedFinalityProof::V1(ref sc) => sc.commitment.block_number, }; if block_num <= self.persisted_state.voting_oracle.best_beefy_block { // we've already finalized this round before, short-circuit. - return Ok(()) + return Ok(()); } // Finalize inner round and update voting_oracle state. @@ -740,7 +761,7 @@ where hash } else { warn!(target: LOG_TARGET, "🥩 No MMR root digest found for: {:?}", target_hash); - return Ok(()) + return Ok(()); }; let rounds = self.persisted_state.voting_oracle.active_rounds_mut()?; @@ -754,7 +775,7 @@ where target: LOG_TARGET, "🥩 Missing validator id - can't vote for: {:?}", target_hash ); - return Ok(()) + return Ok(()); }; let commitment = Commitment { payload, block_number: target_number, validator_set_id }; @@ -764,7 +785,7 @@ where Ok(sig) => sig, Err(err) => { warn!(target: LOG_TARGET, "🥩 Error signing commitment: {:?}", err); - return Ok(()) + return Ok(()); }, }; @@ -780,14 +801,15 @@ where error!(target: LOG_TARGET, "🥩 Error handling self vote: {}", err); err })? { - let encoded_proof = GossipMessage::::FinalityProof(finality_proof).encode(); + let encoded_proof = + GossipMessage::::FinalityProof(finality_proof).encode(); self.comms .gossip_engine .gossip_message(proofs_topic::(), encoded_proof, true); } else { metric_inc!(self.metrics, beefy_votes_sent); debug!(target: LOG_TARGET, "🥩 Sent vote message: {:?}", vote); - let encoded_vote = GossipMessage::::Vote(vote).encode(); + let encoded_vote = GossipMessage::::Vote(vote).encode(); self.comms.gossip_engine.gossip_message(votes_topic::(), encoded_vote, false); } @@ -825,9 +847,11 @@ where /// Should never end, returns `Error` otherwise. pub(crate) async fn run( mut self, - block_import_justif: &mut Fuse>>, - finality_notifications: &mut Fuse>, - ) -> (Error, BeefyComms) { + block_import_justif: &mut Fuse< + NotificationReceiver>, + >, + finality_notifications: &mut Fuse>, + ) -> (Error, BeefyComms) { info!( target: LOG_TARGET, "🥩 run BEEFY worker, best grandpa: #{:?}.", @@ -839,9 +863,10 @@ where .gossip_engine .messages_for(votes_topic::()) .filter_map(|notification| async move { - let vote = GossipMessage::::decode_all(&mut ¬ification.message[..]) - .ok() - .and_then(|message| message.unwrap_vote()); + let vote = + GossipMessage::::decode_all(&mut ¬ification.message[..]) + .ok() + .and_then(|message| message.unwrap_vote()); trace!(target: LOG_TARGET, "🥩 Got vote message: {:?}", vote); vote }) @@ -852,9 +877,10 @@ where .gossip_engine .messages_for(proofs_topic::()) .filter_map(|notification| async move { - let proof = GossipMessage::::decode_all(&mut ¬ification.message[..]) - .ok() - .and_then(|message| message.unwrap_finality_proof()); + let proof = + GossipMessage::::decode_all(&mut ¬ification.message[..]) + .ok() + .and_then(|message| message.unwrap_finality_proof()); trace!(target: LOG_TARGET, "🥩 Got gossip proof message: {:?}", proof); proof }) @@ -945,7 +971,11 @@ where /// Report the given equivocation to the BEEFY runtime module. fn report_double_voting( &self, - proof: DoubleVotingProof, AuthorityId, Signature>, + proof: DoubleVotingProof< + NumberFor, + AuthorityId, + ::Signature, + >, ) -> Result<(), Error> { let rounds = self.persisted_state.voting_oracle.active_rounds()?; self.fisherman.report_double_voting(proof, rounds) @@ -1011,10 +1041,10 @@ pub(crate) mod tests { use sc_network_test::TestNetFactory; use sp_blockchain::Backend as BlockchainBackendT; use sp_consensus_beefy::{ - known_payloads, + ecdsa_crypto, known_payloads, known_payloads::MMR_ROOT_ID, mmr::MmrRootProvider, - test_utils::{generate_equivocation_proof, Keyring}, + test_utils::{generate_double_voting_proof, Keyring}, ConsensusLog, Payload, SignedCommitment, }; use sp_runtime::traits::{Header as HeaderT, One}; @@ -1023,8 +1053,8 @@ pub(crate) mod tests { Backend, }; - impl PersistedState { - pub fn active_round(&self) -> Result<&Rounds, Error> { + impl PersistedState { + pub fn active_round(&self) -> Result<&Rounds, Error> { self.voting_oracle.active_rounds() } @@ -1033,17 +1063,17 @@ pub(crate) mod tests { } } - impl VoterOracle { - pub fn sessions(&self) -> &VecDeque> { + impl VoterOracle { + pub fn sessions(&self) -> &VecDeque> { &self.sessions } } fn create_beefy_worker( peer: &mut BeefyPeer, - key: &Keyring, + key: &Keyring, min_block_delta: u32, - genesis_validator_set: ValidatorSet, + genesis_validator_set: ValidatorSet, ) -> BeefyWorker< Block, Backend, @@ -1051,15 +1081,16 @@ pub(crate) mod tests { TestApi, Arc>, TestNetwork, + ecdsa_crypto::AuthorityId, > { let keystore = create_beefy_keystore(key); let (to_rpc_justif_sender, from_voter_justif_stream) = - BeefyVersionedFinalityProofStream::::channel(); + BeefyVersionedFinalityProofStream::::channel(); let (to_rpc_best_block_sender, from_voter_best_beefy_stream) = BeefyBestBlockStream::::channel(); let (_, from_block_import_justif_stream) = - BeefyVersionedFinalityProofStream::::channel(); + BeefyVersionedFinalityProofStream::::channel(); let beefy_rpc_links = BeefyRPCLinks { from_voter_justif_stream, from_voter_best_beefy_stream }; @@ -1115,7 +1146,8 @@ pub(crate) mod tests { .unwrap(); let payload_provider = MmrRootProvider::new(api.clone()); let comms = BeefyComms { gossip_engine, gossip_validator, on_demand_justifications }; - let key_store: Arc> = Arc::new(Some(keystore).into()); + let key_store: Arc> = + Arc::new(Some(keystore).into()); BeefyWorker { backend: backend.clone(), runtime: api.clone(), @@ -1233,13 +1265,14 @@ pub(crate) mod tests { Default::default(), Digest::default(), ); - let mut oracle = VoterOracle:: { + let mut oracle = VoterOracle:: { best_beefy_block: 0, best_grandpa_block_header: header, min_block_delta: 1, sessions: VecDeque::new(), + _phantom: PhantomData, }; - let voting_target_with = |oracle: &mut VoterOracle, + let voting_target_with = |oracle: &mut VoterOracle, best_beefy: NumberFor, best_grandpa: NumberFor| -> Option> { @@ -1295,18 +1328,20 @@ pub(crate) mod tests { Default::default(), Digest::default(), ); - let mut oracle = VoterOracle:: { + let mut oracle = VoterOracle:: { best_beefy_block: 0, best_grandpa_block_header: header, min_block_delta: 1, sessions: VecDeque::new(), + _phantom: PhantomData, }; - let accepted_interval_with = |oracle: &mut VoterOracle, - best_grandpa: NumberFor| - -> Result<(NumberFor, NumberFor), Error> { - oracle.best_grandpa_block_header.number = best_grandpa; - oracle.accepted_interval() - }; + let accepted_interval_with = + |oracle: &mut VoterOracle, + best_grandpa: NumberFor| + -> Result<(NumberFor, NumberFor), Error> { + oracle.best_grandpa_block_header.number = best_grandpa; + oracle.accepted_interval() + }; // rounds not initialized -> should accept votes: `None` assert!(accepted_interval_with(&mut oracle, 1).is_err()); @@ -1377,18 +1412,19 @@ pub(crate) mod tests { ); // verify empty digest shows nothing - assert!(find_authorities_change::(&header).is_none()); + assert!(find_authorities_change::(&header).is_none()); let peers = &[Keyring::One, Keyring::Two]; let id = 42; let validator_set = ValidatorSet::new(make_beefy_ids(peers), id).unwrap(); header.digest_mut().push(DigestItem::Consensus( BEEFY_ENGINE_ID, - ConsensusLog::::AuthoritiesChange(validator_set.clone()).encode(), + ConsensusLog::::AuthoritiesChange(validator_set.clone()) + .encode(), )); // verify validator set is correctly extracted from digest - let extracted = find_authorities_change::(&header); + let extracted = find_authorities_change::(&header); assert_eq!(extracted, Some(validator_set)); } @@ -1555,7 +1591,7 @@ pub(crate) mod tests { let payload2 = Payload::from_single_entry(MMR_ROOT_ID, vec![128]); // generate an equivocation proof, with Bob as perpetrator - let good_proof = generate_equivocation_proof( + let good_proof = generate_double_voting_proof( (block_num, payload1.clone(), set_id, &Keyring::Bob), (block_num, payload2.clone(), set_id, &Keyring::Bob), ); @@ -1587,7 +1623,7 @@ pub(crate) mod tests { assert!(api_alice.reported_equivocations.as_ref().unwrap().lock().is_empty()); // now let's try reporting a self-equivocation - let self_proof = generate_equivocation_proof( + let self_proof = generate_double_voting_proof( (block_num, payload1.clone(), set_id, &Keyring::Alice), (block_num, payload2.clone(), set_id, &Keyring::Alice), ); diff --git a/substrate/client/consensus/common/Cargo.toml b/substrate/client/consensus/common/Cargo.toml index 6d642ec78fefa88692503152595f8548d715426c..77cd50ad784bb5e055480466036e573b9ec7cbc8 100644 --- a/substrate/client/consensus/common/Cargo.toml +++ b/substrate/client/consensus/common/Cargo.toml @@ -4,7 +4,7 @@ version = "0.33.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Collection of common consensus specific implementations for Substrate (client)" readme = "README.md" @@ -16,24 +16,23 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -async-trait = "0.1.79" -futures = { version = "0.3.30", features = ["thread-pool"] } -futures-timer = "3.0.1" +async-trait = { workspace = true } +futures = { features = ["thread-pool"], workspace = true } log = { workspace = true, default-features = true } -mockall = "0.11.3" -parking_lot = "0.12.1" +mockall = { workspace = true } +parking_lot = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-client-api = { path = "../../api" } -sc-network-types = { path = "../../network/types" } -sc-utils = { path = "../../utils" } -sp-api = { path = "../../../primitives/api" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-core = { path = "../../../primitives/core" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-state-machine = { path = "../../../primitives/state-machine" } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } [dev-dependencies] -sp-test-primitives = { path = "../../../primitives/test-primitives" } +sp-test-primitives = { workspace = true } diff --git a/substrate/client/consensus/common/src/block_import.rs b/substrate/client/consensus/common/src/block_import.rs index d91851aea62cf4564464b67bcd0bdcd5d712e139..4d7b89f37d86c7e178ed3cabb1c6dba997b83103 100644 --- a/substrate/client/consensus/common/src/block_import.rs +++ b/substrate/client/consensus/common/src/block_import.rs @@ -307,16 +307,10 @@ pub trait BlockImport { type Error: std::error::Error + Send + 'static; /// Check block preconditions. - async fn check_block( - &mut self, - block: BlockCheckParams, - ) -> Result; + async fn check_block(&self, block: BlockCheckParams) -> Result; /// Import a block. - async fn import_block( - &mut self, - block: BlockImportParams, - ) -> Result; + async fn import_block(&self, block: BlockImportParams) -> Result; } #[async_trait::async_trait] @@ -324,18 +318,12 @@ impl BlockImport for crate::import_queue::BoxBlockImport { type Error = sp_consensus::error::Error; /// Check block preconditions. - async fn check_block( - &mut self, - block: BlockCheckParams, - ) -> Result { + async fn check_block(&self, block: BlockCheckParams) -> Result { (**self).check_block(block).await } /// Import a block. - async fn import_block( - &mut self, - block: BlockImportParams, - ) -> Result { + async fn import_block(&self, block: BlockImportParams) -> Result { (**self).import_block(block).await } } @@ -348,17 +336,11 @@ where { type Error = E; - async fn check_block( - &mut self, - block: BlockCheckParams, - ) -> Result { + async fn check_block(&self, block: BlockCheckParams) -> Result { (&**self).check_block(block).await } - async fn import_block( - &mut self, - block: BlockImportParams, - ) -> Result { + async fn import_block(&self, block: BlockImportParams) -> Result { (&**self).import_block(block).await } } diff --git a/substrate/client/consensus/common/src/import_queue.rs b/substrate/client/consensus/common/src/import_queue.rs index 371465536c35a5feea5d6e157eb3ee8b019b94db..1baa67398a49c3461a2d4f85d9c23de3191e9c22 100644 --- a/substrate/client/consensus/common/src/import_queue.rs +++ b/substrate/client/consensus/common/src/import_queue.rs @@ -28,6 +28,10 @@ //! queues to be instantiated simply. use log::{debug, trace}; +use std::{ + fmt, + time::{Duration, Instant}, +}; use sp_consensus::{error::Error as ConsensusError, BlockOrigin}; use sp_runtime::{ @@ -93,18 +97,18 @@ pub struct IncomingBlock { /// Verify a justification of a block #[async_trait::async_trait] -pub trait Verifier: Send { +pub trait Verifier: Send + Sync { /// Verify the given block data and return the `BlockImportParams` to /// continue the block import process. - async fn verify(&mut self, block: BlockImportParams) - -> Result, String>; + async fn verify(&self, block: BlockImportParams) -> Result, String>; } /// Blocks import queue API. /// /// The `import_*` methods can be called in order to send elements for the import queue to verify. pub trait ImportQueueService: Send { - /// Import bunch of blocks. + /// Import bunch of blocks, every next block must be an ancestor of the previous block in the + /// list. fn import_blocks(&mut self, origin: BlockOrigin, blocks: Vec>); /// Import block justifications. @@ -165,16 +169,16 @@ pub trait Link: Send { /// Block import successful result. #[derive(Debug, PartialEq)] -pub enum BlockImportStatus { +pub enum BlockImportStatus { /// Imported known block. - ImportedKnown(N, Option), + ImportedKnown(BlockNumber, Option), /// Imported unknown block. - ImportedUnknown(N, ImportedAux, Option), + ImportedUnknown(BlockNumber, ImportedAux, Option), } -impl BlockImportStatus { +impl BlockImportStatus { /// Returns the imported block number. - pub fn number(&self) -> &N { + pub fn number(&self) -> &BlockNumber { match self { BlockImportStatus::ImportedKnown(n, _) | BlockImportStatus::ImportedUnknown(n, _, _) => n, @@ -221,46 +225,32 @@ pub async fn import_single_block>( import_handle: &mut impl BlockImport, block_origin: BlockOrigin, block: IncomingBlock, - verifier: &mut V, + verifier: &V, ) -> BlockImportResult { - import_single_block_metered(import_handle, block_origin, block, verifier, None).await + match verify_single_block_metered(import_handle, block_origin, block, verifier, None).await? { + SingleBlockVerificationOutcome::Imported(import_status) => Ok(import_status), + SingleBlockVerificationOutcome::Verified(import_parameters) => + import_single_block_metered(import_handle, import_parameters, None).await, + } } -/// Single block import function with metering. -pub(crate) async fn import_single_block_metered>( - import_handle: &mut impl BlockImport, - block_origin: BlockOrigin, - block: IncomingBlock, - verifier: &mut V, - metrics: Option, -) -> BlockImportResult { - let peer = block.origin; - - let (header, justifications) = match (block.header, block.justifications) { - (Some(header), justifications) => (header, justifications), - (None, _) => { - if let Some(ref peer) = peer { - debug!(target: LOG_TARGET, "Header {} was not provided by {} ", block.hash, peer); - } else { - debug!(target: LOG_TARGET, "Header {} was not provided ", block.hash); - } - return Err(BlockImportError::IncompleteHeader(peer)) - }, - }; - - trace!(target: LOG_TARGET, "Header {} has {:?} logs", block.hash, header.digest().logs().len()); - - let number = *header.number(); - let hash = block.hash; - let parent_hash = *header.parent_hash(); - - let import_handler = |import| match import { +fn import_handler( + number: NumberFor, + hash: Block::Hash, + parent_hash: Block::Hash, + block_origin: Option, + import: Result, +) -> Result>, BlockImportError> +where + Block: BlockT, +{ + match import { Ok(ImportResult::AlreadyInChain) => { trace!(target: LOG_TARGET, "Block already in chain {}: {:?}", number, hash); - Ok(BlockImportStatus::ImportedKnown(number, peer)) + Ok(BlockImportStatus::ImportedKnown(number, block_origin)) }, Ok(ImportResult::Imported(aux)) => - Ok(BlockImportStatus::ImportedUnknown(number, aux, peer)), + Ok(BlockImportStatus::ImportedUnknown(number, aux, block_origin)), Ok(ImportResult::MissingState) => { debug!( target: LOG_TARGET, @@ -277,15 +267,60 @@ pub(crate) async fn import_single_block_metered>( }, Ok(ImportResult::KnownBad) => { debug!(target: LOG_TARGET, "Peer gave us a bad block {}: {:?}", number, hash); - Err(BlockImportError::BadBlock(peer)) + Err(BlockImportError::BadBlock(block_origin)) }, Err(e) => { debug!(target: LOG_TARGET, "Error importing block {}: {:?}: {}", number, hash, e); Err(BlockImportError::Other(e)) }, + } +} + +pub(crate) enum SingleBlockVerificationOutcome { + /// Block is already imported. + Imported(BlockImportStatus>), + /// Block is verified, but needs to be imported. + Verified(SingleBlockImportParameters), +} + +pub(crate) struct SingleBlockImportParameters { + import_block: BlockImportParams, + hash: Block::Hash, + block_origin: Option, + verification_time: Duration, +} + +/// Single block import function with metering. +pub(crate) async fn verify_single_block_metered>( + import_handle: &impl BlockImport, + block_origin: BlockOrigin, + block: IncomingBlock, + verifier: &V, + metrics: Option<&Metrics>, +) -> Result, BlockImportError> { + let peer = block.origin; + let justifications = block.justifications; + + let Some(header) = block.header else { + if let Some(ref peer) = peer { + debug!(target: LOG_TARGET, "Header {} was not provided by {peer} ", block.hash); + } else { + debug!(target: LOG_TARGET, "Header {} was not provided ", block.hash); + } + return Err(BlockImportError::IncompleteHeader(peer)) }; - match import_handler( + trace!(target: LOG_TARGET, "Header {} has {:?} logs", block.hash, header.digest().logs().len()); + + let number = *header.number(); + let hash = block.hash; + let parent_hash = *header.parent_hash(); + + match import_handler::( + number, + hash, + parent_hash, + peer, import_handle .check_block(BlockCheckParams { hash, @@ -298,10 +333,13 @@ pub(crate) async fn import_single_block_metered>( .await, )? { BlockImportStatus::ImportedUnknown { .. } => (), - r => return Ok(r), // Any other successful result means that the block is already imported. + r => { + // Any other successful result means that the block is already imported. + return Ok(SingleBlockVerificationOutcome::Imported(r)) + }, } - let started = std::time::Instant::now(); + let started = Instant::now(); let mut import_block = BlockImportParams::new(block_origin, header); import_block.body = block.body; @@ -332,19 +370,42 @@ pub(crate) async fn import_single_block_metered>( } else { trace!(target: LOG_TARGET, "Verifying {}({}) failed: {}", number, hash, msg); } - if let Some(metrics) = metrics.as_ref() { + if let Some(metrics) = metrics { metrics.report_verification(false, started.elapsed()); } BlockImportError::VerificationFailed(peer, msg) })?; - if let Some(metrics) = metrics.as_ref() { - metrics.report_verification(true, started.elapsed()); + let verification_time = started.elapsed(); + if let Some(metrics) = metrics { + metrics.report_verification(true, verification_time); } + Ok(SingleBlockVerificationOutcome::Verified(SingleBlockImportParameters { + import_block, + hash, + block_origin: peer, + verification_time, + })) +} + +pub(crate) async fn import_single_block_metered( + import_handle: &mut impl BlockImport, + import_parameters: SingleBlockImportParameters, + metrics: Option<&Metrics>, +) -> BlockImportResult { + let started = Instant::now(); + + let SingleBlockImportParameters { import_block, hash, block_origin, verification_time } = + import_parameters; + + let number = *import_block.header.number(); + let parent_hash = *import_block.header.parent_hash(); + let imported = import_handle.import_block(import_block).await; - if let Some(metrics) = metrics.as_ref() { - metrics.report_verification_and_import(started.elapsed()); + if let Some(metrics) = metrics { + metrics.report_verification_and_import(started.elapsed() + verification_time); } - import_handler(imported) + + import_handler::(number, hash, parent_hash, block_origin, imported) } diff --git a/substrate/client/consensus/common/src/import_queue/basic_queue.rs b/substrate/client/consensus/common/src/import_queue/basic_queue.rs index f4f618d1b31825e17987130b20a96c21e475b098..7b371145e2e7df871d8c959bdc04fd405451ff39 100644 --- a/substrate/client/consensus/common/src/import_queue/basic_queue.rs +++ b/substrate/client/consensus/common/src/import_queue/basic_queue.rs @@ -19,7 +19,6 @@ use futures::{ prelude::*, task::{Context, Poll}, }; -use futures_timer::Delay; use log::{debug, trace}; use prometheus_endpoint::Registry; use sc_utils::mpsc::{tracing_unbounded, TracingUnboundedReceiver, TracingUnboundedSender}; @@ -28,14 +27,14 @@ use sp_runtime::{ traits::{Block as BlockT, Header as HeaderT, NumberFor}, Justification, Justifications, }; -use std::{pin::Pin, time::Duration}; +use std::pin::Pin; use crate::{ import_queue::{ buffered_link::{self, BufferedLinkReceiver, BufferedLinkSender}, - import_single_block_metered, BlockImportError, BlockImportStatus, BoxBlockImport, - BoxJustificationImport, ImportQueue, ImportQueueService, IncomingBlock, Link, - RuntimeOrigin, Verifier, LOG_TARGET, + import_single_block_metered, verify_single_block_metered, BlockImportError, + BlockImportStatus, BoxBlockImport, BoxJustificationImport, ImportQueue, ImportQueueService, + IncomingBlock, Link, RuntimeOrigin, SingleBlockVerificationOutcome, Verifier, LOG_TARGET, }, metrics::Metrics, }; @@ -61,13 +60,16 @@ impl BasicQueue { /// Instantiate a new basic queue, with given verifier. /// /// This creates a background task, and calls `on_start` on the justification importer. - pub fn new>( + pub fn new( verifier: V, block_import: BoxBlockImport, justification_import: Option>, spawner: &impl sp_core::traits::SpawnEssentialNamed, prometheus_registry: Option<&Registry>, - ) -> Self { + ) -> Self + where + V: Verifier + 'static, + { let (result_sender, result_port) = buffered_link::buffered_link(100_000); let metrics = prometheus_registry.and_then(|r| { @@ -220,11 +222,10 @@ mod worker_messages { /// Returns when `block_import` ended. async fn block_import_process( mut block_import: BoxBlockImport, - mut verifier: impl Verifier, + verifier: impl Verifier, mut result_sender: BufferedLinkSender, mut block_import_receiver: TracingUnboundedReceiver>, metrics: Option, - delay_between_blocks: Duration, ) { loop { let worker_messages::ImportBlocks(origin, blocks) = match block_import_receiver.next().await @@ -239,15 +240,8 @@ async fn block_import_process( }, }; - let res = import_many_blocks( - &mut block_import, - origin, - blocks, - &mut verifier, - delay_between_blocks, - metrics.clone(), - ) - .await; + let res = + import_many_blocks(&mut block_import, origin, blocks, &verifier, metrics.clone()).await; result_sender.blocks_processed(res.imported, res.block_count, res.results); } @@ -260,7 +254,7 @@ struct BlockImportWorker { } impl BlockImportWorker { - fn new>( + fn new( result_sender: BufferedLinkSender, verifier: V, block_import: BoxBlockImport, @@ -270,19 +264,20 @@ impl BlockImportWorker { impl Future + Send, TracingUnboundedSender>, TracingUnboundedSender>, - ) { + ) + where + V: Verifier + 'static, + { use worker_messages::*; let (justification_sender, mut justification_port) = tracing_unbounded("mpsc_import_queue_worker_justification", 100_000); - let (block_import_sender, block_import_port) = + let (block_import_sender, block_import_receiver) = tracing_unbounded("mpsc_import_queue_worker_blocks", 100_000); let mut worker = BlockImportWorker { result_sender, justification_import, metrics }; - let delay_between_blocks = Duration::default(); - let future = async move { // Let's initialize `justification_import` if let Some(justification_import) = worker.justification_import.as_mut() { @@ -295,9 +290,8 @@ impl BlockImportWorker { block_import, verifier, worker.result_sender.clone(), - block_import_port, + block_import_receiver, worker.metrics.clone(), - delay_between_blocks, ); futures::pin_mut!(block_import_process); @@ -393,8 +387,7 @@ async fn import_many_blocks>( import_handle: &mut BoxBlockImport, blocks_origin: BlockOrigin, blocks: Vec>, - verifier: &mut V, - delay_between_blocks: Duration, + verifier: &V, metrics: Option, ) -> ImportManyBlocksResult { let count = blocks.len(); @@ -431,15 +424,22 @@ async fn import_many_blocks>( let import_result = if has_error { Err(BlockImportError::Cancelled) } else { - // The actual import. - import_single_block_metered( + let verification_fut = verify_single_block_metered( import_handle, blocks_origin, block, verifier, - metrics.clone(), - ) - .await + metrics.as_ref(), + ); + match verification_fut.await { + Ok(SingleBlockVerificationOutcome::Imported(import_status)) => Ok(import_status), + Ok(SingleBlockVerificationOutcome::Verified(import_parameters)) => { + // The actual import. + import_single_block_metered(import_handle, import_parameters, metrics.as_ref()) + .await + }, + Err(e) => Err(e), + } }; if let Some(metrics) = metrics.as_ref() { @@ -460,11 +460,7 @@ async fn import_many_blocks>( results.push((import_result, block_hash)); - if delay_between_blocks != Duration::default() && !has_error { - Delay::new(delay_between_blocks).await; - } else { - Yield::new().await - } + Yield::new().await } } @@ -510,7 +506,7 @@ mod tests { #[async_trait::async_trait] impl Verifier for () { async fn verify( - &mut self, + &self, block: BlockImportParams, ) -> Result, String> { Ok(BlockImportParams::new(block.origin, block.header)) @@ -522,14 +518,14 @@ mod tests { type Error = sp_consensus::Error; async fn check_block( - &mut self, + &self, _block: BlockCheckParams, ) -> Result { Ok(ImportResult::imported(false)) } async fn import_block( - &mut self, + &self, _block: BlockImportParams, ) -> Result { Ok(ImportResult::imported(true)) diff --git a/substrate/client/consensus/epochs/Cargo.toml b/substrate/client/consensus/epochs/Cargo.toml index ff6bf86a6a441d49a8950c38d2333bd0e067724d..c51671d6d75d83ddfe4d7644428ab9b4122a7d1d 100644 --- a/substrate/client/consensus/epochs/Cargo.toml +++ b/substrate/client/consensus/epochs/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Generic epochs-based utilities for consensus" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,9 +16,9 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] } -fork-tree = { path = "../../../utils/fork-tree" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-runtime = { path = "../../../primitives/runtime" } +codec = { features = ["derive"], workspace = true, default-features = true } +fork-tree = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } diff --git a/substrate/client/consensus/grandpa/Cargo.toml b/substrate/client/consensus/grandpa/Cargo.toml index 235017d20ceaac42e67d05ba5dc277502b77e377..65ba39d34c214014c0a2f29e67fbe211e4763b25 100644 --- a/substrate/client/consensus/grandpa/Cargo.toml +++ b/substrate/client/consensus/grandpa/Cargo.toml @@ -4,7 +4,7 @@ version = "0.19.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Integration of the GRANDPA finality gadget into substrate." documentation = "https://docs.rs/sc-consensus-grandpa" @@ -17,51 +17,51 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -ahash = "0.8.2" -array-bytes = "6.2.2" -async-trait = "0.1.79" -dyn-clone = "1.0" -finality-grandpa = { version = "0.16.2", features = ["derive-codec"] } -futures = "0.3.30" -futures-timer = "3.0.1" +ahash = { workspace = true } +array-bytes = { workspace = true, default-features = true } +async-trait = { workspace = true } +dyn-clone = { workspace = true } +finality-grandpa = { features = ["derive-codec"], workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -parity-scale-codec = { version = "3.6.1", features = ["derive"] } -parking_lot = "0.12.1" -rand = "0.8.5" +codec = { features = ["derive"], workspace = true, default-features = true } +parking_lot = { workspace = true, default-features = true } +rand = { workspace = true, default-features = true } serde_json = { workspace = true, default-features = true } thiserror = { workspace = true } -fork-tree = { path = "../../../utils/fork-tree" } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-block-builder = { path = "../../block-builder" } -sc-chain-spec = { path = "../../chain-spec" } -sc-client-api = { path = "../../api" } -sc-transaction-pool-api = { path = "../../transaction-pool/api" } -sc-consensus = { path = "../common" } -sc-network = { path = "../../network" } -sc-network-gossip = { path = "../../network-gossip" } -sc-network-common = { path = "../../network/common" } -sc-network-sync = { path = "../../network/sync" } -sc-network-types = { path = "../../network/types" } -sc-telemetry = { path = "../../telemetry" } -sc-utils = { path = "../../utils" } -sp-api = { path = "../../../primitives/api" } -sp-application-crypto = { path = "../../../primitives/application-crypto" } -sp-arithmetic = { path = "../../../primitives/arithmetic" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-core = { path = "../../../primitives/core" } -sp-crypto-hashing = { path = "../../../primitives/crypto/hashing" } -sp-consensus-grandpa = { path = "../../../primitives/consensus/grandpa" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } +fork-tree = { workspace = true, default-features = true } +prometheus-endpoint = { workspace = true, default-features = true } +sc-block-builder = { workspace = true, default-features = true } +sc-chain-spec = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-gossip = { workspace = true, default-features = true } +sc-network-common = { workspace = true, default-features = true } +sc-network-sync = { workspace = true, default-features = true } +sc-network-types = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sc-utils = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-application-crypto = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -assert_matches = "1.3.0" -finality-grandpa = { version = "0.16.2", features = ["derive-codec", "test-helpers"] } +assert_matches = { workspace = true } +finality-grandpa = { features = ["derive-codec", "test-helpers"], workspace = true, default-features = true } serde = { workspace = true, default-features = true } -tokio = "1.37" -sc-network = { path = "../../network" } -sc-network-test = { path = "../../network/test" } -sp-keyring = { path = "../../../primitives/keyring" } -sp-tracing = { path = "../../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } +tokio = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sc-network-test = { workspace = true } +sp-keyring = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/consensus/grandpa/rpc/Cargo.toml b/substrate/client/consensus/grandpa/rpc/Cargo.toml index 9b73418c958e5def75e96416523f9ecaacde14f8..86513ac5df153f600f898bffa88513bd19d263e4 100644 --- a/substrate/client/consensus/grandpa/rpc/Cargo.toml +++ b/substrate/client/consensus/grandpa/rpc/Cargo.toml @@ -7,31 +7,31 @@ repository.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" readme = "README.md" -homepage = "https://substrate.io" +homepage.workspace = true [lints] workspace = true [dependencies] -finality-grandpa = { version = "0.16.2", features = ["derive-codec"] } -futures = "0.3.30" -jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] } +finality-grandpa = { features = ["derive-codec"], workspace = true, default-features = true } +futures = { workspace = true } +jsonrpsee = { features = ["client-core", "macros", "server-core"], workspace = true } log = { workspace = true, default-features = true } -parity-scale-codec = { version = "3.6.1", features = ["derive"] } +codec = { features = ["derive"], workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } -sc-client-api = { path = "../../../api" } -sc-consensus-grandpa = { path = ".." } -sc-rpc = { path = "../../../rpc" } -sp-blockchain = { path = "../../../../primitives/blockchain" } -sp-core = { path = "../../../../primitives/core" } -sp-runtime = { path = "../../../../primitives/runtime" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus-grandpa = { workspace = true, default-features = true } +sc-rpc = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } [dev-dependencies] -sc-block-builder = { path = "../../../block-builder" } -sc-rpc = { path = "../../../rpc", features = ["test-helpers"] } -sp-core = { path = "../../../../primitives/core" } -sp-consensus-grandpa = { path = "../../../../primitives/consensus/grandpa" } -sp-keyring = { path = "../../../../primitives/keyring" } -substrate-test-runtime-client = { path = "../../../../test-utils/runtime/client" } -tokio = { version = "1.22.0", features = ["macros"] } +sc-block-builder = { workspace = true, default-features = true } +sc-rpc = { features = ["test-helpers"], workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-consensus-grandpa = { workspace = true, default-features = true } +sp-keyring = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +tokio = { features = ["macros"], workspace = true, default-features = true } diff --git a/substrate/client/consensus/grandpa/rpc/src/lib.rs b/substrate/client/consensus/grandpa/rpc/src/lib.rs index 68de068c3058377a6be9c8907581498d3466aaba..99f98b81261a2fd34a7f8495c3c5cc859c91b881 100644 --- a/substrate/client/consensus/grandpa/rpc/src/lib.rs +++ b/substrate/client/consensus/grandpa/rpc/src/lib.rs @@ -38,7 +38,10 @@ use finality::{EncodedFinalityProof, RpcFinalityProofProvider}; use notification::JustificationNotification; use report::{ReportAuthoritySet, ReportVoterState, ReportedRoundStates}; use sc_consensus_grandpa::GrandpaJustificationStream; -use sc_rpc::{utils::pipe_from_stream, SubscriptionTaskExecutor}; +use sc_rpc::{ + utils::{BoundedVecDeque, PendingSubscription}, + SubscriptionTaskExecutor, +}; use sp_runtime::traits::{Block as BlockT, NumberFor}; /// Provides RPC methods for interacting with GRANDPA. @@ -108,7 +111,10 @@ where }, ); - sc_rpc::utils::spawn_subscription_task(&self.executor, pipe_from_stream(pending, stream)); + sc_rpc::utils::spawn_subscription_task( + &self.executor, + PendingSubscription::from(pending).pipe_from_stream(stream, BoundedVecDeque::default()), + ); } async fn prove_finality( @@ -127,8 +133,8 @@ mod tests { use super::*; use std::{collections::HashSet, sync::Arc}; + use codec::{Decode, Encode}; use jsonrpsee::{core::EmptyServerParams as EmptyParams, types::SubscriptionId, RpcModule}; - use parity_scale_codec::{Decode, Encode}; use sc_block_builder::BlockBuilderBuilder; use sc_consensus_grandpa::{ report, AuthorityId, FinalityProof, GrandpaJustification, GrandpaJustificationSender, @@ -269,7 +275,7 @@ mod tests { #[tokio::test] async fn uninitialized_rpc_handler() { let (rpc, _) = setup_io_handler(EmptyVoterState); - let expected_response = r#"{"jsonrpc":"2.0","error":{"code":1,"message":"GRANDPA RPC endpoint not ready"},"id":0}"#.to_string(); + let expected_response = r#"{"jsonrpc":"2.0","id":0,"error":{"code":1,"message":"GRANDPA RPC endpoint not ready"}}"#.to_string(); let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#; let (response, _) = rpc.raw_json_request(&request, 1).await.unwrap(); @@ -279,7 +285,7 @@ mod tests { #[tokio::test] async fn working_rpc_handler() { let (rpc, _) = setup_io_handler(TestVoterState); - let expected_response = "{\"jsonrpc\":\"2.0\",\"result\":{\ + let expected_response = "{\"jsonrpc\":\"2.0\",\"id\":0,\"result\":{\ \"setId\":1,\ \"best\":{\ \"round\":2,\"totalWeight\":100,\"thresholdWeight\":67,\ @@ -291,7 +297,7 @@ mod tests { \"prevotes\":{\"currentWeight\":100,\"missing\":[]},\ \"precommits\":{\"currentWeight\":100,\"missing\":[]}\ }]\ - },\"id\":0}".to_string(); + }}".to_string(); let request = r#"{"jsonrpc":"2.0","method":"grandpa_roundState","params":[],"id":0}"#; let (response, _) = rpc.raw_json_request(&request, 1).await.unwrap(); @@ -315,7 +321,7 @@ mod tests { ) .await .unwrap(); - let expected = r#"{"jsonrpc":"2.0","result":false,"id":1}"#; + let expected = r#"{"jsonrpc":"2.0","id":1,"result":false}"#; assert_eq!(response, expected); } diff --git a/substrate/client/consensus/grandpa/rpc/src/notification.rs b/substrate/client/consensus/grandpa/rpc/src/notification.rs index 42b9123ed8c145a174ea8c7a11be3bfa740fce97..5bcf90f4d79d06a4e9b2e5bdfc5d83551e276423 100644 --- a/substrate/client/consensus/grandpa/rpc/src/notification.rs +++ b/substrate/client/consensus/grandpa/rpc/src/notification.rs @@ -16,7 +16,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use parity_scale_codec::Encode; +use codec::Encode; use sc_consensus_grandpa::GrandpaJustification; use serde::{Deserialize, Serialize}; use sp_runtime::traits::Block as BlockT; diff --git a/substrate/client/consensus/grandpa/src/authorities.rs b/substrate/client/consensus/grandpa/src/authorities.rs index 623223e41eb8234d85b3aa51a35bd4c1116e8ee7..2ac15d761b2e2e7306207290db7bb8726ff68d2a 100644 --- a/substrate/client/consensus/grandpa/src/authorities.rs +++ b/substrate/client/consensus/grandpa/src/authorities.rs @@ -20,10 +20,10 @@ use std::{cmp::Ord, fmt::Debug, ops::Add}; +use codec::{Decode, Encode}; use finality_grandpa::voter_set::VoterSet; use fork_tree::{FilterAction, ForkTree}; use log::debug; -use parity_scale_codec::{Decode, Encode}; use parking_lot::MappedMutexGuard; use sc_consensus::shared_data::{SharedData, SharedDataLocked}; use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_INFO}; @@ -662,9 +662,7 @@ pub struct PendingChange { } impl Decode for PendingChange { - fn decode( - value: &mut I, - ) -> Result { + fn decode(value: &mut I) -> Result { let next_authorities = Decode::decode(value)?; let delay = Decode::decode(value)?; let canon_height = Decode::decode(value)?; diff --git a/substrate/client/consensus/grandpa/src/aux_schema.rs b/substrate/client/consensus/grandpa/src/aux_schema.rs index 97a8bc660317ac36d551d6e0fb50f73a92fffe74..8ec882591be9a682456e55f41fd47becd803a6c4 100644 --- a/substrate/client/consensus/grandpa/src/aux_schema.rs +++ b/substrate/client/consensus/grandpa/src/aux_schema.rs @@ -20,9 +20,9 @@ use std::fmt::Debug; +use codec::{Decode, Encode}; use finality_grandpa::round::State as RoundState; use log::{info, warn}; -use parity_scale_codec::{Decode, Encode}; use fork_tree::ForkTree; use sc_client_api::backend::AuxStore; diff --git a/substrate/client/consensus/grandpa/src/communication/gossip.rs b/substrate/client/consensus/grandpa/src/communication/gossip.rs index c7fe5a46a5eb6db29501effde313cdc6c08894d9..a6aa063357cb8e9327bd2f22ac4cedb18e19d8e2 100644 --- a/substrate/client/consensus/grandpa/src/communication/gossip.rs +++ b/substrate/client/consensus/grandpa/src/communication/gossip.rs @@ -86,8 +86,8 @@ //! We only send polite messages to peers, use ahash::{AHashMap, AHashSet}; +use codec::{Decode, DecodeAll, Encode}; use log::{debug, trace}; -use parity_scale_codec::{Decode, DecodeAll, Encode}; use prometheus_endpoint::{register, CounterVec, Opts, PrometheusError, Registry, U64}; use rand::seq::SliceRandom; use sc_network::ReputationChange; diff --git a/substrate/client/consensus/grandpa/src/communication/mod.rs b/substrate/client/consensus/grandpa/src/communication/mod.rs index cf78e1d4cf089a1097d662756bcf05f5528b48e0..3b0ea2c5ee960ac289992ef52c7c16e27693df0e 100644 --- a/substrate/client/consensus/grandpa/src/communication/mod.rs +++ b/substrate/client/consensus/grandpa/src/communication/mod.rs @@ -40,12 +40,12 @@ use std::{ time::Duration, }; +use codec::{Decode, DecodeAll, Encode}; use finality_grandpa::{ voter, voter_set::VoterSet, Message::{Precommit, Prevote, PrimaryPropose}, }; -use parity_scale_codec::{Decode, DecodeAll, Encode}; use sc_network::{NetworkBlock, NetworkSyncForkRequest, NotificationService, ReputationChange}; use sc_network_gossip::{GossipEngine, Network as GossipNetwork}; use sc_telemetry::{telemetry, TelemetryHandle, CONSENSUS_DEBUG, CONSENSUS_INFO}; diff --git a/substrate/client/consensus/grandpa/src/communication/tests.rs b/substrate/client/consensus/grandpa/src/communication/tests.rs index bc3023fc0281d150864cb3bb21214c3648a73c42..5d1562f05188185ca765781d4f5b1d0d5962513f 100644 --- a/substrate/client/consensus/grandpa/src/communication/tests.rs +++ b/substrate/client/consensus/grandpa/src/communication/tests.rs @@ -23,8 +23,8 @@ use super::{ Round, SetId, VoterSet, }; use crate::{communication::grandpa_protocol_name, environment::SharedVoterSetState}; +use codec::{DecodeAll, Encode}; use futures::prelude::*; -use parity_scale_codec::{DecodeAll, Encode}; use sc_network::{ config::{MultiaddrWithPeerId, Role}, event::Event as NetworkEvent, @@ -706,25 +706,12 @@ fn peer_with_higher_view_leads_to_catch_up_request() { } fn local_chain_spec() -> Box { - use sc_chain_spec::{ChainSpec, GenericChainSpec}; - use serde::{Deserialize, Serialize}; - use sp_runtime::{BuildStorage, Storage}; - - #[derive(Debug, Serialize, Deserialize)] - struct Genesis(std::collections::BTreeMap); - impl BuildStorage for Genesis { - fn assimilate_storage(&self, storage: &mut Storage) -> Result<(), String> { - storage.top.extend( - self.0.iter().map(|(a, b)| (a.clone().into_bytes(), b.clone().into_bytes())), - ); - Ok(()) - } - } - let chain_spec = GenericChainSpec::::from_json_bytes( - &include_bytes!("../../../../chain-spec/res/chain_spec.json")[..], - ) - .unwrap(); - chain_spec.cloned_box() + let chain_spec = + sc_chain_spec::GenericChainSpec::::from_json_bytes( + &include_bytes!("../../../../chain-spec/res/chain_spec.json")[..], + ) + .unwrap(); + sc_chain_spec::ChainSpec::cloned_box(&chain_spec) } #[test] diff --git a/substrate/client/consensus/grandpa/src/environment.rs b/substrate/client/consensus/grandpa/src/environment.rs index 31df038044a4904e49f8447c4ab05c4cd36a5142..a618b7ff07ad8f5411b54d63b98faf44a0d169ad 100644 --- a/substrate/client/consensus/grandpa/src/environment.rs +++ b/substrate/client/consensus/grandpa/src/environment.rs @@ -24,13 +24,13 @@ use std::{ time::Duration, }; +use codec::{Decode, Encode}; use finality_grandpa::{ round::State as RoundState, voter, voter_set::VoterSet, BlockNumberOps, Error as GrandpaError, }; use futures::prelude::*; use futures_timer::Delay; use log::{debug, warn}; -use parity_scale_codec::{Decode, Encode}; use parking_lot::RwLock; use prometheus_endpoint::{register, Counter, Gauge, PrometheusError, U64}; @@ -104,12 +104,10 @@ impl Encode for CompletedRounds { } } -impl parity_scale_codec::EncodeLike for CompletedRounds {} +impl codec::EncodeLike for CompletedRounds {} impl Decode for CompletedRounds { - fn decode( - value: &mut I, - ) -> Result { + fn decode(value: &mut I) -> Result { <(Vec>, SetId, Vec)>::decode(value) .map(|(rounds, set_id, voters)| CompletedRounds { rounds, set_id, voters }) } @@ -1216,14 +1214,20 @@ where .header(target_hash)? .expect("Header known to exist after `finality_target` call; qed"), Err(err) => { - warn!( + debug!( target: LOG_TARGET, "Encountered error finding best chain containing {:?}: couldn't find target block: {}", block, err, ); - return Ok(None) + // NOTE: in case the given `SelectChain` doesn't provide any block we fallback to using + // the given base block provided by the GRANDPA voter. + // + // For example, `LongestChain` will error if the given block to use as base isn't part + // of the best chain (as defined by `LongestChain`), which could happen if there was a + // re-org. + base_header.clone() }, }; diff --git a/substrate/client/consensus/grandpa/src/finality_proof.rs b/substrate/client/consensus/grandpa/src/finality_proof.rs index 80b6249ade86ca9d44e9ed1284c0e6189731c86c..8a47d121e86932cdc9ca86bfa3f4d42c1bd9c6e7 100644 --- a/substrate/client/consensus/grandpa/src/finality_proof.rs +++ b/substrate/client/consensus/grandpa/src/finality_proof.rs @@ -39,7 +39,7 @@ use log::{trace, warn}; use std::sync::Arc; -use parity_scale_codec::{Decode, Encode}; +use codec::{Decode, Encode}; use sc_client_api::backend::Backend; use sp_blockchain::{Backend as BlockchainBackend, HeaderBackend}; use sp_consensus_grandpa::GRANDPA_ENGINE_ID; @@ -319,7 +319,7 @@ mod tests { ) -> (Arc, Arc, Vec) { let builder = TestClientBuilder::new(); let backend = builder.backend(); - let mut client = Arc::new(builder.build()); + let client = Arc::new(builder.build()); let mut blocks = Vec::new(); for _ in 0..number_of_blocks { diff --git a/substrate/client/consensus/grandpa/src/import.rs b/substrate/client/consensus/grandpa/src/import.rs index bc2983569c533bcefbac2d98cad908e5ee6bcd01..5cec5204c7396774d210c5b3152a46a95fc8dc4a 100644 --- a/substrate/client/consensus/grandpa/src/import.rs +++ b/substrate/client/consensus/grandpa/src/import.rs @@ -18,8 +18,9 @@ use std::{collections::HashMap, marker::PhantomData, sync::Arc}; +use codec::Decode; use log::debug; -use parity_scale_codec::Decode; +use parking_lot::Mutex; use sc_client_api::{backend::Backend, utils::is_descendent_of}; use sc_consensus::{ @@ -62,7 +63,8 @@ pub struct GrandpaBlockImport { select_chain: SC, authority_set: SharedAuthoritySet>, send_voter_commands: TracingUnboundedSender>>, - authority_set_hard_forks: HashMap>>, + authority_set_hard_forks: + Mutex>>>, justification_sender: GrandpaJustificationSender, telemetry: Option, _phantom: PhantomData, @@ -78,7 +80,7 @@ impl Clone select_chain: self.select_chain.clone(), authority_set: self.authority_set.clone(), send_voter_commands: self.send_voter_commands.clone(), - authority_set_hard_forks: self.authority_set_hard_forks.clone(), + authority_set_hard_forks: Mutex::new(self.authority_set_hard_forks.lock().clone()), justification_sender: self.justification_sender.clone(), telemetry: self.telemetry.clone(), _phantom: PhantomData, @@ -242,7 +244,7 @@ where hash: Block::Hash, ) -> Option>> { // check for forced authority set hard forks - if let Some(change) = self.authority_set_hard_forks.get(&hash) { + if let Some(change) = self.authority_set_hard_forks.lock().get(&hash) { return Some(change.clone()) } @@ -461,7 +463,7 @@ where /// Import whole new state and reset authority set. async fn import_state( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let hash = block.post_hash(); @@ -474,7 +476,7 @@ where // We've just imported a new state. We trust the sync module has verified // finality proofs and that the state is correct and final. // So we can read the authority list and set id from the state. - self.authority_set_hard_forks.clear(); + self.authority_set_hard_forks.lock().clear(); let authorities = self .inner .runtime_api() @@ -518,12 +520,12 @@ where Client: ClientForGrandpa, Client::Api: GrandpaApi, for<'a> &'a Client: BlockImport, - SC: Send, + SC: Send + Sync, { type Error = ConsensusError; async fn import_block( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let hash = block.post_hash(); @@ -697,7 +699,7 @@ where } async fn check_block( - &mut self, + &self, block: BlockCheckParams, ) -> Result { self.inner.check_block(block).await @@ -750,7 +752,7 @@ impl GrandpaBlockImport, justification: Justification, diff --git a/substrate/client/consensus/grandpa/src/justification.rs b/substrate/client/consensus/grandpa/src/justification.rs index a38cb113b40a7ad1b73a5d9302468c09a3c926a9..934c0d695fdab754e3d82e93402f1188c9a81d8c 100644 --- a/substrate/client/consensus/grandpa/src/justification.rs +++ b/substrate/client/consensus/grandpa/src/justification.rs @@ -22,8 +22,8 @@ use std::{ sync::Arc, }; +use codec::{Decode, DecodeAll, Encode}; use finality_grandpa::{voter_set::VoterSet, Error as GrandpaError}; -use parity_scale_codec::{Decode, DecodeAll, Encode}; use sp_blockchain::{Error as ClientError, HeaderBackend}; use sp_consensus_grandpa::AuthorityId; use sp_runtime::traits::{Block as BlockT, Header as HeaderT, NumberFor}; diff --git a/substrate/client/consensus/grandpa/src/lib.rs b/substrate/client/consensus/grandpa/src/lib.rs index 03452bd07c757fa9dac9b130a149aa264eb04834..a07dc035de35ce85c5f1b1d052298fd77c834b30 100644 --- a/substrate/client/consensus/grandpa/src/lib.rs +++ b/substrate/client/consensus/grandpa/src/lib.rs @@ -56,9 +56,9 @@ #![warn(missing_docs)] +use codec::Decode; use futures::{prelude::*, StreamExt}; use log::{debug, error, info}; -use parity_scale_codec::Decode; use parking_lot::RwLock; use prometheus_endpoint::{PrometheusError, Registry}; use sc_client_api::{ diff --git a/substrate/client/consensus/grandpa/src/tests.rs b/substrate/client/consensus/grandpa/src/tests.rs index 14708cc89e890bd3fe7963589010896f78bb6ab1..9cca28a395995c54c5ae7b416b203d366a7202b5 100644 --- a/substrate/client/consensus/grandpa/src/tests.rs +++ b/substrate/client/consensus/grandpa/src/tests.rs @@ -906,7 +906,7 @@ async fn allows_reimporting_change_blocks() { let mut net = GrandpaTestNet::new(api.clone(), 3, 0); let client = net.peer(0).client().clone(); - let (mut block_import, ..) = net.make_block_import(client.clone()); + let (block_import, ..) = net.make_block_import(client.clone()); let full_client = client.as_client(); let mut builder = BlockBuilderBuilder::new(&*full_client) @@ -954,7 +954,7 @@ async fn test_bad_justification() { let mut net = GrandpaTestNet::new(api.clone(), 3, 0); let client = net.peer(0).client().clone(); - let (mut block_import, ..) = net.make_block_import(client.clone()); + let (block_import, ..) = net.make_block_import(client.clone()); let full_client = client.as_client(); let mut builder = BlockBuilderBuilder::new(&*full_client) @@ -1820,6 +1820,116 @@ async fn grandpa_environment_checks_if_best_block_is_descendent_of_finality_targ ); } +// This is a regression test for an issue that was triggered by a reorg +// - https://github.com/paritytech/polkadot-sdk/issues/3487 +// - https://github.com/humanode-network/humanode/issues/1104 +#[tokio::test] +async fn grandpa_environment_uses_round_base_block_for_voting_if_finality_target_errors() { + use finality_grandpa::voter::Environment; + use sp_consensus::SelectChain; + + let peers = &[Ed25519Keyring::Alice]; + let voters = make_ids(peers); + + let mut net = GrandpaTestNet::new(TestApi::new(voters), 1, 0); + let peer = net.peer(0); + let network_service = peer.network_service().clone(); + let sync_service = peer.sync_service().clone(); + let notification_service = + peer.take_notification_service(&grandpa_protocol_name::NAME.into()).unwrap(); + let link = peer.data.lock().take().unwrap(); + let client = peer.client().as_client().clone(); + let select_chain = sc_consensus::LongestChain::new(peer.client().as_backend()); + + // create a chain that is 10 blocks long + peer.push_blocks(10, false); + + let env = test_environment_with_select_chain( + &link, + None, + network_service.clone(), + sync_service, + notification_service, + select_chain.clone(), + VotingRulesBuilder::default().build(), + ); + + let hashof7 = client.expect_block_hash_from_id(&BlockId::Number(7)).unwrap(); + let hashof8_a = client.expect_block_hash_from_id(&BlockId::Number(8)).unwrap(); + + // finalize the 7th block + peer.client().finalize_block(hashof7, None, false).unwrap(); + + assert_eq!(peer.client().info().finalized_hash, hashof7); + + // simulate completed grandpa round + env.completed( + 1, + finality_grandpa::round::State { + prevote_ghost: Some((hashof8_a, 8)), + finalized: Some((hashof7, 7)), + estimate: Some((hashof8_a, 8)), + completable: true, + }, + Default::default(), + &finality_grandpa::HistoricalVotes::new(), + ) + .unwrap(); + + // check simulated last completed round + assert_eq!( + env.voter_set_state.read().last_completed_round().state, + finality_grandpa::round::State { + prevote_ghost: Some((hashof8_a, 8)), + finalized: Some((hashof7, 7)), + estimate: Some((hashof8_a, 8)), + completable: true + } + ); + + // `hashof8_a` should be finalized next, `best_chain_containing` should return `hashof8_a` + assert_eq!(env.best_chain_containing(hashof8_a).await.unwrap().unwrap().0, hashof8_a); + + // simulate reorg on block 8 by creating a fork starting at block 7 that is 10 blocks long + peer.generate_blocks_at( + BlockId::Number(7), + 10, + BlockOrigin::File, + |mut builder| { + builder.push_deposit_log_digest_item(DigestItem::Other(vec![1])).unwrap(); + builder.build().unwrap().block + }, + false, + false, + true, + ForkChoiceStrategy::LongestChain, + ); + + // check that new best chain is on longest chain + assert_eq!(env.select_chain.best_chain().await.unwrap().number, 17); + + // verify that last completed round has `prevote_ghost` and `estimate` blocks related to + // `hashof8_a` + assert_eq!( + env.voter_set_state.read().last_completed_round().state, + finality_grandpa::round::State { + prevote_ghost: Some((hashof8_a, 8)), + finalized: Some((hashof7, 7)), + estimate: Some((hashof8_a, 8)), + completable: true + } + ); + + // `hashof8_a` should be finalized next, `best_chain_containing` should still return `hashof8_a` + assert_eq!(env.best_chain_containing(hashof8_a).await.unwrap().unwrap().0, hashof8_a); + + // simulate finalization of the `hashof8_a` block + peer.client().finalize_block(hashof8_a, None, false).unwrap(); + + // check that best chain is reorged back + assert_eq!(env.select_chain.best_chain().await.unwrap().number, 10); +} + #[tokio::test] async fn grandpa_environment_never_overwrites_round_voter_state() { use finality_grandpa::voter::Environment; @@ -1973,7 +2083,7 @@ async fn imports_justification_for_regular_blocks_on_import() { let mut net = GrandpaTestNet::new(api.clone(), 1, 0); let client = net.peer(0).client().clone(); - let (mut block_import, ..) = net.make_block_import(client.clone()); + let (block_import, ..) = net.make_block_import(client.clone()); let full_client = client.as_client(); // create a new block (without importing it) @@ -2012,7 +2122,7 @@ async fn imports_justification_for_regular_blocks_on_import() { GrandpaJustification::from_commit(&full_client, round, commit).unwrap() }; - let mut generate_and_import_block_with_justification = |parent| { + let generate_and_import_block_with_justification = |parent| { // we import the block with justification attached let block = generate_block(parent); let block_hash = block.hash(); diff --git a/substrate/client/consensus/grandpa/src/voting_rule.rs b/substrate/client/consensus/grandpa/src/voting_rule.rs index c37596d20f68625b21f443e16db3c03fc08357da..c1d3cd2fbd6ab6b5f8d45e555a43aeb289791a80 100644 --- a/substrate/client/consensus/grandpa/src/voting_rule.rs +++ b/substrate/client/consensus/grandpa/src/voting_rule.rs @@ -367,7 +367,7 @@ mod tests { // where each subtracts 50 blocks from the current target let rule = VotingRulesBuilder::new().add(Subtract(50)).add(Subtract(50)).build(); - let mut client = Arc::new(TestClientBuilder::new().build()); + let client = Arc::new(TestClientBuilder::new().build()); let mut hashes = Vec::with_capacity(200); for _ in 0..200 { @@ -416,7 +416,7 @@ mod tests { fn before_best_by_has_cutoff_at_base() { let rule = BeforeBestBlockBy(2); - let mut client = Arc::new(TestClientBuilder::new().build()); + let client = Arc::new(TestClientBuilder::new().build()); let n = 5; let mut hashes = Vec::with_capacity(n); diff --git a/substrate/client/consensus/grandpa/src/warp_proof.rs b/substrate/client/consensus/grandpa/src/warp_proof.rs index 7169a424c14a7726efa9531b80ef13f829bc9529..a79581b1e9f13092b917b64a443af31aa7cd8a27 100644 --- a/substrate/client/consensus/grandpa/src/warp_proof.rs +++ b/substrate/client/consensus/grandpa/src/warp_proof.rs @@ -16,7 +16,7 @@ //! Utilities for generating and verifying GRANDPA warp sync proofs. -use parity_scale_codec::{Decode, DecodeAll, Encode}; +use codec::{Decode, DecodeAll, Encode}; use crate::{ best_justification, find_scheduled_change, AuthoritySetChanges, AuthoritySetHardFork, @@ -38,7 +38,7 @@ use std::{collections::HashMap, sync::Arc}; pub enum Error { /// Decoding error. #[error("Failed to decode block hash: {0}.")] - DecodeScale(#[from] parity_scale_codec::Error), + DecodeScale(#[from] codec::Error), /// Client backend error. #[error("{0}")] Client(#[from] sp_blockchain::Error), @@ -320,7 +320,7 @@ where mod tests { use super::WarpSyncProof; use crate::{AuthoritySetChanges, GrandpaJustification}; - use parity_scale_codec::Encode; + use codec::Encode; use rand::prelude::*; use sc_block_builder::BlockBuilderBuilder; use sp_blockchain::HeaderBackend; @@ -338,7 +338,7 @@ mod tests { let mut rng = rand::rngs::StdRng::from_seed([0; 32]); let builder = TestClientBuilder::new(); let backend = builder.backend(); - let mut client = Arc::new(builder.build()); + let client = Arc::new(builder.build()); let available_authorities = Ed25519Keyring::iter().collect::>(); let genesis_authorities = vec![(Ed25519Keyring::Alice.public().into(), 1)]; diff --git a/substrate/client/consensus/manual-seal/Cargo.toml b/substrate/client/consensus/manual-seal/Cargo.toml index 7aa8df248b7c1486b61116c7ae0ec5cbb87292a6..49111434015af9cbba80a091102259a781972853 100644 --- a/substrate/client/consensus/manual-seal/Cargo.toml +++ b/substrate/client/consensus/manual-seal/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Manual sealing engine for Substrate" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,37 +16,37 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -jsonrpsee = { version = "0.22.5", features = ["client-core", "macros", "server-core"] } -assert_matches = "1.3.0" -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" -futures-timer = "3.0.1" +jsonrpsee = { features = ["client-core", "macros", "server-core"], workspace = true } +assert_matches = { workspace = true } +async-trait = { workspace = true } +codec = { workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } serde = { features = ["derive"], workspace = true, default-features = true } thiserror = { workspace = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sc-consensus-aura = { path = "../aura" } -sc-consensus-babe = { path = "../babe" } -sc-consensus-epochs = { path = "../epochs" } -sc-transaction-pool = { path = "../../transaction-pool" } -sc-transaction-pool-api = { path = "../../transaction-pool/api" } -sp-api = { path = "../../../primitives/api" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-aura = { path = "../../../primitives/consensus/aura" } -sp-consensus-babe = { path = "../../../primitives/consensus/babe" } -sp-consensus-slots = { path = "../../../primitives/consensus/slots" } -sp-core = { path = "../../../primitives/core" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-keystore = { path = "../../../primitives/keystore" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-timestamp = { path = "../../../primitives/timestamp" } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-consensus-aura = { workspace = true, default-features = true } +sc-consensus-babe = { workspace = true, default-features = true } +sc-consensus-epochs = { workspace = true, default-features = true } +sc-transaction-pool = { workspace = true, default-features = true } +sc-transaction-pool-api = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-aura = { workspace = true, default-features = true } +sp-consensus-babe = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-keystore = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-timestamp = { workspace = true, default-features = true } [dev-dependencies] -tokio = { version = "1.22.0", features = ["macros", "rt-multi-thread"] } -sc-basic-authorship = { path = "../../basic-authorship" } -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } -substrate-test-runtime-transaction-pool = { path = "../../../test-utils/runtime/transaction-pool" } +tokio = { features = ["macros", "rt-multi-thread"], workspace = true, default-features = true } +sc-basic-authorship = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +substrate-test-runtime-transaction-pool = { workspace = true } diff --git a/substrate/client/consensus/manual-seal/src/consensus/babe.rs b/substrate/client/consensus/manual-seal/src/consensus/babe.rs index bc56ce0227142fee2c001c39ce8d31cd9e6fb9b5..a68e46f0134d655d1b034b2b4a40727627724164 100644 --- a/substrate/client/consensus/manual-seal/src/consensus/babe.rs +++ b/substrate/client/consensus/manual-seal/src/consensus/babe.rs @@ -96,7 +96,7 @@ where C: HeaderBackend + HeaderMetadata, { async fn verify( - &mut self, + &self, mut import_params: BlockImportParams, ) -> Result, String> { import_params.finalized = false; diff --git a/substrate/client/consensus/manual-seal/src/lib.rs b/substrate/client/consensus/manual-seal/src/lib.rs index 8fc7e7ecab2f45cf8359c2f449dde3b480bb3ad3..39f8f8609d8d7f35867cc8108ad6667263fe5b74 100644 --- a/substrate/client/consensus/manual-seal/src/lib.rs +++ b/substrate/client/consensus/manual-seal/src/lib.rs @@ -65,7 +65,7 @@ struct ManualSealVerifier; #[async_trait::async_trait] impl Verifier for ManualSealVerifier { async fn verify( - &mut self, + &self, mut block: BlockImportParams, ) -> Result, String> { block.finalized = false; diff --git a/substrate/client/consensus/pow/Cargo.toml b/substrate/client/consensus/pow/Cargo.toml index ecfa29aa194d424d35eba858a0b829fb58a610e3..bc89deb0b50d60d2872cc73aba7705f360b53381 100644 --- a/substrate/client/consensus/pow/Cargo.toml +++ b/substrate/client/consensus/pow/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "PoW consensus algorithm for substrate" edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,21 +16,21 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1", features = ["derive"] } -futures = "0.3.30" -futures-timer = "3.0.1" +async-trait = { workspace = true } +codec = { features = ["derive"], workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -parking_lot = "0.12.1" +parking_lot = { workspace = true, default-features = true } thiserror = { workspace = true } -prometheus-endpoint = { package = "substrate-prometheus-endpoint", path = "../../../utils/prometheus" } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sp-api = { path = "../../../primitives/api" } -sp-block-builder = { path = "../../../primitives/block-builder" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-pow = { path = "../../../primitives/consensus/pow" } -sp-core = { path = "../../../primitives/core" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-runtime = { path = "../../../primitives/runtime" } +prometheus-endpoint = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-block-builder = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-pow = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } diff --git a/substrate/client/consensus/pow/src/lib.rs b/substrate/client/consensus/pow/src/lib.rs index ee5c1dfc6f11a26599c0f01efee9224caded43cd..cd7da128549f0d8ded3b073568e735fae970028f 100644 --- a/substrate/client/consensus/pow/src/lib.rs +++ b/substrate/client/consensus/pow/src/lib.rs @@ -312,15 +312,12 @@ where { type Error = ConsensusError; - async fn check_block( - &mut self, - block: BlockCheckParams, - ) -> Result { + async fn check_block(&self, block: BlockCheckParams) -> Result { self.inner.check_block(block).await.map_err(Into::into) } async fn import_block( - &mut self, + &self, mut block: BlockImportParams, ) -> Result { let best_header = self @@ -442,7 +439,7 @@ where Algorithm::Difficulty: 'static + Send, { async fn verify( - &mut self, + &self, mut block: BlockImportParams, ) -> Result, String> { let hash = block.header.hash(); diff --git a/substrate/client/consensus/pow/src/worker.rs b/substrate/client/consensus/pow/src/worker.rs index 9e9c4fc137d86dd3945d5cbc3aa44b43558a757d..73400136483a7cf8e3f03aa75a64e1a3aaf8fba2 100644 --- a/substrate/client/consensus/pow/src/worker.rs +++ b/substrate/client/consensus/pow/src/worker.rs @@ -192,7 +192,7 @@ where import_block.insert_intermediate(INTERMEDIATE_KEY, intermediate); let header = import_block.post_header(); - let mut block_import = self.block_import.lock(); + let block_import = self.block_import.lock(); match block_import.import_block(import_block).await { Ok(res) => { diff --git a/substrate/client/consensus/slots/Cargo.toml b/substrate/client/consensus/slots/Cargo.toml index 4ac6ce90713798d2cce4172f3544c6a116736a84..cc39575efe82806bbf86c2d34f993a9d961af18a 100644 --- a/substrate/client/consensus/slots/Cargo.toml +++ b/substrate/client/consensus/slots/Cargo.toml @@ -6,7 +6,7 @@ description = "Generic slots-based utilities for consensus" edition.workspace = true build = "build.rs" license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -17,22 +17,22 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -async-trait = "0.1.79" -codec = { package = "parity-scale-codec", version = "3.6.1" } -futures = "0.3.30" -futures-timer = "3.0.1" +async-trait = { workspace = true } +codec = { workspace = true, default-features = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -sc-client-api = { path = "../../api" } -sc-consensus = { path = "../common" } -sc-telemetry = { path = "../../telemetry" } -sp-arithmetic = { path = "../../../primitives/arithmetic" } -sp-blockchain = { path = "../../../primitives/blockchain" } -sp-consensus = { path = "../../../primitives/consensus/common" } -sp-consensus-slots = { path = "../../../primitives/consensus/slots" } -sp-core = { path = "../../../primitives/core" } -sp-inherents = { path = "../../../primitives/inherents" } -sp-runtime = { path = "../../../primitives/runtime" } -sp-state-machine = { path = "../../../primitives/state-machine" } +sc-client-api = { workspace = true, default-features = true } +sc-consensus = { workspace = true, default-features = true } +sc-telemetry = { workspace = true, default-features = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-consensus = { workspace = true, default-features = true } +sp-consensus-slots = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-inherents = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } [dev-dependencies] -substrate-test-runtime-client = { path = "../../../test-utils/runtime/client" } +substrate-test-runtime-client = { workspace = true } diff --git a/substrate/client/consensus/slots/src/lib.rs b/substrate/client/consensus/slots/src/lib.rs index d9d792005312503f48bb2d628235794952104ccd..06e0756fc968910cf1333c13303c2fa65479df71 100644 --- a/substrate/client/consensus/slots/src/lib.rs +++ b/substrate/client/consensus/slots/src/lib.rs @@ -29,8 +29,8 @@ mod aux_schema; mod slots; pub use aux_schema::{check_equivocation, MAX_SLOT_CAPACITY, PRUNING_BOUND}; -pub use slots::SlotInfo; use slots::Slots; +pub use slots::{time_until_next_slot, SlotInfo}; use futures::{future::Either, Future, TryFutureExt}; use futures_timer::Delay; @@ -517,16 +517,15 @@ pub async fn start_slot_worker( CIDP: CreateInherentDataProviders + Send + 'static, CIDP::InherentDataProviders: InherentDataProviderExt + Send, { - let mut slots = Slots::new(slot_duration.as_duration(), create_inherent_data_providers, client); + let mut slots = Slots::new( + slot_duration.as_duration(), + create_inherent_data_providers, + client, + sync_oracle, + ); loop { let slot_info = slots.next_slot().await; - - if sync_oracle.is_major_syncing() { - debug!(target: LOG_TARGET, "Skipping proposal slot due to sync."); - continue - } - let _ = worker.on_slot(slot_info).await; } } diff --git a/substrate/client/consensus/slots/src/slots.rs b/substrate/client/consensus/slots/src/slots.rs index 203764310601af5f6225582a1e775a6beeb4d1dc..c0b412e8ad5b08402d02505a2594026ef179e483 100644 --- a/substrate/client/consensus/slots/src/slots.rs +++ b/substrate/client/consensus/slots/src/slots.rs @@ -21,7 +21,7 @@ //! This is used instead of `futures_timer::Interval` because it was unreliable. use super::{InherentDataProviderExt, Slot, LOG_TARGET}; -use sp_consensus::SelectChain; +use sp_consensus::{SelectChain, SyncOracle}; use sp_inherents::{CreateInherentDataProviders, InherentDataProvider}; use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; @@ -87,21 +87,23 @@ impl SlotInfo { } /// A stream that returns every time there is a new slot. -pub(crate) struct Slots { +pub(crate) struct Slots { last_slot: Slot, slot_duration: Duration, until_next_slot: Option, create_inherent_data_providers: IDP, select_chain: SC, + sync_oracle: SO, _phantom: std::marker::PhantomData, } -impl Slots { +impl Slots { /// Create a new `Slots` stream. pub fn new( slot_duration: Duration, create_inherent_data_providers: IDP, select_chain: SC, + sync_oracle: SO, ) -> Self { Slots { last_slot: 0.into(), @@ -109,17 +111,19 @@ impl Slots { until_next_slot: None, create_inherent_data_providers, select_chain, + sync_oracle, _phantom: Default::default(), } } } -impl Slots +impl Slots where Block: BlockT, SC: SelectChain, IDP: CreateInherentDataProviders + 'static, IDP::InherentDataProviders: crate::InherentDataProviderExt, + SO: SyncOracle, { /// Returns a future that fires when the next slot starts. pub async fn next_slot(&mut self) -> SlotInfo { @@ -138,6 +142,11 @@ where let wait_dur = time_until_next_slot(self.slot_duration); self.until_next_slot = Some(Delay::new(wait_dur)); + if self.sync_oracle.is_major_syncing() { + log::debug!(target: LOG_TARGET, "Skipping slot: major sync is in progress."); + continue; + } + let chain_head = match self.select_chain.best_chain().await { Ok(x) => x, Err(e) => { diff --git a/substrate/client/db/Cargo.toml b/substrate/client/db/Cargo.toml index f67a662949abc19da3c5408177bd49731d08ccba..5725155579fc70450afad9ff46580afc721d2ea0 100644 --- a/substrate/client/db/Cargo.toml +++ b/substrate/client/db/Cargo.toml @@ -4,7 +4,7 @@ version = "0.35.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Client backend that uses RocksDB database as storage." readme = "README.md" @@ -16,38 +16,38 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -codec = { package = "parity-scale-codec", version = "3.6.1", features = [ +codec = { features = [ "derive", -] } -hash-db = "0.16.0" -kvdb = "0.13.0" -kvdb-memorydb = "0.13.0" -kvdb-rocksdb = { version = "0.19.0", optional = true } -linked-hash-map = "0.5.4" +], workspace = true, default-features = true } +hash-db = { workspace = true, default-features = true } +kvdb = { workspace = true } +kvdb-memorydb = { workspace = true } +kvdb-rocksdb = { optional = true, workspace = true } +linked-hash-map = { workspace = true } log = { workspace = true, default-features = true } -parity-db = "0.4.12" -parking_lot = "0.12.1" -sc-client-api = { path = "../api" } -sc-state-db = { path = "../state-db" } -schnellru = "0.2.1" -sp-arithmetic = { path = "../../primitives/arithmetic" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-core = { path = "../../primitives/core" } -sp-database = { path = "../../primitives/database" } -sp-runtime = { path = "../../primitives/runtime" } -sp-state-machine = { path = "../../primitives/state-machine" } -sp-trie = { path = "../../primitives/trie" } +parity-db = { workspace = true } +parking_lot = { workspace = true, default-features = true } +sc-client-api = { workspace = true, default-features = true } +sc-state-db = { workspace = true, default-features = true } +schnellru = { workspace = true } +sp-arithmetic = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-database = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } [dev-dependencies] -criterion = "0.5.1" -kvdb-rocksdb = "0.19.0" -rand = "0.8.5" -tempfile = "3.1.0" -quickcheck = { version = "1.0.3", default-features = false } -kitchensink-runtime = { path = "../../bin/node/runtime" } -sp-tracing = { path = "../../primitives/tracing" } -substrate-test-runtime-client = { path = "../../test-utils/runtime/client" } -array-bytes = "6.2.2" +criterion = { workspace = true, default-features = true } +kvdb-rocksdb = { workspace = true } +rand = { workspace = true, default-features = true } +tempfile = { workspace = true } +quickcheck = { workspace = true } +kitchensink-runtime = { workspace = true } +sp-tracing = { workspace = true, default-features = true } +substrate-test-runtime-client = { workspace = true } +array-bytes = { workspace = true, default-features = true } [features] default = [] diff --git a/substrate/client/db/src/bench.rs b/substrate/client/db/src/bench.rs index 32503cf63c0ad7eeae1ab502d38b09aa210d9bc9..3d590bd2bb76ea7c574363566e6f5b3f4782f699 100644 --- a/substrate/client/db/src/bench.rs +++ b/substrate/client/db/src/bench.rs @@ -179,6 +179,11 @@ impl BenchmarkingState { Ok(state) } + /// Get the proof recorder for this state + pub fn recorder(&self) -> Option> { + self.proof_recorder.clone() + } + fn reopen(&self) -> Result<(), String> { *self.state.borrow_mut() = None; let db = match self.db.take() { diff --git a/substrate/client/db/src/lib.rs b/substrate/client/db/src/lib.rs index 0faa90dfc4f925db8776c6914fcf864813b790a5..ba0cbc09d53dad38939efd4017da27ecd48f213a 100644 --- a/substrate/client/db/src/lib.rs +++ b/substrate/client/db/src/lib.rs @@ -68,8 +68,8 @@ use sc_client_api::{ use sc_state_db::{IsPruned, LastCanonicalized, StateDb}; use sp_arithmetic::traits::Saturating; use sp_blockchain::{ - Backend as _, CachedHeaderMetadata, Error as ClientError, HeaderBackend, HeaderMetadata, - HeaderMetadataCache, Result as ClientResult, + Backend as _, CachedHeaderMetadata, DisplacedLeavesAfterFinalization, Error as ClientError, + HeaderBackend, HeaderMetadata, HeaderMetadataCache, Result as ClientResult, }; use sp_core::{ offchain::OffchainOverlayedChange, @@ -747,19 +747,6 @@ impl sc_client_api::blockchain::Backend for BlockchainDb, - ) -> ClientResult> { - Ok(self - .leaves - .read() - .displaced_by_finalize_height(block_number) - .leaves() - .cloned() - .collect::>()) - } - fn children(&self, parent_hash: Block::Hash) -> ClientResult> { children::read_children(&*self.db, columns::META, meta_keys::CHILDREN_PREFIX, parent_hash) } @@ -1370,6 +1357,8 @@ impl Backend { Ok(()) } + /// `remove_displaced` can be set to `false` if this is not the last of many subsequent calls + /// for performance reasons. fn finalize_block_with_transaction( &self, transaction: &mut Transaction, @@ -1378,6 +1367,7 @@ impl Backend { last_finalized: Option, justification: Option, current_transaction_justifications: &mut HashMap, + remove_displaced: bool, ) -> ClientResult> { // TODO: ensure best chain contains this block. let number = *header.number(); @@ -1390,6 +1380,7 @@ impl Backend { hash, with_state, current_transaction_justifications, + remove_displaced, )?; if let Some(justification) = justification { @@ -1467,7 +1458,8 @@ impl Backend { let mut current_transaction_justifications: HashMap = HashMap::new(); - for (block_hash, justification) in operation.finalized_blocks { + let mut finalized_blocks = operation.finalized_blocks.into_iter().peekable(); + while let Some((block_hash, justification)) = finalized_blocks.next() { let block_header = self.blockchain.expect_header(block_hash)?; meta_updates.push(self.finalize_block_with_transaction( &mut transaction, @@ -1476,6 +1468,7 @@ impl Backend { Some(last_finalized_hash), justification, &mut current_transaction_justifications, + finalized_blocks.peek().is_none(), )?); last_finalized_hash = block_hash; last_finalized_num = *block_header.number(); @@ -1655,6 +1648,7 @@ impl Backend { hash, operation.commit_state, &mut current_transaction_justifications, + true, )?; } else { // canonicalize blocks which are old enough, regardless of finality. @@ -1779,9 +1773,10 @@ impl Backend { Ok(()) } - // write stuff to a transaction after a new block is finalized. - // this canonicalizes finalized blocks. Fails if called with a block which - // was not a child of the last finalized block. + // Write stuff to a transaction after a new block is finalized. This canonicalizes finalized + // blocks. Fails if called with a block which was not a child of the last finalized block. + /// `remove_displaced` can be set to `false` if this is not the last of many subsequent calls + /// for performance reasons. fn note_finalized( &self, transaction: &mut Transaction, @@ -1789,6 +1784,7 @@ impl Backend { f_hash: Block::Hash, with_state: bool, current_transaction_justifications: &mut HashMap, + remove_displaced: bool, ) -> ClientResult<()> { let f_num = *f_header.number(); @@ -1813,14 +1809,19 @@ impl Backend { apply_state_commit(transaction, commit); } - let new_displaced = self.blockchain.leaves.write().finalize_height(f_num); - self.prune_blocks( - transaction, - f_num, - f_hash, - &new_displaced, - current_transaction_justifications, - )?; + if remove_displaced { + let new_displaced = self.blockchain.displaced_leaves_after_finalizing(f_hash, f_num)?; + + self.blockchain.leaves.write().remove_displaced_leaves(FinalizationOutcome::new( + new_displaced.displaced_leaves.iter().copied(), + )); + + if !matches!(self.blocks_pruning, BlocksPruning::KeepAll) { + self.prune_displaced_branches(transaction, &new_displaced)?; + } + } + + self.prune_blocks(transaction, f_num, current_transaction_justifications)?; Ok(()) } @@ -1829,40 +1830,29 @@ impl Backend { &self, transaction: &mut Transaction, finalized_number: NumberFor, - finalized_hash: Block::Hash, - displaced: &FinalizationOutcome>, current_transaction_justifications: &mut HashMap, ) -> ClientResult<()> { - match self.blocks_pruning { - BlocksPruning::KeepAll => {}, - BlocksPruning::Some(blocks_pruning) => { - // Always keep the last finalized block - let keep = std::cmp::max(blocks_pruning, 1); - if finalized_number >= keep.into() { - let number = finalized_number.saturating_sub(keep.into()); - - // Before we prune a block, check if it is pinned - if let Some(hash) = self.blockchain.hash(number)? { - self.blockchain.insert_persisted_body_if_pinned(hash)?; - - // If the block was finalized in this transaction, it will not be in the db - // yet. - if let Some(justification) = - current_transaction_justifications.remove(&hash) - { - self.blockchain.insert_justifications_if_pinned(hash, justification); - } else { - self.blockchain.insert_persisted_justifications_if_pinned(hash)?; - } - }; + if let BlocksPruning::Some(blocks_pruning) = self.blocks_pruning { + // Always keep the last finalized block + let keep = std::cmp::max(blocks_pruning, 1); + if finalized_number >= keep.into() { + let number = finalized_number.saturating_sub(keep.into()); + + // Before we prune a block, check if it is pinned + if let Some(hash) = self.blockchain.hash(number)? { + self.blockchain.insert_persisted_body_if_pinned(hash)?; + + // If the block was finalized in this transaction, it will not be in the db + // yet. + if let Some(justification) = current_transaction_justifications.remove(&hash) { + self.blockchain.insert_justifications_if_pinned(hash, justification); + } else { + self.blockchain.insert_persisted_justifications_if_pinned(hash)?; + } + }; - self.prune_block(transaction, BlockId::::number(number))?; - } - self.prune_displaced_branches(transaction, finalized_hash, displaced)?; - }, - BlocksPruning::KeepFinalized => { - self.prune_displaced_branches(transaction, finalized_hash, displaced)?; - }, + self.prune_block(transaction, BlockId::::number(number))?; + } } Ok(()) } @@ -1870,22 +1860,12 @@ impl Backend { fn prune_displaced_branches( &self, transaction: &mut Transaction, - finalized: Block::Hash, - displaced: &FinalizationOutcome>, + displaced: &DisplacedLeavesAfterFinalization, ) -> ClientResult<()> { // Discard all blocks from displaced branches - for h in displaced.leaves() { - match sp_blockchain::tree_route(&self.blockchain, *h, finalized) { - Ok(tree_route) => - for r in tree_route.retracted() { - self.blockchain.insert_persisted_body_if_pinned(r.hash)?; - self.prune_block(transaction, BlockId::::hash(r.hash))?; - }, - Err(sp_blockchain::Error::UnknownBlock(_)) => { - // Sometimes routes can't be calculated. E.g. after warp sync. - }, - Err(e) => Err(e)?, - } + for &hash in displaced.displaced_blocks.iter() { + self.blockchain.insert_persisted_body_if_pinned(hash)?; + self.prune_block(transaction, BlockId::::hash(hash))?; } Ok(()) } @@ -2133,6 +2113,7 @@ impl sc_client_api::backend::Backend for Backend { None, justification, &mut current_transaction_justifications, + true, )?; self.storage.db.commit(transaction)?; @@ -2632,6 +2613,35 @@ pub(crate) mod tests { Ok(header.hash()) } + pub fn insert_disconnected_header( + backend: &Backend, + number: u64, + parent_hash: H256, + extrinsics_root: H256, + best: bool, + ) -> H256 { + use sp_runtime::testing::Digest; + + let digest = Digest::default(); + let header = + Header { number, parent_hash, state_root: Default::default(), digest, extrinsics_root }; + + let mut op = backend.begin_operation().unwrap(); + + op.set_block_data( + header.clone(), + Some(vec![]), + None, + None, + if best { NewBlockState::Best } else { NewBlockState::Normal }, + ) + .unwrap(); + + backend.commit_operation(op).unwrap(); + + header.hash() + } + pub fn insert_header_no_head( backend: &Backend, number: u64, @@ -3131,6 +3141,248 @@ pub(crate) mod tests { } } + #[test] + fn displaced_leaves_after_finalizing_works_with_disconnect() { + // In this test we will create a situation that can typically happen after warp sync. + // The situation looks like this: + // g -> -> a3 -> a4 + // Basically there is a gap of unimported blocks at some point in the chain. + let backend = Backend::::new_test(1000, 100); + let blockchain = backend.blockchain(); + let genesis_number = 0; + let genesis_hash = + insert_header(&backend, genesis_number, Default::default(), None, Default::default()); + + let a3_number = 3; + let a3_hash = insert_disconnected_header( + &backend, + a3_number, + H256::from([200; 32]), + H256::from([1; 32]), + true, + ); + + let a4_number = 4; + let a4_hash = + insert_disconnected_header(&backend, a4_number, a3_hash, H256::from([2; 32]), true); + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![a4_hash, genesis_hash]); + assert_eq!(displaced.displaced_leaves, vec![(genesis_number, genesis_hash)]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a4_hash, a4_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![a4_hash, genesis_hash]); + assert_eq!(displaced.displaced_leaves, vec![(genesis_number, genesis_hash)]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + // Import block a1 which has the genesis block as parent. + // g -> a1 -> -> a3(f) -> a4 + let a1_number = 1; + let a1_hash = insert_disconnected_header( + &backend, + a1_number, + genesis_hash, + H256::from([123; 32]), + false, + ); + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![a4_hash, a1_hash]); + assert_eq!(displaced.displaced_leaves, vec![]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + // Import block b1 which has the genesis block as parent. + // g -> a1 -> -> a3(f) -> a4 + // \-> b1 + let b1_number = 1; + let b1_hash = insert_disconnected_header( + &backend, + b1_number, + genesis_hash, + H256::from([124; 32]), + false, + ); + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![a4_hash, a1_hash, b1_hash]); + assert_eq!(displaced.displaced_leaves, vec![]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + // If branch of b blocks is higher in number than a branch, we + // should still not prune disconnected leafs. + // g -> a1 -> -> a3(f) -> a4 + // \-> b1 -> b2 ----------> b3 ----> b4 -> b5 + let b2_number = 2; + let b2_hash = + insert_disconnected_header(&backend, b2_number, b1_hash, H256::from([40; 32]), false); + let b3_number = 3; + let b3_hash = + insert_disconnected_header(&backend, b3_number, b2_hash, H256::from([41; 32]), false); + let b4_number = 4; + let b4_hash = + insert_disconnected_header(&backend, b4_number, b3_hash, H256::from([42; 32]), false); + let b5_number = 5; + let b5_hash = + insert_disconnected_header(&backend, b5_number, b4_hash, H256::from([43; 32]), false); + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![b5_hash, a4_hash, a1_hash]); + assert_eq!(displaced.displaced_leaves, vec![]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + // Even though there is a disconnect, diplace should still detect + // branches above the block gap. + // /-> c4 + // g -> a1 -> -> a3 -> a4(f) + // \-> b1 -> b2 ----------> b3 -> b4 -> b5 + let c4_number = 4; + let c4_hash = + insert_disconnected_header(&backend, c4_number, a3_hash, H256::from([44; 32]), false); + { + let displaced = + blockchain.displaced_leaves_after_finalizing(a4_hash, a4_number).unwrap(); + assert_eq!(blockchain.leaves().unwrap(), vec![b5_hash, a4_hash, c4_hash, a1_hash]); + assert_eq!(displaced.displaced_leaves, vec![(c4_number, c4_hash)]); + assert_eq!(displaced.displaced_blocks, vec![c4_hash]); + } + } + #[test] + fn displaced_leaves_after_finalizing_works() { + let backend = Backend::::new_test(1000, 100); + let blockchain = backend.blockchain(); + let genesis_number = 0; + let genesis_hash = + insert_header(&backend, genesis_number, Default::default(), None, Default::default()); + + // fork from genesis: 3 prong. + // block 0 -> a1 -> a2 -> a3 + // \ + // -> b1 -> b2 -> c1 -> c2 + // \ + // -> d1 -> d2 + let a1_number = 1; + let a1_hash = insert_header(&backend, a1_number, genesis_hash, None, Default::default()); + let a2_number = 2; + let a2_hash = insert_header(&backend, a2_number, a1_hash, None, Default::default()); + let a3_number = 3; + let a3_hash = insert_header(&backend, a3_number, a2_hash, None, Default::default()); + + { + let displaced = blockchain + .displaced_leaves_after_finalizing(genesis_hash, genesis_number) + .unwrap(); + assert_eq!(displaced.displaced_leaves, vec![]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + { + let displaced_a1 = + blockchain.displaced_leaves_after_finalizing(a1_hash, a1_number).unwrap(); + assert_eq!(displaced_a1.displaced_leaves, vec![]); + assert_eq!(displaced_a1.displaced_blocks, vec![]); + + let displaced_a2 = + blockchain.displaced_leaves_after_finalizing(a2_hash, a3_number).unwrap(); + assert_eq!(displaced_a2.displaced_leaves, vec![]); + assert_eq!(displaced_a2.displaced_blocks, vec![]); + + let displaced_a3 = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(displaced_a3.displaced_leaves, vec![]); + assert_eq!(displaced_a3.displaced_blocks, vec![]); + } + { + // Finalized block is above leaves and not imported yet. + // We will not be able to make a connection, + // nothing can be marked as displaced. + let displaced = + blockchain.displaced_leaves_after_finalizing(H256::from([57; 32]), 10).unwrap(); + assert_eq!(displaced.displaced_leaves, vec![]); + assert_eq!(displaced.displaced_blocks, vec![]); + } + + // fork from genesis: 2 prong. + let b1_number = 1; + let b1_hash = insert_header(&backend, b1_number, genesis_hash, None, H256::from([1; 32])); + let b2_number = 2; + let b2_hash = insert_header(&backend, b2_number, b1_hash, None, Default::default()); + + // fork from b2. + let c1_number = 3; + let c1_hash = insert_header(&backend, c1_number, b2_hash, None, H256::from([2; 32])); + let c2_number = 4; + let c2_hash = insert_header(&backend, c2_number, c1_hash, None, Default::default()); + + // fork from b1. + let d1_number = 2; + let d1_hash = insert_header(&backend, d1_number, b1_hash, None, H256::from([3; 32])); + let d2_number = 3; + let d2_hash = insert_header(&backend, d2_number, d1_hash, None, Default::default()); + + { + let displaced_a1 = + blockchain.displaced_leaves_after_finalizing(a1_hash, a1_number).unwrap(); + assert_eq!( + displaced_a1.displaced_leaves, + vec![(c2_number, c2_hash), (d2_number, d2_hash)] + ); + let mut displaced_blocks = vec![b1_hash, b2_hash, c1_hash, c2_hash, d1_hash, d2_hash]; + displaced_blocks.sort(); + assert_eq!(displaced_a1.displaced_blocks, displaced_blocks); + + let displaced_a2 = + blockchain.displaced_leaves_after_finalizing(a2_hash, a2_number).unwrap(); + assert_eq!(displaced_a1.displaced_leaves, displaced_a2.displaced_leaves); + assert_eq!(displaced_a1.displaced_blocks, displaced_a2.displaced_blocks); + + let displaced_a3 = + blockchain.displaced_leaves_after_finalizing(a3_hash, a3_number).unwrap(); + assert_eq!(displaced_a1.displaced_leaves, displaced_a3.displaced_leaves); + assert_eq!(displaced_a1.displaced_blocks, displaced_a3.displaced_blocks); + } + { + let displaced = + blockchain.displaced_leaves_after_finalizing(b1_hash, b1_number).unwrap(); + assert_eq!(displaced.displaced_leaves, vec![(a3_number, a3_hash)]); + let mut displaced_blocks = vec![a1_hash, a2_hash, a3_hash]; + displaced_blocks.sort(); + assert_eq!(displaced.displaced_blocks, displaced_blocks); + } + { + let displaced = + blockchain.displaced_leaves_after_finalizing(b2_hash, b2_number).unwrap(); + assert_eq!( + displaced.displaced_leaves, + vec![(a3_number, a3_hash), (d2_number, d2_hash)] + ); + let mut displaced_blocks = vec![a1_hash, a2_hash, a3_hash, d1_hash, d2_hash]; + displaced_blocks.sort(); + assert_eq!(displaced.displaced_blocks, displaced_blocks); + } + { + let displaced = + blockchain.displaced_leaves_after_finalizing(c2_hash, c2_number).unwrap(); + assert_eq!( + displaced.displaced_leaves, + vec![(a3_number, a3_hash), (d2_number, d2_hash)] + ); + let mut displaced_blocks = vec![a1_hash, a2_hash, a3_hash, d1_hash, d2_hash]; + displaced_blocks.sort(); + assert_eq!(displaced.displaced_blocks, displaced_blocks); + } + } + #[test] fn test_tree_route_regression() { // NOTE: this is a test for a regression introduced in #3665, the result @@ -3190,6 +3442,9 @@ pub(crate) mod tests { #[test] fn test_leaves_pruned_on_finality() { + // / 1b - 2b - 3b + // 0 - 1a - 2a + // \ 1c let backend: Backend = Backend::new_test(10, 10); let block0 = insert_header(&backend, 0, Default::default(), None, Default::default()); @@ -3201,18 +3456,16 @@ pub(crate) mod tests { let block2_a = insert_header(&backend, 2, block1_a, None, Default::default()); let block2_b = insert_header(&backend, 2, block1_b, None, Default::default()); - let block2_c = insert_header(&backend, 2, block1_b, None, [1; 32].into()); - assert_eq!( - backend.blockchain().leaves().unwrap(), - vec![block2_a, block2_b, block2_c, block1_c] - ); + let block3_b = insert_header(&backend, 3, block2_b, None, [3; 32].into()); + + assert_eq!(backend.blockchain().leaves().unwrap(), vec![block3_b, block2_a, block1_c]); backend.finalize_block(block1_a, None).unwrap(); backend.finalize_block(block2_a, None).unwrap(); - // leaves at same height stay. Leaves at lower heights pruned. - assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a, block2_b, block2_c]); + // All leaves are pruned that are known to not belong to canonical branch + assert_eq!(backend.blockchain().leaves().unwrap(), vec![block2_a]); } #[test] diff --git a/substrate/client/executor/Cargo.toml b/substrate/client/executor/Cargo.toml index c08a7f5af342274ab41d4029f531581c7f65ee37..ca78afd470681227c07a2fad61bcc5b945d01e94 100644 --- a/substrate/client/executor/Cargo.toml +++ b/substrate/client/executor/Cargo.toml @@ -4,7 +4,7 @@ version = "0.32.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "A crate that provides means of executing/dispatching calls into the runtime." documentation = "https://docs.rs/sc-executor" @@ -17,43 +17,42 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -parking_lot = "0.12.1" -schnellru = "0.2.1" -tracing = "0.1.29" +parking_lot = { workspace = true, default-features = true } +schnellru = { workspace = true } +tracing = { workspace = true, default-features = true } -codec = { package = "parity-scale-codec", version = "3.6.1" } -sc-executor-common = { path = "common" } -sc-executor-polkavm = { path = "polkavm" } -sc-executor-wasmtime = { path = "wasmtime" } -sp-api = { path = "../../primitives/api" } -sp-core = { path = "../../primitives/core" } -sp-externalities = { path = "../../primitives/externalities" } -sp-io = { path = "../../primitives/io" } -sp-panic-handler = { path = "../../primitives/panic-handler" } -sp-runtime-interface = { path = "../../primitives/runtime-interface" } -sp-trie = { path = "../../primitives/trie" } -sp-version = { path = "../../primitives/version" } -sp-wasm-interface = { path = "../../primitives/wasm-interface" } +codec = { workspace = true, default-features = true } +sc-executor-common = { workspace = true, default-features = true } +sc-executor-polkavm = { workspace = true, default-features = true } +sc-executor-wasmtime = { workspace = true, default-features = true } +sp-api = { workspace = true, default-features = true } +sp-core = { workspace = true, default-features = true } +sp-externalities = { workspace = true, default-features = true } +sp-io = { workspace = true, default-features = true } +sp-panic-handler = { workspace = true, default-features = true } +sp-runtime-interface = { workspace = true, default-features = true } +sp-trie = { workspace = true, default-features = true } +sp-version = { workspace = true, default-features = true } +sp-wasm-interface = { workspace = true, default-features = true } [dev-dependencies] -array-bytes = "6.2.2" -assert_matches = "1.3.0" -wat = "1.0" -sc-runtime-test = { path = "runtime-test" } -substrate-test-runtime = { path = "../../test-utils/runtime" } -sp-crypto-hashing = { path = "../../primitives/crypto/hashing" } -sp-state-machine = { path = "../../primitives/state-machine" } -sp-runtime = { path = "../../primitives/runtime" } -sp-maybe-compressed-blob = { path = "../../primitives/maybe-compressed-blob" } -sc-tracing = { path = "../tracing" } -sp-tracing = { path = "../../primitives/tracing" } +array-bytes = { workspace = true, default-features = true } +assert_matches = { workspace = true } +wat = { workspace = true } +sc-runtime-test = { workspace = true } +substrate-test-runtime = { workspace = true } +sp-crypto-hashing = { workspace = true, default-features = true } +sp-state-machine = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sc-tracing = { workspace = true, default-features = true } +sp-tracing = { workspace = true, default-features = true } tracing-subscriber = { workspace = true } -paste = "1.0" -regex = "1.6.0" -criterion = "0.5.1" -env_logger = "0.11" -num_cpus = "1.13.1" -tempfile = "3.3.0" +paste = { workspace = true, default-features = true } +regex = { workspace = true } +criterion = { workspace = true, default-features = true } +num_cpus = { workspace = true } +tempfile = { workspace = true } [[bench]] name = "bench" diff --git a/substrate/client/executor/benches/bench.rs b/substrate/client/executor/benches/bench.rs index 86c769f88811b9d004e373ac22a166ae84416df2..4cde8c2a4a64678bc43b2c6001a105249e94453c 100644 --- a/substrate/client/executor/benches/bench.rs +++ b/substrate/client/executor/benches/bench.rs @@ -147,7 +147,7 @@ fn run_benchmark( } fn bench_call_instance(c: &mut Criterion) { - let _ = env_logger::try_init(); + sp_tracing::try_init_simple(); let strategies = [ ( diff --git a/substrate/client/executor/common/Cargo.toml b/substrate/client/executor/common/Cargo.toml index 8ff34c3709a5e486fb9036a638788a532c6f296c..58fb0b423f24235a0ddd277b3feaca5c193482d2 100644 --- a/substrate/client/executor/common/Cargo.toml +++ b/substrate/client/executor/common/Cargo.toml @@ -4,7 +4,7 @@ version = "0.29.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "A set of common definitions that are needed for defining execution engines." documentation = "https://docs.rs/sc-executor-common/" @@ -18,10 +18,10 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] thiserror = { workspace = true } -wasm-instrument = "0.4" -sc-allocator = { path = "../../allocator" } -sp-maybe-compressed-blob = { path = "../../../primitives/maybe-compressed-blob" } -sp-wasm-interface = { path = "../../../primitives/wasm-interface" } +wasm-instrument = { workspace = true, default-features = true } +sc-allocator = { workspace = true, default-features = true } +sp-maybe-compressed-blob = { workspace = true, default-features = true } +sp-wasm-interface = { workspace = true, default-features = true } polkavm = { workspace = true } [features] diff --git a/substrate/client/executor/polkavm/Cargo.toml b/substrate/client/executor/polkavm/Cargo.toml index 9d0eb8ccf0ee072c86195068a589309edd132ba4..941c830ba16a29204e81c4e5c1db1b3e154b5b25 100644 --- a/substrate/client/executor/polkavm/Cargo.toml +++ b/substrate/client/executor/polkavm/Cargo.toml @@ -4,7 +4,7 @@ version = "0.29.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "PolkaVM executor for Substrate" readme = "README.md" @@ -19,5 +19,5 @@ targets = ["x86_64-unknown-linux-gnu"] log = { workspace = true } polkavm = { workspace = true } -sc-executor-common = { path = "../common" } -sp-wasm-interface = { path = "../../../primitives/wasm-interface" } +sc-executor-common = { workspace = true, default-features = true } +sp-wasm-interface = { workspace = true, default-features = true } diff --git a/substrate/client/executor/runtime-test/Cargo.toml b/substrate/client/executor/runtime-test/Cargo.toml index 82610c4f50c2841fea13c1f859cc242f8ae427c7..5ab92cbb9332dace3f4da65f4c4abcc91b60d2ab 100644 --- a/substrate/client/executor/runtime-test/Cargo.toml +++ b/substrate/client/executor/runtime-test/Cargo.toml @@ -6,7 +6,7 @@ edition.workspace = true build = "build.rs" license = "GPL-3.0-or-later WITH Classpath-exception-2.0" publish = false -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true [lints] @@ -16,14 +16,13 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -sp-core = { path = "../../../primitives/core", default-features = false } -sp-io = { path = "../../../primitives/io", default-features = false, features = ["improved_panic_error_reporting"] } -sp-runtime = { path = "../../../primitives/runtime", default-features = false } -sp-runtime-interface = { path = "../../../primitives/runtime-interface", default-features = false } -sp-std = { path = "../../../primitives/std", default-features = false } +sp-core = { workspace = true } +sp-io = { features = ["improved_panic_error_reporting"], workspace = true } +sp-runtime = { workspace = true } +sp-runtime-interface = { workspace = true } [build-dependencies] -substrate-wasm-builder = { path = "../../../utils/wasm-builder", optional = true } +substrate-wasm-builder = { optional = true, workspace = true, default-features = true } [features] default = ["std"] @@ -32,6 +31,5 @@ std = [ "sp-io/std", "sp-runtime-interface/std", "sp-runtime/std", - "sp-std/std", "substrate-wasm-builder", ] diff --git a/substrate/client/executor/runtime-test/src/lib.rs b/substrate/client/executor/runtime-test/src/lib.rs index 40683fbb664aadb6daf68595befcc68881322f05..08a5e39dff2cfdca2a2f3629caf939e836ef3144 100644 --- a/substrate/client/executor/runtime-test/src/lib.rs +++ b/substrate/client/executor/runtime-test/src/lib.rs @@ -32,7 +32,10 @@ pub fn wasm_binary_unwrap() -> &'static [u8] { } #[cfg(not(feature = "std"))] -use sp_std::{vec, vec::Vec}; +extern crate alloc; + +#[cfg(not(feature = "std"))] +use alloc::{vec, vec::Vec}; #[cfg(not(feature = "std"))] use sp_core::{ed25519, sr25519}; @@ -332,7 +335,7 @@ sp_core::wasm_export_functions! { let test_message = b"Hello invalid heap memory"; let ptr = (heap_base + offset) as *mut u8; - let message_slice = unsafe { sp_std::slice::from_raw_parts_mut(ptr, test_message.len()) }; + let message_slice = unsafe { alloc::slice::from_raw_parts_mut(ptr, test_message.len()) }; assert_ne!(test_message, message_slice); message_slice.copy_from_slice(test_message); diff --git a/substrate/client/executor/src/integration_tests/mod.rs b/substrate/client/executor/src/integration_tests/mod.rs index 7f91b3ffe7644e37ebee0bc035faafbf38e21148..5d94ec6dcd38628be7858b8477e7e4892a45b210 100644 --- a/substrate/client/executor/src/integration_tests/mod.rs +++ b/substrate/client/executor/src/integration_tests/mod.rs @@ -178,7 +178,7 @@ fn storage_should_work(wasm_method: WasmExecutionMethod) { assert_eq!(output, b"all ok!".to_vec().encode()); } - let expected = TestExternalities::new(sp_core::storage::Storage { + let mut expected = TestExternalities::new(sp_core::storage::Storage { top: map![ b"input".to_vec() => value, b"foo".to_vec() => b"bar".to_vec(), @@ -186,7 +186,7 @@ fn storage_should_work(wasm_method: WasmExecutionMethod) { ], children_default: map![], }); - assert_eq!(ext, expected); + assert!(ext.eq(&mut expected)); } test_wasm_execution!(clear_prefix_should_work); @@ -208,7 +208,7 @@ fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) { assert_eq!(output, b"all ok!".to_vec().encode()); } - let expected = TestExternalities::new(sp_core::storage::Storage { + let mut expected = TestExternalities::new(sp_core::storage::Storage { top: map![ b"aaa".to_vec() => b"1".to_vec(), b"aab".to_vec() => b"2".to_vec(), @@ -216,7 +216,7 @@ fn clear_prefix_should_work(wasm_method: WasmExecutionMethod) { ], children_default: map![], }); - assert_eq!(expected, ext); + assert!(expected.eq(&mut ext)); } test_wasm_execution!(blake2_256_should_work); diff --git a/substrate/client/executor/wasmtime/Cargo.toml b/substrate/client/executor/wasmtime/Cargo.toml index f3fef4046914128dff2ad0904d445e89cba11c6a..ef8e5da876aa606e32790e9e8eb0ffb077ce2174 100644 --- a/substrate/client/executor/wasmtime/Cargo.toml +++ b/substrate/client/executor/wasmtime/Cargo.toml @@ -4,7 +4,7 @@ version = "0.29.0" authors.workspace = true edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true description = "Defines a `WasmRuntime` that uses the Wasmtime JIT to execute." readme = "README.md" @@ -17,24 +17,24 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] log = { workspace = true, default-features = true } -cfg-if = "1.0" -libc = "0.2.152" -parking_lot = "0.12.1" +cfg-if = { workspace = true } +libc = { workspace = true } +parking_lot = { workspace = true, default-features = true } # When bumping wasmtime do not forget to also bump rustix # to exactly the same version as used by wasmtime! -wasmtime = { version = "8.0.1", default-features = false, features = [ +wasmtime = { features = [ "cache", "cranelift", "jitdump", "parallel-compilation", "pooling-allocator", -] } -anyhow = "1.0.81" -sc-allocator = { path = "../../allocator" } -sc-executor-common = { path = "../common" } -sp-runtime-interface = { path = "../../../primitives/runtime-interface" } -sp-wasm-interface = { path = "../../../primitives/wasm-interface", features = ["wasmtime"] } +], workspace = true } +anyhow = { workspace = true } +sc-allocator = { workspace = true, default-features = true } +sc-executor-common = { workspace = true, default-features = true } +sp-runtime-interface = { workspace = true, default-features = true } +sp-wasm-interface = { features = ["wasmtime"], workspace = true, default-features = true } # Here we include the rustix crate in the exactly same semver-compatible version as used by # wasmtime and enable its 'use-libc' flag. @@ -42,13 +42,13 @@ sp-wasm-interface = { path = "../../../primitives/wasm-interface", features = [" # By default rustix directly calls the appropriate syscalls completely bypassing libc; # this doesn't have any actual benefits for us besides making it harder to debug memory # problems (since then `mmap` etc. cannot be easily hooked into). -rustix = { version = "0.36.7", default-features = false, features = ["fs", "mm", "param", "std", "use-libc"] } +rustix = { features = ["fs", "mm", "param", "std", "use-libc"], workspace = true } [dev-dependencies] -wat = "1.0" -sc-runtime-test = { path = "../runtime-test" } -sp-io = { path = "../../../primitives/io" } -tempfile = "3.3.0" -paste = "1.0" -codec = { package = "parity-scale-codec", version = "3.6.1" } -cargo_metadata = "0.15.4" +wat = { workspace = true } +sc-runtime-test = { workspace = true } +sp-io = { workspace = true, default-features = true } +tempfile = { workspace = true } +paste = { workspace = true, default-features = true } +codec = { workspace = true, default-features = true } +cargo_metadata = { workspace = true } diff --git a/substrate/client/executor/wasmtime/src/lib.rs b/substrate/client/executor/wasmtime/src/lib.rs index 82e62b4a5dd3cd6d7b009e019f0c24c28551743a..8e8e92017df91260d7d79f8f237200c1ef9936c0 100644 --- a/substrate/client/executor/wasmtime/src/lib.rs +++ b/substrate/client/executor/wasmtime/src/lib.rs @@ -41,3 +41,7 @@ pub use runtime::{ prepare_runtime_artifact, Config, DeterministicStackLimit, InstantiationStrategy, Semantics, WasmtimeRuntime, }; +pub use sc_executor_common::{ + runtime_blob::RuntimeBlob, + wasm_runtime::{HeapAllocStrategy, WasmModule}, +}; diff --git a/substrate/client/informant/Cargo.toml b/substrate/client/informant/Cargo.toml index 191ef5f19f8df65b3c817129fe34c4db7438826d..87a4be320d689d984f0b8ac94c12f78fda84eaa8 100644 --- a/substrate/client/informant/Cargo.toml +++ b/substrate/client/informant/Cargo.toml @@ -5,7 +5,7 @@ authors.workspace = true description = "Substrate informant." edition.workspace = true license = "GPL-3.0-or-later WITH Classpath-exception-2.0" -homepage = "https://substrate.io" +homepage.workspace = true repository.workspace = true readme = "README.md" @@ -16,13 +16,13 @@ workspace = true targets = ["x86_64-unknown-linux-gnu"] [dependencies] -ansi_term = "0.12.1" -futures = "0.3.30" -futures-timer = "3.0.1" +console = { workspace = true } +futures = { workspace = true } +futures-timer = { workspace = true } log = { workspace = true, default-features = true } -sc-client-api = { path = "../api" } -sc-network-common = { path = "../network/common" } -sc-network-sync = { path = "../network/sync" } -sc-network = { path = "../network" } -sp-blockchain = { path = "../../primitives/blockchain" } -sp-runtime = { path = "../../primitives/runtime" } +sc-client-api = { workspace = true, default-features = true } +sc-network-common = { workspace = true, default-features = true } +sc-network-sync = { workspace = true, default-features = true } +sc-network = { workspace = true, default-features = true } +sp-blockchain = { workspace = true, default-features = true } +sp-runtime = { workspace = true, default-features = true } diff --git a/substrate/client/informant/src/display.rs b/substrate/client/informant/src/display.rs index cdbb83b6596c2f235c5513d6e11a04fe4c6a793f..2decd76747827bdeb702e19fbf1d2e0cceca28e9 100644 --- a/substrate/client/informant/src/display.rs +++ b/substrate/client/informant/src/display.rs @@ -16,8 +16,7 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -use crate::OutputFormat; -use ansi_term::Colour; +use console::style; use log::info; use sc_client_api::ClientInfo; use sc_network::NetworkStatus; @@ -47,19 +46,16 @@ pub struct InformantDisplay { last_total_bytes_inbound: u64, /// The last seen total of bytes sent. last_total_bytes_outbound: u64, - /// The format to print output in. - format: OutputFormat, } impl InformantDisplay { /// Builds a new informant display system. - pub fn new(format: OutputFormat) -> InformantDisplay { + pub fn new() -> InformantDisplay { InformantDisplay { last_number: None, last_update: Instant::now(), last_total_bytes_inbound: 0, last_total_bytes_outbound: 0, - format, } } @@ -69,11 +65,11 @@ impl InformantDisplay { info: &ClientInfo, net_status: NetworkStatus, sync_status: SyncStatus, + num_connected_peers: usize, ) { let best_number = info.chain.best_number; let best_hash = info.chain.best_hash; let finalized_number = info.chain.finalized_number; - let num_connected_peers = sync_status.num_connected_peers; let speed = speed::(best_number, self.last_number, self.last_update); let total_bytes_inbound = net_status.total_bytes_inbound; let total_bytes_outbound = net_status.total_bytes_outbound; @@ -105,17 +101,9 @@ impl InformantDisplay { _, Some(WarpSyncProgress { phase: WarpSyncPhase::DownloadingBlocks(n), .. }), ) if !sync_status.is_major_syncing() => ("⏩", "Block history".into(), format!(", #{}", n)), - ( - _, - _, - Some(WarpSyncProgress { phase: WarpSyncPhase::AwaitingTargetBlock, .. }), - ) => ("⏩", "Waiting for pending target block".into(), "".into()), // Handle all phases besides the two phases we already handle above. (_, _, Some(warp)) - if !matches!( - warp.phase, - WarpSyncPhase::AwaitingTargetBlock | WarpSyncPhase::DownloadingBlocks(_) - ) => + if !matches!(warp.phase, WarpSyncPhase::DownloadingBlocks(_)) => ( "⏩", "Warping".into(), @@ -144,17 +132,17 @@ impl InformantDisplay { info!( target: "substrate", - "{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), {} {}", + "{} {}{} ({} peers), best: #{} ({}), finalized #{} ({}), ⬇ {} ⬆ {}", level, - self.format.print_with_color(Colour::White.bold(), status), + style(&status).white().bold(), target, - self.format.print_with_color(Colour::White.bold(), num_connected_peers), - self.format.print_with_color(Colour::White.bold(), best_number), + style(num_connected_peers).white().bold(), + style(best_number).white().bold(), best_hash, - self.format.print_with_color(Colour::White.bold(), finalized_number), + style(finalized_number).white().bold(), info.chain.finalized_hash, - self.format.print_with_color(Colour::Green, format!("⬇ {}", TransferRateFormat(avg_bytes_per_sec_inbound))), - self.format.print_with_color(Colour::Red, format!("⬆ {}", TransferRateFormat(avg_bytes_per_sec_outbound))), + style(TransferRateFormat(avg_bytes_per_sec_inbound)).green(), + style(TransferRateFormat(avg_bytes_per_sec_outbound)).red(), ) } } diff --git a/substrate/client/informant/src/lib.rs b/substrate/client/informant/src/lib.rs index af778529ffc58e13736352265b74856477f597eb..0b0e13dc08bbbdad372a29b497578a43b09925d7 100644 --- a/substrate/client/informant/src/lib.rs +++ b/substrate/client/informant/src/lib.rs @@ -18,13 +18,13 @@ //! Console informant. Prints sync progress and block events. Runs on the calling thread. -use ansi_term::{Colour, Style}; +use console::style; use futures::prelude::*; use futures_timer::Delay; use log::{debug, info, trace}; use sc_client_api::{BlockchainEvents, UsageProvider}; use sc_network::NetworkStatusProvider; -use sc_network_sync::SyncStatusProvider; +use sc_network_sync::{SyncStatusProvider, SyncingService}; use sp_blockchain::HeaderMetadata; use sp_runtime::traits::{Block as BlockT, Header}; use std::{collections::VecDeque, fmt::Display, sync::Arc, time::Duration}; @@ -36,71 +36,14 @@ fn interval(duration: Duration) -> impl Stream + Unpin { futures::stream::unfold((), move |_| Delay::new(duration).map(|_| Some(((), ())))).map(drop) } -/// The format to print telemetry output in. -#[derive(Clone, Debug)] -pub struct OutputFormat { - /// Enable color output in logs. - /// - /// Is enabled by default. - pub enable_color: bool, -} - -impl Default for OutputFormat { - fn default() -> Self { - Self { enable_color: true } - } -} - -enum ColorOrStyle { - Color(Colour), - Style(Style), -} - -impl From for ColorOrStyle { - fn from(value: Colour) -> Self { - Self::Color(value) - } -} - -impl From